From 2d41c29cb771ec1a67d5a5d0815f11abc4d5bd57 Mon Sep 17 00:00:00 2001
From: Khushi Jain <khushij393@gmail.com>
Date: Thu, 23 May 2024 14:20:07 +0530
Subject: [PATCH] otelzap: Implement methods on arrayEncoder (#5632)

Part of
https://github.com/open-telemetry/opentelemetry-go-contrib/issues/5191

Pre-work
https://github.com/open-telemetry/opentelemetry-go-contrib/pull/5279

This PR partially implements `arrayEncoder`
---
 bridges/otelzap/encoder.go      | 42 ++++++++++++++++++++++++++-------
 bridges/otelzap/encoder_test.go | 42 +++++++++++++++++++++++++++++++++
 2 files changed, 75 insertions(+), 9 deletions(-)

diff --git a/bridges/otelzap/encoder.go b/bridges/otelzap/encoder.go
index 017253d9f7c..f59c97646f7 100644
--- a/bridges/otelzap/encoder.go
+++ b/bridges/otelzap/encoder.go
@@ -32,8 +32,11 @@ func newObjectEncoder(len int) *objectEncoder {
 }
 
 func (m *objectEncoder) AddArray(key string, v zapcore.ArrayMarshaler) error {
-	// TODO
-	return nil
+	// TODO: Use arrayEncoder from a pool.
+	arr := &arrayEncoder{}
+	err := v.MarshalLogArray(arr)
+	m.kv = append(m.kv, log.Slice(key, arr.elems...))
+	return err
 }
 
 func (m *objectEncoder) AddObject(k string, v zapcore.ObjectMarshaler) error {
@@ -170,16 +173,37 @@ func (a *arrayEncoder) AppendReflected(v interface{}) error {
 	return nil
 }
 
+func (a *arrayEncoder) AppendByteString(v []byte) {
+	a.elems = append(a.elems, log.StringValue(string(v)))
+}
+
+func (a *arrayEncoder) AppendBool(v bool) {
+	a.elems = append(a.elems, log.BoolValue(v))
+}
+
+func (a *arrayEncoder) AppendFloat64(v float64) {
+	a.elems = append(a.elems, log.Float64Value(v))
+}
+
+func (a *arrayEncoder) AppendFloat32(v float32) {
+	a.AppendFloat64(float64(v))
+}
+
+func (a *arrayEncoder) AppendInt(v int) {
+	a.elems = append(a.elems, log.IntValue(v))
+}
+
+func (a *arrayEncoder) AppendInt64(v int64) {
+	a.elems = append(a.elems, log.Int64Value(v))
+}
+
+func (a *arrayEncoder) AppendString(v string) {
+	a.elems = append(a.elems, log.StringValue(v))
+}
+
 // TODO.
 func (a *arrayEncoder) AppendComplex128(v complex128)  {}
-func (a *arrayEncoder) AppendFloat32(v float32)        {}
-func (a *arrayEncoder) AppendByteString(v []byte)      {}
-func (a *arrayEncoder) AppendBool(v bool)              {}
 func (a *arrayEncoder) AppendUint64(v uint64)          {}
-func (a *arrayEncoder) AppendFloat64(v float64)        {}
-func (a *arrayEncoder) AppendInt(v int)                {}
-func (a *arrayEncoder) AppendInt64(v int64)            {}
-func (a *arrayEncoder) AppendString(v string)          {}
 func (a *arrayEncoder) AppendComplex64(v complex64)    {}
 func (a *arrayEncoder) AppendDuration(v time.Duration) {}
 func (a *arrayEncoder) AppendInt32(v int32)            {}
diff --git a/bridges/otelzap/encoder_test.go b/bridges/otelzap/encoder_test.go
index 81b342e7b24..d4e51db2825 100644
--- a/bridges/otelzap/encoder_test.go
+++ b/bridges/otelzap/encoder_test.go
@@ -23,6 +23,18 @@ func TestObjectEncoder(t *testing.T) {
 		f        func(zapcore.ObjectEncoder)
 		expected interface{}
 	}{
+		{
+			desc: "AddArray",
+			f: func(e zapcore.ObjectEncoder) {
+				assert.NoError(t, e.AddArray("k", zapcore.ArrayMarshalerFunc(func(arr zapcore.ArrayEncoder) error {
+					arr.AppendBool(true)
+					arr.AppendBool(false)
+					arr.AppendBool(true)
+					return nil
+				})), "Expected AddArray to succeed.")
+			},
+			expected: []interface{}{true, false, true},
+		},
 		{
 			desc:     "AddBinary",
 			f:        func(e zapcore.ObjectEncoder) { e.AddBinary("k", []byte("foo")) },
@@ -145,6 +157,36 @@ func TestObjectEncoder(t *testing.T) {
 	}
 }
 
+// Copied from https://github.com/uber-go/zap/blob/b39f8b6b6a44d8371a87610be50cce58eeeaabcb/zapcore/memory_encoder_test.go.
+func TestArrayEncoder(t *testing.T) {
+	tests := []struct {
+		desc     string
+		f        func(zapcore.ArrayEncoder)
+		expected interface{}
+	}{
+		{"AppendBool", func(e zapcore.ArrayEncoder) { e.AppendBool(true) }, true},
+		{"AppendByteString", func(e zapcore.ArrayEncoder) { e.AppendByteString([]byte("foo")) }, "foo"},
+		{"AppendFloat64", func(e zapcore.ArrayEncoder) { e.AppendFloat64(3.14) }, 3.14},
+		{"AppendFloat32", func(e zapcore.ArrayEncoder) { e.AppendFloat32(3.14) }, float64(float32(3.14))},
+		{"AppendInt64", func(e zapcore.ArrayEncoder) { e.AppendInt64(42) }, int64(42)},
+		{"AppendInt", func(e zapcore.ArrayEncoder) { e.AppendInt(42) }, int64(42)},
+		{"AppendString", func(e zapcore.ArrayEncoder) { e.AppendString("foo") }, "foo"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			enc := newObjectEncoder(1)
+			assert.NoError(t, enc.AddArray("k", zapcore.ArrayMarshalerFunc(func(arr zapcore.ArrayEncoder) error {
+				tt.f(arr)
+				tt.f(arr)
+				return nil
+			})), "Expected AddArray to succeed.")
+
+			assert.Equal(t, []interface{}{tt.expected, tt.expected}, value2Result(enc.kv[0].Value), "Unexpected encoder output.")
+		})
+	}
+}
+
 func value2Result(v log.Value) any {
 	switch v.Kind() {
 	case log.KindBool: