From 7bc31c25c5f9c6dec785dd1f96b1ad49139d622a Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Wed, 27 May 2020 22:15:00 -0700 Subject: [PATCH] Get rid of InfoLogger, implement V() as additive --- example/main.go | 8 ++++-- go.mod | 2 +- zapr.go | 75 ++++++++++++++++++------------------------------- 3 files changed, 34 insertions(+), 51 deletions(-) diff --git a/example/main.go b/example/main.go index 887bc97..c5d68b0 100644 --- a/example/main.go +++ b/example/main.go @@ -16,8 +16,10 @@ limitations under the License. package main -import "github.com/go-logr/zapr" -import "go.uber.org/zap" +import ( + "github.com/go-logr/zapr" + "go.uber.org/zap" +) type E struct { str string @@ -32,7 +34,7 @@ func main() { log = log.WithName("MyName").WithValues("user", "you") log.Info("hello", "val1", 1, "val2", map[string]int{"k": 1}) log.V(1).Info("you should see this") - log.V(3).Info("you should NOT see this") + log.V(1).V(1).Info("you should NOT see this") log.Error(nil, "uh oh", "trouble", true, "reasons", []float64{0.1, 0.11, 3.14}) log.Error(E{"an error occurred"}, "goodbye", "code", -1) } diff --git a/go.mod b/go.mod index 8eb0517..f7d7e25 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,7 @@ module github.com/go-logr/zapr go 1.12 require ( - github.com/go-logr/logr v0.1.0 + github.com/go-logr/logr v0.2.0 go.uber.org/atomic v1.3.2 go.uber.org/multierr v1.1.0 go.uber.org/zap v1.8.0 diff --git a/zapr.go b/zapr.go index 3819535..09a074d 100644 --- a/zapr.go +++ b/zapr.go @@ -43,7 +43,7 @@ limitations under the License. // For the most part, concepts in Zap correspond directly with those in // logr. // -// Unlike Zap, all fields *must* be in the form of suggared fields -- +// Unlike Zap, all fields *must* be in the form of sugared fields -- // it's illegal to pass a strongly-typed Zap field in a key position // to any of the log methods. // @@ -59,40 +59,18 @@ import ( "go.uber.org/zap/zapcore" ) -// noopInfoLogger is a logr.InfoLogger that's always disabled, and does nothing. -type noopInfoLogger struct{} - -func (l *noopInfoLogger) Enabled() bool { return false } -func (l *noopInfoLogger) Info(_ string, _ ...interface{}) {} - -var disabledInfoLogger = &noopInfoLogger{} - // NB: right now, we always use the equivalent of sugared logging. // This is necessary, since logr doesn't define non-suggared types, // and using zap-specific non-suggared types would make uses tied // directly to Zap. -// infoLogger is a logr.InfoLogger that uses Zap to log at a particular -// level. The level has already been converted to a Zap level, which -// is to say that `logrLevel = -1*zapLevel`. -type infoLogger struct { - lvl zapcore.Level - l *zap.Logger -} - -func (l *infoLogger) Enabled() bool { return true } -func (l *infoLogger) Info(msg string, keysAndVals ...interface{}) { - if checkedEntry := l.l.Check(l.lvl, msg); checkedEntry != nil { - checkedEntry.Write(handleFields(l.l, keysAndVals)...) - } -} - -// zapLogger is a logr.Logger that uses Zap to log. +// zapLogger is a logr.Logger that uses Zap to log. The level has already been +// converted to a Zap level, which is to say that `logrLevel = -1*zapLevel`. type zapLogger struct { // NB: this looks very similar to zap.SugaredLogger, but // deals with our desire to have multiple verbosity levels. - l *zap.Logger - infoLogger + l *zap.Logger + lvl zapcore.Level } // handleFields converts a bunch of arbitrary key-value pairs into Zap fields. It takes @@ -140,30 +118,36 @@ func handleFields(l *zap.Logger, args []interface{}, additional ...zap.Field) [] return append(fields, additional...) } -func (l *zapLogger) Error(err error, msg string, keysAndVals ...interface{}) { - if checkedEntry := l.l.Check(zap.ErrorLevel, msg); checkedEntry != nil { - checkedEntry.Write(handleFields(l.l, keysAndVals, zap.Error(err))...) +func (zl *zapLogger) Enabled() bool { + return zl.l.Core().Enabled(zl.lvl) +} + +func (zl *zapLogger) Info(msg string, keysAndVals ...interface{}) { + if checkedEntry := zl.l.Check(zl.lvl, msg); checkedEntry != nil { + checkedEntry.Write(handleFields(zl.l, keysAndVals)...) } } -func (l *zapLogger) V(level int) logr.InfoLogger { - lvl := zapcore.Level(-1 * level) - if l.l.Core().Enabled(lvl) { - return &infoLogger{ - lvl: lvl, - l: l.l, - } +func (zl *zapLogger) Error(err error, msg string, keysAndVals ...interface{}) { + if checkedEntry := zl.l.Check(zap.ErrorLevel, msg); checkedEntry != nil { + checkedEntry.Write(handleFields(zl.l, keysAndVals, zap.Error(err))...) + } +} + +func (zl *zapLogger) V(level int) logr.Logger { + return &zapLogger{ + lvl: zl.lvl - zapcore.Level(level), + l: zl.l, } - return disabledInfoLogger } -func (l *zapLogger) WithValues(keysAndValues ...interface{}) logr.Logger { - newLogger := l.l.With(handleFields(l.l, keysAndValues)...) +func (zl *zapLogger) WithValues(keysAndValues ...interface{}) logr.Logger { + newLogger := zl.l.With(handleFields(zl.l, keysAndValues)...) return newLoggerWithExtraSkip(newLogger, 0) } -func (l *zapLogger) WithName(name string) logr.Logger { - newLogger := l.l.Named(name) +func (zl *zapLogger) WithName(name string) logr.Logger { + newLogger := zl.l.Named(name) return newLoggerWithExtraSkip(newLogger, 0) } @@ -171,11 +155,8 @@ func (l *zapLogger) WithName(name string) logr.Logger { func newLoggerWithExtraSkip(l *zap.Logger, callerSkip int) logr.Logger { log := l.WithOptions(zap.AddCallerSkip(callerSkip)) return &zapLogger{ - l: log, - infoLogger: infoLogger{ - l: log, - lvl: zap.InfoLevel, - }, + l: log, + lvl: zap.InfoLevel, } }