Is it possible to recover from panic on google app engine?

I'm wondering if it's possible to recover from a panic. It seems GAE has it's own panic recovery mechanism but I can't find any hook to handle it on my app.

Handlers in an AppEngine webapp are registered in the same way as would be in a normal Go application. You just don't have to call http.ListenAndServe() explicitly (because it will be by the platform), and handler registration happens in an init() function (not in main()).

Having said that, the same panic-recover wrapping works on AppEngine too, and unfortunately there is no other, better way.

Take a look at this example: it uses a function registered with HandleFunc() and a Handler registered with Handle() to handle 2 URL patterns, but both intentionally panics (they refuse to serve):

func myHandleFunc(w http.ResponseWriter, r *http.Request) {
	panic("I'm myHandlerFunc and I refuse to serve!")
}

type MyHandler int

func (m *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	panic("I'm MyHandler and I refuse to serve!")
}

func main() {
	http.HandleFunc("/myfunc", myHandleFunc)
	http.Handle("/myhandler", new(MyHandler))

	panic(http.ListenAndServe(":8080", nil))
}

Directing your browser to http://localhost:8080/myfunc and http://localhost:8080/myhandler results in HTTP 500 status: internal server error (or an empty response depending on where you check it).

The general idea is to use recover to "catch" the panics from handlers (spec: Handling panics). We can "wrap" handle functions or Handlers in a way that we first register a defer statement which is called even if the rest of the function panics, and in which we recover from the panicing state.

See these 2 functions:

func protectFunc(hf func(http.ResponseWriter,
	*http.Request)) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			r := recover()
			if r != nil {
				// hf() paniced, we just recovered from it.
				// Handle error somehow, serve custom error page.
				w.Write([]byte("Something went bad but I recovered and sent this!"))
			}
		}()
		hf(w, r)
	}
}

func protectHandler(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			r := recover()
			if r != nil {
				// h.ServeHTTP() paniced, we just recovered from it.
				// Handle error somehow, serve custom error page.
				w.Write([]byte("Something went bad but I recovered and sent this!"))
			}
		}()
		h.ServeHTTP(w, r)
	})
}

The first one takes a function and returns one which calles the one we passed but recovers from panicing state if one was initiated.

The second one takes a Handler and returns another Handler which similarly calls the passed one but also handles panics and restores normal execution.

Now if we register handler functions and Handlers protected by these methods, the registered handlers will never panic (assuming the code after restoring normal execution does not panic):

http.HandleFunc("/myfunc-protected", protectFunc(myHandleFunc))
http.Handle("/myhandler-protected", protectHandler(new(MyHandler)))

Visiting http://localhost:8080/myfunc-protected and http://localhost:8080/myhandler-protected URLs resuls in HTTP 200 status (OK) with the message:

Something went bad but I recovered and sent this!