🔥 feat: Add Filter option to logger middleware

docs/middleware/logger.md

@@ -139,6 +139,7 @@ Writing to os.File is goroutine-safe, but if you are using a custom Output that
 | Property         | Type                       | Description                                                                                                                      | Default                                                               |
 |:-----------------|:---------------------------|:---------------------------------------------------------------------------------------------------------------------------------|:----------------------------------------------------------------------|
 | Next             | `func(fiber.Ctx) bool`    | Next defines a function to skip this middleware when returned true.                                                              | `nil`                                                                 |
+| Filter           | `func(fiber.Ctx) bool` | Filter is a function that is called before the log string for a request is written to Output. | `nil`                                                                 |
 | Done             | `func(fiber.Ctx, []byte)` | Done is a function that is called after the log string for a request is written to Output, and pass the log string as parameter. | `nil`                                                                 |
 | CustomTags       | `map[string]LogFunc`       | tagFunctions defines the custom tag action.                                                                                      | `map[string]LogFunc`                                                  |
 | Format           | `string`                   | Format defines the logging tags.                                                                                                 | `[${time}] ${ip} ${status} - ${latency} ${method} ${path} ${error}\n` |
@@ -157,6 +158,7 @@ Writing to os.File is goroutine-safe, but if you are using a custom Output that
 ```go
 var ConfigDefault = Config{
     Next:          nil,
+    Filter         nil,
     Done:          nil,
     Format:        "[${time}] ${ip} ${status} - ${latency} ${method} ${path} ${error}\n",
     TimeFormat:    "15:04:05",

docs/whats_new.md

@@ -912,6 +912,29 @@ func main() {
 
 </details>
 
+The `Filter` is a function that is called before the log string for a request is written to Output. If it returns true, the log will be written; otherwise, it will be skipped.
+
+<details>
+<summary>Example</summary>
+
+```go
+app.Use(logger.New(logger.Config{
+    Filter: func(c fiber.Ctx) bool {
+        // Skip logging for 404 requests
+        return c.Response().StatusCode() == fiber.StatusNotFound
+    },
+}))
+
+app.Use(logger.New(logger.Config{
+    Filter: func(c fiber.Ctx) bool {
+        // Only log requests with status code 200
+        return c.Response().StatusCode() == fiber.StatusOK
+    },
+}))
+```
+
+</details>
+
 ### Filesystem
 
 We've decided to remove filesystem middleware to clear up the confusion between static and filesystem middleware.

middleware/logger/config.go

@@ -20,6 +20,12 @@ type Config struct {
 	// Optional. Default: nil
 	Next func(c fiber.Ctx) bool
 
+	// Filter is a function that is called before writing the log string.
+	// If it returns true, the log will be written; otherwise, it will be skipped.
+	//
+	// Optional. Default: nil
+	Filter func(c fiber.Ctx) bool
+
 	// Done is a function that is called after the log string for a request is written to Output,
 	// and pass the log string as parameter.
 	//
@@ -98,6 +104,7 @@ type LogFunc func(output Buffer, c fiber.Ctx, data *Data, extraParam string) (in
 // ConfigDefault is the default config
 var ConfigDefault = Config{
 	Next:              nil,
+	Filter:            nil,
 	Done:              nil,
 	Format:            defaultFormat,
 	TimeFormat:        "15:04:05",
@@ -126,6 +133,9 @@ func configDefault(config ...Config) Config {
 	if cfg.Next == nil {
 		cfg.Next = ConfigDefault.Next
 	}
+	if cfg.Filter == nil {
+		cfg.Filter = ConfigDefault.Filter
+	}
 	if cfg.Done == nil {
 		cfg.Done = ConfigDefault.Done
 	}

middleware/logger/default_logger.go

@@ -15,6 +15,11 @@ import (
 
 // default logger for fiber
 func defaultLoggerInstance(c fiber.Ctx, data *Data, cfg Config) error {
+	// Check if Filter is defined and call it
+	if cfg.Filter != nil && !cfg.Filter(c) {
+		return nil // Skip logging if Filter returns false
+	}
+
 	// Alias colors
 	colors := c.App().Config().ColorScheme
 

middleware/logger/logger_test.go

@@ -171,6 +171,58 @@ func Test_Logger_Done(t *testing.T) {
 	require.Positive(t, buf.Len(), 0)
 }
 
+func Test_Logger_Filter(t *testing.T) {
+	t.Parallel()
+
+	t.Run("Test Not Found", func(t *testing.T) {
+		t.Parallel()
+		app := fiber.New()
+
+		logOutput := bytes.Buffer{}
+
+		// Create a single logging middleware with both filter and output capture
+		app.Use(New(Config{
+			Filter: func(c fiber.Ctx) bool {
+				return c.Response().StatusCode() == fiber.StatusNotFound
+			},
+			Output: &logOutput,
+		}))
+
+		resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/nonexistent", nil))
+		require.NoError(t, err)
+		require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
+
+		// Verify the log output contains the "404" message
+		require.Contains(t, logOutput.String(), "404")
+	})
+
+	t.Run("Test OK", func(t *testing.T) {
+		t.Parallel()
+		app := fiber.New()
+
+		logOutput := bytes.Buffer{}
+
+		// Create a single logging middleware with both filter and output capture
+		app.Use(New(Config{
+			Filter: func(c fiber.Ctx) bool {
+				return c.Response().StatusCode() == fiber.StatusNotFound
+			},
+			Output: &logOutput,
+		}))
+
+		app.Get("/", func(c fiber.Ctx) error {
+			return c.SendStatus(fiber.StatusOK)
+		})
+
+		resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/", nil))
+		require.NoError(t, err)
+		require.Equal(t, fiber.StatusOK, resp.StatusCode)
+
+		// Verify the log output does not contain the "200" message
+		require.NotContains(t, logOutput.String(), "200")
+	})
+}
+
 // go test -run Test_Logger_ErrorTimeZone
 func Test_Logger_ErrorTimeZone(t *testing.T) {
 	t.Parallel()