Update zap logger

Author: boekkooi-fresh

Gopkg.lock

@@ -14,42 +14,65 @@ func Wrap(logger *zap.Logger) goengine.Logger {
 	return &wrapper{logger}
 }
 
-// Error writes a log with log level error
-func (w wrapper) Error(msg string) {
-	w.logger.Error(msg)
+func (w wrapper) Error(msg string, fields func(goengine.LoggerEntry)) {
+	if ce := w.logger.Check(zap.ErrorLevel, msg); ce != nil {
+		ce.Write(fieldsToZapFields(fields)...)
+	}
 }
 
-// Warn writes a log with log level warning
-func (w wrapper) Warn(msg string) {
-	w.logger.Warn(msg)
+func (w wrapper) Warn(msg string, fields func(goengine.LoggerEntry)) {
+	if ce := w.logger.Check(zap.WarnLevel, msg); ce != nil {
+		ce.Write(fieldsToZapFields(fields)...)
+	}
 }
 
-// Info writes a log with log level info
-func (w wrapper) Info(msg string) {
-	w.logger.Info(msg)
+func (w wrapper) Info(msg string, fields func(goengine.LoggerEntry)) {
+	if ce := w.logger.Check(zap.InfoLevel, msg); ce != nil {
+		ce.Write(fieldsToZapFields(fields)...)
+	}
 }
 
-// Debug writes a log with log level debug
-func (w wrapper) Debug(msg string) {
-	w.logger.Debug(msg)
+func (w wrapper) Debug(msg string, fields func(goengine.LoggerEntry)) {
+	if ce := w.logger.Check(zap.DebugLevel, msg); ce != nil {
+		ce.Write(fieldsToZapFields(fields)...)
+	}
 }
 
-// WithField Adds a field to the log entry
-func (w wrapper) WithField(key string, val interface{}) goengine.Logger {
-	return wrapper{logger: w.logger.With(zap.Any(key, val))}
+func (w *wrapper) WithFields(fields func(goengine.LoggerEntry)) goengine.Logger {
+	if fields == nil {
+		return w
+	}
+
+	return &wrapper{logger: w.logger.With(fieldsToZapFields(fields)...)}
 }
 
-//WithFields Adds a set of fields to the log entry
-func (w wrapper) WithFields(fields goengine.Fields) goengine.Logger {
-	zapFields := make([]zap.Field, 0, len(fields))
-	for k, v := range fields {
-		zapFields = append(zapFields, zap.Any(k, v))
+func fieldsToZapFields(fields func(goengine.LoggerEntry)) []zap.Field {
+	if fields == nil {
+		return make([]zap.Field, 0)
 	}
 
-	return wrapper{logger: w.logger.With(zapFields...)}
+	// TODO use some sort of pool
+	e := &entry{fields: []zap.Field{}}
+	fields(e)
+	return e.fields
+}
+
+type entry struct {
+	fields []zap.Field
+}
+
+func (e *entry) Int(k string, v int) {
+	e.fields = append(e.fields, zap.Int(k, v))
+}
+
+func (e *entry) String(k, v string) {
+	e.fields = append(e.fields, zap.String(k, v))
+}
+
+func (e *entry) Error(err error) {
+	e.fields = append(e.fields, zap.Error(err))
 }
 
-// WithError Add an error as single field to the log entry
-func (w wrapper) WithError(err error) goengine.Logger {
-	return wrapper{logger: w.logger.With(zap.Error(err))}
+func (e *entry) Any(k string, v interface{}) {
+	e.fields = append(e.fields, zap.Any(k, v))
 }

extension/zap/zap.go

@@ -3,14 +3,135 @@
 package zap_test
 
 import (
+	"errors"
 	"testing"
 
 	"github.com/hellofresh/goengine"
-
 	zapExtension "github.com/hellofresh/goengine/extension/zap"
+	"github.com/stretchr/testify/assert"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"go.uber.org/zap/zaptest/observer"
 )
 
+func TestWrap_LogEntry(t *testing.T) {
+	zapCore, logObserver := observer.New(zapcore.DebugLevel)
+	logger := zapExtension.Wrap(zap.New(zapCore))
+
+	testCases := []struct {
+		msg    string
+		fields func(goengine.LoggerEntry)
+
+		expectedMsg     string
+		expectedContext map[string]interface{}
+	}{
+		{
+			"test nil fields",
+			nil,
+			"test nil fields",
+			map[string]interface{}{},
+		},
+		{
+			"test with fields",
+			func(e goengine.LoggerEntry) {
+				e.String("test", "a value")
+				e.Int("normal_int", 99)
+				e.Int64("int_64", 2)
+				e.Error(errors.New("some error"))
+				e.Any("obj", struct {
+					test string
+				}{test: "test property"})
+			},
+			"test with fields",
+			map[string]interface{}{
+				"test":       "a value",
+				"normal_int": int64(99),
+				"int_64":     int64(2),
+				"error":      "some error",
+				"obj": struct {
+					test string
+				}{test: "test property"},
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.msg, func(t *testing.T) {
+			logger.Error(testCase.msg, testCase.fields)
+			logger.Warn(testCase.msg, testCase.fields)
+			logger.Info(testCase.msg, testCase.fields)
+			logger.Debug(testCase.msg, testCase.fields)
+
+			logs := logObserver.TakeAll()
+
+			if !assert.Len(t, logs, 4) {
+				return
+			}
+
+			levelOrder := []zapcore.Level{
+				zapcore.ErrorLevel,
+				zapcore.WarnLevel,
+				zapcore.InfoLevel,
+				zapcore.DebugLevel,
+			}
+
+			for i, level := range levelOrder {
+				assert.Equal(t, level, logs[i].Level)
+				assert.Equal(t, testCase.expectedMsg, logs[i].Message)
+				assert.Equal(t, testCase.expectedContext, logs[i].ContextMap())
+			}
+		})
+	}
+
+	t.Run("Do not log disabled levels", func(t *testing.T) {
+		zapCore, logObserver := observer.New(zapcore.InfoLevel)
+		logger := zapExtension.Wrap(zap.New(zapCore))
+
+		logger.Debug("should not be logged", func(e goengine.LoggerEntry) {
+			t.Error("fields should not be called")
+		})
+
+		assert.Equal(t, 0, logObserver.Len())
+	})
+}
+
+func TestWrapper_WithFields(t *testing.T) {
+	zapCore, logObserver := observer.New(zapcore.DebugLevel)
+	logger := zapExtension.Wrap(zap.New(zapCore))
+
+	t.Run("With fields", func(t *testing.T) {
+		loggerWithFields := logger.WithFields(func(e goengine.LoggerEntry) {
+			e.String("with field", "check")
+			e.String("val", "default")
+		})
+
+		loggerWithFields.Debug("test with nil", nil)
+		loggerWithFields.Debug("test with override", func(e goengine.LoggerEntry) {
+			e.String("val", "override")
+		})
+
+		logs := logObserver.TakeAll()
+		if assert.Len(t, logs, 2) {
+			assert.Equal(t, "test with nil", logs[0].Message)
+			assert.Equal(t, map[string]interface{}{
+				"with field": "check",
+				"val":        "default",
+			}, logs[0].ContextMap())
+
+			assert.Equal(t, "test with override", logs[1].Message)
+			assert.Equal(t, map[string]interface{}{
+				"with field": "check",
+				"val":        "override",
+			}, logs[1].ContextMap())
+		}
+	})
+
+	t.Run("With fields nil", func(t *testing.T) {
+		loggerWithFields := logger.WithFields(nil)
+		assert.Equal(t, logger, loggerWithFields)
+	})
+}
+
 func BenchmarkStandardLoggerEntry(b *testing.B) {
 	b.ReportAllocs()