Skip to content

Modern Docker Management, Designed for Everyone

feat: migrate logging to json

Kyle Mendellb66afe258028
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index c8880d427..2cdbf3262 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -34,6 +34,13 @@ type App struct {
func InitializeApp() (*App, error) {
ctx := context.Background()
+ {
+ level := new(slog.LevelVar)
+ level.Set(slog.LevelInfo)
+ h := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: level})
+ slog.SetDefault(slog.New(h))
+ }
+
if err := godotenv.Load(); err != nil {
slog.InfoContext(ctx, "No .env file found, using environment variables")
}
diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.go
index c02f97fa9..23fe7e509 100644
--- a/backend/internal/bootstrap/router_bootstrap.go
+++ b/backend/internal/bootstrap/router_bootstrap.go
@@ -18,7 +18,8 @@ func setupRouter(cfg *config.Config, appServices *api.Services) *gin.Engine {
} else {
gin.SetMode(gin.DebugMode)
}
- router := gin.Default()
+ router := gin.New()
+ router.Use(gin.Recovery())
router.Use(middleware.SetupCORS(cfg))
loggingMiddleware := middleware.LoggingMiddleware(
diff --git a/backend/internal/database/database.go b/backend/internal/database/database.go
index 1552121eb..4344e419a 100644
--- a/backend/internal/database/database.go
+++ b/backend/internal/database/database.go
@@ -3,7 +3,6 @@ package database
import (
"errors"
"fmt"
- "log"
"log/slog"
"net/url"
"os"
@@ -260,25 +259,18 @@ func parseSqliteConnectionString(connString string) (string, error) {
}
func getLogger(environment string) logger.Interface {
- var logLevel logger.LogLevel
+ var lvl logger.LogLevel
switch environment {
case "development":
- logLevel = logger.Info
+ lvl = logger.Info
case "production":
- logLevel = logger.Silent
+ // Be quiet in prod by default; change to Warn for some visibility
+ lvl = logger.Warn
default:
- logLevel = logger.Warn
+ lvl = logger.Warn
}
- return logger.New(
- log.New(os.Stdout, "\r\n", log.LstdFlags),
- logger.Config{
- SlowThreshold: 200 * time.Millisecond,
- LogLevel: logLevel,
- IgnoreRecordNotFoundError: true,
- Colorful: environment == "development",
- },
- )
+ return newSlogGormLogger(lvl, 200*time.Millisecond, true)
}
func (db *DB) Close() error {
diff --git a/backend/internal/middleware/logging.go b/backend/internal/middleware/logging.go
index 5759d9710..d0312d67b 100644
--- a/backend/internal/middleware/logging.go
+++ b/backend/internal/middleware/logging.go
@@ -1,17 +1,81 @@
package middleware
import (
+ "log/slog"
+ "path"
+ "time"
+
"github.com/gin-gonic/gin"
)
-// LoggingMiddleware creates a custom logging middleware that excludes certain paths
-func LoggingMiddleware(excludePaths ...string) gin.HandlerFunc {
- excluded := make(map[string]bool)
- for _, path := range excludePaths {
- excluded[path] = true
+// matchesExcluded checks if the given request path matches any of the exclude patterns.
+// Patterns can include '*' wildcards for path segments (e.g., "/api/containers/*/stats/stream").
+func matchesExcluded(p string, patterns []string) bool {
+ for _, pat := range patterns {
+ if pat == "" {
+ continue
+ }
+ if pat == p {
+ return true
+ }
+ if ok, err := path.Match(pat, p); err == nil && ok {
+ return true
+ }
}
+ return false
+}
+
+// LoggingMiddleware is a JSON slog-based request logger with robust path ignoring.
+func LoggingMiddleware(excludePatterns ...string) gin.HandlerFunc {
+ return func(c *gin.Context) {
+ reqPath := c.Request.URL.Path
+ if matchesExcluded(reqPath, excludePatterns) {
+ // Skip logging entirely for excluded paths
+ c.Next()
+ return
+ }
+
+ start := time.Now()
+ c.Next()
- return gin.LoggerWithConfig(gin.LoggerConfig{
- SkipPaths: excludePaths,
- })
+ latency := time.Since(start)
+ status := c.Writer.Status()
+ size := c.Writer.Size()
+ method := c.Request.Method
+ ip := c.ClientIP()
+ ua := c.Request.UserAgent()
+ query := c.Request.URL.RawQuery
+ msg := "HTTP request"
+
+ // Log errors as error level if any were recorded in the context
+ if len(c.Errors) > 0 || status >= 500 {
+ slog.ErrorContext(
+ c.Request.Context(),
+ msg,
+ slog.Int("status", status),
+ slog.String("method", method),
+ slog.String("path", reqPath),
+ slog.String("query", query),
+ slog.String("ip", ip),
+ slog.String("user_agent", ua),
+ slog.Duration("latency", latency),
+ slog.Int("bytes_out", size),
+ slog.String("errors", c.Errors.String()),
+ )
+ return
+ }
+
+ slog.InfoContext(
+ c.Request.Context(),
+ msg,
+ slog.Int("status", status),
+ slog.String("method", method),
+ slog.String("path", reqPath),
+ slog.String("query", query),
+ slog.String("ip", ip),
+ slog.String("user_agent", ua),
+ slog.Duration("latency", latency),
+ slog.Int("bytes_out", size),
+ )
+ }
}