🚀 [Feature]: Add Logger interface

[kousikmitra]

Feature Description

As pointed out by @efectn in #2402 and #2432 (comment) xurrently we log everything using default logger like log.Print*, this makes it hard to replace the standard logger with any other logger like logrus, zap etc.

We can add a logger interface and give an option to replace the default logger via fiber.Config

Additional Context (optional)

No response

Code Snippet (optional)

package main

import "github.com/gofiber/fiber/v2"
import "log"

func main() {
  // Enable fiber to use slog to log messages.
  app := fiber.New(fiber.Config{Logger: slog.New()})

  log.Fatal(app.Listen(":3000"))
}

Checklist:

• I agree to follow Fiber's Code of Conduct.
• I have checked for existing issues that describe my suggestion prior to opening this one.
• I understand that improperly formatted feature requests may be closed without explanation.

[welcome]

Thanks for opening your first issue here! 🎉 Be sure to follow the issue template! If you need help or want to chat with us, join us on Discord https://gofiber.io/discord

[jonatan5524]

Hi, I am new to this repo and would like to tackle this issue

[ReneWerner87]

Sure

[jonatan5524]

I am a bit overwhelmed on this issue, I might search for an easier issue in this repo.

[iDevoid]

Hi team, I'd like to work on this.
which one do you prefer as the best approach?

1. create a logger interface on the root level, and use a var Logger public type, so we can use it inside the middleware
   directory:

app.go
.
.
log.go

interface + holder:

var Logger Logger

type Logger interface{
    ...
}

2. create a package log that has a logger interface, and has private var to hold the logger interface
   directory:

log/
    log.go
    ....
app.go

interface + holder:

var logger Logger

type Logger interface{
    ...
}

func (log *logger) Print(...)

[ReneWerner87]

approach 2

[iDevoid]

I just did a bit of research on loggers that are listed in the description. if the objective is to create a common interface that can be used by multiple loggers and covers the usage of the fiber library.

I am thinking to create an adaptor for listed loggers, for example:

file: log.go
type Logger interface {
	Info(v string)
}

file: adapter_slog.go
// SlogAdapter is the adapter for the slog library
type SlogAdapter struct {
    logger *slog.Logger
}

// UsingSlogAdaptor to initialize fiber logger using slog
func UsingSlogAdaptor(logger *slog.Logger) Logger {
    return &SlogAdapter{logger: logger}
}

func (a *SlogAdapter) Info(v string) {
    a.logger.Info(v)
}

file: adapter_logrus.go
// LogrusAdapter is the adapter for the slog library
type LogrusAdapter struct {
    logger *logrus.Logger
}

// UsingLogrusAdaptor to initialize fiber logger using slog
func UsingLogrusAdaptor(logger *slog.Logger) Logger {
    return &LogrusAdapter{logger: logger}
}

func (a *LogrusAdapter) Info(v string) {
    a.logger.Print(v)
}

and more...

with this method, we can expand the variety of loggers. what do you think?

[ReneWerner87]

we only need something like this
#2432 (comment)

its just for the internal logging
we should not build up a new dependency there

[iDevoid]

From the code snippet, you shared.
I found that we are trying to create a local logging system from the standard library.
Instead of the initial issue as described above:

this makes it hard to replace the standard logger with any other logger like logrus, zap etc.
We can add a logger interface and give an option to replace the default logger via fiber.Config

If it is the case, I'd like to know the meaning of internal logging.
does internal log mean for the user/client to use or for fiber's dev to use?

if it's only a minimal log that is not really impacting. I actually agree that we should use a built-in log library but with a customized format.

But, let me know which one I should proceed with because your suggestion is contradicting the issue's description above.
thank you

[Skyenought]

@ReneWerner87 I think we could add a log package to the fiber, assuming it's called fiberlog

package main

import (
	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/fiber/v2/flog"
	"log"
)

func main() {
	app := fiber.New(fiber.Config{
		Logger: fiberzap.NewLogger(),
	})
	app.Get("/hello/world", func(c *fiber.Ctx) error {
		fiberlog.Info("Hello World!")
		return c.SendString("Hello World 👋!")
	})
	app.Get("/:option/world", func(c *fiber.Ctx) error {
		return c.SendString(c.Params("option") + " World 👋!")
	})
	log.Fatal(app.Listen(":3000"))
}

We can adapt libraries such as zap, zerolog, etc. by implementing the interface provided by fiberlog.

package fiberlog

type Logger interface {
	Trace(v ...interface{})
	Debug(v ...interface{})
	Info(v ...interface{})
	Notice(v ...interface{})
	Warn(v ...interface{})
	Error(v ...interface{})
	Fatal(v ...interface{})
	Panic(v ...interface{})
}

// Control provides methods to config a logger.
type Control interface {
	SetLevel(Level)
	SetOutput(io.Writer)
}

// ...

type FullLogger interface {
	Logger
	FormatLogger
	CtxLogger
	Control
}

package fiberzap

import (
	"context"
	"github.com/gofiber/fiber/v2/flog"
	"go.uber.org/zap"
	"io"
)

var _ flog.FullLogger = (*Logger)(nil)

type Logger struct {
	l *zap.SugaredLogger
}

func (l *Logger) Trace(v ...interface{}) {
	//TODO implement me
	panic("implement me")
}

func (l *Logger) Debug(v ...interface{}) {
	//TODO implement me
	panic("implement me")
}

If this option works, I will try to propose a PR to solve this issue

[ReneWerner87]

Please without external dependencies.

[Skyenought]

Please without external dependencies.

Of course, pls assign me, let me try