3 import "github.com/go-kit/kit/log"
5 // Error returns a logger that includes a Key/ErrorValue pair.
6 func Error(logger log.Logger) log.Logger {
7 return log.WithPrefix(logger, Key(), ErrorValue())
10 // Warn returns a logger that includes a Key/WarnValue pair.
11 func Warn(logger log.Logger) log.Logger {
12 return log.WithPrefix(logger, Key(), WarnValue())
15 // Info returns a logger that includes a Key/InfoValue pair.
16 func Info(logger log.Logger) log.Logger {
17 return log.WithPrefix(logger, Key(), InfoValue())
20 // Debug returns a logger that includes a Key/DebugValue pair.
21 func Debug(logger log.Logger) log.Logger {
22 return log.WithPrefix(logger, Key(), DebugValue())
25 // NewFilter wraps next and implements level filtering. See the commentary on
26 // the Option functions for a detailed description of how to configure levels.
27 // If no options are provided, all leveled log events created with Debug,
28 // Info, Warn or Error helper methods are squelched and non-leveled log
29 // events are passed to next unmodified.
30 func NewFilter(next log.Logger, options ...Option) log.Logger {
34 for _, option := range options {
48 func (l *logger) Log(keyvals ...interface{}) error {
49 var hasLevel, levelAllowed bool
50 for i := 1; i < len(keyvals); i += 2 {
51 if v, ok := keyvals[i].(*levelValue); ok {
53 levelAllowed = l.allowed&v.level != 0
57 if !hasLevel && l.squelchNoLevel {
60 if hasLevel && !levelAllowed {
61 return l.errNotAllowed
63 return l.next.Log(keyvals...)
66 // Option sets a parameter for the leveled logger.
67 type Option func(*logger)
69 // AllowAll is an alias for AllowDebug.
70 func AllowAll() Option {
74 // AllowDebug allows error, warn, info and debug level log events to pass.
75 func AllowDebug() Option {
76 return allowed(levelError | levelWarn | levelInfo | levelDebug)
79 // AllowInfo allows error, warn and info level log events to pass.
80 func AllowInfo() Option {
81 return allowed(levelError | levelWarn | levelInfo)
84 // AllowWarn allows error and warn level log events to pass.
85 func AllowWarn() Option {
86 return allowed(levelError | levelWarn)
89 // AllowError allows only error level log events to pass.
90 func AllowError() Option {
91 return allowed(levelError)
94 // AllowNone allows no leveled log events to pass.
95 func AllowNone() Option {
99 func allowed(allowed level) Option {
100 return func(l *logger) { l.allowed = allowed }
103 // ErrNotAllowed sets the error to return from Log when it squelches a log
104 // event disallowed by the configured Allow[Level] option. By default,
105 // ErrNotAllowed is nil; in this case the log event is squelched with no
107 func ErrNotAllowed(err error) Option {
108 return func(l *logger) { l.errNotAllowed = err }
111 // SquelchNoLevel instructs Log to squelch log events with no level, so that
112 // they don't proceed through to the wrapped logger. If SquelchNoLevel is set
113 // to true and a log event is squelched in this way, the error value
114 // configured with ErrNoLevel is returned to the caller.
115 func SquelchNoLevel(squelch bool) Option {
116 return func(l *logger) { l.squelchNoLevel = squelch }
119 // ErrNoLevel sets the error to return from Log when it squelches a log event
120 // with no level. By default, ErrNoLevel is nil; in this case the log event is
121 // squelched with no error.
122 func ErrNoLevel(err error) Option {
123 return func(l *logger) { l.errNoLevel = err }
126 // NewInjector wraps next and returns a logger that adds a Key/level pair to
127 // the beginning of log events that don't already contain a level. In effect,
128 // this gives a default level to logs without a level.
129 func NewInjector(next log.Logger, level Value) log.Logger {
136 type injector struct {
141 func (l *injector) Log(keyvals ...interface{}) error {
142 for i := 1; i < len(keyvals); i += 2 {
143 if _, ok := keyvals[i].(*levelValue); ok {
144 return l.next.Log(keyvals...)
147 kvs := make([]interface{}, len(keyvals)+2)
148 kvs[0], kvs[1] = key, l.level
149 copy(kvs[2:], keyvals)
150 return l.next.Log(kvs...)
153 // Value is the interface that each of the canonical level values implement.
154 // It contains unexported methods that prevent types from other packages from
155 // implementing it and guaranteeing that NewFilter can distinguish the levels
156 // defined in this package from all other values.
157 type Value interface {
162 // Key returns the unique key added to log events by the loggers in this
164 func Key() interface{} { return key }
166 // ErrorValue returns the unique value added to log events by Error.
167 func ErrorValue() Value { return errorValue }
169 // WarnValue returns the unique value added to log events by Warn.
170 func WarnValue() Value { return warnValue }
172 // InfoValue returns the unique value added to log events by Info.
173 func InfoValue() Value { return infoValue }
175 // DebugValue returns the unique value added to log events by Warn.
176 func DebugValue() Value { return debugValue }
179 // key is of type interfae{} so that it allocates once during package
180 // initialization and avoids allocating every type the value is added to a
181 // []interface{} later.
182 key interface{} = "level"
184 errorValue = &levelValue{level: levelError, name: "error"}
185 warnValue = &levelValue{level: levelWarn, name: "warn"}
186 infoValue = &levelValue{level: levelInfo, name: "info"}
187 debugValue = &levelValue{level: levelDebug, name: "debug"}
193 levelDebug level = 1 << iota
199 type levelValue struct {
204 func (v *levelValue) String() string { return v.name }
205 func (v *levelValue) levelVal() {}