otelzap: Use pool for encoder

bridges/otelzap/core.go

@@ -172,9 +172,9 @@ func (o *Core) Write(ent zapcore.Entry, fields []zapcore.Field) error {
 }
 
 func convertField(fields []zapcore.Field) (context.Context, []log.KeyValue) {
-	// TODO: Use objectEncoder from a pool instead of newObjectEncoder.
 	var ctx context.Context
-	enc := newObjectEncoder(len(fields))
+	enc, free := getObjectEncoder()
+	defer free()
 	for _, field := range fields {
 		if ctxFld, ok := field.Interface.(context.Context); ok {
 			ctx = ctxFld

bridges/otelzap/encoder.go

@@ -6,13 +6,47 @@ package otelzap // import "go.opentelemetry.io/contrib/bridges/otelzap"
 import (
 	"fmt"
 	"reflect"
+	"sync"
 	"time"
 
 	"go.uber.org/zap/zapcore"
 
 	"go.opentelemetry.io/otel/log"
 )
 
+var arrayEncoderPool = sync.Pool{
+	New: func() interface{} {
+		// Similar to console_encoder which uses capacity of 2
+		return &arrayEncoder{elems: make([]log.Value, 0, 2)}
+	},
+}
+
+func getArrayEncoder() (arr *arrayEncoder, free func()) {
+	arr = arrayEncoderPool.Get().(*arrayEncoder)
+	return arr, func() {
+		arr.elems = arr.elems[:0]
+		arrayEncoderPool.Put(arr)
+	}
+}
+
+var objectEncoderPool = sync.Pool{
+	New: func() interface{} {
+		// Similar to console_encoder which uses capacity of 2
+		return newObjectEncoder(2)
+	},
+}
+
+func getObjectEncoder() (obj *objectEncoder, free func()) {
+	obj = objectEncoderPool.Get().(*objectEncoder)
+	return obj, func() {
+		obj.root.attrs = obj.root.attrs[:0]
+		obj.root.name = ""
+		obj.root.next = nil
+		obj.cur = obj.root
+		objectEncoderPool.Put(obj)
+	}
+}
+
 var (
 	_ zapcore.ObjectEncoder = (*objectEncoder)(nil)
 	_ zapcore.ArrayEncoder  = (*arrayEncoder)(nil)
@@ -55,16 +89,16 @@ func (m *objectEncoder) calculate(o *namespace) {
 }
 
 func (m *objectEncoder) AddArray(key string, v zapcore.ArrayMarshaler) error {
-	// TODO: Use arrayEncoder from a pool.
-	arr := &arrayEncoder{}
+	arr, free := getArrayEncoder()
+	defer free()
 	err := v.MarshalLogArray(arr)
 	m.cur.attrs = append(m.cur.attrs, log.Slice(key, arr.elems...))
 	return err
 }
 
 func (m *objectEncoder) AddObject(k string, v zapcore.ObjectMarshaler) error {
-	// TODO: Use objectEncoder from a pool.
-	newobj := newObjectEncoder(2)
+	newobj, free := getObjectEncoder()
+	defer free()
 	err := v.MarshalLogObject(newobj)
 	newobj.calculate(newobj.root)
 	m.cur.attrs = append(m.cur.attrs, log.Map(k, newobj.root.attrs...))
@@ -196,15 +230,13 @@ type arrayEncoder struct {
 }
 
 func (a *arrayEncoder) AppendArray(v zapcore.ArrayMarshaler) error {
-	// TODO: Use arrayEncoder from a pool.
 	arr := &arrayEncoder{}
 	err := v.MarshalLogArray(arr)
 	a.elems = append(a.elems, log.SliceValue(arr.elems...))
 	return err
 }
 
 func (a *arrayEncoder) AppendObject(v zapcore.ObjectMarshaler) error {
-	// TODO: Use objectEncoder from a pool.
 	m := newObjectEncoder(2)
 	err := v.MarshalLogObject(m)
 	m.calculate(m.root)

bridges/otelzap/encoder_test.go

@@ -7,6 +7,7 @@ package otelzap
 
 import (
 	"errors"
+	"fmt"
 	"testing"
 	"time"
 
@@ -55,6 +56,7 @@ func TestObjectEncoder(t *testing.T) {
 					arr.AppendBool(true)
 					return nil
 				})), "Expected AddArray to succeed.")
+
 			},
 			expected: []interface{}{true, false, true},
 		},
@@ -65,6 +67,13 @@ func TestObjectEncoder(t *testing.T) {
 			},
 			expected: []interface{}{wantTurducken, wantTurducken},
 		},
+		{
+			desc: "AddArray-with AppendArray",
+			f: func(e zapcore.ObjectEncoder) {
+				assert.NoError(t, e.AddArray("k", number(2)), "Expected AddArray to succeed.")
+			},
+			expected: []interface{}{[]interface{}{"1"}, []interface{}{"2"}},
+		},
 		{
 			desc: "AddReflected",
 			f: func(e zapcore.ObjectEncoder) {
@@ -361,6 +370,23 @@ func (t turduckens) MarshalLogArray(enc zapcore.ArrayEncoder) error {
 	return err
 }
 
+type number int
+
+func (t number) MarshalLogArray(enc zapcore.ArrayEncoder) error {
+	var err error
+	for i := 0; i < int(t); i++ {
+		err = errors.Join(err, enc.AppendArray(numberString(fmt.Sprint(i+1))))
+	}
+	return err
+}
+
+type numberString string
+
+func (t numberString) MarshalLogArray(enc zapcore.ArrayEncoder) error {
+	enc.AppendString(string(t))
+	return nil
+}
+
 type loggable struct{ bool }
 
 func (l loggable) MarshalLogObject(enc zapcore.ObjectEncoder) error {