Add a log adapter for zap.Logger

log/zap/zap_sugar_logger.go

@@ -0,0 +1,40 @@
+package zap
+
+import (
+	"github.com/go-kit/kit/log"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+type zapSugarLogger func(msg string, keysAndValues ...interface{})
+
+func (l zapSugarLogger) Log(kv ...interface{}) error {
+	l("", kv...)
+	return nil
+}
+
+// NewZapSugarLogger returns a Go kit log.Logger that sends
+// log events to a zap.Logger.
+func NewZapSugarLogger(logger *zap.Logger, level zapcore.Level) log.Logger {
+	sugarLogger := logger.WithOptions(zap.AddCallerSkip(2)).Sugar()
+	var sugar zapSugarLogger
+	switch level {
+	case zapcore.DebugLevel:
+		sugar = sugarLogger.Debugw
+	case zapcore.InfoLevel:
+		sugar = sugarLogger.Infow
+	case zapcore.WarnLevel:
+		sugar = sugarLogger.Warnw
+	case zapcore.ErrorLevel:
+		sugar = sugarLogger.Errorw
+	case zapcore.DPanicLevel:
+		sugar = sugarLogger.DPanicw
+	case zapcore.PanicLevel:
+		sugar = sugarLogger.Panicw
+	case zapcore.FatalLevel:
+		sugar = sugarLogger.Fatalw
+	default:
+		sugar = sugarLogger.Infow
+	}
+	return sugar
+}

log/zap/zap_sugar_logger_test.go

@@ -0,0 +1,86 @@
+package zap_test
+
+import (
+	"encoding/json"
+	kitzap "github.com/go-kit/kit/log/zap"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"strings"
+	"testing"
+)
+
+func TestZapSugarLogger(t *testing.T) {
+	// logger config
+	encoderConfig := zap.NewDevelopmentEncoderConfig()
+	encoder := zapcore.NewJSONEncoder(encoderConfig)
+	levelKey := encoderConfig.LevelKey
+	// basic test cases
+	type testCase struct {
+		level zapcore.Level
+		kvs   []interface{}
+		want  map[string]string
+	}
+	testCases := []testCase{
+		{level: zapcore.DebugLevel, kvs: []interface{}{"key1", "value1"},
+			want: map[string]string{levelKey: "DEBUG", "key1": "value1"}},
+
+		{level: zapcore.InfoLevel, kvs: []interface{}{"key2", "value2"},
+			want: map[string]string{levelKey: "INFO", "key2": "value2"}},
+
+		{level: zapcore.WarnLevel, kvs: []interface{}{"key3", "value3"},
+			want: map[string]string{levelKey: "WARN", "key3": "value3"}},
+
+		{level: zapcore.ErrorLevel, kvs: []interface{}{"key4", "value4"},
+			want: map[string]string{levelKey: "ERROR", "key4": "value4"}},
+
+		{level: zapcore.DPanicLevel, kvs: []interface{}{"key5", "value5"},
+			want: map[string]string{levelKey: "DPANIC", "key5": "value5"}},
+
+		{level: zapcore.PanicLevel, kvs: []interface{}{"key6", "value6"},
+			want: map[string]string{levelKey: "PANIC", "key6": "value6"}},
+	}
+	// test
+	for _, testCase := range testCases {
+		t.Run(testCase.level.String(), func(t *testing.T) {
+			// make logger
+			writer := &tbWriter{tb: t}
+			logger := zap.New(
+				zapcore.NewCore(encoder, zapcore.AddSync(writer), zap.DebugLevel),
+				zap.Development())
+			// check panic
+			shouldPanic := testCase.level >= zapcore.DPanicLevel
+			kitLogger := kitzap.NewZapSugarLogger(logger, testCase.level)
+			defer func() {
+				isPanic := recover() != nil
+				if shouldPanic != isPanic {
+					t.Errorf("test level %v should panic(%v), but %v", testCase.level, shouldPanic, isPanic)
+				}
+				// check log kvs
+				logMap := make(map[string]string)
+				err := json.Unmarshal([]byte(writer.sb.String()), &logMap)
+				if err != nil {
+					t.Errorf("unmarshal error: %v", err)
+				} else {
+					for k, v := range testCase.want {
+						vv, ok := logMap[k]
+						if !ok || v != vv {
+							t.Error("error log")
+						}
+					}
+				}
+			}()
+			kitLogger.Log(testCase.kvs...)
+		})
+	}
+}
+
+type tbWriter struct {
+	tb testing.TB
+	sb strings.Builder
+}
+
+func (w *tbWriter) Write(b []byte) (n int, err error) {
+	w.tb.Logf(string(b))
+	w.sb.Write(b)
+	return len(b), nil
+}