Deprecate Array attribute in favor of *Slice types (#2162)

* Deprecate Array attribute in favor of *Slice types

* Use new attr types in Jaeger exporter

* Use slice attr types in otlpmetric

* Use slice attr types in otlptrace

* Use slice attr types in zipkin exporter

* Remove array attr test from deprectated oteltest func

* Use StringSlice for cmd arg resource attr

* Add changes to the changelog

* Remove use of deprecated Array func

attribute/value.go

@@ -33,9 +33,7 @@ type Value struct {
 	vtype    Type
 	numeric  uint64
 	stringly string
-	// TODO Lazy value type?
-
-	array interface{}
+	slice    interface{}
 }
 
 const (
@@ -49,9 +47,19 @@ 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
 	// ARRAY is an array Type Value used to store 1-dimensional slices or
 	// arrays of bool, int, int32, int64, uint, uint32, uint64, float,
 	// float32, float64, or string types.
+	//
+	// Deprecated: Use slice types instead.
 	ARRAY
 )
 
@@ -63,11 +71,33 @@ func BoolValue(v bool) Value {
 	}
 }
 
+// BoolSliceValue creates a BOOLSLICE Value.
+func BoolSliceValue(v []bool) Value {
+	cp := make([]bool, len(v))
+	copy(cp, v)
+	return Value{
+		vtype: BOOLSLICE,
+		slice: cp,
+	}
+}
+
 // 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 := make([]int64, 0, len(v))
+	for _, i := range v {
+		cp = append(cp, int64(i))
+	}
+	return Value{
+		vtype: INT64SLICE,
+		slice: cp,
+	}
+}
+
 // Int64Value creates an INT64 Value.
 func Int64Value(v int64) Value {
 	return Value{
@@ -76,6 +106,16 @@ func Int64Value(v int64) Value {
 	}
 }
 
+// Int64SliceValue creates an INT64SLICE Value.
+func Int64SliceValue(v []int64) Value {
+	cp := make([]int64, len(v))
+	copy(cp, v)
+	return Value{
+		vtype: INT64SLICE,
+		slice: cp,
+	}
+}
+
 // Float64Value creates a FLOAT64 Value.
 func Float64Value(v float64) Value {
 	return Value{
@@ -84,6 +124,16 @@ func Float64Value(v float64) Value {
 	}
 }
 
+// Float64SliceValue creates a FLOAT64SLICE Value.
+func Float64SliceValue(v []float64) Value {
+	cp := make([]float64, len(v))
+	copy(cp, v)
+	return Value{
+		vtype: FLOAT64SLICE,
+		slice: cp,
+	}
+}
+
 // StringValue creates a STRING Value.
 func StringValue(v string) Value {
 	return Value{
@@ -92,11 +142,23 @@ func StringValue(v string) Value {
 	}
 }
 
+// StringSliceValue creates a STRINGSLICE Value.
+func StringSliceValue(v []string) Value {
+	cp := make([]string, len(v))
+	copy(cp, v)
+	return Value{
+		vtype: STRINGSLICE,
+		slice: cp,
+	}
+}
+
 // ArrayValue creates an ARRAY value from an array or slice.
 // Only arrays or slices of bool, int, int64, float, float64, or string types are allowed.
 // Specifically, arrays  and slices can not contain other arrays, slices, structs, or non-standard
 // types. If the passed value is not an array or slice of these types an
 // INVALID value is returned.
+//
+// Deprecated: Use the typed *SliceValue functions instead.
 func ArrayValue(v interface{}) Value {
 	switch reflect.TypeOf(v).Kind() {
 	case reflect.Array, reflect.Slice:
@@ -112,7 +174,7 @@ func ArrayValue(v interface{}) Value {
 			reflect.Copy(frozen, val)
 			return Value{
 				vtype: ARRAY,
-				array: frozen.Interface(),
+				slice: frozen.Interface(),
 			}
 		default:
 			return Value{vtype: INVALID}
@@ -132,27 +194,65 @@ func (v Value) AsBool() bool {
 	return internal.RawToBool(v.numeric)
 }
 
+// AsBoolSlice returns the []bool value. Make sure that the Value's type is
+// BOOLSLICE.
+func (v Value) AsBoolSlice() []bool {
+	if s, ok := v.slice.([]bool); ok {
+		return s
+	}
+	return nil
+}
+
 // AsInt64 returns the int64 value. Make sure that the Value's type is
 // INT64.
 func (v Value) AsInt64() int64 {
 	return internal.RawToInt64(v.numeric)
 }
 
+// AsInt64Slice returns the []int64 value. Make sure that the Value's type is
+// INT64SLICE.
+func (v Value) AsInt64Slice() []int64 {
+	if s, ok := v.slice.([]int64); ok {
+		return s
+	}
+	return nil
+}
+
 // AsFloat64 returns the float64 value. Make sure that the Value's
 // type is FLOAT64.
 func (v Value) AsFloat64() float64 {
 	return internal.RawToFloat64(v.numeric)
 }
 
+// AsFloat64Slice returns the []float64 value. Make sure that the Value's type is
+// INT64SLICE.
+func (v Value) AsFloat64Slice() []float64 {
+	if s, ok := v.slice.([]float64); ok {
+		return s
+	}
+	return nil
+}
+
 // 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
+// INT64SLICE.
+func (v Value) AsStringSlice() []string {
+	if s, ok := v.slice.([]string); ok {
+		return s
+	}
+	return nil
+}
+
 // AsArray returns the array Value as an interface{}.
+//
+// Deprecated: Use the typed As*Slice functions instead.
 func (v Value) AsArray() interface{} {
-	return v.array
+	return v.slice
 }
 
 type unknownValueType struct{}
@@ -164,12 +264,20 @@ func (v Value) AsInterface() interface{} {
 		return v.AsArray()
 	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()
 	}
 	return unknownValueType{}
 }
@@ -177,8 +285,8 @@ func (v Value) AsInterface() interface{} {
 // Emit returns a string representation of Value's data.
 func (v Value) Emit() string {
 	switch v.Type() {
-	case ARRAY:
-		return fmt.Sprint(v.array)
+	case ARRAY, BOOLSLICE, INT64SLICE, FLOAT64SLICE, STRINGSLICE:
+		return fmt.Sprint(v.slice)
 	case BOOL:
 		return strconv.FormatBool(v.AsBool())
 	case INT64: