128 lines
3.8 KiB
Go
128 lines
3.8 KiB
Go
package levels
|
|
|
|
import "github.com/go-kit/kit/log"
|
|
|
|
// Levels provides a leveled logging wrapper around a logger. It has five
|
|
// levels: debug, info, warning (warn), error, and critical (crit). If you
|
|
// want a different set of levels, you can create your own levels type very
|
|
// easily, and you can elide the configuration.
|
|
type Levels struct {
|
|
ctx *log.Context
|
|
levelKey string
|
|
|
|
// We have a choice between storing level values in string fields or
|
|
// making a separate context for each level. When using string fields the
|
|
// Log method must combine the base context, the level data, and the
|
|
// logged keyvals; but the With method only requires updating one context.
|
|
// If we instead keep a separate context for each level the Log method
|
|
// must only append the new keyvals; but the With method would have to
|
|
// update all five contexts.
|
|
|
|
// Roughly speaking, storing multiple contexts breaks even if the ratio of
|
|
// Log/With calls is more than the number of levels. We have chosen to
|
|
// make the With method cheap and the Log method a bit more costly because
|
|
// we do not expect most applications to Log more than five times for each
|
|
// call to With.
|
|
|
|
debugValue string
|
|
infoValue string
|
|
warnValue string
|
|
errorValue string
|
|
critValue string
|
|
}
|
|
|
|
// New creates a new leveled logger, wrapping the passed logger.
|
|
func New(logger log.Logger, options ...Option) Levels {
|
|
l := Levels{
|
|
ctx: log.NewContext(logger),
|
|
levelKey: "level",
|
|
|
|
debugValue: "debug",
|
|
infoValue: "info",
|
|
warnValue: "warn",
|
|
errorValue: "error",
|
|
critValue: "crit",
|
|
}
|
|
for _, option := range options {
|
|
option(&l)
|
|
}
|
|
return l
|
|
}
|
|
|
|
// With returns a new leveled logger that includes keyvals in all log events.
|
|
func (l Levels) With(keyvals ...interface{}) Levels {
|
|
return Levels{
|
|
ctx: l.ctx.With(keyvals...),
|
|
levelKey: l.levelKey,
|
|
debugValue: l.debugValue,
|
|
infoValue: l.infoValue,
|
|
warnValue: l.warnValue,
|
|
errorValue: l.errorValue,
|
|
critValue: l.critValue,
|
|
}
|
|
}
|
|
|
|
// Debug returns a debug level logger.
|
|
func (l Levels) Debug() log.Logger {
|
|
return l.ctx.WithPrefix(l.levelKey, l.debugValue)
|
|
}
|
|
|
|
// Info returns an info level logger.
|
|
func (l Levels) Info() log.Logger {
|
|
return l.ctx.WithPrefix(l.levelKey, l.infoValue)
|
|
}
|
|
|
|
// Warn returns a warning level logger.
|
|
func (l Levels) Warn() log.Logger {
|
|
return l.ctx.WithPrefix(l.levelKey, l.warnValue)
|
|
}
|
|
|
|
// Error returns an error level logger.
|
|
func (l Levels) Error() log.Logger {
|
|
return l.ctx.WithPrefix(l.levelKey, l.errorValue)
|
|
}
|
|
|
|
// Crit returns a critical level logger.
|
|
func (l Levels) Crit() log.Logger {
|
|
return l.ctx.WithPrefix(l.levelKey, l.critValue)
|
|
}
|
|
|
|
// Option sets a parameter for leveled loggers.
|
|
type Option func(*Levels)
|
|
|
|
// Key sets the key for the field used to indicate log level. By default,
|
|
// the key is "level".
|
|
func Key(key string) Option {
|
|
return func(l *Levels) { l.levelKey = key }
|
|
}
|
|
|
|
// DebugValue sets the value for the field used to indicate the debug log
|
|
// level. By default, the value is "debug".
|
|
func DebugValue(value string) Option {
|
|
return func(l *Levels) { l.debugValue = value }
|
|
}
|
|
|
|
// InfoValue sets the value for the field used to indicate the info log level.
|
|
// By default, the value is "info".
|
|
func InfoValue(value string) Option {
|
|
return func(l *Levels) { l.infoValue = value }
|
|
}
|
|
|
|
// WarnValue sets the value for the field used to indicate the warning log
|
|
// level. By default, the value is "warn".
|
|
func WarnValue(value string) Option {
|
|
return func(l *Levels) { l.warnValue = value }
|
|
}
|
|
|
|
// ErrorValue sets the value for the field used to indicate the error log
|
|
// level. By default, the value is "error".
|
|
func ErrorValue(value string) Option {
|
|
return func(l *Levels) { l.errorValue = value }
|
|
}
|
|
|
|
// CritValue sets the value for the field used to indicate the critical log
|
|
// level. By default, the value is "crit".
|
|
func CritValue(value string) Option {
|
|
return func(l *Levels) { l.critValue = value }
|
|
}
|