Logging bridge for Zap

bridges/zap/go.mod

@@ -0,0 +1,25 @@
+module zap
+
+go 1.21.3
+
+require (
+	github.com/stretchr/testify v1.9.0
+	go.opentelemetry.io/otel/log v0.0.1-alpha.0.20240316100606-6fb46a12116d
+	go.uber.org/zap v1.27.0
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/go-logr/logr v1.4.1 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.11.0 // indirect
+	go.opentelemetry.io/otel v1.24.0 // indirect
+	go.opentelemetry.io/otel/metric v1.24.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.24.0 // indirect
+	go.opentelemetry.io/otel/trace v1.24.0 // indirect
+	go.uber.org/multierr v1.10.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

bridges/zap/go.sum

@@ -0,0 +1,46 @@
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
+go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
+go.opentelemetry.io/otel/log v0.0.1-alpha.0.20240316100606-6fb46a12116d h1:xxDRDnKdUKYwciWJK0DQJEMKYjQHBNLCLb2Oiv4VABU=
+go.opentelemetry.io/otel/log v0.0.1-alpha.0.20240316100606-6fb46a12116d/go.mod h1:ToOZ06+agH/C+P2+bp6Ea/CLMDviyMVUNUQaKTB1ieg=
+go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
+go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco=
+go.opentelemetry.io/otel/sdk v1.24.0 h1:YMPPDNymmQN3ZgczicBY3B6sf9n62Dlj9pWD3ucgoDw=
+go.opentelemetry.io/otel/sdk v1.24.0/go.mod h1:KVrIYw6tEubO9E96HQpcmpTKDVn9gdv35HoYiQWGDFg=
+go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
+go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
+go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

bridges/zap/version.go

@@ -0,0 +1,6 @@
+package zap // import "go.opentelemetry.io/contrib/bridges/zap"
+
+// Version is the current release version of sloghandler in use.
+func Version() string {
+	return "0.0.1-alpha"
+}

bridges/zap/version_test.go

@@ -0,0 +1,19 @@
+package zap
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// regex taken from https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+var versionRegex = regexp.MustCompile(`^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)` +
+	`(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)` +
+	`(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?` +
+	`(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$`)
+
+func TestVersionSemver(t *testing.T) {
+	v := Version()
+	assert.NotNil(t, versionRegex.FindStringSubmatch(v), "version is not semver: %s", v)
+}

bridges/zap/zap_encoder.go

