feat: logger_middleware — middleware HTTP con logs estructurados (infra)

Middleware que envuelve cualquier http.Handler y emite un log info por
cada request con method, path, status y duration_ms. Hereda los campos
contextuales del Logger (app, version, request_id...) y se compone con
HTTPMiddlewareChain + HTTPCORSMiddleware.

Diferencia con http_logger_middleware: este escribe JSON estructurado via
slog en vez de texto plano a un io.Writer.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

functions/infra/logger_middleware.go

@@ -0,0 +1,38 @@
+package infra
+
+import (
+	"net/http"
+	"time"
+)
+
+// LoggerMiddleware retorna un Middleware que emite un log estructurado por cada request HTTP.
+// Cada request produce una entrada a nivel info con method, path, status y duration_ms.
+// Respeta los campos contextuales que ya tenga el logger (app, version, request_id...).
+func LoggerMiddleware(logger *Logger) Middleware {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
+			rw := &loggerResponseWriter{ResponseWriter: w, status: http.StatusOK}
+			next.ServeHTTP(rw, r)
+			duration := time.Since(start)
+			LogInfo(logger, "http request",
+				"method", r.Method,
+				"path", r.URL.Path,
+				"status", rw.status,
+				"duration_ms", duration.Milliseconds(),
+			)
+		})
+	}
+}
+
+// loggerResponseWriter captura el status code escrito al ResponseWriter.
+// Nombrado distinto de responseWriter (http_logger_middleware.go) para evitar colision.
+type loggerResponseWriter struct {
+	http.ResponseWriter
+	status int
+}
+
+func (rw *loggerResponseWriter) WriteHeader(status int) {
+	rw.status = status
+	rw.ResponseWriter.WriteHeader(status)
+}

functions/infra/logger_middleware.md

@@ -0,0 +1,43 @@
+---
+name: logger_middleware
+kind: function
+lang: go
+domain: infra
+version: "1.0.0"
+purity: impure
+signature: "func LoggerMiddleware(logger *Logger) Middleware"
+description: "Retorna un Middleware HTTP que emite un log estructurado por cada request. Cada request produce una entrada info con method, path, status y duration_ms. Respeta los campos contextuales del Logger (app, version, request_id...)."
+tags: [logging, log, slog, middleware, http, server, infra]
+uses_functions: [log_info_go_infra]
+uses_types: [Logger_go_infra, Middleware_go_infra]
+returns: [Middleware_go_infra]
+returns_optional: false
+error_type: "error_go_core"
+imports: [net/http, time]
+params:
+  - name: logger
+    desc: "Logger estructurado al que emitir cada request. Hereda los campos contextuales (app, version...)"
+output: "Middleware que loguea cada request HTTP tras su procesamiento"
+tested: true
+tests: ["loguea method, path, status y duration_ms", "usa status 200 si el handler no llama WriteHeader", "preserva los campos contextuales del logger"]
+test_file_path: "functions/infra/logger_test.go"
+file_path: "functions/infra/logger_middleware.go"
+---
+
+## Ejemplo
+
+```go
+base, _ := LoggerNew(LogLevelInfo, os.Stdout, "json")
+appLog := LoggerWith(base, map[string]any{"app": "sqlite_api"})
+
+mux := HTTPRouter(routes)
+chain := HTTPMiddlewareChain(LoggerMiddleware(appLog), HTTPCORSMiddleware([]string{"*"}, []string{"GET"}))
+
+http.ListenAndServe(":8484", chain(mux))
+// Cada request produce:
+// {"time":"...","level":"INFO","msg":"http request","app":"sqlite_api","method":"GET","path":"/health","status":200,"duration_ms":1}
+```
+
+## Notas
+
+Funcion impura — captura el status code con un `loggerResponseWriter` envolvente que intercepta `WriteHeader`. Si el handler no llama `WriteHeader` explicitamente el status por defecto es 200. La duracion se mide desde el inicio del middleware hasta despues de que el handler siguiente termine — incluye el tiempo de los middlewares internos pero no los externos en la cadena. El mensaje emitido es `"http request"` a nivel info para facilitar filtrado via `msg:"http request"` en queries downstream.