otelzap: Basic implementation of Core.Write

bridges/otelzap/core.go

@@ -6,6 +6,10 @@
 package otelzap // import "go.opentelemetry.io/contrib/bridges/otelzap"
 
 import (
+	"context"
+	"fmt"
+	"slices"
+
 	"go.uber.org/zap/zapcore"
 
 	"go.opentelemetry.io/otel/log"
@@ -92,6 +96,7 @@
 // Core is a [zapcore.Core] that sends logging records to OpenTelemetry.
 type Core struct {
 	logger log.Logger
+	attr   []log.KeyValue
 }
 
 // Compile-time check *Core implements zapcore.Core.
@@ -105,16 +110,22 @@
 	}
 }
 
-// TODO
 // LevelEnabler decides whether a given logging level is enabled when logging a message.
 func (o *Core) Enabled(level zapcore.Level) bool {
-	return true
+	r := log.Record{}
+	r.SetSeverity(getOTelLevel(level))
+	return o.logger.Enabled(context.Background(), r)
 }
 
 // TODO
 // With adds structured context to the Core.
 func (o *Core) With(fields []zapcore.Field) zapcore.Core {
-	return o
+	clone := o.clone()
+	if len(fields) > 0 {
+		// TODO convert zap fields to otel attributes
+		fmt.Println("TODO")
+	}
+	return clone
 }
 
 // TODO
@@ -123,14 +134,58 @@
 	return nil
 }
 
-// TODO
 // Check determines whether the supplied Entry should be logged using core.Enabled method.
 func (o *Core) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
+	if o.Enabled(ent.Level) {
+		return ce.AddCore(ent, o)
+	}
 	return ce
 }
 
 // TODO
 // Write method encodes zap fields to OTel logs and emits them.
 func (o *Core) Write(ent zapcore.Entry, fields []zapcore.Field) error {
+	r := log.Record{}
+	r.SetTimestamp(ent.Time)
+	r.SetBody(log.StringValue(ent.Message))
+	r.SetSeverity(getOTelLevel(ent.Level))
+
+	if len(fields) > 0 {
+		// TODO map zap field to otel attributes
+		fmt.Println("TODO")
+	} else {
+		r.AddAttributes(o.attr...)
+	}
+
+	o.logger.Emit(context.Background(), r)
 	return nil
 }
+
+func (o *Core) clone() *Core {
+	return &Core{
+		logger: o.logger,
+		attr:   slices.Clone(o.attr),
+	}
+}
+
+// converts zap level to OTel log level.
+func getOTelLevel(level zapcore.Level) log.Severity {
+	switch level {
+	case zapcore.DebugLevel:
+		return log.SeverityDebug
+	case zapcore.InfoLevel:
+		return log.SeverityInfo
+	case zapcore.WarnLevel:
+		return log.SeverityWarn
+	case zapcore.ErrorLevel:
+		return log.SeverityError
+	case zapcore.DPanicLevel:
+		return log.SeverityFatal1
+	case zapcore.PanicLevel:
+		return log.SeverityFatal2
+	case zapcore.FatalLevel:
+		return log.SeverityFatal3
+	default:
+		return log.SeverityUndefined
+	}
+}

bridges/otelzap/core_test.go

@@ -4,16 +4,30 @@
 package otelzap
 
 import (
+	"context"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 
+	"go.opentelemetry.io/otel/log"
 	"go.opentelemetry.io/otel/log/global"
 	"go.opentelemetry.io/otel/log/logtest"
 	"go.opentelemetry.io/otel/sdk/instrumentation"
 )
 
+var (
+	testBodyString = "log message"
+	testSeverity   = log.SeverityInfo
+	entry          = zapcore.Entry{
+		Level:   zapcore.InfoLevel,
+		Message: testBodyString,
+	}
+	field = zap.String("key", "testValue")
+)
+
 func TestNewCoreConfiguration(t *testing.T) {
 	t.Run("Default", func(t *testing.T) {
 		r := logtest.NewRecorder()
@@ -53,3 +67,71 @@ func TestNewCoreConfiguration(t *testing.T) {
 		assert.Equal(t, want, got)
 	})
 }
+
+func TestCoreEnabled(t *testing.T) {
+	enabledFunc := func(c context.Context, r log.Record) bool {
+		return r.Severity() >= log.SeverityInfo
+	}
+
+	r := logtest.NewRecorder(logtest.WithEnabledFunc(enabledFunc))
+	zc := NewCore(WithLoggerProvider(r))
+
+	assert.False(t, zc.Enabled(zap.DebugLevel), "level conversion: permissive")
+	assert.True(t, zc.Enabled(zap.InfoLevel), "level conversion: restrictive")
+}
+
+// Test conversion of Zap Level to OTel level.
+func TestGetOTelLevel(t *testing.T) {
+	tests := []struct {
+		level       zapcore.Level
+		expectedSev log.Severity
+	}{
+		{zapcore.DebugLevel, log.SeverityDebug},
+		{zapcore.InfoLevel, log.SeverityInfo},
+		{zapcore.WarnLevel, log.SeverityWarn},
+		{zapcore.ErrorLevel, log.SeverityError},
+		{zapcore.DPanicLevel, log.SeverityFatal1},
+		{zapcore.PanicLevel, log.SeverityFatal2},
+		{zapcore.FatalLevel, log.SeverityFatal3},
+		{zapcore.InvalidLevel, log.SeverityUndefined},
+	}
+
+	for _, test := range tests {
+		result := getOTelLevel(test.level)
+		if result != test.expectedSev {
+			t.Errorf("For level %v, expected %v but got %v", test.level, test.expectedSev, result)
+		}
+	}
+}
+
+// Tests [Core] write method.
+func TestCore(t *testing.T) {
+	rec := logtest.NewRecorder()
+	zc := NewCore(WithLoggerProvider(rec))
+
+	t.Run("test Write method of Core", func(t *testing.T) {
+		err := zc.Write(entry, []zap.Field{field})
+		if err != nil {
+			t.Errorf("Error occurred: %v", err)
+		}
+
+		// why is index 1 populated with results and not 0?
+		got := rec.Result()[1].Records[0]
+		assert.Equal(t, testBodyString, got.Body().AsString())
+		assert.Equal(t, testSeverity, got.Severity())
+
+		// TODO test record attributes
+
+		rec.Reset()
+	})
+
+	t.Run("test With method of Core", func(t *testing.T) {
+		childCore := zc.With([]zap.Field{field})
+		assert.Equal(t, childCore, zc)
+
+		// TODO test record attributes
+
+		rec.Reset()
+	})
+
+}