feat(attribute): add int32 support

- Extend Value with Int32Value and Int32SliceValue.
- Extend KeyValue with Int32 and Int32Slice.
- Extend the Key type with Int32 and Int32Slice methods.

attribute/key.go

@@ -51,6 +51,28 @@ func (k Key) IntSlice(v []int) KeyValue {
 	}
 }
 
+// Int32 creates a KeyValue instance with an INT64 Value.
+//
+// If creating both a key and value at the same time, use the provided
+// convenience function instead -- Int32(name, value).
+func (k Key) Int32(v int32) KeyValue {
+	return KeyValue{
+		Key:   k,
+		Value: Int32Value(v),
+	}
+}
+
+// Int32Slice creates a KeyValue instance with an INT64SLICE Value.
+//
+// If creating both a key and value at the same time, use the provided
+// convenience function instead -- Int32Slice(name, value).
+func (k Key) Int32Slice(v []int32) KeyValue {
+	return KeyValue{
+		Key:   k,
+		Value: Int32SliceValue(v),
+	}
+}
+
 // Int64 creates a KeyValue instance with an INT64 Value.
 //
 // If creating both a key and value at the same time, use the provided

attribute/kv.go

@@ -38,6 +38,16 @@ func IntSlice(k string, v []int) KeyValue {
 	return Key(k).IntSlice(v)
 }
 
+// Int32 creates a KeyValue with an INT64 Value type.
+func Int32(k string, v int32) KeyValue {
+	return Key(k).Int32(v)
+}
+
+// Int32Slice creates a KeyValue with an INT64 Value type.
+func Int32Slice(k string, v []int32) KeyValue {
+	return Key(k).Int32Slice(v)
+}
+
 // Int64 creates a KeyValue with an INT64 Value type.
 func Int64(k string, v int64) KeyValue {
 	return Key(k).Int64(v)

attribute/value.go

@@ -78,6 +78,24 @@ func IntSliceValue(v []int) Value {
 	}
 }
 
+// Int32Value creates an INT32 Value.
+func Int32Value(v int32) Value {
+	return Int64Value(int64(v))
+}
+
+// Int32SliceValue creates an INT32SLICE Value.
+func Int32SliceValue(v []int32) Value {
+	var int64Val int64
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeOf(int64Val)))
+	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{

attribute/value_test.go

@@ -62,6 +62,18 @@ func TestValue(t *testing.T) {
 			wantType:  attribute.INT64SLICE,
 			wantValue: []int64{42, -3, 12},
 		},
+		{
+			name:      "Key.Int32() correctly returns keys's internal signed integral value",
+			value:     k.Int32(42).Value,
+			wantType:  attribute.INT64,
+			wantValue: int64(42),
+		},
+		{
+			name:      "Key.Int32Slice() correctly returns keys's internal []int32 value",
+			value:     k.Int32Slice([]int32{42, -3, 12}).Value,
+			wantType:  attribute.INT64SLICE,
+			wantValue: []int64{42, -3, 12},
+		},
 		{
 			name:      "Key.Float64() correctly returns keys's internal float64 value",
 			value:     k.Float64(42.1).Value,
@@ -119,6 +131,14 @@ func TestEquivalence(t *testing.T) {
 			attribute.IntSlice("IntSlice", []int{312, 1, -2}),
 			attribute.IntSlice("IntSlice", []int{312, 1, -2}),
 		},
+		{
+			attribute.Int32("Int32", 44),
+			attribute.Int32("Int32", 44),
+		},
+		{
+			attribute.Int32Slice("Int32Slice", []int32{212, 21, -2}),
+			attribute.Int32Slice("Int32Slice", []int32{212, 21, -2}),
+		},
 		{
 			attribute.Int64("Int64", 98),
 			attribute.Int64("Int64", 98),