Publicate Zap based logger, and allow custom loggers to be used.

Author: cardil

pkg/output/logging/context.go

@@ -18,7 +18,6 @@ package logging
 
 import (
 	"context"
-	"fmt"
 	"os"
 	"time"
 
@@ -40,39 +39,43 @@ var ErrCallEnsureLoggerFirst = errors.New("call EnsureLogger() before LoggerFrom
 // context will have a logger attached to it. Given fields will be added to the
 // logger, either new or existing.
 func EnsureLogger(ctx context.Context, fields ...Fields) context.Context {
-	z, err := loggerFrom(ctx)
+	z, err := zapLoggerFrom(ctx)
 	if errors.Is(err, ErrCallEnsureLoggerFirst) {
 		ctx = EnsureLogFile(ctx)
 		z = setupLogging(ctx)
 	}
-	l := &zapLogger{SugaredLogger: z}
+	l := &ZapLogger{SugaredLogger: z}
 	for _, f := range fields {
-		l = l.WithFields(f).(*zapLogger)
+		l = l.WithFields(f).(*ZapLogger)
 	}
 	return WithLogger(ctx, l)
 }
 
 // LoggerFrom returns the logger from the context. If EnsureLogger() was not
 // called before, it will panic.
 func LoggerFrom(ctx context.Context) Logger {
-	z, err := loggerFrom(ctx)
+	if l, ok := ctx.Value(loggerKey).(Logger); ok {
+		return l
+	}
+	z, err := zapLoggerFrom(ctx)
 	if err != nil {
 		fatal(err)
 	}
 
-	return &zapLogger{z}
+	return &ZapLogger{z}
 }
 
 // WithLogger attaches the given logger to the context.
 func WithLogger(ctx context.Context, l Logger) context.Context {
-	if z, ok := l.(*zapLogger); ok {
+	if z, ok := l.(*ZapLogger); ok {
 		return logging.WithLogger(ctx, z.SugaredLogger)
 	}
-	fatal("unsupported logger type: " + fmt.Sprintf("%#v", l))
-	return nil
+	return context.WithValue(ctx, loggerKey, l)
 }
 
-func loggerFrom(ctx context.Context) (*zap.SugaredLogger, error) {
+var loggerKey = struct{}{}
+
+func zapLoggerFrom(ctx context.Context) (*zap.SugaredLogger, error) {
 	l := logging.FromContext(ctx)
 	if l.Desugar().Name() == "fallback" {
 		return nil, ErrCallEnsureLoggerFirst
@@ -161,6 +164,8 @@ func activeLogLevel(defaultLevel zapcore.Level) zapcore.Level {
 	return defaultLevel
 }
 
+// ElapsedMillisTimeEncoder is a time encoder using elapsed time since the
+// logger setup.
 func ElapsedMillisTimeEncoder(setupTime time.Time) zapcore.TimeEncoder {
 	return func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
 		enc.AppendInt64(t.Sub(setupTime).Milliseconds())

pkg/output/logging/zap.go

@@ -18,23 +18,24 @@ package logging
 
 import "go.uber.org/zap"
 
-type zapLogger struct {
+// ZapLogger is a Google' zap logger based logger.
+type ZapLogger struct {
 	*zap.SugaredLogger
 }
 
-func (z zapLogger) WithName(name string) Logger {
-	return &zapLogger{
+func (z ZapLogger) WithName(name string) Logger {
+	return &ZapLogger{
 		SugaredLogger: z.SugaredLogger.Named(name),
 	}
 }
 
-func (z zapLogger) WithFields(fields Fields) Logger {
+func (z ZapLogger) WithFields(fields Fields) Logger {
 	a := make([]interface{}, 0, len(fields)*2)
 	for k, v := range fields {
 		a = append(a, k, v)
 	}
 
-	return &zapLogger{
+	return &ZapLogger{
 		SugaredLogger: z.SugaredLogger.With(a...),
 	}
 }