feat: add support for homogenous arrays (#1203)

Author: giortzisg

attribute/builder.go

@@ -30,6 +30,31 @@ func Bool(key string, v bool) Builder {
 	return Builder{key, BoolValue(v)}
 }
 
+// BoolSlice returns a Builder for a bool slice.
+func BoolSlice(key string, v []bool) Builder {
+	return Builder{key, BoolSliceValue(v)}
+}
+
+// IntSlice returns a Builder for an int slice.
+func IntSlice(key string, v []int) Builder {
+	return Builder{key, IntSliceValue(v)}
+}
+
+// Int64Slice returns a Builder for an int64 slice.
+func Int64Slice(key string, v []int64) Builder {
+	return Builder{key, Int64SliceValue(v)}
+}
+
+// Float64Slice returns a Builder for a float64 slice.
+func Float64Slice(key string, v []float64) Builder {
+	return Builder{key, Float64SliceValue(v)}
+}
+
+// StringSlice returns a Builder for a string slice.
+func StringSlice(key string, v []string) Builder {
+	return Builder{key, StringSliceValue(v)}
+}
+
 // Valid checks for valid key and type.
 func (b *Builder) Valid() bool {
 	return len(b.Key) > 0 && b.Value.Type() != INVALID

attribute/builder_test.go

@@ -2,6 +2,8 @@ package attribute
 
 import (
 	"testing"
+
+	"github.com/google/go-cmp/cmp"
 )
 
 func TestBuilder(t *testing.T) {
@@ -42,10 +44,47 @@ func TestBuilder(t *testing.T) {
 			wantType:  STRING,
 			wantValue: "foo",
 		},
+		{
+			name:      "BoolSlice() correctly returns a bool slice builder",
+			value:     BoolSlice(k, []bool{true, false, true}),
+			wantType:  BOOLSLICE,
+			wantValue: []bool{true, false, true},
+		},
+		{
+			name:      "IntSlice() correctly returns an int slice builder",
+			value:     IntSlice(k, []int{1, 2, 3}),
+			wantType:  INT64SLICE,
+			wantValue: []int64{1, 2, 3},
+		},
+		{
+			name:      "Int64Slice() correctly returns an int64 slice builder",
+			value:     Int64Slice(k, []int64{42, 43, 44}),
+			wantType:  INT64SLICE,
+			wantValue: []int64{42, 43, 44},
+		},
+		{
+			name:      "Float64Slice() correctly returns a float64 slice builder",
+			value:     Float64Slice(k, []float64{1.5, 2.5, 3.5}),
+			wantType:  FLOAT64SLICE,
+			wantValue: []float64{1.5, 2.5, 3.5},
+		},
+		{
+			name:      "StringSlice() correctly returns a string slice builder",
+			value:     StringSlice(k, []string{"foo", "bar", "baz"}),
+			wantType:  STRINGSLICE,
+			wantValue: []string{"foo", "bar", "baz"},
+		},
 	} {
 		if testcase.value.Value.Type() != testcase.wantType {
 			t.Errorf("wrong value type, got %#v, expected %#v", testcase.value.Value.Type(), testcase.wantType)
 		}
+		if testcase.value.Key != k {
+			t.Errorf("wrong key, got %#v, expected %#v", testcase.value.Key, k)
+		}
+		got := testcase.value.Value.AsInterface()
+		if diff := cmp.Diff(testcase.wantValue, got); diff != "" {
+			t.Errorf("+got, -want: %s", diff)
+		}
 	}
 }
 
@@ -79,6 +118,26 @@ func TestBuilder_Valid(t *testing.T) {
 			},
 			wantValid: false,
 		},