@@ -0,0 +1,211 @@
+package zap
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+
+	"go.opentelemetry.io/otel/log"
+	"go.uber.org/zap/zapcore"
+)
+
+// not optimized yet
+// this file implements object and array encoder - similar to memory encoder by zapcore
+var (
+	_ zapcore.ObjectEncoder = (*OtelObjectEncoder)(nil)
+	_ zapcore.ArrayEncoder  = (*sliceArrayEncoder)(nil)
+)
+
+type OtelObjectEncoder struct {
+	// Fields contains the entire encoded log context.
+	Fields []log.KeyValue
+	// cur is a pointer to the namespace we're currently writing to.
+	cur []log.KeyValue
+
+	reflectval log.Value
+	zapcore.Encoder
+}
+
+// NewMapObjectEncoder creates a new map-backed ObjectEncoder.
+func NewOtelObjectEncoder() *OtelObjectEncoder {
+	m := make([]log.KeyValue, 0)
+	return &OtelObjectEncoder{
+		Fields: m,
+		cur:    m,
+	}
+}
+
+// AddArray implements ObjectEncoder.
+func (m *OtelObjectEncoder) AddArray(key string, v zapcore.ArrayMarshaler) error {
+	fmt.Println(v, "inside array")
+	arr := &sliceArrayEncoder{elems: make([]log.Value, 0)}
+	err := v.MarshalLogArray(arr)
+	m.cur = append(m.cur, log.Slice(key, arr.elems...))
+	return err
+}
+
+// AddObject implements ObjectEncoder.
+func (m *OtelObjectEncoder) AddObject(k string, v zapcore.ObjectMarshaler) error {
+	fmt.Println(v, "inside object")
+	newMap := NewOtelObjectEncoder() //min
+	err := v.MarshalLogObject(newMap)
+	m.cur = append(m.cur, log.Map(k, newMap.cur...))
+	return err
+}
+
+// AddBinary implements ObjectEncoder.
+func (m *OtelObjectEncoder) AddBinary(k string, v []byte) {
+	m.cur = append(m.cur, log.Bytes(k, v))
+}
+
+// AddByteString implements ObjectEncoder.
+func (m *OtelObjectEncoder) AddByteString(k string, v []byte) {
+	m.cur = append(m.cur, log.String(k, string(v)))
+}
+
+// AddBool implements ObjectEncoder.
+func (m *OtelObjectEncoder) AddBool(k string, v bool) {
+	m.cur = append(m.cur, log.Bool(k, v))
+}
+
+// AddDuration implements ObjectEncoder.
+func (m *OtelObjectEncoder) AddDuration(k string, v time.Duration) { m.AddInt64(k, v.Nanoseconds()) }
+
+// AddComplex128 implements ObjectEncoder.
+func (m *OtelObjectEncoder) AddComplex128(k string, v complex128) {
+	stringValue := strconv.FormatComplex(v, 'f', -1, 64)
+	m.cur = append(m.cur, log.String(k, stringValue))
+}
+
+func (m *OtelObjectEncoder) AddFloat64(k string, v float64) {
+	m.cur = append(m.cur, log.Float64(k, v))
+}
+
+func (m *OtelObjectEncoder) AddInt64(k string, v int64) {
+	m.cur = append(m.cur, log.Int64(k, v))
+}
+
+func (m *OtelObjectEncoder) AddInt(k string, v int) {
+	m.cur = append(m.cur, log.Int(k, v))
+}
+
+func (m *OtelObjectEncoder) AddString(k string, v string) {
+	m.cur = append(m.cur, log.String(k, v))
+}
+
+func (m *OtelObjectEncoder) AddUint64(k string, v uint64) {
+	m.cur = append(m.cur,
+		log.KeyValue{
+			Key:   k,
+			Value: assignUintValue(v),
+		})
+}
+
+// AddReflected implements ObjectEncoder.
+// It calls this func if interface cannot be mapped to supported zap types
+// For ex: an array of arrays or Objects passed using zap.Any()
+// this converts everything else to a JSON string
+func (m *OtelObjectEncoder) AddReflected(k string, v interface{}) error {
+	enc := json.NewEncoder(m)
+	enc.Encode(v)
+	fmt.Println(m.reflectval.AsString(), "inside reflect")
+	m.AddString(k, m.reflectval.AsString())
+	return nil
+}
+
+// Implements Write method to which json encoder writes to
+func (r *OtelObjectEncoder) Write(p []byte) (n int, err error) {
+	r.reflectval = log.StringValue(string(p))
+	return
+}
+
+// OpenNamespace implements ObjectEncoder.
+func (m *OtelObjectEncoder) OpenNamespace(k string) {
+	ns := make([]log.KeyValue, 0)
+	m.cur = append(m.cur, log.String(k, "Namesspace"))
+	m.cur = ns
+}
+func (m *OtelObjectEncoder) AddComplex64(k string, v complex64) { m.AddComplex128(k, complex128(v)) }
+
+func (m *OtelObjectEncoder) AddFloat32(k string, v float32) {
+	// preserves float32 value
+	value, _ := strconv.ParseFloat(strconv.FormatFloat(float64(v), 'f', -1, 32), 64)
+	m.AddFloat64(k, value)
+}
+func (m *OtelObjectEncoder) AddInt32(k string, v int32)     { m.AddInt64(k, int64(v)) }
+func (m *OtelObjectEncoder) AddInt16(k string, v int16)     { m.AddInt64(k, int64(v)) }
+func (m *OtelObjectEncoder) AddInt8(k string, v int8)       { m.AddInt64(k, int64(v)) }
+func (m *OtelObjectEncoder) AddTime(k string, v time.Time)  { m.AddInt64(k, v.UnixNano()) }
+func (m *OtelObjectEncoder) AddUint(k string, v uint)       { m.AddUint64(k, uint64(v)) }
+func (m *OtelObjectEncoder) AddUint32(k string, v uint32)   { m.AddInt64(k, int64(v)) }
+func (m *OtelObjectEncoder) AddUint16(k string, v uint16)   { m.AddInt64(k, int64(v)) }
+func (m *OtelObjectEncoder) AddUint8(k string, v uint8)     { m.AddInt64(k, int64(v)) }
+func (m *OtelObjectEncoder) AddUintptr(k string, v uintptr) { m.AddUint64(k, uint64(v)) }
+
+func assignUintValue(v uint64) log.Value {
+	const maxInt64 = ^uint64(0) >> 1
+	if v > maxInt64 {
+		value := strconv.FormatUint(v, 10)
+		return log.StringValue(value)
+
+	} else {
+		return log.Int64Value(int64(v))
+	}
+}
+
+// sliceArrayEncoder implements zapcore.ArrayEncoder
+type sliceArrayEncoder struct {
+	elems []log.Value
+}
+
+func (s *sliceArrayEncoder) AppendArray(v zapcore.ArrayMarshaler) error {
+	enc := &sliceArrayEncoder{}
+	err := v.MarshalLogArray(enc)
+	s.elems = append(s.elems, enc.elems...)
+	return err
+}
+
+func (s *sliceArrayEncoder) AppendObject(v zapcore.ObjectMarshaler) error {
+	m := NewOtelObjectEncoder()
+	err := v.MarshalLogObject(m)
+	s.elems = append(s.elems, log.MapValue(m.cur...))
+	return err
+}
+
+func (s *sliceArrayEncoder) AppendReflected(v interface{}) error {
+	//s.elems = append(s.elems, v)
+	return nil
+}
+
+func (s *sliceArrayEncoder) AppendBool(v bool)         { s.elems = append(s.elems, log.BoolValue(v)) }
+func (s *sliceArrayEncoder) AppendByteString(v []byte) { s.elems = append(s.elems, log.BytesValue(v)) }
+
+func (s *sliceArrayEncoder) AppendComplex128(v complex128) {
+	stringValue := `"` + strconv.FormatComplex(v, 'f', -1, 64) + `"`
+	s.elems = append(s.elems, log.StringValue(stringValue))
+}
+
+func (s *sliceArrayEncoder) AppendUint64(v uint64)   { s.elems = append(s.elems, assignUintValue(v)) }
+func (s *sliceArrayEncoder) AppendFloat64(v float64) { s.elems = append(s.elems, log.Float64Value(v)) }
+func (s *sliceArrayEncoder) AppendInt(v int)         { s.elems = append(s.elems, log.IntValue(v)) }
+func (s *sliceArrayEncoder) AppendInt64(v int64)     { s.elems = append(s.elems, log.Int64Value(v)) }
+func (s *sliceArrayEncoder) AppendString(v string)   { s.elems = append(s.elems, log.StringValue(v)) }
+
+func (s *sliceArrayEncoder) AppendComplex64(v complex64)    { s.AppendComplex128(complex128(v)) }
+func (s *sliceArrayEncoder) AppendDuration(v time.Duration) { s.AppendInt64(v.Nanoseconds()) }
+
+func (s *sliceArrayEncoder) AppendFloat32(v float32) {
+	// preserves float32 value
+	value, _ := strconv.ParseFloat(strconv.FormatFloat(float64(v), 'f', -1, 32), 64)
+	s.AppendFloat64(value)
+}
+func (s *sliceArrayEncoder) AppendInt32(v int32)     { s.AppendInt64(int64(v)) }
+func (s *sliceArrayEncoder) AppendInt16(v int16)     { s.AppendInt64(int64(v)) }
+func (s *sliceArrayEncoder) AppendInt8(v int8)       { s.AppendInt64(int64(v)) }
+func (s *sliceArrayEncoder) AppendTime(v time.Time)  { s.AppendInt64(int64(v.UnixNano())) }
+func (s *sliceArrayEncoder) AppendUint(v uint)       { s.AppendUint64(uint64(v)) }
+func (s *sliceArrayEncoder) AppendUint32(v uint32)   { s.AppendInt64(int64(v)) }
+func (s *sliceArrayEncoder) AppendUint16(v uint16)   { s.AppendInt64(int64(v)) }
+func (s *sliceArrayEncoder) AppendUint8(v uint8)     { s.AppendInt64(int64(v)) }
+func (s *sliceArrayEncoder) AppendUintptr(v uintptr) { s.AppendUint64(uint64(v)) }