backend/middleware: add logger per request instance using AttachLogger

middleware

Author: hengadev

backend/cmd/leviosa/logger.go

@@ -7,14 +7,14 @@ import (
 	"github.com/hengadev/leviosa/pkg/serverutil/logger"
 )
 
-func setLogger() (*slog.Logger, error) {
+// func setLogger() (*slog.Logger, error) {
+func setLogger() (slog.Handler, error) {
 	if err := logger.SetOptions(opts.mode, &opts.logger.level, &opts.logger.style); err != nil {
 		return nil, fmt.Errorf("set logger options: %w", err)
 	}
 	slogHandler, err := logger.SetHandler(opts.logger.level, opts.logger.style)
 	if err != nil {
 		return nil, fmt.Errorf("create logger handler: %w", err)
 	}
-	logger := slog.New(slogHandler)
-	return logger, nil
+	return slogHandler, nil
 }

backend/cmd/leviosa/run.go

@@ -4,13 +4,15 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
 	"os/signal"
 	"syscall"
 
 	// api
 	"github.com/hengadev/leviosa/internal/server"
 	"github.com/hengadev/leviosa/internal/server/app"
+
 	// "github.com/hengadev/leviosa/internal/server/cron"
 	"github.com/hengadev/leviosa/pkg/config"
 	"github.com/hengadev/leviosa/pkg/flags"
@@ -43,8 +45,9 @@ func run(ctx context.Context, w io.Writer) error {
 	if err := setupEnvVars(); err != nil {
 		return fmt.Errorf("failed to get env variables: %w", err)
 	}
+
 	// set logger
-	logger, err := setLogger()
+	slogHandler, err := setLogger()
 	if err != nil {
 		return fmt.Errorf("failed to setup logger: %w", err)
 	}
@@ -73,7 +76,8 @@ func run(ctx context.Context, w io.Writer) error {
 	appCtx := app.New(&appSvcs, &appRepos)
 	srv := server.New(
 		appCtx,
-		logger,
+		opts.mode,
+		slogHandler,
 		server.WithPort(opts.server.port),
 	)
 	var srvErrCh = make(chan error)
@@ -88,7 +92,7 @@ func run(ctx context.Context, w io.Writer) error {
 	// }()
 
 	go func() {
-		logger.Info(fmt.Sprintf("Running server on port %d...", opts.server.port))
+		slog.InfoContext(ctx, fmt.Sprintf("Server running on port %d.", opts.server.port))
 		if err := srv.ListenAndServe(); err != nil {
 			srvErrCh <- fmt.Errorf("launch server: %w", err)
 			return

backend/internal/server/middleware/logging.go

@@ -6,24 +6,40 @@ import (
 	"math/rand"
 	"net/http"
 	"os"
+	"slices"
 	"time"
 
 	"github.com/hengadev/leviosa/pkg/contextutil"
 	"github.com/hengadev/leviosa/pkg/domainutil"
+	mode "github.com/hengadev/leviosa/pkg/flags"
 )
 
-func AttachLogger(logger *slog.Logger) func(http.Handler) http.Handler {
+func AttachLogger(env mode.EnvMode, slogHandler slog.Handler) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			skipLogging := []string{
+				"/healthz",
+			}
+			if slices.Contains(skipLogging, r.URL.Path) {
+				next.ServeHTTP(w, r)
+				return
+			}
 			ctx := r.Context()
-			start := time.Now()
 
 			requestID := rand.Int63()
 
 			// I just make a fake IP for now, I know my function to work:
-			IP := "127.0.0.1"
-			// TODO: use the getCgetClientIP function instead
-			// IP := r.Header.Get("X-Client-IP")
+			var IP string
+			switch env {
+			case mode.ModeDev:
+				IP = "127.0.0.1"
+			case mode.ModeStaging, mode.ModeProd:
+				// TODO: fix that one later with getting the right header for the IP address
+				header := r.Header
+				_ = header
+				IP = "127.0.0.1"
+			}
+
 			if IP == "" {
 				slog.ErrorContext(ctx, "client IP not found with required header")
 				http.Error(w, "Cannot determine Client IP", http.StatusBadRequest)
@@ -32,13 +48,15 @@ func AttachLogger(logger *slog.Logger) func(http.Handler) http.Handler {
 
 			loggingSalt := os.Getenv("LOGGING_SALT")
 			if loggingSalt == "" {
-				slog.ErrorContext(ctx, "logging salt not found in environment variables")
+				slog.ErrorContext(ctx, "LOGGING_SALT not found in environment variables")
 				http.Error(w, "Missing environment variable: LOGGING_SALT", http.StatusInternalServerError)
 				return
 			}
 
 			hashedIP := domainutil.HashWithSalt(IP, loggingSalt)
 
+			logger := slog.New(slogHandler)
+
 			logger = logger.With(
 				"method", r.Method,
 				"URL", r.URL.String(),
@@ -49,7 +67,7 @@ func AttachLogger(logger *slog.Logger) func(http.Handler) http.Handler {
 			ctx = context.WithValue(r.Context(), contextutil.LoggerKey, logger)
 
 			logger.InfoContext(ctx, "Request started")
-
+			start := time.Now()
 			next.ServeHTTP(w, r.WithContext(ctx))
 			duration := time.Since(start)
 			logger.InfoContext(ctx, "Request completed", "duration", duration)

backend/internal/server/middleware/rate_limiter.go

@@ -2,7 +2,7 @@ package middleware
 
 import (
 	"fmt"
-	"net"
+	// "net"
 	"net/http"
 	"os"
 
@@ -68,14 +68,14 @@ func PerIPRateLimit(lim, burst int) Middleware {
 	}
 }
 
-// getClientIP retrieves the client IP set in the custom header 'X-Client-IP'. It returns an empty string if the IP address sent is invalid, unknown or could ne be parsed.
-func getClientIP(r *http.Request) string {
-	clientIP := r.Header.Get("X-Client-IP")
-	if clientIP == "" || clientIP == "unknown" {
-		return ""
-	}
-	if ip := net.ParseIP(clientIP); ip == nil {
-		return ""
-	}
-	return clientIP
-}
+// // getClientIP retrieves the client IP set in the custom header 'X-Client-IP'. It returns an empty string if the IP address sent is invalid, unknown or could ne be parsed.
+// func getClientIP(r *http.Request) string {
+// 	clientIP := r.Header.Get("X-Client-IP")
+// 	if clientIP == "" || clientIP == "unknown" {
+// 		return ""
+// 	}
+// 	if ip := net.ParseIP(clientIP); ip == nil {
+// 		return ""
+// 	}
+// 	return clientIP
+// }

backend/internal/server/middleware/user_context.go

@@ -15,13 +15,6 @@ func SetUserContext(sessionGetter sessionGetterFunc) func(http.Handler) http.Han
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			ctx := r.Context()
 
-			logger, ok := ctx.Value(contextutil.LoggerKey).(*slog.Logger)
-			if !ok {
-				slog.ErrorContext(ctx, "logger not found in context")
-				http.Error(w, "logger not found in context", http.StatusInternalServerError)
-				return
-			}
-
 			exceptPath := []string{
 				"/healthz",
 				"/user/register",
@@ -35,6 +28,13 @@ func SetUserContext(sessionGetter sessionGetterFunc) func(http.Handler) http.Han
 				return
 			}
 
+			logger, ok := ctx.Value(contextutil.LoggerKey).(*slog.Logger)
+			if !ok {
+				slog.ErrorContext(ctx, "logger not found in context")
+				http.Error(w, "logger not found in context", http.StatusInternalServerError)
+				return
+			}
+
 			// get session ID from request
 			sessionID, err := getSessionIDFromRequest(r)
 			if err != nil {

backend/internal/server/routes.go

@@ -82,8 +82,7 @@ func (s *Server) addRoutes(h *app.App) {
 // TODO: how can I make groups for that thing and make sure that I can add as much middleware to a group as I want ?
 
 func healthz(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(http.StatusOK)
-	fmt.Fprintln(w, "OK")
+	w.Write([]byte("OK"))
 }
 
 func handleImage(w http.ResponseWriter, r *http.Request) {

backend/internal/server/server.go

@@ -8,13 +8,20 @@ import (
 
 	"github.com/hengadev/leviosa/internal/server/app"
 	mw "github.com/hengadev/leviosa/internal/server/middleware"
+	mode "github.com/hengadev/leviosa/pkg/flags"
 )
 
 type Server struct {
 	srv *http.Server
 }
 
-func New(appCtx *app.App, logger *slog.Logger, opts ...ServerOption) *Server {
+func New(
+	appCtx *app.App,
+	env mode.EnvMode,
+	slogHandler slog.Handler,
+	opts ...ServerOption,
+) *Server {
+
 	// build server with default options.
 	server := &Server{
 		srv: &http.Server{
@@ -37,7 +44,7 @@ func New(appCtx *app.App, logger *slog.Logger, opts ...ServerOption) *Server {
 	// add middlewares common to all routes. [Order important]
 	server.Use(
 		mw.SetUserContext(appCtx.Svcs.Session.GetSession),
-		mw.AttachLogger(logger),
+		mw.AttachLogger(env, slogHandler),
 		mw.SetOrigin,
 	)
 	return server

compose.yaml

@@ -54,6 +54,7 @@ services:
       interval: 30s
       timeout: 10s
       retries: 3
+      start_period: 10s
 
   redis:
     image: redis:latest