114 lines
2.9 KiB
Go
114 lines
2.9 KiB
Go
package http
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"regexp"
|
|
"time"
|
|
|
|
"github.com/rs/zerolog"
|
|
|
|
"gitea.libretechconsulting.com/rmcguire/go-app/pkg/config"
|
|
)
|
|
|
|
var ExcludeFromLogging = regexp.MustCompile(`\/(ready|live|metrics)$`)
|
|
|
|
type LoggingResponseWriter struct {
|
|
http.ResponseWriter
|
|
statusCode int
|
|
body *bytes.Buffer
|
|
}
|
|
|
|
func loggingMiddleware(appCtx context.Context, next http.Handler) http.Handler {
|
|
appConfig := config.MustFromCtx(appCtx)
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if ExcludeFromLogging.Match([]byte(r.URL.Path)) {
|
|
next.ServeHTTP(w, r)
|
|
return
|
|
}
|
|
|
|
// User-configurable logging exclusions
|
|
for _, re := range appConfig.HTTP.GetExcludeRegexps() {
|
|
if re.MatchString(r.URL.Path) {
|
|
next.ServeHTTP(w, r)
|
|
return
|
|
}
|
|
}
|
|
|
|
log := zerolog.Ctx(appCtx)
|
|
|
|
start := time.Now()
|
|
lrr := newLoggingResponseWriter(w)
|
|
next.ServeHTTP(lrr, r)
|
|
|
|
log.Debug().
|
|
Str("path", r.URL.Path).
|
|
Any("query", r.URL.Query()).
|
|
Int("statusCode", lrr.statusCode).
|
|
Str("protocol", r.Proto).
|
|
Str("remote", r.RemoteAddr).
|
|
Dur("duration", time.Since(start)).
|
|
Msg("http request served")
|
|
|
|
// Log response with body if not 204
|
|
if lrr.statusCode == http.StatusNoContent {
|
|
trcLog := log.Trace().
|
|
Str("path", r.URL.Path).
|
|
Int("statusCode", lrr.statusCode)
|
|
trcLog.Msg("http response (no content)") // Explicitly log 204
|
|
return // No body to log for 204 No Content
|
|
}
|
|
|
|
trcLog := log.Trace().
|
|
Str("path", r.URL.Path).
|
|
Int("statusCode", lrr.statusCode)
|
|
|
|
firstByte, err := lrr.body.ReadByte()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
// Body is empty, which might be valid for some non-204 responses.
|
|
trcLog.Msg("http response (empty body)")
|
|
} else {
|
|
// Other error reading the body. Wrap the original error for context.
|
|
trcLog.Err(fmt.Errorf("error reading response body: %w", err)).Send()
|
|
}
|
|
return // No further body processing if there was an error or it was empty
|
|
}
|
|
lrr.body.UnreadByte() // Put the byte back for Bytes() to read
|
|
|
|
if firstByte == '{' {
|
|
trcLog = trcLog.RawJSON("response", lrr.body.Bytes())
|
|
} else {
|
|
trcLog = trcLog.Bytes("response", lrr.body.Bytes())
|
|
}
|
|
trcLog.Msg("http response")
|
|
})
|
|
}
|
|
|
|
// Flush implements the http.Flusher interface to allow flushing buffered data.
|
|
func (w *LoggingResponseWriter) Flush() {
|
|
if flusher, ok := w.ResponseWriter.(http.Flusher); ok {
|
|
flusher.Flush()
|
|
}
|
|
}
|
|
|
|
func (w *LoggingResponseWriter) WriteHeader(code int) {
|
|
w.statusCode = code
|
|
w.ResponseWriter.WriteHeader(code)
|
|
}
|
|
|
|
func (w *LoggingResponseWriter) Write(b []byte) (int, error) {
|
|
w.body.Write(b)
|
|
return w.ResponseWriter.Write(b)
|
|
}
|
|
|
|
func newLoggingResponseWriter(w http.ResponseWriter) *LoggingResponseWriter {
|
|
return &LoggingResponseWriter{
|
|
ResponseWriter: w, statusCode: http.StatusOK, body: bytes.NewBuffer(nil),
|
|
}
|
|
}
|