+		{
+			name:      "BoolSlice builder is valid",
+			builder:   BoolSlice("key", []bool{true}),
+			wantValid: true,
+		},
+		{
+			name:      "Int64Slice builder is valid",
+			builder:   Int64Slice("key", []int64{42}),
+			wantValid: true,
+		},
+		{
+			name:      "Float64Slice builder is valid",
+			builder:   Float64Slice("key", []float64{1.5}),
+			wantValid: true,
+		},
+		{
+			name:      "StringSlice builder is valid",
+			builder:   StringSlice("key", []string{"foo"}),
+			wantValid: true,
+		},
 	} {
 		valid := tt.builder.Valid()
 		if tt.wantValid != valid {

attribute/slicehelpers.go

@@ -0,0 +1,15 @@
+package attribute
+
+import "reflect"
+
+func asSlice[T any](v any) []T {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Array {
+		return nil
+	}
+	cpy := make([]T, rv.Len())
+	if len(cpy) > 0 {
+		_ = reflect.Copy(reflect.ValueOf(cpy), rv)
+	}
+	return cpy
+}

attribute/value.go

@@ -19,6 +19,7 @@ package attribute
 import (
 	"encoding/json"
 	"fmt"
+	"reflect"
 	"strconv"
 )
 
@@ -30,6 +31,7 @@ type Value struct {
 	vtype    Type
 	numeric  uint64
 	stringly string
+	slice    any
 }
 
 const (
@@ -43,6 +45,14 @@ const (
 	FLOAT64
 	// STRING is a string Type Value.
 	STRING
+	// BOOLSLICE is a slice of booleans Type Value.
+	BOOLSLICE
+	// INT64SLICE is a slice of 64-bit signed integral numbers Type Value.
+	INT64SLICE
+	// FLOAT64SLICE is a slice of 64-bit floating point numbers Type Value.
+	FLOAT64SLICE
+	// STRINGSLICE is a slice of strings Type Value.
+	STRINGSLICE
 	// UINT64 is a 64-bit unsigned integral Type Value.
 	//
 	// This type is intentionally not exposed through the Builder API.
@@ -57,11 +67,30 @@ func BoolValue(v bool) Value {
 	}
 }
 
+// BoolSliceValue creates a BOOLSLICE Value.
+func BoolSliceValue(v []bool) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[bool]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return Value{vtype: BOOLSLICE, slice: cp.Interface()}
+}
+
 // IntValue creates an INT64 Value.
 func IntValue(v int) Value {
 	return Int64Value(int64(v))
 }
 
+// IntSliceValue creates an INTSLICE Value.
+func IntSliceValue(v []int) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[int64]()))
+	for i, val := range v {
+		cp.Elem().Index(i).SetInt(int64(val))
+	}
+	return Value{
+		vtype: INT64SLICE,
+		slice: cp.Elem().Interface(),
+	}
+}
+
 // Int64Value creates an INT64 Value.
 func Int64Value(v int64) Value {
 	return Value{
@@ -70,6 +99,13 @@ func Int64Value(v int64) Value {
 	}
 }
 
+// Int64SliceValue creates an INT64SLICE Value.
+func Int64SliceValue(v []int64) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[int64]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return Value{vtype: INT64SLICE, slice: cp.Interface()}
+}
+
 // Float64Value creates a FLOAT64 Value.
 func Float64Value(v float64) Value {
 	return Value{
@@ -78,6 +114,13 @@ func Float64Value(v float64) Value {
 	}
 }
 
+// Float64SliceValue creates a FLOAT64SLICE Value.
+func Float64SliceValue(v []float64) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[float64]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return Value{vtype: FLOAT64SLICE, slice: cp.Interface()}
+}
+
 // StringValue creates a STRING Value.
 func StringValue(v string) Value {
 	return Value{
@@ -86,6 +129,13 @@ func StringValue(v string) Value {
 	}
 }
 
+// StringSliceValue creates a STRINGSLICE Value.
+func StringSliceValue(v []string) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[string]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return Value{vtype: STRINGSLICE, slice: cp.Interface()}
+}
+
 // Uint64Value creates a UINT64 Value.
 //
 // This constructor is intentionally not exposed through the Builder API.
@@ -107,24 +157,60 @@ func (v Value) AsBool() bool {
 	return rawToBool(v.numeric)
 }
 
+// AsBoolSlice returns the []bool value. Make sure that the Value's type is
+// BOOLSLICE.
+func (v Value) AsBoolSlice() []bool {
+	if v.vtype != BOOLSLICE {
+		return nil
+	}
+	return asSlice[bool](v.slice)
+}
+
 // AsInt64 returns the int64 value. Make sure that the Value's type is
 // INT64.
 func (v Value) AsInt64() int64 {
 	return rawToInt64(v.numeric)
 }
 
