logger

README

logger

A light-weight wrapper of standard log.

Static logger

logger.G().Info("message")

writes like 2022/09/20 10:00:00 I | message to stderr.

Logger instance

l := logger.NewDefault(logger.Lerror)
l.Info("message")

Customized logger

filter := func(ev logger.Event) (logger.Event, error) {
  switch ev.Level() {
  case logger.Linfo, logger.Lwarn, logger.Lerror:
    // select info, warn, error
    return ev, nil
  default:
    // ignore other levels
    return nil. nil
  }
}
consumeError := func(ev logger.Event) (logger.Event, error) {
  if ev.Level() == logger.Lerror {
    // consume event
  }
  return ev, nil
}
l := &logger.Logger{
  Proxy: logger.NewProxy(
    logger.NewMapperList(filter),
    logger.NewMapperList(consumeError, logger.StandardLogConsumer),
  ),
}

Documentation

Index

• type ErrConsumer
• type Event
  • func LogLevelToPrefixMapper(ev Event) (Event, error)
  • func NewEvent(level Level, format string, args []any) Event
  • func StandardLogConsumer(ev Event) (Event, error)
• type GlobalLogger
  • func G() GlobalLogger
• type Level
• type Logger
  • func NewDefault(level Level) *Logger
  • func (l *Logger) Debug(format string, v ...any)
  • func (l *Logger) Error(format string, v ...any)
  • func (l *Logger) Info(format string, v ...any)
  • func (l *Logger) Trace(format string, v ...any)
  • func (l *Logger) Warn(format string, v ...any)
• type Mapper
  • func LogLevelFilter(level Level) Mapper
• type MapperList
  • func NewMapperList(v ...Mapper) MapperList
• type Proxy
  • func NewProxy(list ...MapperList) Proxy

Examples

• G
• Logger
• NewDefault

Types

type ErrConsumer

type ErrConsumer func(error)

ErrConsumer receives an error during mappings.

type Event

type Event interface {
	Level() Level
	Format() string
	Args() []any
}

func LogLevelToPrefixMapper

func LogLevelToPrefixMapper(ev Event) (Event, error)

LogLevelToPrefixMapper adds a prefix depending on the event level.

func NewEvent

func NewEvent(
	level Level,
	format string,
	args []any,
) Event

func StandardLogConsumer

func StandardLogConsumer(ev Event) (Event, error)

StandardLogConsumer writes an event by `log.Printf`.

type GlobalLogger

type GlobalLogger interface {
	Info(format string, v ...any)
	Warn(format string, v ...any)
	Error(format string, v ...any)
	Debug(format string, v ...any)
	Trace(format string, v ...any)
	SetLevel(level Level)
	Level() Level
}

GlobalLogger is a static logger instance. This filters logs by level, adds a prefix depending on event level and writes logs by `log.Printf`.

func G

func G() GlobalLogger

G returns the `GlobalLogger`.

Example

package main

import (
	"log"
	"os"

	"github.com/berquerant/logger"
)

func main() {
	log.SetFlags(0)
	log.SetOutput(os.Stdout)
	logger.G().Info("information")
	logger.G().Error("error")
	logger.G().Debug("debug")
	logger.G().SetLevel(logger.Ldebug)
	logger.G().Info("change level")
	logger.G().Debug("last line")
}

Output:

I | information
E | error
I | change level
D | last line

type Level

type Level int

Level is the threshold for logging.

const (
	Lsilent Level = 0
	Lerror  Level = 10
	Lwarn   Level = 20
	Linfo   Level = 30
	Ldebug  Level = 40
	Ltrace  Level = 50
)

type Logger

type Logger struct {
	Proxy
}

Example

package main

import (
	"fmt"

	"github.com/berquerant/logger"
)

func main() {
	levelToPrefix := func(ev logger.Event) (logger.Event, error) {
		var p string
		switch ev.Level() {
		case logger.Linfo:
			p = "INFO"
		case logger.Lwarn:
			p = "WARN"
		case logger.Lerror:
			p = "ERROR"
		default:
			p = "?"
		}
		return logger.NewEvent(
			ev.Level(),
			fmt.Sprintf("%s %s", p, ev.Format()),
			ev.Args(),
		), nil
	}
	format := func(ev logger.Event) (logger.Event, error) {
		return logger.NewEvent(ev.Level(), fmt.Sprintf(ev.Format(), ev.Args()...), nil), nil
	}
	consumeInfo := func(ev logger.Event) (logger.Event, error) {
		if ev.Level() == logger.Linfo {
			fmt.Printf("ConsumeInfo: %s\n", ev.Format())
		}
		return ev, nil
	}
	consumeAll := func(ev logger.Event) (logger.Event, error) {
		fmt.Println(ev.Format())
		return ev, nil
	}

	l := &logger.Logger{
		Proxy: logger.NewProxy(
			logger.NewMapperList(levelToPrefix, format),
			logger.NewMapperList(consumeInfo),
			logger.NewMapperList(consumeAll),
		),
	}
	l.Info("info msg")
	l.Warn("warn msg")
	l.Error("error msg")
	l.Info("info level value is %d", logger.Linfo)
}

Output:

ConsumeInfo: INFO info msg
INFO info msg
WARN warn msg
ERROR error msg
ConsumeInfo: INFO info level value is 30
INFO info level value is 30

func NewDefault

func NewDefault(level Level) *Logger

NewDefault returns a new logger with `LogLevelFilter`, `LogLevelToPrefixMapper` and `StandardLogConsumer`.

Example

package main

import (
	"log"
	"os"

	"github.com/berquerant/logger"
)

func main() {
	log.SetFlags(0)
	log.SetOutput(os.Stdout)
	l := logger.NewDefault(logger.Lwarn)
	l.Info("information")
	l.Error("error")
	l.Debug("debug")
	l.Warn("warn")
	l.Debug("last line")
}

Output:

E | error
W | warn

func (*Logger) Debug

func (l *Logger) Debug(format string, v ...any)

func (*Logger) Error

func (l *Logger) Error(format string, v ...any)

func (*Logger) Info

func (l *Logger) Info(format string, v ...any)

func (*Logger) Trace

func (l *Logger) Trace(format string, v ...any)

func (*Logger) Warn

func (l *Logger) Warn(format string, v ...any)

type Mapper

type Mapper func(Event) (Event, error)

Mapper converts and/or filters the log event.

func LogLevelFilter

func LogLevelFilter(level Level) Mapper

LogLevelFilter ignores an event with the lower level.

type MapperList

type MapperList interface {
	// Append appends a Mapper to the end of the list.
	Append(f Mapper)
	// Map applies the mappers to the event.
	// If the mapper returns a nil event or an error then cancels the propagation.
	Map(ev Event) (Event, error)
}

MapperList is a set of event conversions. In order from the top of the list, applies the mapper to the event.

func NewMapperList

func NewMapperList(v ...Mapper) MapperList

type Proxy

type Proxy interface {
	// Append appends the mapper list to the end of the list.
	Append(list MapperList)
	// At returns the i-th mapper list.
	// Returns false if out of range.
	At(i int) (MapperList, bool)
	// Put starts processing of the event.
	// Apply the first mappers the event, then the second.
	Put(ev Event)
	SetErrConsumer(ErrConsumer)
}

Proxy accepts an event and processes it.

func NewProxy

func NewProxy(list ...MapperList) Proxy