Logging bridge for Zap

.github/dependabot.yml

@@ -109,6 +109,15 @@ updates:
     schedule:
       interval: weekly
       day: sunday
+  - package-ecosystem: gomod
+    directory: /bridges/otelzap
+    labels:
+      - dependencies
+      - go
+      - Skip Changelog
+    schedule:
+      interval: weekly
+      day: sunday
   - package-ecosystem: gomod
     directory: /bridges/prometheus
     labels:

bridges/otelzap/config.go

@@ -0,0 +1,82 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package otelzap // import "go.opentelemetry.io/contrib/bridges/otelzap"
+
+import (
+	"go.opentelemetry.io/otel/log"
+	"go.opentelemetry.io/otel/log/global"
+	"go.opentelemetry.io/otel/sdk/instrumentation"
+)
+
+type config struct {
+	provider log.LoggerProvider
+	scope    instrumentation.Scope
+}
+
+func newConfig(options []Option) config {
+	var c config
+	for _, opt := range options {
+		c = opt.apply(c)
+	}
+
+	var emptyScope instrumentation.Scope
+	if c.scope == emptyScope {
+		c.scope = instrumentation.Scope{
+			Name:    bridgeName,
+			Version: version,
+		}
+	}
+
+	if c.provider == nil {
+		c.provider = global.GetLoggerProvider()
+	}
+
+	return c
+}
+
+func (c config) logger() log.Logger {
+	var opts []log.LoggerOption
+	if c.scope.Version != "" {
+		opts = append(opts, log.WithInstrumentationVersion(c.scope.Version))
+	}
+	if c.scope.SchemaURL != "" {
+		opts = append(opts, log.WithSchemaURL(c.scope.SchemaURL))
+	}
+	return c.provider.Logger(c.scope.Name, opts...)
+}
+
+// Option configures a [zapcore].
+type Option interface {
+	apply(config) config
+}
+
+type optFunc func(config) config
+
+func (f optFunc) apply(c config) config { return f(c) }
+
+// WithInstrumentationScope returns an [Option] that configures the scope of
+// the [log.Logger] used by a [zapcore].
+//
+// By default if this Option is not provided, the zapcore will use a default
+// instrumentation scope describing this bridge package. It is recommended to
+// provide this so log data can be associated with its source package or
+// module.
+func WithInstrumentationScope(scope instrumentation.Scope) Option {
+	return optFunc(func(c config) config {
+		c.scope = scope
+		return c
+	})
+}
+
+// WithLoggerProvider returns an [Option] that configures [log.LoggerProvider]
+// used by a [Handler] to create its [log.Logger].
+//
+// By default if this Option is not provided, the Handler will use the global
+// LoggerProvider.
+func WithLoggerProvider(provider log.LoggerProvider) Option {
+	return optFunc(func(c config) config {
+		c.provider = provider
+		return c
+	})
+}

bridges/otelzap/core.go

@@ -0,0 +1,136 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// Package otelzap provides a bridge between the [go.uber.org/zap] and
+// OpenTelemetry logging.
+package otelzap // import "go.opentelemetry.io/contrib/bridges/otelzap"
+
+import (
+	"context"
+	"slices"
+
+	"go.uber.org/zap/zapcore"
+
+	"go.opentelemetry.io/otel/log"
+)
+
+const (
+	bridgeName = "go.opentelemetry.io/contrib/bridge/zapcore"
+)
+
+// Core is a [zapcore.Core] that sends logging records to OpenTelemetry.
+type Core struct {
+	logger log.Logger
+	// holds structured context passed using Core.With()
+	attr []log.KeyValue
+	ctx  context.Context
+}
+
+// // Compile-time check *Core implements zapcore.Core.
+var _ zapcore.Core = (*Core)(nil)
+
+// NewOTelZapCore creates a new [zapcore.Core] that can be used with zap.New()
+// this instance will translate zap logs to opentelemetry logs and export them.
+func NewCore(opts ...Option) *Core {
+	cfg := newConfig(opts)
+	return &Core{
+		logger: cfg.logger(),
+		ctx:    context.Background(),
+	}
+}
+
+// LevelEnabler decides whether a given logging level is enabled when logging a message.
+func (o *Core) Enabled(level zapcore.Level) bool {
+	r := log.Record{}
+	r.SetSeverity(getOTelLevel(level))
+	// should we use the context set on core?
+	return o.logger.Enabled(context.Background(), r)
+}
+
+// With adds structured context to the Core.
+func (o *Core) With(fields []zapcore.Field) zapcore.Core {
+	clone := o.clone()
+	if len(fields) > 0 {
+		attrbuf := convertField(&clone.ctx, &fields)
+		clone.attr = append(clone.attr, attrbuf...)
+	}
+	return clone
+}
+
+// Sync flushes buffered logs (if any).
+func (o *Core) Sync() error {
+	return nil
+}
+
+// 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
+}
+
+// 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 {
+		attrbuf := convertField(&o.ctx, &fields)
+		attrbuf = slices.Grow(attrbuf, len(o.attr))
+		attrbuf = append(attrbuf, o.attr...)
+		r.AddAttributes(attrbuf...)
+	} else {
+		r.AddAttributes(o.attr...)
+	}
+
+	o.logger.Emit(o.ctx, r)
+	return nil
+}
+
+func (o *Core) clone() *Core {
+	return &Core{
+		logger: o.logger,
+		attr:   slices.Clone(o.attr),
+		ctx:    o.ctx,
+	}
+}
+
+// converts zap fields to OTel log attributes.
+func convertField(ctx *context.Context, fields *[]zapcore.Field) []log.KeyValue {
+	enc, free := getObjectEncoder()
+	defer free()
+	for _, field := range *fields {
+		if ctxFld, ok := field.Interface.(context.Context); ok {
+			*ctx = ctxFld
+			continue
+		}
+		field.AddTo(enc)
+	}
+	enc.getObjValue(enc.root)
+	return enc.root.kv
+}
+
+// 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
+	}
+}