+// AsInt64Slice returns the []int64 value. Make sure that the Value's type is
+// INT64SLICE.
+func (v Value) AsInt64Slice() []int64 {
+	if v.vtype != INT64SLICE {
+		return nil
+	}
+	return asSlice[int64](v.slice)
+}
+
 // AsFloat64 returns the float64 value. Make sure that the Value's
 // type is FLOAT64.
 func (v Value) AsFloat64() float64 {
 	return rawToFloat64(v.numeric)
 }
 
+// AsFloat64Slice returns the []float64 value. Make sure that the Value's type is
+// FLOAT64SLICE.
+func (v Value) AsFloat64Slice() []float64 {
+	if v.vtype != FLOAT64SLICE {
+		return nil
+	}
+	return asSlice[float64](v.slice)
+}
+
 // AsString returns the string value. Make sure that the Value's type
 // is STRING.
 func (v Value) AsString() string {
 	return v.stringly
 }
 
+// AsStringSlice returns the []string value. Make sure that the Value's type is
+// STRINGSLICE.
+func (v Value) AsStringSlice() []string {
+	if v.vtype != STRINGSLICE {
+		return nil
+	}
+	return asSlice[string](v.slice)
+}
+
 // AsUint64 returns the uint64 value. Make sure that the Value's type is
 // UINT64.
 func (v Value) AsUint64() uint64 {
@@ -138,12 +224,20 @@ func (v Value) AsInterface() interface{} {
 	switch v.Type() {
 	case BOOL:
 		return v.AsBool()
+	case BOOLSLICE:
+		return v.AsBoolSlice()
 	case INT64:
 		return v.AsInt64()
+	case INT64SLICE:
+		return v.AsInt64Slice()
 	case FLOAT64:
 		return v.AsFloat64()
+	case FLOAT64SLICE:
+		return v.AsFloat64Slice()
 	case STRING:
 		return v.stringly
+	case STRINGSLICE:
+		return v.AsStringSlice()
 	case UINT64:
 		return v.numeric
 	}
@@ -153,12 +247,20 @@ func (v Value) AsInterface() interface{} {
 // String returns a string representation of Value's data.
 func (v Value) String() string {
 	switch v.Type() {
+	case BOOLSLICE:
+		return fmt.Sprint(v.AsBoolSlice())
 	case BOOL:
 		return strconv.FormatBool(v.AsBool())
+	case INT64SLICE:
+		return fmt.Sprint(v.AsInt64Slice())
 	case INT64:
 		return strconv.FormatInt(v.AsInt64(), 10)
+	case FLOAT64SLICE:
+		return fmt.Sprint(v.AsFloat64Slice())
 	case FLOAT64:
 		return fmt.Sprint(v.AsFloat64())
+	case STRINGSLICE:
+		return fmt.Sprint(v.AsStringSlice())
 	case STRING:
 		return v.stringly
 	case UINT64:
@@ -183,12 +285,20 @@ func (t Type) String() string {
 	switch t {
 	case BOOL:
 		return "bool"
+	case BOOLSLICE:
+		return "boolslice"
 	case INT64:
 		return "int64"
+	case INT64SLICE:
+		return "int64slice"
 	case FLOAT64:
 		return "float64"
+	case FLOAT64SLICE:
+		return "float64slice"
 	case STRING:
 		return "string"
+	case STRINGSLICE:
+		return "stringslice"
 	case UINT64:
 		return "uint64"
 	}
@@ -198,10 +308,14 @@ func (t Type) String() string {
 // mapTypesToStr is a map from attribute.Type to the primitive types the server understands.
 // https://develop.sentry.dev/sdk/foundations/data-model/attributes/#primitive-types
 var mapTypesToStr = map[Type]string{
-	INVALID: "",
-	BOOL:    "boolean",
-	INT64:   "integer",
-	FLOAT64: "double",
-	STRING:  "string",
-	UINT64:  "integer", // wire format: same "integer" type
+	INVALID:      "",
+	BOOL:         "boolean",
+	INT64:        "integer",
+	FLOAT64:      "double",
+	STRING:       "string",
+	BOOLSLICE:    "array",
+	INT64SLICE:   "array",
+	FLOAT64SLICE: "array",
+	STRINGSLICE:  "array",
+	UINT64:       "integer", // wire format: same "integer" type
 }