fix(otelzap): withoptions(zap.fields(...)) will keep fields with logger

otelzap/fieldextractor.go

@@ -0,0 +1,39 @@
+package otelzap
+
+import (
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// fieldExtractorCore copy zapcore.Fields from With method to extraFields list
+type fieldExtractorCore struct {
+	extraFields *[]zap.Field
+}
+
+var _ zapcore.Core = (*fieldExtractorCore)(nil)
+
+// With adds structured context to the Core.
+func (fe *fieldExtractorCore) With(fs []zapcore.Field) zapcore.Core {
+	*fe.extraFields = append(*fe.extraFields, fs...)
+	return nil
+}
+
+// Check stub
+func (*fieldExtractorCore) Check(zapcore.Entry, *zapcore.CheckedEntry) *zapcore.CheckedEntry {
+	return nil
+}
+
+// Write stub
+func (*fieldExtractorCore) Write(zapcore.Entry, []zapcore.Field) error {
+	return nil
+}
+
+// Sync stub
+func (*fieldExtractorCore) Sync() error {
+	return nil
+}
+
+// Enabled stub
+func (*fieldExtractorCore) Enabled(zapcore.Level) bool {
+	return false
+}

otelzap/otelzap.go

@@ -39,6 +39,9 @@ type Logger struct {
 
 	caller     bool
 	stackTrace bool
+
+	// extraFields contains a number of zap.Fields that are  added to every log entry
+	extraFields []zap.Field
 }
 
 func New(logger *zap.Logger, opts ...Option) *Logger {
@@ -59,8 +62,13 @@ func New(logger *zap.Logger, opts ...Option) *Logger {
 // WithOptions clones the current Logger, applies the supplied Options,
 // and returns the resulting Logger. It's safe to use concurrently.
 func (l *Logger) WithOptions(opts ...zap.Option) *Logger {
+	extraFields := []zap.Field{}
+	// zap.New side effect is extracting fields from .WithOptions(zap.Fields(...))
+	zap.New(&fieldExtractorCore{extraFields: &extraFields}, opts...)
 	clone := *l
 	clone.Logger = l.Logger.WithOptions(opts...)
+	clone.skipCaller = l.skipCaller.WithOptions(opts...)
+	clone.extraFields = append(clone.extraFields, extraFields...)
 	return &clone
 }
 
@@ -149,6 +157,14 @@ func (l *Logger) logFields(
 		attrs = appendField(attrs, f)
 	}
 
+	for _, f := range l.extraFields {
+		if f.Type == zapcore.NamespaceType {
+			// should this be a prefix?
+			continue
+		}
+		attrs = appendField(attrs, f)
+	}
+
 	l.log(span, lvl, msg, attrs)
 
 	if l.withTraceID {

otelzap/otelzap_test.go

@@ -102,6 +102,39 @@ func TestOtelZap(t *testing.T) {
 				requireCodeAttrs(t, m)
 			},
 		},
+		{
+			log: func(ctx context.Context, log *Logger) {
+				log.Ctx(ctx).
+					WithOptions(zap.Fields(zap.String("baz", "baz1"))).
+					WithOptions(zap.Fields(zap.String("faz", "faz1"))).
+					Warn("hello", zap.Strings("foo", []string{"bar1", "bar2", "bar3"}))
+			},
+			require: func(t *testing.T, event sdktrace.Event) {
+				m := attrMap(event.Attributes)
+
+				sev, ok := m[logSeverityKey]
+				require.True(t, ok)
+				require.Equal(t, "WARN", sev.AsString())
+
+				msg, ok := m[logMessageKey]
+				require.True(t, ok)
+				require.Equal(t, "hello", msg.AsString())
+
+				foo, ok := m["foo"]
+				require.True(t, ok)
+				require.Equal(t, []string{"bar1", "bar2", "bar3"}, foo.AsStringSlice())
+
+				baz, ok := m["baz"]
+				require.True(t, ok)
+				require.Equal(t, "baz1", baz.AsString())
+
+				faz, ok := m["faz"]
+				require.True(t, ok)
+				require.Equal(t, "faz1", faz.AsString())
+
+				requireCodeAttrs(t, m)
+			},
+		},
 		{
 			log: func(ctx context.Context, log *Logger) {
 				log.Ctx(ctx).Warn("hello", zap.Durations("foo", []time.Duration{time.Millisecond, time.Second, time.Hour}))