Initial Commitv0.1.0

1 files changed, 134 insertions, 0 deletions

diff --git a/logging/http/http.go b/logging/http/http.go
new file mode 100644
index 0000000..b88ae3a
--- /dev/null
+++ b/logging/http/http.go
@@ -0,0 +1,134 @@
+// Package http provides HTTP middleware and utilities, including request logging using slog.
+//
+// The LoggingHandler middleware logs HTTP request details, response status, bytes written,
+// and handles panics gracefully with stack trace logging.
+
+package http
+
+import (
+	"bufio"
+	"log/slog"
+	"net"
+	"net/http"
+	"time"
+
+	"go.sudomsg.com/kit/logging"
+)
+
+type tracingWriter struct {
+	http.ResponseWriter
+	StatusCode   int
+	BytesWritten int
+	Hijacked     bool
+}
+
+var (
+	_ http.ResponseWriter                       = &tracingWriter{}
+	_ http.Flusher                              = &tracingWriter{}
+	_ http.Hijacker                             = &tracingWriter{}
+	_ interface{ Unwrap() http.ResponseWriter } = &tracingWriter{}
+)
+
+func (tw *tracingWriter) WriteHeader(code int) {
+	tw.ResponseWriter.WriteHeader(code)
+	tw.StatusCode = code
+}
+
+func (tw *tracingWriter) Write(b []byte) (int, error) {
+	if tw.StatusCode == 0 {
+		tw.WriteHeader(http.StatusOK)
+	}
+	n, err := tw.ResponseWriter.Write(b)
+	tw.BytesWritten += n
+	return n, err
+}
+
+func (tw *tracingWriter) Flush() {
+	rc := http.NewResponseController(tw.ResponseWriter)
+	_ = rc.Flush()
+}
+
+func (tw *tracingWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	rc := http.NewResponseController(tw.ResponseWriter)
+	conn, rw, err := rc.Hijack()
+	if err == nil {
+		tw.Hijacked = true
+	}
+	return conn, rw, err
+}
+
+func (tw *tracingWriter) Unwrap() http.ResponseWriter {
+	return tw.ResponseWriter
+}
+
+// LoggingHandler is an HTTP middleware that logs requests and responses using slog.
+//
+// It recovers panics during request processing, logs them with stack traces,
+// and returns a 500 Internal Server Error if the connection is not hijacked.
+type LoggingHandler struct {
+	next   http.Handler
+	logger *slog.Logger
+}
+
+var _ http.Handler = &LoggingHandler{}
+
+// New creates a new LoggingHandler wrapping the next http.Handler, using the provided slog.Logger.
+//
+// If logger is nil, it attempts to obtain one from the request context.
+func New(next http.Handler, logger *slog.Logger) *LoggingHandler {
+	return &LoggingHandler{
+		next:   next,
+		logger: logger,
+	}
+}
+
+// ServeHTTP implements the http.Handler interface.
+//
+// It logs the HTTP method, path, client IP, protocol, host, user-agent, referer,
+// request latency, response status, and bytes written.
+// It also recovers panics, logs them, and returns HTTP 500 if appropriate.
+func (h *LoggingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	logger := h.logger
+	if logger == nil {
+		logger = logging.FromContext(ctx)
+	}
+
+	logger = logger.With(
+		slog.String("method", r.Method),
+		slog.String("path", r.URL.RequestURI()),
+		slog.String("ip", r.RemoteAddr),
+	)
+	ctx = logging.WithLogger(ctx, logger)
+	r = r.WithContext(ctx)
+
+	tw := &tracingWriter{ResponseWriter: w}
+
+	defer func() {
+		if err := recover(); err != nil {
+			logging.RecoverAndLog(ctx, "http panic", err)
+			if !tw.Hijacked && tw.StatusCode == 0 {
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			}
+		}
+	}()
+
+	start := time.Now()
+
+	h.next.ServeHTTP(tw, r)
+
+	if !tw.Hijacked {
+		latency := time.Since(start)
+
+		logger.LogAttrs(r.Context(), slog.LevelInfo, "HTTP request Handled",
+			slog.String("proto", r.Proto),
+			slog.String("host", r.Host),
+			slog.String("user-agent", r.UserAgent()),
+			slog.String("referer", r.Referer()),
+			slog.Duration("latency", latency),
+			slog.Int("status", tw.StatusCode),
+			slog.Int("bytes", tw.BytesWritten),
+		)
+	}
+}