From cad24bb5f1367787999a8e20e16d863802c7b0db Mon Sep 17 00:00:00 2001 From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com> Date: Tue, 20 Oct 2026 17:18:36 +0000 Subject: [PATCH] Update module github.com/ziflex/lecho/v3 to v4 --- go.mod | 3 +- go.sum | 3 + vendor/github.com/rs/zerolog/.gitignore | 4 +- vendor/github.com/ziflex/lecho/v3/README.md | 541 +++--------------- vendor/github.com/ziflex/lecho/v3/levels.go | 13 - .../github.com/ziflex/lecho/v3/middleware.go | 80 +-- vendor/github.com/ziflex/lecho/v3/options.go | 3 +- vendor/modules.txt | 6 +- 8 files changed, 127 insertions(+), 526 deletions(-) diff --git a/go.mod b/go.mod index b2d77df8..058d29a9 100644 --- a/go.mod +++ b/go.mod @@ -25,7 +25,8 @@ require ( github.com/stretchr/testify v1.12.1 github.com/swaggo/echo-swagger v1.5.2 github.com/swaggo/swag v1.16.6 - github.com/ziflex/lecho/v3 v3.11.1 + github.com/ziflex/lecho/v3 v3.8.0 + github.com/ziflex/lecho/v4 v4.0.0 go.etcd.io/bbolt v1.5.0 golang.org/x/exp v0.0.0-20261007192929-f45ad48fbe92 golang.org/x/net v0.60.0 diff --git a/go.sum b/go.sum index ea465369..001c056e 100644 --- a/go.sum +++ b/go.sum @@ -203,8 +203,11 @@ github.com/valyala/histogram v1.2.0 h1:wyYGAZZt3CpwUiIb9AU/Zbllg1llXyrtApRS815OL github.com/valyala/histogram v1.2.0/go.mod h1:Hb4kBwb4UxsaNbbbh+RRz8ZR6pdodR57tzWUS3BUzXY= github.com/yuin/goldmark v1.8.6 h1:d0VcaP1sx9GkFVkoW+KtggpGi2KZ965i14b0+bDQST4= github.com/yuin/goldmark v1.8.6/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= +github.com/ziflex/lecho/v3 v3.8.0 h1:de/IyTw5jykpb0GKGk7Di5Y6IeeLpr2PdEBvTvsktD0= +github.com/ziflex/lecho/v3 v3.8.0/go.mod h1:2GzFCQn/W809nLzikFiHkubtU08QRXyE6+VQ9nAhHPE= github.com/ziflex/lecho/v3 v3.11.1 h1:v1YL7JQz8no2u51L55/0qhfUBET+Bhmmp17/RYnWoD4= github.com/ziflex/lecho/v3 v3.11.1/go.mod h1:8IDTHsPyFnP0BtzWfkwqezXgMiXBnIIV04+fuGZWi/Y= +github.com/ziflex/lecho/v4 v4.0.0/go.mod h1:rlckz1b3puHLJ9AX3fDGV2cG5MJ3snBTWKmNxdGDyeQ= go.etcd.io/bbolt v1.5.0 h1:S7GAl7Fxv12yohbwFfIbQCGDWbQbtDGPET4P/bD4lxU= go.etcd.io/bbolt v1.5.0/go.mod h1:mkltfYE5aUHQxUct9N9V+Kp7aSjFqjgrhcXIS70Lrdk= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= diff --git a/vendor/github.com/rs/zerolog/.gitignore b/vendor/github.com/rs/zerolog/.gitignore index c3622a0a..1a2fc214 100644 --- a/vendor/github.com/rs/zerolog/.gitignore +++ b/vendor/github.com/rs/zerolog/.gitignore @@ -23,5 +23,5 @@ _testmain.go *.exe *.test *.prof - -coverage.out + +coverage.out diff --git a/vendor/github.com/ziflex/lecho/v3/README.md b/vendor/github.com/ziflex/lecho/v3/README.md index 93c0f672..f5599e4e 100644 --- a/vendor/github.com/ziflex/lecho/v3/README.md +++ b/vendor/github.com/ziflex/lecho/v3/README.md @@ -1,549 +1,194 @@ # lecho :tomato: -A high-performance [Zerolog](https://github.com/rs/zerolog) wrapper for [Echo](https://echo.labstack.com/) web framework that provides structured logging with minimal overhead. - -## Features - -- 🚀 **High Performance** - Built on top of zerolog, one of the fastest structured loggers for Go -- 📊 **Structured Logging** - JSON formatted logs with rich contextual information -- 🔗 **Request Correlation** - Automatic request ID tracking and context propagation -- ⚡ **Low Latency** - Minimal overhead request/response logging -- 🛠 **Highly Configurable** - Extensive middleware configuration options -- 🔍 **Request Enrichment** - Add custom fields based on request context -- 📈 **Performance Monitoring** - Built-in slow request detection and alerting - -## Table of Contents - -- [Installation](#installation) -- [Quick Start](#quick-start) -- [Configuration Options](#options) -- [Middleware](#middleware) -- [Helpers](#helpers) -- [Advanced Configuration](#advanced-configuration) +[Zerolog](https://github.com/rs/zerolog) wrapper for [Echo](https://echo.labstack.com/) web framework. ## Installation -Install lecho based on your Echo version: +For Echo v4: -**For Echo v4 (recommended):** -```bash +``` go get github.com/ziflex/lecho/v3 ``` -**For Echo v3 (legacy):** -```bash +For Echo v3: + +``` go get github.com/ziflex/lecho ``` -## Quick Start - -### Basic Usage - -Replace Echo's default logger with lecho for structured logging: +## Quick start ```go -package main +package main import ( "os" "github.com/labstack/echo/v4" + "github.com/labstack/echo/v4/middleware" "github.com/ziflex/lecho/v3" ) func main() { - e := echo.New() - e.Logger = lecho.New(os.Stdout) - - // Your routes and middleware here - e.Start(":8080") + e := echo.New() + e.Logger = lecho.New(os.Stdout) } ``` -### Using Existing Zerolog Instance - -If you already have a zerolog logger configured, you can wrap it with lecho: +### Using existing zerolog instance ```go -package main +package main import ( "os" "github.com/labstack/echo/v4" - "github.com/rs/zerolog" + "github.com/labstack/echo/v4/middleware" "github.com/ziflex/lecho/v3" + "github.com/rs/zerolog" ) func main() { - // Configure your zerolog instance - log := zerolog.New(os.Stdout).With().Timestamp().Logger() - - e := echo.New() - e.Logger = lecho.From(log) - - e.Start(":8080") + log := zerolog.New(os.Stdout) + e := echo.New() + e.Logger = lecho.From(log) } + ``` ## Options -Lecho provides several configuration options to customize logging behavior: - ```go -package main import ( - "os" - "github.com/labstack/echo/v4" - "github.com/labstack/gommon/log" + "os", + "github.com/labstack/echo" + "github.com/labstack/echo/middleware" "github.com/ziflex/lecho/v3" ) func main() { - e := echo.New() - e.Logger = lecho.New( - os.Stdout, - lecho.WithLevel(log.DEBUG), // Set log level - lecho.WithFields(map[string]interface{}{"service": "api"}), // Add default fields - lecho.WithTimestamp(), // Add timestamp to logs - lecho.WithCaller(), // Add caller information - lecho.WithPrefix("MyApp"), // Add a prefix to logs - // lecho.WithHook(myHook), // Add custom hooks - // lecho.WithHookFunc(myHookFunc), // Add hook functions - ) - - e.Start(":8080") + e := echo.New() + e.Logger = lecho.New( + os.Stdout, + lecho.WithLevel(log.DEBUG), + lecho.WithFields(map[string]interface{}{ "name": "lecho factory"}), + lecho.WithTimestamp(), + lecho.WithCaller(), + lecho.WithPrefix("we ❤️ lecho"), + lecho.WithHook(...), + lecho.WithHookFunc(...), + ) } ``` -### Available Options - -- **`WithLevel(level log.Lvl)`** - Set the minimum log level (DEBUG, INFO, WARN, ERROR, OFF) -- **`WithFields(fields map[string]interface{})`** - Add default fields to all log entries -- **`WithField(key string, value interface{})`** - Add a single default field -- **`WithTimestamp()`** - Include timestamp in log entries -- **`WithCaller()`** - Include caller file and line information -- **`WithCallerWithSkipFrameCount(count int)`** - Include caller info with custom skip frame count -- **`WithPrefix(prefix string)`** - Add a prefix field to all log entries -- **`WithHook(hook zerolog.Hook)`** - Add a custom zerolog hook -- **`WithHookFunc(hookFunc zerolog.HookFunc)`** - Add a custom hook function - ## Middleware -The lecho middleware provides automatic request logging with rich contextual information. It integrates seamlessly with Echo's request lifecycle and supports various customization options. - -### Basic Request Logging +### Logging requests and attaching request id to a context logger ```go -package main import ( - "net/http" - "os" - "github.com/labstack/echo/v4" - "github.com/labstack/echo/v4/middleware" - "github.com/labstack/gommon/log" - "github.com/rs/zerolog" + "os", + "github.com/labstack/echo" + "github.com/labstack/echo/middleware" "github.com/ziflex/lecho/v3" -) - -func main() { - e := echo.New() - - // Create and configure logger - logger := lecho.New( - os.Stdout, - lecho.WithLevel(log.DEBUG), - lecho.WithTimestamp(), - lecho.WithCaller(), - ) - e.Logger = logger - - // Add request ID middleware (optional but recommended) - e.Use(middleware.RequestID()) - - // Add lecho middleware for request logging - e.Use(lecho.Middleware(lecho.Config{ - Logger: logger, - })) - - // Example route - e.GET("/", func(c echo.Context) error { - // Log using Echo's logger interface - c.Logger().Info("Processing request") - - // Or use zerolog directly from context - zerolog.Ctx(c.Request().Context()).Info().Msg("Using zerolog interface") - - return c.String(http.StatusOK, "Hello, World!") - }) - - e.Start(":8080") -} -``` - -**Sample output:** -```json -{"level":"info","id":"123e4567-e89b-12d3-a456-426614174000","remote_ip":"127.0.0.1","host":"localhost:8080","method":"GET","uri":"/","user_agent":"curl/7.68.0","status":200,"referer":"","latency":1.234,"latency_human":"1.234ms","bytes_in":"0","bytes_out":"13","time":"2023-10-15T10:30:00Z"} -``` - -### Escalate Log Level for Slow Requests - -Monitor and highlight slow requests by logging them at a higher level when they exceed a specified duration: - -```go -package main - -import ( - "os" - "time" - "github.com/labstack/echo/v4" "github.com/rs/zerolog" - "github.com/ziflex/lecho/v3" ) func main() { - e := echo.New() - logger := lecho.New(os.Stdout, lecho.WithTimestamp()) - - e.Use(lecho.Middleware(lecho.Config{ - Logger: logger, - RequestLatencyLevel: zerolog.WarnLevel, // Log level for slow requests - RequestLatencyLimit: 500 * time.Millisecond, // Threshold for slow requests - })) + e := echo.New() + logger := lecho.New( + os.Stdout, + lecho.WithLevel(log.DEBUG), + lecho.WithTimestamp(), + lecho.WithCaller(), + ) + e.Logger = logger + + e.Use(middleware.RequestID()) + e.Use(lecho.Middleware(lecho.Config{ + Logger: logger + })) + e.GET("/", func(c echo.Context) error { + c.Logger().Print("Echo interface") + zerolog.Ctx(c.Request().Context()).Print("Zerolog interface") - // Requests taking longer than 500ms will be logged at WARN level - // instead of the default INFO level + return c.String(http.StatusOK, "Hello, World!") + }) } -``` -**Output for slow request:** -```json -{"level":"warn","remote_ip":"127.0.0.1","method":"GET","uri":"/slow","status":200,"latency":750.123,"latency_human":"750.123ms","time":"2023-10-15T10:30:00Z"} ``` - -### Nesting Under a Sub Dictionary - -Organize request information under a nested key for better log structure: - +### Escalate log level for slow requests: ```go -package main - -import ( - "os" - "github.com/labstack/echo/v4" - "github.com/ziflex/lecho/v3" -) - -func main() { - e := echo.New() - logger := lecho.New(os.Stdout, lecho.WithTimestamp()) - - e.Use(lecho.Middleware(lecho.Config{ - Logger: logger, - NestKey: "request", // Nest all request info under this key - })) - - // All request-related fields will be nested under "request" -} -``` - -**Sample output:** -```json -{"level":"info","request":{"remote_ip":"127.0.0.1","method":"GET","uri":"/api/users","status":200,"latency":15.234,"latency_human":"15.234ms"},"time":"2023-10-15T10:30:00Z"} +e.Use(lecho.Middleware(lecho.Config{ + Logger: logger, + RequestLatencyLevel: zerolog.WarnLevel, + RequestLatencyLimit: 500 * time.Millisecond, +})) ``` -### Enricher -The Enricher function allows you to add custom fields to log entries based on request context. This is useful for adding user IDs, trace IDs, or other contextual information: +### Nesting under a sub dictionary ```go -package main - -import ( - "os" - "github.com/labstack/echo/v4" - "github.com/rs/zerolog" - "github.com/ziflex/lecho/v3" -) - -func main() { - e := echo.New() - logger := lecho.New(os.Stdout, lecho.WithTimestamp()) - - e.Use(lecho.Middleware(lecho.Config{ - Logger: logger, - Enricher: func(c echo.Context, logger zerolog.Context) zerolog.Context { - // Add user ID if available in context - if userID := c.Get("user_id"); userID != nil { - logger = logger.Str("user_id", userID.(string)) - } - - // Add trace ID from header - if traceID := c.Request().Header.Get("X-Trace-ID"); traceID != "" { - logger = logger.Str("trace_id", traceID) - } - - return logger - }, - })) - - // Set up routes that use user context - e.GET("/api/profile", func(c echo.Context) error { - c.Set("user_id", "user123") // This will be logged - return c.JSON(200, map[string]string{"status": "ok"}) - }) -} +e.Use(lecho.Middleware(lecho.Config{ + Logger: logger, + NestKey: "request" + })) + // Output: {"level":"info","request":{"remote_ip":"5.6.7.8","method":"GET", ...}, ...} ``` -#### AfterNextEnricher +### Enricher -The `AfterNextEnricher` function allows you to add custom fields to log entries after the next handler has executed. This is useful for adding fields that depend on the outcome of the request processing, such as response status or values set during request handling. +Enricher allows you to add additional fields to the log entry. ```go -package main - -import ( - "os" - "github.com/labstack/echo/v4" - "github.com/rs/zerolog" - "github.com/ziflex/lecho/v3" -) - -func main() { - e := echo.New() - logger := lecho.New(os.Stdout, lecho.WithTimestamp()) - - e.Use(lecho.Middleware(lecho.Config{ +e.Use(lecho.Middleware(lecho.Config{ Logger: logger, - AfterNextEnricher: func(c echo.Context, logger zerolog.Context) zerolog.Context { - // Add response status code after the handler has executed - logger = logger.Int("status", c.Response().Status) - return logger + Enricher: func(c echo.Context, logger zerolog.Context) zerolog.Context { + return e.Str("user_id", c.Get("user_id")) }, })) - - e.GET("/api/profile", func(c echo.Context) error { - c.Set("user_id", "user123") // This will be logged - return c.JSON(200, map[string]string{"status": "ok"}) - }) -} -``` - -**Sample output:** -```json -{"level":"info","user_id":"user123","trace_id":"abc-def-123","remote_ip":"127.0.0.1","method":"GET","uri":"/api/profile","status":200,"time":"2023-10-15T10:30:00Z"} + // Output: {"level":"info","user_id":"123", ...} ``` -### Error Handling - -Control how errors are handled in the middleware chain. By default, lecho logs errors but doesn't propagate them to Echo's error handler: - -```go -package main - -import ( - "errors" - "net/http" - "os" - "github.com/labstack/echo/v4" - "github.com/ziflex/lecho/v3" -) - -func main() { - e := echo.New() - logger := lecho.New(os.Stdout, lecho.WithTimestamp()) - - // Configure error handling - e.Use(lecho.Middleware(lecho.Config{ - Logger: logger, - HandleError: true, // Propagate errors to Echo's error handler - })) - - // Custom error handler - e.HTTPErrorHandler = func(err error, c echo.Context) { - code := http.StatusInternalServerError - if he, ok := err.(*echo.HTTPError); ok { - code = he.Code - } - c.JSON(code, map[string]string{"error": err.Error()}) - } - - // Route that may return an error - e.GET("/error", func(c echo.Context) error { - return errors.New("something went wrong") - }) -} -``` - -**With `HandleError: false` (default):** Errors are logged but not propagated to Echo's error handler. -**With `HandleError: true`:** Errors are both logged and passed to Echo's error handler for proper HTTP response handling. - -### Skipping Built-in Request Fields - -Use `SkipDefaultFields` when you want full control over which request attributes are emitted, for example when you need to log OpenTelemetry-style field names instead of lecho's built-in keys. +### Errors +Since lecho v3.4.0, the middleware does not automatically propagate errors up the chain. +If you want to do that, you can set `HandleError` to ``true``. ```go e.Use(lecho.Middleware(lecho.Config{ - Logger: logger, - SkipDefaultFields: true, - Enricher: func(c echo.Context, logger zerolog.Context) zerolog.Context { - return logger. - Str("http.request.method", c.Request().Method). - Str("url.path", c.Request().URL.Path) - }, + Logger: logger, + HandleError: true, })) ``` -When `SkipDefaultFields` is enabled: - -- built-in request fields such as `method`, `status`, `latency`, and `bytes_out` are not added automatically -- `RequestIDHeader` / `RequestIDKey` are ignored -- `NestKey` is ignored because only built-in fields can be nested -- at least one of `Enricher` or `AfterNextEnricher` must be configured - -### Middleware Configuration Options - -The `lecho.Config` struct provides extensive customization options: - -| Option | Type | Description | Default | -|--------|------|-------------|---------| -| `Logger` | `*lecho.Logger` | Custom logger instance | `lecho.New(os.Stdout, WithTimestamp())` | -| `Skipper` | `middleware.Skipper` | Function to skip middleware | `middleware.DefaultSkipper` | -| `AfterNextSkipper` | `middleware.Skipper` | Skip logging after handler execution | `middleware.DefaultSkipper` | -| `BeforeNext` | `middleware.BeforeFunc` | Function executed before next handler | `nil` | -| `Enricher` | `lecho.Enricher` | Function to add custom fields | `nil` | -| `AfterNextEnricher` | `lecho.Enricher` | Function to add custom fields after the next handler runs; invoked only if `AfterNextSkipper` returns false | `nil` | -| `RequestIDHeader` | `string` | Header name for request ID; used only if `SkipDefaultFields` is set to `false` | `"X-Request-ID"` | -| `RequestIDKey` | `string` | JSON key for request ID in logs; used only if `SkipDefaultFields` is set to `false` | `"id"` | -| `NestKey` | `string` | Key for nesting request fields. Will only affect built-in fields (`SkipDefaultFields` is set to `false`) | `""` (no nesting) | -| `HandleError` | `bool` | Propagate errors to error handler | `false` | -| `RequestLatencyLimit` | `time.Duration` | Threshold for slow request detection | `0` (disabled) | -| `RequestLatencyLevel` | `zerolog.Level` | Log level for slow requests | `zerolog.InfoLevel` | -| `SkipDefaultFields` | `bool` | Disable built-in request fields (`remote_ip`, `host`, `method`, `uri`, `user_agent`, `status`, `referer`, `latency`, `bytes_in`, `bytes_out`); only fields added through `Enricher` or `AfterNextEnricher` are logged, and at least one of them must be configured | `false` | - ## Helpers -### Level Converters - -Lecho provides utilities to convert between Echo and Zerolog log levels: +### Level converters ```go -package main import ( - "fmt" - "github.com/labstack/gommon/log" - "github.com/rs/zerolog" - "github.com/ziflex/lecho/v3" + "fmt", + "github.com/labstack/echo" + "github.com/labstack/echo/middleware" + "github.com/labstack/gommon/log" + "github.com/ziflex/lecho/v3" ) func main() { - // Convert Echo log level to Zerolog level - zeroLevel, echoLevel := lecho.MatchEchoLevel(log.WARN) - fmt.Printf("Echo WARN -> Zerolog: %s, Echo: %s\n", zeroLevel, echoLevel) - - // Convert Zerolog level to Echo level - echoLevel2, zeroLevel2 := lecho.MatchZeroLevel(zerolog.InfoLevel) - fmt.Printf("Zerolog INFO -> Echo: %s, Zerolog: %s\n", echoLevel2, zeroLevel2) -} -``` - -### Context Logger Access - -Access the logger from Echo context in your handlers: - -```go -e.GET("/api/users", func(c echo.Context) error { - // Method 1: Using Echo's logger interface - c.Logger().Info("Fetching users") - - // Method 2: Using zerolog directly from request context - zerolog.Ctx(c.Request().Context()).Info().Str("action", "fetch_users").Msg("Processing request") - - // Method 3: If using lecho.Context wrapper - if lechoCtx, ok := c.(*lecho.Context); ok { - lechoCtx.Logger().Info("Using lecho context") - } + var z zerolog.Level + var e log.Lvl - return c.JSON(200, []string{"user1", "user2"}) -}) -``` - -## Advanced Configuration - -### Complete Configuration Example - -```go -package main - -import ( - "net/http" - "os" - "time" - "github.com/labstack/echo/v4" - "github.com/labstack/echo/v4/middleware" - "github.com/labstack/gommon/log" - "github.com/rs/zerolog" - "github.com/ziflex/lecho/v3" -) + z, e = lecho.MatchEchoLevel(log.WARN) + + fmt.Println(z, e) + + e, z = lecho.MatchZeroLevel(zerolog.INFO) -func main() { - e := echo.New() - - // Configure logger with all options - logger := lecho.New( - os.Stdout, - lecho.WithLevel(log.INFO), - lecho.WithTimestamp(), - lecho.WithCaller(), - lecho.WithFields(map[string]interface{}{ - "service": "api", - "version": "1.0.0", - }), - ) - e.Logger = logger - - // Add middleware stack - e.Use(middleware.RequestID()) - e.Use(lecho.Middleware(lecho.Config{ - Logger: logger, - HandleError: true, - RequestLatencyLevel: zerolog.WarnLevel, - RequestLatencyLimit: 200 * time.Millisecond, - NestKey: "http", - Enricher: func(c echo.Context, logger zerolog.Context) zerolog.Context { - if userID := c.Get("user_id"); userID != nil { - logger = logger.Str("user_id", userID.(string)) - } - return logger - }, - AfterNextEnricher: func(c echo.Context, logger zerolog.Context) zerolog.Context { - // Example of adding a field after the next handler runs, based on context value - logger = logger.Interface("some_key", c.Get("some_key")) - return logger - }, - Skipper: func(c echo.Context) bool { - // Skip logging for health check endpoints - return c.Request().URL.Path == "/health" - }, - })) - e.Use(func(next echo.HandlerFunc) echo.HandlerFunc { - return func(c echo.Context) error { - c.Set("some_key", "some_value") // Example of setting context value for after next enricher - return next(c) - } - }) - - e.GET("/health", func(c echo.Context) error { - return c.String(http.StatusOK, "OK") - }) - - e.GET("/api/slow", func(c echo.Context) error { - time.Sleep(300 * time.Millisecond) // Simulates slow operation - return c.JSON(200, map[string]string{"result": "completed"}) - }) - - e.Start(":8080") + fmt.Println(z, e) } + ``` diff --git a/vendor/github.com/ziflex/lecho/v3/levels.go b/vendor/github.com/ziflex/lecho/v3/levels.go index ad505ac8..7787a816 100644 --- a/vendor/github.com/ziflex/lecho/v3/levels.go +++ b/vendor/github.com/ziflex/lecho/v3/levels.go @@ -45,16 +45,3 @@ func MatchZeroLevel(level zerolog.Level) (log.Lvl, zerolog.Level) { return log.OFF, zerolog.NoLevel } - -// GetEffectiveZerologLevel returns the effective level for a zerolog logger, -// considering both the logger's level and the global level -func GetEffectiveZerologLevel(logger zerolog.Logger) zerolog.Level { - loggerLevel := logger.GetLevel() - globalLevel := zerolog.GlobalLevel() - - // The effective level is the maximum (most restrictive) of the two - if loggerLevel > globalLevel { - return loggerLevel - } - return globalLevel -} diff --git a/vendor/github.com/ziflex/lecho/v3/middleware.go b/vendor/github.com/ziflex/lecho/v3/middleware.go index 6892173f..59bbe572 100644 --- a/vendor/github.com/ziflex/lecho/v3/middleware.go +++ b/vendor/github.com/ziflex/lecho/v3/middleware.go @@ -25,13 +25,6 @@ type ( BeforeNext middleware.BeforeFunc // Enricher is a function that can be used to enrich the logger with additional information. Enricher Enricher - // AfterNextEnricher is a function that can be used to enrich the logger with additional information - // after the next handler is called. - // - // This is typically used when you need to log values that are only available after other - // middleware/handlers have run, such as values stored on the echo.Context by previous - // middleware (for example, correlation IDs, user information, or computed response data). - AfterNextEnricher Enricher // RequestIDHeader is the header name to use for the request ID in a log record. RequestIDHeader string // RequestIDKey is the key name to use for the request ID in a log record. @@ -44,19 +37,6 @@ type ( RequestLatencyLimit time.Duration // The level to log at if RequestLatencyLimit is exceeded RequestLatencyLevel zerolog.Level - // SkipDefaultFields controls whether the middleware adds its built-in request fields - // (such as method, path, status, and latency) in addition to the attributes defined by - // the caller or Enricher. When set to true, those built-in request fields are not added - // automatically and must be supplied explicitly. - // Otherwise the logs won't contain any request information. - // This flag also affects request ID injection via RequestIDHeader/RequestIDKey, which will - // also be skipped if this flag is set to 'true'. - // - // If a NestKey is supplied, it will only be used if the flag is set to 'false'. So only - // built-in fields can be nested. - // - // This flag does not affect any fields added by AfterNextEnricher. - SkipDefaultFields bool } // Enricher is a function that can be used to enrich the logger with additional information. @@ -100,10 +80,6 @@ func Middleware(config Config) echo.MiddlewareFunc { config.RequestIDHeader = echo.HeaderXRequestID } - if config.SkipDefaultFields && config.Enricher == nil && config.AfterNextEnricher == nil { - panic("lecho: SkipDefaultFields requires at least one of Enricher or AfterNextEnricher to be set") - } - return func(next echo.HandlerFunc) echo.HandlerFunc { return func(c echo.Context) error { if config.Skipper(c) { @@ -124,7 +100,7 @@ func Middleware(config Config) echo.MiddlewareFunc { cloned := false logger := config.Logger - if id != "" && !config.SkipDefaultFields { + if id != "" { logger = From(logger.log, WithField(config.RequestIDKey, id)) cloned = true } @@ -163,57 +139,45 @@ func Middleware(config Config) echo.MiddlewareFunc { return err } - afterNextLog := logger.log - - if config.AfterNextEnricher != nil { - afterNextLog = config.AfterNextEnricher(c, logger.log.With()).Logger() - } - stop := time.Now() latency := stop.Sub(start) - var mainEvt *zerolog.Event if err != nil { - mainEvt = afterNextLog.Err(err) + mainEvt = logger.log.Err(err) } else if config.RequestLatencyLimit != 0 && latency > config.RequestLatencyLimit { - mainEvt = afterNextLog.WithLevel(config.RequestLatencyLevel) + mainEvt = logger.log.WithLevel(config.RequestLatencyLevel) } else { - mainEvt = afterNextLog.WithLevel(afterNextLog.GetLevel()) + mainEvt = logger.log.WithLevel(logger.log.GetLevel()) } var evt *zerolog.Event - - withNewDict := config.NestKey != "" && !config.SkipDefaultFields - - if withNewDict { // Start a new event (dict) if there's a nest key for default fields. + if config.NestKey != "" { // Start a new event (dict) if there's a nest key. evt = zerolog.Dict() } else { evt = mainEvt } - if !config.SkipDefaultFields { - evt.Str("remote_ip", c.RealIP()) - evt.Str("host", req.Host) - evt.Str("method", req.Method) - evt.Str("uri", req.RequestURI) - evt.Str("user_agent", req.UserAgent()) - evt.Int("status", res.Status) - evt.Str("referer", req.Referer()) - evt.Dur("latency", latency) - evt.Str("latency_human", latency.String()) - - cl := req.Header.Get(echo.HeaderContentLength) - if cl == "" { - cl = "0" - } - evt.Str("bytes_in", cl) - evt.Str("bytes_out", strconv.FormatInt(res.Size, 10)) + evt.Str("remote_ip", c.RealIP()) + evt.Str("host", req.Host) + evt.Str("method", req.Method) + evt.Str("uri", req.RequestURI) + evt.Str("user_agent", req.UserAgent()) + evt.Int("status", res.Status) + evt.Str("referer", req.Referer()) + evt.Dur("latency", latency) + evt.Str("latency_human", latency.String()) + + cl := req.Header.Get(echo.HeaderContentLength) + if cl == "" { + cl = "0" } - if withNewDict { // Nest the new event (dict) under the nest key for default fields. + evt.Str("bytes_in", cl) + evt.Str("bytes_out", strconv.FormatInt(res.Size, 10)) + + if config.NestKey != "" { // Nest the new event (dict) under the nest key. mainEvt.Dict(config.NestKey, evt) } - mainEvt.Send() return err diff --git a/vendor/github.com/ziflex/lecho/v3/options.go b/vendor/github.com/ziflex/lecho/v3/options.go index 39c56c69..fc59c5bb 100644 --- a/vendor/github.com/ziflex/lecho/v3/options.go +++ b/vendor/github.com/ziflex/lecho/v3/options.go @@ -16,8 +16,7 @@ type ( ) func newOptions(log zerolog.Logger, setters []Setter) *Options { - effectiveLevel := GetEffectiveZerologLevel(log) - elvl, _ := MatchZeroLevel(effectiveLevel) + elvl, _ := MatchZeroLevel(log.GetLevel()) opts := &Options{ context: log.With(), diff --git a/vendor/modules.txt b/vendor/modules.txt index 6d96f60b..2dbf505c 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -409,9 +409,11 @@ github.com/yuin/goldmark/renderer github.com/yuin/goldmark/renderer/html github.com/yuin/goldmark/text github.com/yuin/goldmark/util -# github.com/ziflex/lecho/v3 v3.11.1 -## explicit; go 1.25.0 +# github.com/ziflex/lecho/v3 v3.8.0 +## explicit; go 1.20 github.com/ziflex/lecho/v3 +# github.com/ziflex/lecho/v4 v4.0.0 +## explicit; go 1.25.0 # go.etcd.io/bbolt v1.5.0 ## explicit; go 1.25.0 go.etcd.io/bbolt