mirror of https://github.com/grafana/grafana
Chore: Remove the old log format (#51526)
* remove the old log format * fix CI Co-authored-by: Emil Tullstedt <emil.tullstedt@grafana.com>pull/51989/head
ying-jeanne
4 years ago
committed by
GitHub
parent
e1f876eee8
commit
56f3f3fe69
@ -1,264 +0,0 @@ |
||||
package level |
||||
|
||||
import ( |
||||
"github.com/go-kit/log" |
||||
gokitlevel "github.com/go-kit/log/level" |
||||
) |
||||
|
||||
// Error returns a logger that includes a Key/ErrorValue pair.
|
||||
func Error(logger log.Logger) log.Logger { |
||||
return log.WithPrefix(logger, Key(), ErrorValue()) |
||||
} |
||||
|
||||
// Warn returns a logger that includes a Key/WarnValue pair.
|
||||
func Warn(logger log.Logger) log.Logger { |
||||
return log.WithPrefix(logger, Key(), WarnValue()) |
||||
} |
||||
|
||||
// Info returns a logger that includes a Key/InfoValue pair.
|
||||
func Info(logger log.Logger) log.Logger { |
||||
return log.WithPrefix(logger, Key(), InfoValue()) |
||||
} |
||||
|
||||
// Debug returns a logger that includes a Key/DebugValue pair.
|
||||
func Debug(logger log.Logger) log.Logger { |
||||
return log.WithPrefix(logger, Key(), DebugValue()) |
||||
} |
||||
|
||||
// NewFilter wraps next and implements level filtering. See the commentary on
|
||||
// the Option functions for a detailed description of how to configure levels.
|
||||
// If no options are provided, all leveled log events created with Debug,
|
||||
// Info, Warn or Error helper methods are squelched and non-leveled log
|
||||
// events are passed to next unmodified.
|
||||
func NewFilter(next log.Logger, options ...Option) log.Logger { |
||||
l := &logger{ |
||||
next: next, |
||||
} |
||||
for _, option := range options { |
||||
option(l) |
||||
} |
||||
return l |
||||
} |
||||
|
||||
type logger struct { |
||||
next log.Logger |
||||
allowed level |
||||
squelchNoLevel bool |
||||
errNotAllowed error |
||||
errNoLevel error |
||||
} |
||||
|
||||
func (l *logger) Log(keyvals ...interface{}) error { |
||||
var hasLevel, levelAllowed bool |
||||
for i := 1; i < len(keyvals); i += 2 { |
||||
if v, ok := keyvals[i].(*levelValue); ok { |
||||
hasLevel = true |
||||
levelAllowed = l.allowed&v.level != 0 |
||||
break |
||||
} |
||||
|
||||
if v, ok := keyvals[i].(gokitlevel.Value); ok { |
||||
hasLevel = true |
||||
levelAllowed = l.allowed&levelFromGokitLevel(v) != 0 |
||||
break |
||||
} |
||||
} |
||||
if !hasLevel && l.squelchNoLevel { |
||||
return l.errNoLevel |
||||
} |
||||
if hasLevel && !levelAllowed { |
||||
return l.errNotAllowed |
||||
} |
||||
return l.next.Log(keyvals...) |
||||
} |
||||
|
||||
// Option sets a parameter for the leveled logger.
|
||||
type Option func(*logger) |
||||
|
||||
// AllowAll is an alias for AllowDebug.
|
||||
func AllowAll() Option { |
||||
return AllowDebug() |
||||
} |
||||
|
||||
// AllowDebug allows error, warn, info and debug level log events to pass.
|
||||
func AllowDebug() Option { |
||||
return allowed(levelError | levelWarn | levelInfo | levelDebug) |
||||
} |
||||
|
||||
// AllowInfo allows error, warn and info level log events to pass.
|
||||
func AllowInfo() Option { |
||||
return allowed(levelError | levelWarn | levelInfo) |
||||
} |
||||
|
||||
// AllowWarn allows error and warn level log events to pass.
|
||||
func AllowWarn() Option { |
||||
return allowed(levelError | levelWarn) |
||||
} |
||||
|
||||
// AllowError allows only error level log events to pass.
|
||||
func AllowError() Option { |
||||
return allowed(levelError) |
||||
} |
||||
|
||||
// AllowNone allows no leveled log events to pass.
|
||||
func AllowNone() Option { |
||||
return allowed(0) |
||||
} |
||||
|
||||
func allowed(allowed level) Option { |
||||
return func(l *logger) { l.allowed = allowed } |
||||
} |
||||
|
||||
// ErrNotAllowed sets the error to return from Log when it squelches a log
|
||||
// event disallowed by the configured Allow[Level] option. By default,
|
||||
// ErrNotAllowed is nil; in this case the log event is squelched with no
|
||||
// error.
|
||||
func ErrNotAllowed(err error) Option { |
||||
return func(l *logger) { l.errNotAllowed = err } |
||||
} |
||||
|
||||
// SquelchNoLevel instructs Log to squelch log events with no level, so that
|
||||
// they don't proceed through to the wrapped logger. If SquelchNoLevel is set
|
||||
// to true and a log event is squelched in this way, the error value
|
||||
// configured with ErrNoLevel is returned to the caller.
|
||||
func SquelchNoLevel(squelch bool) Option { |
||||
return func(l *logger) { l.squelchNoLevel = squelch } |
||||
} |
||||
|
||||
// ErrNoLevel sets the error to return from Log when it squelches a log event
|
||||
// with no level. By default, ErrNoLevel is nil; in this case the log event is
|
||||
// squelched with no error.
|
||||
func ErrNoLevel(err error) Option { |
||||
return func(l *logger) { l.errNoLevel = err } |
||||
} |
||||
|
||||
// NewInjector wraps next and returns a logger that adds a Key/level pair to
|
||||
// the beginning of log events that don't already contain a level. In effect,
|
||||
// this gives a default level to logs without a level.
|
||||
func NewInjector(next log.Logger, level Value) log.Logger { |
||||
return &injector{ |
||||
next: next, |
||||
level: level, |
||||
} |
||||
} |
||||
|
||||
type injector struct { |
||||
next log.Logger |
||||
level interface{} |
||||
} |
||||
|
||||
func (l *injector) Log(keyvals ...interface{}) error { |
||||
for i := 1; i < len(keyvals); i += 2 { |
||||
if _, ok := keyvals[i].(*levelValue); ok { |
||||
return l.next.Log(keyvals...) |
||||
} |
||||
} |
||||
kvs := make([]interface{}, len(keyvals)+2) |
||||
kvs[0], kvs[1] = key, l.level |
||||
copy(kvs[2:], keyvals) |
||||
return l.next.Log(kvs...) |
||||
} |
||||
|
||||
// Value is the interface that each of the canonical level values implement.
|
||||
// It contains unexported methods that prevent types from other packages from
|
||||
// implementing it and guaranteeing that NewFilter can distinguish the levels
|
||||
// defined in this package from all other values.
|
||||
type Value interface { |
||||
String() string |
||||
levelVal() |
||||
} |
||||
|
||||
// Key returns the unique key added to log events by the loggers in this
|
||||
// package.
|
||||
func Key() interface{} { return key } |
||||
|
||||
// ErrorValue returns the unique value added to log events by Error.
|
||||
func ErrorValue() Value { return errorValue } |
||||
|
||||
// WarnValue returns the unique value added to log events by Warn.
|
||||
func WarnValue() Value { return warnValue } |
||||
|
||||
// InfoValue returns the unique value added to log events by Info.
|
||||
func InfoValue() Value { return infoValue } |
||||
|
||||
// DebugValue returns the unique value added to log events by Debug.
|
||||
func DebugValue() Value { return debugValue } |
||||
|
||||
var ( |
||||
// key is of type interface{} so that it allocates once during package
|
||||
// initialization and avoids allocating every time the value is added to a
|
||||
// []interface{} later.
|
||||
key interface{} = "lvl" |
||||
|
||||
errorValue = &levelValue{level: levelError, name: "eror"} |
||||
warnValue = &levelValue{level: levelWarn, name: "warn"} |
||||
infoValue = &levelValue{level: levelInfo, name: "info"} |
||||
debugValue = &levelValue{level: levelDebug, name: "dbug"} |
||||
) |
||||
|
||||
func SetLevelKeyAndValuesToGokitLog() { |
||||
key = "level" |
||||
errorValue = &levelValue{level: levelError, name: "error"} |
||||
warnValue = &levelValue{level: levelWarn, name: "warn"} |
||||
infoValue = &levelValue{level: levelInfo, name: "info"} |
||||
debugValue = &levelValue{level: levelDebug, name: "debug"} |
||||
} |
||||
|
||||
type level byte |
||||
|
||||
const ( |
||||
levelDebug level = 1 << iota |
||||
levelInfo |
||||
levelWarn |
||||
levelError |
||||
) |
||||
|
||||
func IsKey(v interface{}) bool { |
||||
return v != nil && (v == Key() || v == gokitlevel.Key()) |
||||
} |
||||
|
||||
func GetValue(v interface{}) Value { |
||||
if v == nil { |
||||
return nil |
||||
} |
||||
|
||||
if val, ok := v.(Value); ok { |
||||
return val |
||||
} |
||||
|
||||
if val, ok := v.(gokitlevel.Value); ok { |
||||
switch val { |
||||
case gokitlevel.InfoValue(): |
||||
return InfoValue() |
||||
case gokitlevel.WarnValue(): |
||||
return WarnValue() |
||||
case gokitlevel.ErrorValue(): |
||||
return ErrorValue() |
||||
case gokitlevel.DebugValue(): |
||||
return DebugValue() |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
type levelValue struct { |
||||
name string |
||||
level |
||||
} |
||||
|
||||
func (v *levelValue) String() string { return v.name } |
||||
func (v *levelValue) levelVal() {} |
||||
|
||||
func levelFromGokitLevel(l gokitlevel.Value) level { |
||||
switch l.String() { |
||||
case gokitlevel.ErrorValue().String(): |
||||
return levelError |
||||
case gokitlevel.WarnValue().String(): |
||||
return levelWarn |
||||
case gokitlevel.DebugValue().String(): |
||||
return levelDebug |
||||
} |
||||
|
||||
return levelInfo |
||||
} |
||||
@ -1,155 +0,0 @@ |
||||
package level_test |
||||
|
||||
import ( |
||||
"testing" |
||||
|
||||
gokitlog "github.com/go-kit/log" |
||||
gokitlevel "github.com/go-kit/log/level" |
||||
"github.com/stretchr/testify/require" |
||||
|
||||
"github.com/grafana/grafana/pkg/infra/log" |
||||
"github.com/grafana/grafana/pkg/infra/log/level" |
||||
) |
||||
|
||||
func TestNewFilter(t *testing.T) { |
||||
newFilteredLoggerScenario(t, "Given all levels is allowed should log all messages", level.AllowAll(), func(t *testing.T, ctx *scenarioContext) { |
||||
logTestMessages(t, ctx) |
||||
|
||||
require.Len(t, ctx.loggedArgs, 8) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[0][2].(string)) |
||||
require.Equal(t, "info", ctx.loggedArgs[0][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[1][2].(string)) |
||||
require.Equal(t, "warn", ctx.loggedArgs[1][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[2][2].(string)) |
||||
require.Equal(t, "eror", ctx.loggedArgs[2][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[3][2].(string)) |
||||
require.Equal(t, "dbug", ctx.loggedArgs[3][3].(level.Value).String()) |
||||
|
||||
require.Equal(t, "level", ctx.loggedArgs[4][2].(string)) |
||||
require.Equal(t, "info", ctx.loggedArgs[4][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[5][2].(string)) |
||||
require.Equal(t, "warn", ctx.loggedArgs[5][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[6][2].(string)) |
||||
require.Equal(t, "error", ctx.loggedArgs[6][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[7][2].(string)) |
||||
require.Equal(t, "debug", ctx.loggedArgs[7][3].(gokitlevel.Value).String()) |
||||
}) |
||||
|
||||
newFilteredLoggerScenario(t, "Given error, warnings, info, debug is allowed should log all messages", level.AllowDebug(), func(t *testing.T, ctx *scenarioContext) { |
||||
logTestMessages(t, ctx) |
||||
|
||||
require.Len(t, ctx.loggedArgs, 8) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[0][2].(string)) |
||||
require.Equal(t, "info", ctx.loggedArgs[0][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[1][2].(string)) |
||||
require.Equal(t, "warn", ctx.loggedArgs[1][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[2][2].(string)) |
||||
require.Equal(t, "eror", ctx.loggedArgs[2][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[3][2].(string)) |
||||
require.Equal(t, "dbug", ctx.loggedArgs[3][3].(level.Value).String()) |
||||
|
||||
require.Equal(t, "level", ctx.loggedArgs[4][2].(string)) |
||||
require.Equal(t, "info", ctx.loggedArgs[4][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[5][2].(string)) |
||||
require.Equal(t, "warn", ctx.loggedArgs[5][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[6][2].(string)) |
||||
require.Equal(t, "error", ctx.loggedArgs[6][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[7][2].(string)) |
||||
require.Equal(t, "debug", ctx.loggedArgs[7][3].(gokitlevel.Value).String()) |
||||
}) |
||||
|
||||
newFilteredLoggerScenario(t, "Given error, warnings is allowed should log error and warning messages", level.AllowWarn(), func(t *testing.T, ctx *scenarioContext) { |
||||
logTestMessages(t, ctx) |
||||
|
||||
require.Len(t, ctx.loggedArgs, 4) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[0][2].(string)) |
||||
require.Equal(t, "warn", ctx.loggedArgs[0][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[1][2].(string)) |
||||
require.Equal(t, "eror", ctx.loggedArgs[1][3].(level.Value).String()) |
||||
|
||||
require.Equal(t, "level", ctx.loggedArgs[2][2].(string)) |
||||
require.Equal(t, "warn", ctx.loggedArgs[2][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[3][2].(string)) |
||||
require.Equal(t, "error", ctx.loggedArgs[3][3].(gokitlevel.Value).String()) |
||||
}) |
||||
|
||||
newFilteredLoggerScenario(t, "Given error allowed should log error messages", level.AllowError(), func(t *testing.T, ctx *scenarioContext) { |
||||
logTestMessages(t, ctx) |
||||
|
||||
require.Len(t, ctx.loggedArgs, 2) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[0][2].(string)) |
||||
require.Equal(t, "eror", ctx.loggedArgs[0][3].(level.Value).String()) |
||||
|
||||
require.Equal(t, "level", ctx.loggedArgs[1][2].(string)) |
||||
require.Equal(t, "error", ctx.loggedArgs[1][3].(gokitlevel.Value).String()) |
||||
}) |
||||
|
||||
newFilteredLoggerScenario(t, "Given error, warnings, info is allowed should log error, warning and info messages", level.AllowInfo(), func(t *testing.T, ctx *scenarioContext) { |
||||
logTestMessages(t, ctx) |
||||
|
||||
require.Len(t, ctx.loggedArgs, 6) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[0][2].(string)) |
||||
require.Equal(t, "info", ctx.loggedArgs[0][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[1][2].(string)) |
||||
require.Equal(t, "warn", ctx.loggedArgs[1][3].(level.Value).String()) |
||||
require.Equal(t, "lvl", ctx.loggedArgs[2][2].(string)) |
||||
require.Equal(t, "eror", ctx.loggedArgs[2][3].(level.Value).String()) |
||||
|
||||
require.Equal(t, "level", ctx.loggedArgs[3][2].(string)) |
||||
require.Equal(t, "info", ctx.loggedArgs[3][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[4][2].(string)) |
||||
require.Equal(t, "warn", ctx.loggedArgs[4][3].(gokitlevel.Value).String()) |
||||
require.Equal(t, "level", ctx.loggedArgs[5][2].(string)) |
||||
require.Equal(t, "error", ctx.loggedArgs[5][3].(gokitlevel.Value).String()) |
||||
}) |
||||
|
||||
newFilteredLoggerScenario(t, "Given no levels is allowed should not log any messages", level.AllowNone(), func(t *testing.T, ctx *scenarioContext) { |
||||
logTestMessages(t, ctx) |
||||
|
||||
require.Len(t, ctx.loggedArgs, 0) |
||||
}) |
||||
} |
||||
|
||||
func logTestMessages(t *testing.T, ctx *scenarioContext) { |
||||
t.Helper() |
||||
|
||||
ctx.logger.Info("info msg") |
||||
ctx.logger.Warn("warn msg") |
||||
ctx.logger.Error("error msg") |
||||
ctx.logger.Debug("debug msg") |
||||
err := gokitlevel.Info(ctx.logger).Log("msg", "gokit info msg") |
||||
require.NoError(t, err) |
||||
err = gokitlevel.Warn(ctx.logger).Log("msg", "gokit warn msg") |
||||
require.NoError(t, err) |
||||
err = gokitlevel.Error(ctx.logger).Log("msg", "gokit error msg") |
||||
require.NoError(t, err) |
||||
err = gokitlevel.Debug(ctx.logger).Log("msg", "gokit debug msg") |
||||
require.NoError(t, err) |
||||
} |
||||
|
||||
type scenarioContext struct { |
||||
loggedArgs [][]interface{} |
||||
logger log.Logger |
||||
} |
||||
|
||||
func newFilteredLoggerScenario(t *testing.T, desc string, option level.Option, fn func(t *testing.T, ctx *scenarioContext)) { |
||||
t.Helper() |
||||
|
||||
ctx := &scenarioContext{ |
||||
loggedArgs: [][]interface{}{}, |
||||
} |
||||
|
||||
l := gokitlog.LoggerFunc(func(i ...interface{}) error { |
||||
ctx.loggedArgs = append(ctx.loggedArgs, i) |
||||
return nil |
||||
}) |
||||
filteredLogger := level.NewFilter(l, option) |
||||
testLogger := log.New("test") |
||||
testLogger.Swap(filteredLogger) |
||||
|
||||
ctx.logger = testLogger |
||||
|
||||
t.Run(desc, func(t *testing.T) { |
||||
fn(t, ctx) |
||||
}) |
||||
} |
||||
Loading…
Reference in new issue