🔥 Feature: Add AllLogger to Config

docs/api/log.md

@@ -186,3 +186,20 @@
 ```
 
 Binding the logger to a context allows you to include context-specific information in your logs, improving traceability and debugging.
+
+## GetLoggerInstance
+
+You can use GetLoggerInstance to retrieve the logger instance. It is useful when you need to access underlying methods of the logger.
+To retrieve the logger instance, use the following method:
+
+```go
+logger := fiberlog.DefaultLogger() // Call DefaultLogger to get the default logger instance
+
+stdlogger, ok := logger.GetLoggerInstance().(*log.Logger) // Get the logger instance and assert it to *log.Logger
+if !ok {
+    panic("logger is not *log.Logger")
+}
+
+stdlogger.SetFlags(0) // Hide timestamp by setting flags to 0
+```
+

docs/middleware/logger.md

@@ -90,6 +90,44 @@
 }))
 ```
 
+### Use Logger Middleware with Other Loggers
+
+In order to use Fiber logger middleware with other loggers such as zerolog, zap, logrus; you can use `LoggerToWriter` helper which converts Fiber logger to a writer, which is compatible with the middleware.
+
+```go
+package main
+
+import (
+	"github.com/gofiber/contrib/fiberzap/v2"
+	"github.com/gofiber/fiber/v3"
+	"github.com/gofiber/fiber/v3/log"
+	"github.com/gofiber/fiber/v3/middleware/logger"
+)
+
+func main() {
+	// Create a new Fiber instance
+	app := fiber.New()
+
+    // Create a new zap logger which is compatible with Fiber AllLogger interface
+	zap := fiberzap.NewLogger(fiberzap.LoggerConfig{
+		ExtraKeys: []string{"request_id"},
+	})
+
+	// Use the logger middleware with zerolog logger
+	app.Use(logger.New(logger.Config{
+		Output: logger.LoggerToWriter(zap, log.LevelDebug),
+	}))
+
+	// Define a route
+	app.Get("/", func(c fiber.Ctx) error {
+		return c.SendString("Hello, World!")
+	})
+
+	// Start server on http://localhost:3000
+	app.Listen(":3000")
+}
+```
+
 :::tip
 Writing to os.File is goroutine-safe, but if you are using a custom Output that is not goroutine-safe, make sure to implement locking to properly serialize writes.
 :::
@@ -108,6 +146,7 @@
 | TimeZone         | `string`                   | TimeZone can be specified, such as "UTC" and "America/New_York" and "Asia/Chongqing", etc                                        | `"Local"`                                                             |
 | TimeInterval     | `time.Duration`            | TimeInterval is the delay before the timestamp is updated.                                                                       | `500 * time.Millisecond`                                              |
 | Output           | `io.Writer`                | Output is a writer where logs are written.                                                                                       | `os.Stdout`                                                           |
+| LoggerFunc | `func(c fiber.Ctx, data *Data, cfg Config) error` | Custom logger function for integration with logging libraries (Zerolog, Zap, Logrus, etc). Defaults to Fiber's default logger if not defined. | `see default_logger.go defaultLoggerInstance` |
 | DisableColors    | `bool`                     | DisableColors defines if the logs output should be colorized.                                                                    | `false`                                                               |
 | enableColors     | `bool`                     | Internal field for enabling colors in the log output. (This is not a user-configurable field)                                    | -                                                                     |
 | enableLatency    | `bool`                     | Internal field for enabling latency measurement in logs. (This is not a user-configurable field)                                 | -                                                                     |
@@ -125,6 +164,7 @@
     TimeInterval:  500 * time.Millisecond,
     Output:        os.Stdout,
     DisableColors: false,
+    LoggerFunc:    defaultLoggerInstance,
 }
 ```
 

docs/whats_new.md

@@ -22,10 +22,12 @@ Here's a quick overview of the changes in Fiber `v3`:
 - [🔄️ Redirect](#-redirect)
 - [🌎 Client package](#-client-package)
 - [🧰 Generic functions](#-generic-functions)
+- [📃 Log](#-log)
 - [🧬 Middlewares](#-middlewares)
   - [CORS](#cors)
   - [CSRF](#csrf)
   - [Session](#session)
+  - [Logger](#logger)
   - [Filesystem](#filesystem)
   - [Monitor](#monitor)
   - [Healthcheck](#healthcheck)
@@ -629,6 +631,12 @@ curl "http://localhost:3000/header"
 
 </details>
 
+## 📃 Log
+
+`fiber.AllLogger` interface now has a new method called `GetLoggerInstance`. This method can be used to get the underlying logger instance from the Fiber logger middleware. This is useful when you want to configure the logger middleware with a custom logger and still want to access the underlying logger instance. 
+
+You can find more details about this feature in [/docs/api/log.md](./api/log.md#getloggerinstance).
+
 ## 🧬 Middlewares
 
 ### Adaptor
@@ -704,6 +712,45 @@ The Session middleware has undergone key changes in v3 to improve functionality
 
 For more details on these changes and migration instructions, check the [Session Middleware Migration Guide](./middleware/session.md#migration-guide).
 
+### Logger
+
+New helper function called `LoggerToWriter` has been added to the logger middleware. 
+This function allows you to use 3rd party loggers such as `logrus` or `zap` with the Fiber logger middleware without any extra afford. For example, you can use `zap` with Fiber logger middleware like this:
+
+```go
+package main
+
+import (
+	"github.com/gofiber/contrib/fiberzap/v2"
+	"github.com/gofiber/fiber/v3"
+	"github.com/gofiber/fiber/v3/log"
+	"github.com/gofiber/fiber/v3/middleware/logger"
+)
+
+func main() {
+	// Create a new Fiber instance
+	app := fiber.New()
+
+  // Create a new zap logger which is compatible with Fiber AllLogger interface
+	zap := fiberzap.NewLogger(fiberzap.LoggerConfig{
+		ExtraKeys: []string{"request_id"},
+	})
+
+	// Use the logger middleware with zerolog logger
+	app.Use(logger.New(logger.Config{
+		Output: logger.LoggerToWriter(zap, log.LevelDebug),
+	}))
+
+	// Define a route
+	app.Get("/", func(c fiber.Ctx) error {
+		return c.SendString("Hello, World!")
+	})
+
+	// Start server on http://localhost:3000
+	app.Listen(":3000")
+}
+```
+
 ### Filesystem
 
 We've decided to remove filesystem middleware to clear up the confusion between static and filesystem middleware.

log/default.go

@@ -210,6 +210,11 @@
 	l.stdlog.SetOutput(writer)
 }
 
+// GetLoggerInstance returns the logger instance. It can be used to adjust the logger configurations in case of need.
+func (l *defaultLogger) GetLoggerInstance() any {
+	return l.stdlog
+}
+
 // DefaultLogger returns the default logger.
 func DefaultLogger() AllLogger {
 	return logger

log/log.go

@@ -54,15 +54,25 @@ type CommonLogger interface {
 
 // ControlLogger provides methods to config a logger.
 type ControlLogger interface {
+	// SetLevel sets logging level.
+	//
+	// Available levels: Trace, Debug, Info, Warn, Error, Fatal, Panic.
 	SetLevel(level Level)
+
+	// SetOutput sets the logger output.
 	SetOutput(w io.Writer)
+
+	// GetLoggerInstance returns the logger instance. It can be used to adjust the logger configurations in case of need.
+	GetLoggerInstance() any
 }
 
 // AllLogger is the combination of Logger, FormatLogger, CtxLogger and ControlLogger.
 // Custom extensions can be made through AllLogger
 type AllLogger interface {
 	CommonLogger
 	ControlLogger
+
+	// WithContext returns a new logger with the given context.
 	WithContext(ctx context.Context) CommonLogger
 }
 

middleware/logger/logger_test.go

@@ -1,3 +1,4 @@
+//nolint:depguard // Because we test logging :D
 package logger
 
 import (
@@ -6,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -15,6 +17,7 @@ import (
 	"time"
 
 	"github.com/gofiber/fiber/v3"
+	fiberlog "github.com/gofiber/fiber/v3/log"
 	"github.com/gofiber/fiber/v3/middleware/requestid"
 	"github.com/stretchr/testify/require"
 	"github.com/valyala/bytebufferpool"
@@ -181,6 +184,48 @@ func Test_Logger_ErrorTimeZone(t *testing.T) {
 	require.Equal(t, fiber.StatusNotFound, resp.StatusCode)
 }
 
+// go test -run Test_Logger_Fiber_Logger
+func Test_Logger_Fiber_Logger(t *testing.T) {
+	t.Parallel()
+	app := fiber.New()
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	logger := fiberlog.DefaultLogger()
+	stdlogger, ok := logger.GetLoggerInstance().(*log.Logger)
+	require.True(t, ok)
+
+	stdlogger.SetFlags(0)
+	logger.SetOutput(buf)
+
+	app.Use(New(Config{
+		Format: "${error}",
+		Output: LoggerToWriter(logger, fiberlog.LevelError),
+	}))
+
+	app.Get("/", func(_ fiber.Ctx) error {
+		return errors.New("some random error")
+	})
+
+	resp, err := app.Test(httptest.NewRequest(fiber.MethodGet, "/", nil))
+	require.NoError(t, err)
+	require.Equal(t, fiber.StatusInternalServerError, resp.StatusCode)
+	require.Equal(t, "[Error] some random error\n", buf.String())
+
+	require.Panics(t, func() {
+		LoggerToWriter(logger, fiberlog.LevelPanic)
+	})
+
+	require.Panics(t, func() {
+		LoggerToWriter(logger, fiberlog.LevelFatal)
+	})
+
+	require.Panics(t, func() {
+		LoggerToWriter(nil, fiberlog.LevelFatal)
+	})
+}
+
 type fakeErrorOutput int
 
 func (o *fakeErrorOutput) Write([]byte) (int, error) {
@@ -733,6 +778,19 @@ func Benchmark_Logger(b *testing.B) {
 		benchmarkSetup(bb, app, "/")
 	})
 
+	b.Run("DefaultFormatWithFiberLog", func(bb *testing.B) {
+		app := fiber.New()
+		logger := fiberlog.DefaultLogger()
+		logger.SetOutput(io.Discard)
+		app.Use(New(Config{
+			Output: LoggerToWriter(logger, fiberlog.LevelDebug),
+		}))
+		app.Get("/", func(c fiber.Ctx) error {
+			return c.SendString("Hello, World!")
+		})
+		benchmarkSetup(bb, app, "/")
+	})
+
 	b.Run("WithTagParameter", func(bb *testing.B) {
 		app := fiber.New()
 		app.Use(New(Config{
@@ -876,6 +934,19 @@ func Benchmark_Logger_Parallel(b *testing.B) {
 		benchmarkSetupParallel(bb, app, "/")
 	})
 
+	b.Run("DefaultFormatWithFiberLog", func(bb *testing.B) {
+		app := fiber.New()
+		logger := fiberlog.DefaultLogger()
+		logger.SetOutput(io.Discard)
+		app.Use(New(Config{
+			Output: LoggerToWriter(logger, fiberlog.LevelDebug),
+		}))
+		app.Get("/", func(c fiber.Ctx) error {
+			return c.SendString("Hello, World!")
+		})
+		benchmarkSetupParallel(bb, app, "/")
+	})
+
 	b.Run("DefaultFormatDisableColors", func(bb *testing.B) {
 		app := fiber.New()
 		app.Use(New(Config{

middleware/logger/utils.go

@@ -1,7 +1,11 @@
 package logger
 
 import (
+	"io"
+
 	"github.com/gofiber/fiber/v3"
+	fiberlog "github.com/gofiber/fiber/v3/log"
+	"github.com/gofiber/utils/v2"
 )
 
 func methodColor(method string, colors fiber.Colors) string {
@@ -37,3 +41,48 @@
 		return colors.Red
 	}
 }
+
+type customLoggerWriter struct {
+	loggerInstance fiberlog.AllLogger
+	level          fiberlog.Level
+}
+
+func (cl *customLoggerWriter) Write(p []byte) (int, error) {
+	switch cl.level {
+	case fiberlog.LevelInfo:
+		cl.loggerInstance.Info(utils.UnsafeString(p))
+	case fiberlog.LevelTrace:
+		cl.loggerInstance.Trace(utils.UnsafeString(p))
+	case fiberlog.LevelWarn:
+		cl.loggerInstance.Warn(utils.UnsafeString(p))
+	case fiberlog.LevelDebug:
+		cl.loggerInstance.Debug(utils.UnsafeString(p))
+	case fiberlog.LevelError:
+		cl.loggerInstance.Error(utils.UnsafeString(p))
+	default:
+		return 0, nil
+	}
+
+	return len(p), nil
+}
+
+// LoggerToWriter is a helper function that returns an io.Writer that writes to a custom logger.
+// You can integrate 3rd party loggers such as zerolog, logrus, etc. to logger middleware using this function.
+//
+// Valid levels: fiberlog.LevelInfo, fiberlog.LevelTrace, fiberlog.LevelWarn, fiberlog.LevelDebug, fiberlog.LevelError
+func LoggerToWriter(customLogger fiberlog.AllLogger, level fiberlog.Level) io.Writer {
+	// Check if customLogger is nil
+	if customLogger == nil {
+		fiberlog.Panic("LoggerToWriter: customLogger must not be nil")
+	}
+
+	// Check if level is valid
+	if level == fiberlog.LevelFatal || level == fiberlog.LevelPanic {
+		fiberlog.Panic("LoggerToWriter: invalid level")
+	}
+
+	return &customLoggerWriter{
+		level:          level,
+		loggerInstance: customLogger,
+	}
+}