otelzap: Basic implementation of Core.Write

bridges/otelzap/core.go

@@ -6,6 +6,8 @@
 package otelzap // import "go.opentelemetry.io/contrib/bridges/otelzap"
 
 import (
+	"context"
+
 	"go.uber.org/zap/zapcore"
 
 	"go.opentelemetry.io/otel/log"
@@ -123,14 +125,48 @@ func (o *Core) Sync() error {
 	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(convertLevel(ent.Level))
+
+	// TODO: Handle attributes passed via fields (exceptions: context.Context and zap.Namespace).
+	// TODO: Handle attributes passed via With (exceptions: context.Context and zap.Namespace).
+	// TODO: Handle context.Context containing trace context.
+	// TODO: Handle zap.Namespace.
+	// TODO: Handle logger name.
+
+	o.logger.Emit(context.Background(), r)
 	return nil
 }
+
+func convertLevel(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

@@ -8,12 +8,30 @@ import (
 
 	"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 testMessage = "log message"
+
+func TestCore(t *testing.T) {
+	rec := logtest.NewRecorder()
+	zc := NewCore(WithLoggerProvider(rec))
+	logger := zap.New(zc)
+
+	logger.Info(testMessage)
+
+	// TODO: not sure why index 1 is populated with results and not 0
+	got := rec.Result()[1].Records[0]
+	assert.Equal(t, testMessage, got.Body().AsString())
+	assert.Equal(t, log.SeverityInfo, got.Severity())
+}
+
 func TestNewCoreConfiguration(t *testing.T) {
 	t.Run("Default", func(t *testing.T) {
 		r := logtest.NewRecorder()
@@ -53,3 +71,26 @@ func TestNewCoreConfiguration(t *testing.T) {
 		assert.Equal(t, want, got)
 	})
 }
+
+func TestConvertLevel(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 := convertLevel(test.level)
+		if result != test.expectedSev {
+			t.Errorf("For level %v, expected %v but got %v", test.level, test.expectedSev, result)
+		}
+	}
+}