package http import ( "fmt" "net/http" "time" "github.com/go-chi/chi/middleware" "github.com/rs/zerolog" "gitlab.com/demodesk/neko/server/pkg/types" "gitlab.com/demodesk/neko/server/pkg/utils" ) type logFormatter struct { logger zerolog.Logger } func (l *logFormatter) NewLogEntry(r *http.Request) middleware.LogEntry { // exclude health & metrics from logs if r.RequestURI == "/health" || r.RequestURI == "/metrics" { return &nulllog{} } req := map[string]interface{}{} if reqID := middleware.GetReqID(r.Context()); reqID != "" { req["id"] = reqID } scheme := "http" if r.TLS != nil { scheme = "https" } req["scheme"] = scheme req["proto"] = r.Proto req["method"] = r.Method req["remote"] = r.RemoteAddr req["agent"] = r.UserAgent() req["uri"] = fmt.Sprintf("%s://%s%s", scheme, r.Host, r.RequestURI) return &logEntry{ logger: l.logger.With().Interface("req", req).Logger(), } } type logEntry struct { logger zerolog.Logger err error panic *logPanic session *types.Session } type logPanic struct { message string stack string } func (e *logEntry) Panic(v interface{}, stack []byte) { e.panic = &logPanic{ message: fmt.Sprintf("%+v", v), stack: string(stack), } } func (e *logEntry) Error(err error) { e.err = err } func (e *logEntry) SetSession(session types.Session) { e.session = &session } func (e *logEntry) Write(status, bytes int, header http.Header, elapsed time.Duration, extra interface{}) { res := map[string]interface{}{} res["time"] = time.Now().UTC().Format(time.RFC1123) res["status"] = status res["bytes"] = bytes res["elapsed"] = float64(elapsed.Nanoseconds()) / 1000000.0 logger := e.logger.With().Interface("res", res).Logger() // add session ID to logs (if exists) if e.session != nil { logger = logger.With().Str("session_id", (*e.session).ID()).Logger() } // handle panic error message if e.panic != nil { logger.WithLevel(zerolog.PanicLevel). Err(e.err). Str("stack", e.panic.stack). Msgf("request failed (%d): %s", status, e.panic.message) return } // handle panic error message if e.err != nil { httpErr, ok := e.err.(*utils.HTTPError) if !ok { logger.Err(e.err).Msgf("request failed (%d)", status) return } if httpErr.Message == "" { httpErr.Message = http.StatusText(httpErr.Code) } var logLevel zerolog.Level if httpErr.Code < 500 { logLevel = zerolog.WarnLevel } else { logLevel = zerolog.ErrorLevel } message := httpErr.Message if httpErr.InternalMsg != "" { message = httpErr.InternalMsg } logger.WithLevel(logLevel).Err(httpErr.InternalErr).Msgf("request failed (%d): %s", status, message) return } logger.Debug().Msgf("request complete (%d)", status) } type nulllog struct{} func (e *nulllog) Panic(v interface{}, stack []byte) {} func (e *nulllog) Error(err error) {} func (e *nulllog) SetSession(session types.Session) {} func (e *nulllog) Write(status, bytes int, header http.Header, elapsed time.Duration, extra interface{}) { }