Custom middleware recovery having to be duplicated about chi HOT 1 OPEN

router.Use(middleware.Logger)
router.Use(recoverMiddleware(logger, config.Debug))


func recoverMiddleware(logger *slog.Logger, isDebug bool) func(next http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			defer func() {
				if rvr := recover(); rvr != nil {
					if rvr == http.ErrAbortHandler {
						// we don't recover http.ErrAbortHandler so the response
						// to the client is aborted, this should not be logged
						panic(rvr)
					}

					logEntry := middleware.GetLogEntry(r)
					if logEntry != nil {
						logEntry.Panic(rvr, debug.Stack())
					} else if isDebug {
						middleware.PrintPrettyStack(rvr)
					} else {
						stack := string(debug.Stack())
						logger.ErrorContext(r.Context(), "panic", "error", rvr, "stack", stack)
					}

					if r.Header.Get("Connection") != "Upgrade" {
						w.WriteHeader(http.StatusInternalServerError)
					}
				}
			}()

			next.ServeHTTP(w, r)
		})
	}
}

router.Use(middleware.RequestLogger(&customLogFormatter{Logger: logger}))
router.Use(middleware.Recoverer)


type customLogFormatter struct {
	Logger *slog.Logger
}

func (f *customLogFormatter) NewLogEntry(r *http.Request) middleware.LogEntry {
	return &customLogEntry{Logger: f.Logger}
}

type customLogEntry struct {
	Logger *slog.Logger
}

func (e *customLogEntry) Write(status, bytes int, header http.Header, elapsed time.Duration, extra interface{}) {
	// no op, gcp logs the request automatically & we don't need to do anything fancy for now (trace ids, etc)
}

func (e *customLogEntry) Panic(v interface{}, stack []byte) {
	e.Logger.Error("panic", "error", v, "stack", string(stack))
}