Finish sugared logger, update tests & benchmarks

Author: Akshay Shah

common_test.go

@@ -41,6 +41,10 @@ func withLogger(t testing.TB, e zapcore.LevelEnabler, opts []Option, f func(Logg
 	f(log, &logs)
 }
 
+func withSugar(t testing.TB, e zapcore.LevelEnabler, opts []Option, f func(*SugaredLogger, *zapcore.ObservedLogs)) {
+	withLogger(t, e, opts, func(logger Logger, logs *zapcore.ObservedLogs) { f(Sugar(logger), logs) })
+}
+
 func runConcurrently(goroutines, iterations int, wg *sync.WaitGroup, f func()) {
 	wg.Add(goroutines)
 	for g := 0; g < goroutines; g++ {

field.go

@@ -156,3 +156,53 @@ func Reflect(key string, val interface{}) zapcore.Field {
 func Nest(key string, fields ...zapcore.Field) zapcore.Field {
 	return zapcore.Field{Key: key, Type: zapcore.ObjectMarshalerType, Interface: zapcore.Fields(fields)}
 }
+
+// Any takes a key and an arbitrary value and chooses the best way to represent
+// them as a field, falling back to a reflection-based approach only if
+// necessary.
+func Any(key string, value interface{}) zapcore.Field {
+	switch val := value.(type) {
+	case zapcore.ObjectMarshaler:
+		return Object(key, val)
+	case bool:
+		return Bool(key, val)
+	case float64:
+		return Float64(key, val)
+	case float32:
+		return Float64(key, float64(val))
+	case int:
+		return Int(key, val)
+	case int64:
+		return Int64(key, val)
+	case int32:
+		return Int64(key, int64(val))
+	case int16:
+		return Int64(key, int64(val))
+	case int8:
+		return Int64(key, int64(val))
+	case uint:
+		return Uint(key, val)
+	case uint64:
+		return Uint64(key, val)
+	case uint32:
+		return Uint64(key, uint64(val))
+	case uint16:
+		return Uint64(key, uint64(val))
+	case uint8:
+		return Uint64(key, uint64(val))
+	case uintptr:
+		return Uintptr(key, val)
+	case string:
+		return String(key, val)
+	case error:
+		return String(key, val.Error())
+	case time.Time:
+		return Time(key, val)
+	case time.Duration:
+		return Duration(key, val)
+	case fmt.Stringer:
+		return String(key, val.String())
+	default:
+		return Reflect(key, val)
+	}
+}

sugar.go

@@ -22,9 +22,12 @@ package zap
 
 import (
 	"fmt"
-	"time"
+
+	"go.uber.org/zap/zapcore"
 )
 
+const oddNumberErrMsg = "Passed an odd number of keys and values to SugaredLogger, ignoring last."
+
 // A SugaredLogger wraps the core Logger functionality in a slower, but less
 // verbose, API.
 type SugaredLogger struct {
@@ -33,19 +36,20 @@ type SugaredLogger struct {
 
 // Sugar converts a Logger to a SugaredLogger.
 func Sugar(core Logger) *SugaredLogger {
+	// TODO: increment caller skip.
 	return &SugaredLogger{core}
 }
 
 // Desugar unwraps a SugaredLogger, exposing the original Logger.
 func Desugar(s *SugaredLogger) Logger {
+	// TODO: decrement caller skip.
 	return s.core
 }
 
 // With adds a variadic number of key-value pairs to the logging context.
 // Even-indexed arguments are treated as keys, and are converted to strings
 // (with fmt.Sprint) if necessary. The keys are then zipped with the
-// odd-indexed values into typed fields, falling back to a reflection-based
-// encoder if necessary.
+// odd-indexed values into typed fields using the Any field constructor.
 //
 // For example,
 //   sugaredLogger.With(
@@ -65,165 +69,146 @@ func (s *SugaredLogger) With(args ...interface{}) *SugaredLogger {
 	return &SugaredLogger{core: s.core.With(sweetenFields(args, s.core)...)}
 }
 
-// WithStack adds a complete stack trace to the logger's context, using the key
-// "stacktrace".
-func (s *SugaredLogger) WithStack() *SugaredLogger {
-	return &SugaredLogger{core: s.core.With(Stack())}
+// WithFields adds structured fields to the logger's context, just like the
+// standard Logger's With method.
+func (s *SugaredLogger) WithFields(fs ...zapcore.Field) *SugaredLogger {
+	return &SugaredLogger{core: s.core.With(fs...)}
 }
 
 // Debug logs a message and some key-value pairs at DebugLevel. Keys and values
 // are treated as they are in the With method.
 func (s *SugaredLogger) Debug(msg interface{}, keysAndValues ...interface{}) {
-	s.core.Debug(sweetenMsg(msg), sweetenFields(keysAndValues, s.core)...)
+	if ce := s.core.Check(DebugLevel, sweetenMsg(msg)); ce != nil {
+		ce.Write(sweetenFields(keysAndValues, s.core)...)
+	}
 }
 
 // Debugf uses fmt.Sprintf to construct a dynamic message and logs it at
 // DebugLevel. It doesn't add to the message's structured context.
 func (s *SugaredLogger) Debugf(template string, args ...interface{}) {
-	s.Debug(fmt.Sprintf(template, args...))
+	if ce := s.core.Check(DebugLevel, fmt.Sprintf(template, args...)); ce != nil {
+		ce.Write()
+	}
 }
 
 // Info logs a message and some key-value pairs at InfoLevel. Keys and values
 // are treated as they are in the With method.
 func (s *SugaredLogger) Info(msg interface{}, keysAndValues ...interface{}) {
-	s.core.Info(sweetenMsg(msg), sweetenFields(keysAndValues, s.core)...)
+	if ce := s.core.Check(InfoLevel, sweetenMsg(msg)); ce != nil {
+		ce.Write(sweetenFields(keysAndValues, s.core)...)
+	}
 }
 
 // Infof uses fmt.Sprintf to construct a dynamic message and logs it at
 // InfoLevel. It doesn't add to the message's structured context.
 func (s *SugaredLogger) Infof(template string, args ...interface{}) {
-	s.Info(fmt.Sprintf(template, args...))
+	if ce := s.core.Check(InfoLevel, fmt.Sprintf(template, args...)); ce != nil {
+		ce.Write()
+	}
 }
 
 // Warn logs a message and some key-value pairs at WarnLevel. Keys and values
 // are treated as they are in the With method.
 func (s *SugaredLogger) Warn(msg interface{}, keysAndValues ...interface{}) {
-	s.core.Warn(sweetenMsg(msg), sweetenFields(keysAndValues, s.core)...)
+	if ce := s.core.Check(WarnLevel, sweetenMsg(msg)); ce != nil {
+		ce.Write(sweetenFields(keysAndValues, s.core)...)
+	}
 }
 
 // Warnf uses fmt.Sprintf to construct a dynamic message and logs it at
 // WarnLevel. It doesn't add to the message's structured context.
 func (s *SugaredLogger) Warnf(template string, args ...interface{}) {
-	s.Warn(fmt.Sprintf(template, args...))
+	if ce := s.core.Check(WarnLevel, fmt.Sprintf(template, args...)); ce != nil {
+		ce.Write()
+	}
 }
 
 // Error logs a message and some key-value pairs at ErrorLevel. Keys and values
 // are treated as they are in the With method.
 func (s *SugaredLogger) Error(msg interface{}, keysAndValues ...interface{}) {
-	s.core.Error(sweetenMsg(msg), sweetenFields(keysAndValues, s.core)...)
+	if ce := s.core.Check(ErrorLevel, sweetenMsg(msg)); ce != nil {
+		ce.Write(sweetenFields(keysAndValues, s.core)...)
+	}
 }
 
 // Errorf uses fmt.Sprintf to construct a dynamic message and logs it at
 // ErrorLevel. It doesn't add to the message's structured context.
 func (s *SugaredLogger) Errorf(template string, args ...interface{}) {
-	s.Error(fmt.Sprintf(template, args...))
+	if ce := s.core.Check(ErrorLevel, fmt.Sprintf(template, args...)); ce != nil {
+		ce.Write()
+	}
+}
+
+// DPanic logs a message and some key-value pairs using the underlying logger's
+// DPanic method. Keys and values are treated as they are in the With
+// method. (See Logger.DPanic for details.)
+func (s *SugaredLogger) DPanic(msg interface{}, keysAndValues ...interface{}) {
+	if ce := s.core.Check(DPanicLevel, sweetenMsg(msg)); ce != nil {
+		ce.Write(sweetenFields(keysAndValues, s.core)...)
+	}
+}
+
+// DPanicf uses fmt.Sprintf to construct a dynamic message, which is passed to
+// the underlying Logger's DPanic method. (See Logger.DPanic for details.) It
+// doesn't add to the message's structured context.
+func (s *SugaredLogger) DPanicf(template string, args ...interface{}) {
+	if ce := s.core.Check(DPanicLevel, fmt.Sprintf(template, args...)); ce != nil {
+		ce.Write()
+	}
 }
 
 // Panic logs a message and some key-value pairs at PanicLevel, then panics.
 // Keys and values are treated as they are in the With method.
 func (s *SugaredLogger) Panic(msg interface{}, keysAndValues ...interface{}) {
-	s.core.Panic(sweetenMsg(msg), sweetenFields(keysAndValues, s.core)...)
+	if ce := s.core.Check(PanicLevel, sweetenMsg(msg)); ce != nil {
+		ce.Write(sweetenFields(keysAndValues, s.core)...)
+	}
 }
 
 // Panicf uses fmt.Sprintf to construct a dynamic message and logs it at
 // PanicLevel, then panics. It doesn't add to the message's structured context.
 func (s *SugaredLogger) Panicf(template string, args ...interface{}) {
-	s.Panic(fmt.Sprintf(template, args...))
+	if ce := s.core.Check(PanicLevel, fmt.Sprintf(template, args...)); ce != nil {
+		ce.Write()
+	}
 }
 
 // Fatal logs a message and some key-value pairs at FatalLevel, then calls
 // os.Exit(1). Keys and values are treated as they are in the With method.
 func (s *SugaredLogger) Fatal(msg interface{}, keysAndValues ...interface{}) {
-	s.core.Fatal(sweetenMsg(msg), sweetenFields(keysAndValues, s.core)...)
+	if ce := s.core.Check(FatalLevel, sweetenMsg(msg)); ce != nil {
+		ce.Write(sweetenFields(keysAndValues, s.core)...)
+	}
 }
 
 // Fatalf uses fmt.Sprintf to construct a dynamic message and logs it at
 // FatalLevel, then calls os.Exit(1). It doesn't add to the message's
 // structured context.
 func (s *SugaredLogger) Fatalf(template string, args ...interface{}) {
-	s.Fatal(fmt.Sprintf(template, args...))
-}
-
-// DFatal logs a message and some key-value pairs using the underlying logger's
-// DFatal method. Keys and values are treated as they are in the With
-// method. (See Logger.DFatal for details.)
-func (s *SugaredLogger) DFatal(msg interface{}, keysAndValues ...interface{}) {
-	s.core.DFatal(sweetenMsg(msg), sweetenFields(keysAndValues, s.core)...)
-}
-
-// DFatalf uses fmt.Sprintf to construct a dynamic message, which is passed to
-// the underlying Logger's DFatal method. (See Logger.DFatal for details.) It
-// doesn't add to the message's structured context.
-func (s *SugaredLogger) DFatalf(template string, args ...interface{}) {
-	s.DFatal(fmt.Sprintf(template, args...))
+	if ce := s.core.Check(FatalLevel, fmt.Sprintf(template, args...)); ce != nil {
+		ce.Write()
+	}
 }
 
-func sweetenFields(args []interface{}, errLogger Logger) []Field {
+func sweetenFields(args []interface{}, errLogger Logger) []zapcore.Field {
 	if len(args) == 0 {
 		return nil
 	}
 	if len(args)%2 == 1 {
-		errLogger.DFatal(
-			"Passed an odd number of keys and values to SugaredLogger, ignoring last.",
-			Object("ignored", args[len(args)-1]),
-		)
+		errLogger.DPanic(oddNumberErrMsg, Any("ignored", args[len(args)-1]))
 	}
 
-	fields := make([]Field, len(args)/2)
+	fields := make([]zapcore.Field, len(args)/2)
 	for i := range fields {
 		key := sweetenMsg(args[2*i])
-
-		switch val := args[2*i+1].(type) {
-		case LogMarshaler:
-			fields[i] = Marshaler(key, val)
-		case bool:
-			fields[i] = Bool(key, val)
-		case float64:
-			fields[i] = Float64(key, val)
-		case float32:
-			fields[i] = Float64(key, float64(val))
-		case int:
-			fields[i] = Int(key, val)
-		case int64:
-			fields[i] = Int64(key, val)
-		case int32:
-			fields[i] = Int64(key, int64(val))
-		case int16:
-			fields[i] = Int64(key, int64(val))
-		case int8:
-			fields[i] = Int64(key, int64(val))
-		case uint:
-			fields[i] = Uint(key, val)
-		case uint64:
-			fields[i] = Uint64(key, val)
-		case uint32:
-			fields[i] = Uint64(key, uint64(val))
-		case uint16:
-			fields[i] = Uint64(key, uint64(val))
-		case uint8:
-			fields[i] = Uint64(key, uint64(val))
-		case uintptr:
-			fields[i] = Uintptr(key, val)
-		case string:
-			fields[i] = String(key, val)
-		case time.Time:
-			fields[i] = Time(key, val)
-		case time.Duration:
-			fields[i] = Duration(key, val)
-		case error:
-			fields[i] = String(key, val.Error())
-		case fmt.Stringer:
-			fields[i] = String(key, val.String())
-		default:
-			fields[i] = Object(key, val)
-		}
+		fields[i] = Any(key, args[2*i+1])
 	}
 	return fields
 }
 
 func sweetenMsg(msg interface{}) string {
-	if m, ok := msg.(string); ok {
-		return m
+	if str, ok := msg.(string); ok {
+		return str
 	}
 	return fmt.Sprint(msg)
 }

sugar_bench_test.go

@@ -20,14 +20,18 @@
 
 package zap
 
-import "testing"
+import (
+	"testing"
+
+	"go.uber.org/zap/testutils"
+	"go.uber.org/zap/zapcore"
+)
 
 func withBenchedSugar(b *testing.B, f func(*SugaredLogger)) {
-	logger := Sugar(New(
-		NewJSONEncoder(),
+	logger := Sugar(New(zapcore.WriterFacility(zapcore.NewJSONEncoder(defaultEncoderConfig()),
+		&testutils.Discarder{},
 		DebugLevel,
-		DiscardOutput,
-	))
+	)))
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {