logrusadapter

Documentation

Overview

Package logrusadapter provides a logger adapter for the logrus logging library.

This adapter enables using logrus as a backend for logger.Logger, bridging the logrus API with the logger abstraction. For documentation on the logger API itself, see the dev.gaijin.team/go/golib/logger package.

Basic Usage

Create a logrus logger, wrap it in an adapter, and use with logger.Logger:

import (
	"github.com/sirupsen/logrus"
	"dev.gaijin.team/go/golib/logger"
	"dev.gaijin.team/go/golib/logger/logrusadapter"
)

ll := logrus.New()
ll.SetFormatter(&logrus.JSONFormatter{})
ll.SetLevel(logrus.TraceLevel)

adapter := logrusadapter.New(logrus.NewEntry(ll))
log := logger.New(adapter, logger.LevelInfo)

log.Info("server started", fields.F("port", 8080))

IMPORTANT: Configure logrus with the highest level (TraceLevel) to ensure all logs are passed to the adapter. Level filtering is performed by logger.Logger, not by logrus. If logrus is set to a lower level (e.g., InfoLevel), it will filter out debug and trace logs if they would be sent by logger.Logger.

Custom Level Mapping

By default, logger levels map to logrus levels using DefaultLogLevelMapper. You can provide a custom mapper if you need different level mapping behavior:

customMapper := func(level int) logrus.Level {
	switch level {
	case logger.LevelError:
		return logrus.FatalLevel  // Map errors to fatal
	default:
		return logrus.InfoLevel
	}
}

adapter := logrusadapter.New(
	logrus.NewEntry(ll),
	logrusadapter.WithLogLevelMapper(customMapper),
)

Index

• func DefaultLogLevelMapper(level int) logrus.Level
• type Adapter
  • func New(lgr *logrus.Entry, opts ...Option) *Adapter
  • func (*Adapter) Flush() error
  • func (a *Adapter) Log(level int, msg string, fs ...fields.Field)
  • func (a *Adapter) WithFields(fs ...fields.Field) logger.Adapter
• type LogLevelMapper
• type Option
  • func WithLogLevelMapper(fn LogLevelMapper) Option

Functions

func DefaultLogLevelMapper

func DefaultLogLevelMapper(level int) logrus.Level

DefaultLogLevelMapper is a default implementation of LogLevelMapper that maps log levels from logger.Logger to appropriate logrus.Level.

Types

type Adapter

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

Adapter of logrus logger for logger.Logger.

This adapter guarantees support of stock logger's levels.

func New

func New(lgr *logrus.Entry, opts ...Option) *Adapter

New creates new logging adapter using provided logrus.Entry.

func (*Adapter) Flush

func (*Adapter) Flush() error

Flush implements logger.Adapter.Flush.

func (*Adapter) Log

func (a *Adapter) Log(level int, msg string, fs ...fields.Field)

Log implements logger.Adapter.Log.

func (*Adapter) WithFields

func (a *Adapter) WithFields(fs ...fields.Field) logger.Adapter

WithFields implements logger.Adapter.WithFields.

type LogLevelMapper

type LogLevelMapper func(level int) logrus.Level

LogLevelMapper is a function that maps logger levels from logger.Logger to logrus.Level.

type Option

type Option func(*Adapter)

func WithLogLevelMapper

func WithLogLevelMapper(fn LogLevelMapper) Option

WithLogLevelMapper sets custom log level mapper for the adapter.