slog access log

alog := AccessLogMiddleware(func(r *http.Request, status, size int, duration time.Duration) {
	slog.InfoContext(
		r.Context(),
		"access log",
		slog.String("method", r.Method),
		slog.String("url", r.URL.RequestURI()),
		slog.String("user_agent", r.UserAgent()),
		slog.String("remote_addr", r.RemoteAddr),
		slog.String("remote_host", getHost(r.RemoteAddr)),
		slog.String("referer", r.Referer()),
		slog.String("proto", r.Proto),
		slog.Duration("took", duration),
		slog.Int("status_code", status),
		slog.Int("bytes", size),
	)
})

handler := &ContextHandler{slog.NewTextHandler(os.Stdout, nil)}
logger := slog.New(handler)
slog.SetDefault(logger)

func main() {
	handler := &ContextHandler{slog.NewTextHandler(os.Stdout, nil)}
	logger := slog.New(handler)
	slog.SetDefault(logger)

	mux := http.NewServeMux()
	mux.HandleFunc("/ping", pingHandler)

	addr := ":8888"
	slog.Info("starting listening", slog.String("addr", addr))

	alog := AccessLogMiddleware(func(r *http.Request, status, size int, duration time.Duration) {
		slog.InfoContext(
			r.Context(),
			"access log",
			slog.String("method", r.Method),
			slog.String("url", r.URL.RequestURI()),
			slog.String("user_agent", r.UserAgent()),
			slog.String("remote_addr", r.RemoteAddr),
			slog.String("remote_host", getHost(r.RemoteAddr)),
			slog.String("referer", r.Referer()),
			slog.String("proto", r.Proto),
			slog.Duration("took", duration),
			slog.Int("status_code", status),
			slog.Int("bytes", size),
		)
	})
	forwarded := CustomHeaderHandler("x-forwarded-for", "X-Forwarded-For")

	err := http.ListenAndServe(addr, forwarded(alog(mux)))
	if err != nil {
		slog.Error(err.Error())
	}
}


func pingHandler(w http.ResponseWriter, r *http.Request) {
	slog.InfoContext(r.Context(), "test")
	fmt.Fprintf(w, "pong")
}

// AccessLogMiddleware creates http.Handler which logs http requests.
// It measures duration of request. It records response code and response size.
// It also adds correlation ID to the log entry.
func AccessLogMiddleware(f func(r *http.Request, status, size int, duration time.Duration)) func(next http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // start is needed to measure the request duration
			start := time.Now()

            // this writer is needed to record status code and bytes written
			lrw := newLoggingResponseWriter(w)

			correlationID := xid.New().String()

            // we are creating a copy of request's context
			ctx := AppendCtx(r.Context(), slog.String("correlation_id", correlationID))
            // replacing request with updated context
			r = r.WithContext(ctx)

			w.Header().Add("X-Correlation-ID", correlationID)

            // executing f closure in defer so the request will be logged even if the code panics
			defer func() {
				f(r, lrw.statusCode, lrw.bytes, time.Since(start))
			}()

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

type ctxKey string

const slogFields ctxKey = "slog_fields"

// ContextHandler is used to log slog.Attrs added to context.Context
type ContextHandler struct {
	slog.Handler
}

func (h ContextHandler) Handle(ctx context.Context, r slog.Record) error {
	if attrs, ok := ctx.Value(slogFields).([]slog.Attr); ok {
		for _, v := range attrs {
			r.AddAttrs(v)
		}
	}
	return h.Handler.Handle(ctx, r)
}

// AppendCtx returns a copy of context.Context with value named slogFields containing []slog.Attr needed for ContextHandler
func AppendCtx(parent context.Context, attr slog.Attr) context.Context {
	if parent == nil {
		parent = context.Background()
	}

	if v, ok := parent.Value(slogFields).([]slog.Attr); ok {
		v = append(v, attr)
		return context.WithValue(parent, slogFields, v)
	}
	v := []slog.Attr{}
	v = append(v, attr)
	return context.WithValue(parent, slogFields, v)
}