Calling panic works for both http1 and http2 and does the right thing in both, and we have tests for both.

See #16542 (comment) for some background.

The docs already say:

If ServeHTTP panics, the server (the caller of ServeHTTP) assumes that the effect of the panic was isolated to the active request. It recovers the panic, logs a stack trace to the server error log, and hangs up the connection.

I suppose you want a way to do this without the stack trace, though?

I thought we had a bug open about that, but I can't find it, so we'll use this one. Thanks for filing.

If ServeHTTP panics [...] hangs up the connection.

Ah, right.

I suppose you want a way to do this without the stack trace, though?

Yes, this is meant to happen when the backend times out, and it's part of
the normal behaviour of the application.

-- Juliusz

I've found that runtime.Goexit() and panic(nil) both work well for this—they interrupt the request and do not cause a stack track to be printed. @bradfitz , are these behaviors intentional and supported?

https://play.golang.org/p/96dhROeoTh
https://play.golang.org/p/g_1P56OIKr

@rhysh, neither of those were intentional. panic(nil) looks like it only works for HTTP/1. In the http2.Server, the code looks like:

// Run on its own goroutine.                                                                                                                                                                                                                           
func (sc *serverConn) runHandler(rw *responseWriter, req *http.Request, handler func(http.ResponseWriter, *http.Request)) {
        didPanic := true
        defer func() {
                rw.rws.stream.cancelCtx()
                if didPanic {
                        e := recover()
                        // Same as net/http:                                                                                                                                                                                                           
                        const size = 64 << 10
                        buf := make([]byte, size)
                        buf = buf[:runtime.Stack(buf, false)]
// ...
                        sc.logf("http2: panic serving %v: %v\n%s", sc.conn.RemoteAddr(), e, buf)
                        return
                }
                rw.handlerDone()
        }()
        handler(rw, req)
        didPanic = false
}

Likewise, it looks like http2.Server would interpret a runtime.Goexit as if it were a panic.

I suppose we could make that the official way, though. One one official way.

I think I'd prefer to make an explicit panic value, though, so if you're using a different http server hosting http.Handlers and that implementation forgets to do the recover() thing, at least the error message will be explicit about the Handler's intentions, rather than a mystery panic.

CL https://golang.org/cl/33099 mentions this issue.

CL https://golang.org/cl/33102 mentions this issue.

CL https://golang.org/cl/33103 mentions this issue.