fiber_zerolog

README

fiber_zerolog

This makes it easy to inject a custom zerologger to your fiber framework

How to install it

go get -u github.com/Adachi324/fiber_zerolog

How to use this repo

It's very easy to replace your original fiber logger, and you don't need to modify any other log print code.

// if you want to use a default logger
    logger := fiber_zerolog.NewLogger()
    log.SetLogger(logger)
    app := fiber.New()
    app.Get("/", func(c *fiber.Ctx) error {
		log.Info("test logger")
        log.Infow("test logger with fields", "foo", "bar")
		return c.SendString("Hello, World!")
	})
    app.Listen(":3000")

 # curl http://localhost:3000
 # outputs
 {"level":"info","time":"2024-01-24T17:00:16+08:00","message":"[test logger]"}
 {"level":"info","foo":"bar","time":"2024-01-24T17:01:27+08:00","message":"test logger with fields"}

Or if you want to use a custom zerologger, you can do this:

    logger := fiber_zerolog.NewLogger()
    logger.SetLogger(zerolog.New(os.Stderr).With().Timestamp().Logger())
    log.SetLogger(logger)
    app := fiber.New()
    app.Get("/", func(c *fiber.Ctx) error {
        log.Info("test logger")
        log.Infow("test logger with fields", "foo", "bar")
        return c.SendString("Hello, World!")
    })
    app.Listen(":3000")

 # curl http://localhost:3000
 # outputs
 {"level":"info","time":"2024-01-24T17:00:16+08:00","message":"[test logger]"}
 {"level":"info","foo":"bar","time":"2024-01-24T17:01:27+08:00","message":"test logger with fields"}

You will get the similar outputs as above.

Middleware

A injection middleware is provided, you can use it to trace some metadata like traceId or something else And you can get a zerologger from the ctx of fiber

	var ctxKey = struct{}{}
	app.Use(func(c *fiber.Ctx) error {
		c.Locals(ctxKey, "ctxValue")
		return c.Next()
	})
	app.Use(fiber_zerolog.InjectLogger(fiber_zerolog.InjectLoggerConfig{
		Logger:           fiber_zerolog.NewLogger(),
		FieldsFromHeader: []string{fiber.HeaderXRequestID},
		FieldsFromLocals: map[string]interface{}{
			"ctxKey": ctxKey,
		},
	}))

	// curl -H "X-Request-ID: 123456" http://localhost:3000/inject
	app.Get("/inject", func(c *fiber.Ctx) error {
		log.Info("test inject logger")
		log.Info(string(c.Request().Header.Peek(fiber.HeaderXRequestID)))
		log.WithContext(c.UserContext()).Info("test inject logger with context")
		zerolog.Ctx(c.UserContext()).Info().Msg("test inject logger with context by zerolog")
		return c.SendString("Hello, World!")
	})

{"level":"info","time":"2024-01-24T17:11:28+08:00","message":"[test inject logger]"}
{"level":"info","time":"2024-01-24T17:11:28+08:00","message":"[123456]"}
{"level":"info","X-Request-ID":"123456","ctxKey":"ctxValue","time":"2024-01-24T17:11:28+08:00","message":"[test inject logger with context]"}
{"level":"info","X-Request-ID":"123456","ctxKey":"ctxValue","time":"2024-01-24T17:11:28+08:00","message":"test inject logger with context by zerolog"}

Documentation

Index

