[DO NOT MERGE] attribute: add BYTES type support

CHANGELOG.md

@@ -14,6 +14,7 @@ The next release will require at least [Go 1.25].
 ### Added
 
 - Support testing of [Go 1.26]. (#7902)
+- Add `Bytes` and `BytesValue` functions for new `BYTES Type` in `go.opentelemetry.io/otel/attribute`. (#7948)
 
 <!-- Released section -->
 <!-- Don't change this section unless doing release -->

attribute/benchmark_test.go

@@ -23,6 +23,7 @@ var (
 	outFloat64Slice []float64
 	outStr          string
 	outStrSlice     []string
+	outBytes        []byte
 )
 
 func benchmarkEmit(kv attribute.KeyValue) func(*testing.B) {
@@ -272,6 +273,31 @@ func BenchmarkStringSlice(b *testing.B) {
 	b.Run("Emit", benchmarkEmit(kv))
 }
 
+func BenchmarkBytes(b *testing.B) {
+	k, v := "bytes", []byte("forty-two")
+	kv := attribute.Bytes(k, v)
+
+	b.Run("Value", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			outV = attribute.BytesValue(v)
+		}
+	})
+	b.Run("KeyValue", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			outKV = attribute.Bytes(k, v)
+		}
+	})
+	b.Run("AsBytes", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			outBytes = kv.Value.AsBytes()
+		}
+	})
+	b.Run("Emit", benchmarkEmit(kv))
+}
+
 func BenchmarkSetEquals(b *testing.B) {
 	b.Run("Empty", func(b *testing.B) {
 		benchmarkSetEquals(b, attribute.EmptySet())

attribute/hash.go

@@ -27,6 +27,7 @@ const (
 	int64SliceID   uint64 = 3762322556277578591 // "_[]int64" (little endian)
 	float64SliceID uint64 = 7308324551835016539 // "[]double" (little endian)
 	stringSliceID  uint64 = 7453010373645655387 // "[]string" (little endian)
+	bytesID        uint64 = 6874028470941080415 // "_[]byte_" (little endian)
 )
 
 // hashKVs returns a new xxHash64 hash of kvs.
@@ -80,6 +81,15 @@ func hashKV(h xxhash.Hash, kv KeyValue) xxhash.Hash {
 		for i := 0; i < rv.Len(); i++ {
 			h = h.String(rv.Index(i).String())
 		}
+	case BYTES:
+		h = h.Uint64(bytesID)
+		if kv.Value.slice == nil {
+			break
+		}
+		rv := reflect.ValueOf(kv.Value.slice)
+		for i := 0; i < rv.Len(); i++ {
+			h = h.Uint64(rv.Index(i).Uint())
+		}
 	case INVALID:
 	default:
 		// Logging is an alternative, but using the internal logger here

attribute/hash_test.go

@@ -36,6 +36,8 @@ var keyVals = []func(string) KeyValue{
 	func(k string) KeyValue { return String(k, "bar") },
 	func(k string) KeyValue { return StringSlice(k, []string{"foo", "bar", "baz"}) },
 	func(k string) KeyValue { return StringSlice(k, []string{"[]i1"}) },
+	func(k string) KeyValue { return Bytes(k, []byte("foo")) },
+	func(k string) KeyValue { return Bytes(k, []byte("[]i1")) },
 }
 
 func TestHashKVsEquality(t *testing.T) {
@@ -187,7 +189,7 @@ func FuzzHashKVs(f *testing.F) {
 
 		// Add slice types based on sliceType parameter
 		if numAttrs > 5 {
-			switch sliceType % 4 {
+			switch sliceType % 5 {
 			case 0:
 				// Test BoolSlice with variable length.
 				bools := make([]bool, len(s)%5) // 0-4 elements
@@ -225,6 +227,13 @@ func FuzzHashKVs(f *testing.F) {
 					}
 				}
 				kvs = append(kvs, Float64Slice("float64slice", float64s))
+			case 4:
+				// Test Bytes with variable length.
+				bytes := make([]byte, len(s)%5)
+				for i := range bytes {
+					bytes[i] = byte(i + len(k1))
+				}
+				kvs = append(kvs, Bytes("bytes", bytes))
 			}
 		}
 

attribute/internal/attribute.go

@@ -39,6 +39,13 @@ func StringSliceValue(v []string) any {
 	return cp.Interface()
 }
 
+// BytesValue converts a bytes slice into an array with same elements as slice.
+func BytesValue(v []byte) any {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[byte]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return cp.Interface()
+}
+
 // AsBoolSlice converts a bool array into a slice into with same elements as array.
 func AsBoolSlice(v any) []bool {
 	rv := reflect.ValueOf(v)
@@ -90,3 +97,16 @@ func AsStringSlice(v any) []string {
 	}
 	return cpy
 }
+
+// AsBytes converts a bytes array into a slice into with same elements as array.
+func AsBytes(v any) []byte {
+	rv := reflect.ValueOf(v)
+	if rv.Type().Kind() != reflect.Array {
+		return nil
+	}
+	cpy := make([]byte, rv.Len())
+	if len(cpy) > 0 {
+		_ = reflect.Copy(reflect.ValueOf(cpy), rv)
+	}
+	return cpy
+}

attribute/key.go

@@ -117,6 +117,17 @@ func (k Key) StringSlice(v []string) KeyValue {
 	}
 }
 
+// Bytes creates a KeyValue instance with a BYTES Value.
+//
+// If creating both a key and value at the same time, use the provided
+// convenience function instead -- Bytes(name, value).
+func (k Key) Bytes(v []byte) KeyValue {
+	return KeyValue{
+		Key:   k,
+		Value: BytesValue(v),
+	}
+}
+
 // Defined reports whether the key is not empty.
 func (k Key) Defined() bool {
 	return len(k) != 0

attribute/key_test.go

@@ -108,6 +108,11 @@ func TestEmit(t *testing.T) {
 			v:    attribute.StringSliceValue([]string{"foo", "bar"}),
 			want: `["foo","bar"]`,
 		},
+		{
+			name: `test Key.Emit() can emit a string representing self.BYTES`,
+			v:    attribute.BytesValue([]byte("foo")),
+			want: `Zm9v`,
+		},
 	} {
 		t.Run(testcase.name, func(t *testing.T) {
 			// proto: func (v attribute.Value) Emit() string {

attribute/kv.go

@@ -68,6 +68,11 @@ func StringSlice(k string, v []string) KeyValue {
 	return Key(k).StringSlice(v)
 }
 
+// Bytes creates a KeyValue with a BYTES Value type.
+func Bytes(k string, v []byte) KeyValue {
+	return Key(k).Bytes(v)
+}
+
 // Stringer creates a new key-value pair with a passed name and a string
 // value generated by the passed Stringer interface.
 func Stringer(k string, v fmt.Stringer) KeyValue {

attribute/kv_test.go

@@ -58,6 +58,14 @@ func TestKeyValueConstructors(t *testing.T) {
 				Value: attribute.IntValue(123),
 			},
 		},
+		{
+			name:   "Bytes",
+			actual: attribute.Bytes("k1", []byte{123}),
+			expected: attribute.KeyValue{
+				Key:   "k1",
+				Value: attribute.BytesValue([]byte{123}),
+			},
+		},
 	}
 
 	for _, test := range tt {
@@ -114,6 +122,11 @@ func TestKeyValueValid(t *testing.T) {
 			valid: true,
 			kv:    attribute.String("string", ""),
 		},
+		{
+			desc:  "non-empty key with BYTE type Value should be valid",
+			valid: true,
+			kv:    attribute.Bytes("string", []byte{}),
+		},
 	}
 
 	for _, test := range tests {
@@ -152,6 +165,10 @@ func TestIncorrectCast(t *testing.T) {
 			name: "StringSlice",
 			val:  attribute.BoolSliceValue([]bool{true}),
 		},
+		{
+			name: "Bytes",
+			val:  attribute.BytesValue([]byte{123}),
+		},
 	}
 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
@@ -165,6 +182,7 @@ func TestIncorrectCast(t *testing.T) {
 				tt.val.AsInterface()
 				tt.val.AsString()
 				tt.val.AsStringSlice()
+				tt.val.AsBytes()
 			})
 		})
 	}

attribute/value.go

@@ -4,6 +4,7 @@
 package attribute // import "go.opentelemetry.io/otel/attribute"
 
 import (
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"reflect"
@@ -44,6 +45,8 @@ const (
 	FLOAT64SLICE
 	// STRINGSLICE is a slice of strings Type Value.
 	STRINGSLICE
+	// BYTES is a slice of bytes Type Value.
+	BYTES
 )
 
 // BoolValue creates a BOOL Value.
@@ -115,6 +118,14 @@ func StringSliceValue(v []string) Value {
 	return Value{vtype: STRINGSLICE, slice: attribute.StringSliceValue(v)}
 }
 
+// BytesValue creates a BYTES Value.
+func BytesValue(v []byte) Value {
+	return Value{
+		vtype: BYTES,
+		slice: attribute.BytesValue(v),
+	}
+}
+
 // Type returns a type of the Value.
 func (v Value) Type() Type {
 	return v.vtype
@@ -196,6 +207,15 @@ func (v Value) asStringSlice() []string {
 	return attribute.AsStringSlice(v.slice)
 }
 
+// AsBytes returns the bytes value. Make sure that the Value's type
+// is BYTES.
+func (v Value) AsBytes() []byte {
+	if v.vtype != BYTES {
+		return nil
+	}
+	return attribute.AsBytes(v.slice)
+}
+
 type unknownValueType struct{}
 
 // AsInterface returns Value's data as any.
@@ -217,6 +237,8 @@ func (v Value) AsInterface() any {
 		return v.stringly
 	case STRINGSLICE:
 		return v.asStringSlice()
+	case BYTES:
+		return v.AsBytes()
 	}
 	return unknownValueType{}
 }
@@ -252,6 +274,8 @@ func (v Value) Emit() string {
 		return string(j)
 	case STRING:
 		return v.stringly
+	case BYTES:
+		return base64.StdEncoding.EncodeToString(v.AsBytes())
 	default:
 		return "unknown"
 	}

attribute/value_test.go

@@ -86,6 +86,12 @@ func TestValue(t *testing.T) {
 			wantType:  attribute.STRINGSLICE,
 			wantValue: []string{"forty-two", "negative three", "twelve"},
 		},
+		{
+			name:      "Key.Bytes() correctly returns keys's internal []byte value",
+			value:     k.Bytes([]byte("hello world")).Value,
+			wantType:  attribute.BYTES,
+			wantValue: []byte("hello world"),
+		},
 	} {
 		t.Logf("Running test case %s", testcase.name)
 		if testcase.value.Type() != testcase.wantType {
@@ -143,6 +149,10 @@ func TestEquivalence(t *testing.T) {
 			attribute.StringSlice("StringSlice", []string{"one", "two", "three"}),
 			attribute.StringSlice("StringSlice", []string{"one", "two", "three"}),
 		},
+		{
+			attribute.Bytes("Bytes", []byte("one")),
+			attribute.Bytes("Bytes", []byte("one")),
+		},
 	}
 
 	t.Run("Distinct", func(t *testing.T) {
@@ -205,4 +215,9 @@ func TestAsSlice(t *testing.T) {
 	kv = attribute.StringSlice("StringSlice", ss1)
 	ss2 := kv.Value.AsStringSlice()
 	assert.Equal(t, ss1, ss2)
+
+	b1 := []byte("one")
+	kv = attribute.Bytes("Bytes", b1)
+	b2 := kv.Value.AsBytes()
+	assert.Equal(t, b1, b2)
 }

log/keyvalue.go

@@ -428,6 +428,9 @@ func ValueFromAttribute(value attribute.Value) Value {
 			res = append(res, StringValue(v))
 		}
 		return SliceValue(res...)
+	case attribute.BYTES:
+		val := value.AsBytes()
+		return BytesValue(val)
 	}
 	// This code should never be reached
 	// as log attributes are a superset of standard attributes.