• Variables
• func InjectLogger(cfg ...InjectLoggerConfig) func(ctx *fiber.Ctx) error
• type InjectLoggerConfig
• type Logger
  • func NewLogger() *Logger
  • func NewLoggerByZerolog(l zerolog.Logger) *Logger
  • func (lg *Logger) Debug(v ...interface{})
  • func (lg *Logger) Debugf(format string, v ...interface{})
  • func (lg *Logger) Debugw(msg string, keysAndValues ...interface{})
  • func (lg *Logger) Error(v ...interface{})
  • func (lg *Logger) Errorf(format string, v ...interface{})
  • func (lg *Logger) Errorw(msg string, keysAndValues ...interface{})
  • func (lg *Logger) Fatal(v ...interface{})
  • func (lg *Logger) Fatalf(format string, v ...interface{})
  • func (lg *Logger) Fatalw(msg string, keysAndValues ...interface{})
  • func (lg *Logger) Info(v ...interface{})
  • func (lg *Logger) Infof(format string, v ...interface{})
  • func (lg *Logger) Infow(msg string, keysAndValues ...interface{})
  • func (lg *Logger) Panic(v ...interface{})
  • func (lg *Logger) Panicf(format string, v ...interface{})
  • func (lg *Logger) Panicw(msg string, keysAndValues ...interface{})
  • func (lg *Logger) SetLevel(level log.Level)
  • func (lg *Logger) SetOutput(writer io.Writer)
  • func (lg *Logger) Trace(val ...interface{})
  • func (lg *Logger) Tracef(format string, v ...interface{})
  • func (lg *Logger) Tracew(msg string, keysAndValues ...interface{})
  • func (lg *Logger) Warn(v ...interface{})
  • func (lg *Logger) Warnf(format string, v ...interface{})
  • func (lg *Logger) Warnw(msg string, keysAndValues ...interface{})
  • func (lg *Logger) WithContext(ctx context.Context) log.CommonLogger

Variables

var DefaultInjectLoggerConfig = InjectLoggerConfig{
	Logger:           NewLogger(),
	FieldsFromHeader: []string{fiber.HeaderXRequestID},
}

Functions

func InjectLogger

func InjectLogger(cfg ...InjectLoggerConfig) func(ctx *fiber.Ctx) error

InjectLogger injects logger into fiber context, which can trace your request by your request id or something else, and you can get it by zerolog.Ctx(c.UserContext) or log.WithContext(c.UserContext) this middleware should be used after your keys are all set

Types

type InjectLoggerConfig

type InjectLoggerConfig struct {
	Logger           *Logger
	FieldsFromHeader []string
	FieldsFromLocals map[string]interface{}
}

type Logger

type Logger struct {
	// contains filtered or unexported fields
}

func NewLogger

func NewLogger() *Logger

func NewLoggerByZerolog

func NewLoggerByZerolog(l zerolog.Logger) *Logger

func (*Logger) Debug

func (lg *Logger) Debug(v ...interface{})

func (*Logger) Debugf

func (lg *Logger) Debugf(format string, v ...interface{})

func (*Logger) Debugw

func (lg *Logger) Debugw(msg string, keysAndValues ...interface{})

func (*Logger) Error

func (lg *Logger) Error(v ...interface{})

func (*Logger) Errorf

func (lg *Logger) Errorf(format string, v ...interface{})

func (*Logger) Errorw

func (lg *Logger) Errorw(msg string, keysAndValues ...interface{})

func (*Logger) Fatal

func (lg *Logger) Fatal(v ...interface{})

func (*Logger) Fatalf

func (lg *Logger) Fatalf(format string, v ...interface{})

func (*Logger) Fatalw

func (lg *Logger) Fatalw(msg string, keysAndValues ...interface{})

func (*Logger) Info

func (lg *Logger) Info(v ...interface{})

func (*Logger) Infof

func (lg *Logger) Infof(format string, v ...interface{})

func (*Logger) Infow

func (lg *Logger) Infow(msg string, keysAndValues ...interface{})

func (*Logger) Panic

func (lg *Logger) Panic(v ...interface{})

func (*Logger) Panicf

func (lg *Logger) Panicf(format string, v ...interface{})

func (*Logger) Panicw

func (lg *Logger) Panicw(msg string, keysAndValues ...interface{})

func (*Logger) SetLevel

func (lg *Logger) SetLevel(level log.Level)

func (*Logger) SetOutput

func (lg *Logger) SetOutput(writer io.Writer)

func (*Logger) Trace

func (lg *Logger) Trace(val ...interface{})

func (*Logger) Tracef

func (lg *Logger) Tracef(format string, v ...interface{})

func (*Logger) Tracew

func (lg *Logger) Tracew(msg string, keysAndValues ...interface{})

func (*Logger) Warn

func (lg *Logger) Warn(v ...interface{})

func (*Logger) Warnf

func (lg *Logger) Warnf(format string, v ...interface{})

func (*Logger) Warnw

func (lg *Logger) Warnw(msg string, keysAndValues ...interface{})

func (*Logger) WithContext

func (lg *Logger) WithContext(ctx context.Context) log.CommonLogger