Added support for list values for a key in processor

internal/processor/filterhelper/filterhelper.go

@@ -34,7 +34,27 @@ func NewAttributeValueRaw(value interface{}) (pdata.AttributeValue, error) {
 		return pdata.NewAttributeValueString(val), nil
 	case bool:
 		return pdata.NewAttributeValueBool(val), nil
+	case []interface{}:
+		attributeVal, err := fromArray(val)
+		if err != nil {
+			return attributeVal, err
+		}
+		return attributeVal, nil
 	default:
 		return pdata.AttributeValue{}, fmt.Errorf("error unsupported value type \"%T\"", value)
 	}
 }
+
+func fromArray(val []interface{}) (pdata.AttributeValue, error) {
+	arr := pdata.NewAnyValueArray()
+	for _, v := range val {
+		attributeVal, err := NewAttributeValueRaw(v)
+		if err != nil {
+			return attributeVal, err
+		}
+		arr.Append(attributeVal)
+	}
+	av := pdata.NewAttributeValueArray()
+	av.SetArrayVal(arr)
+	return av, nil
+}

internal/processor/filterhelper/filterhelper_test.go

@@ -61,3 +61,62 @@ func TestHelper_AttributeValue(t *testing.T) {
 	_, err = NewAttributeValueRaw(t)
 	assert.Error(t, err)
 }
+
+func TestHelper_AttributeValueArray(t *testing.T) {
+	testData := []interface{}{"alpha", "beta", "gamma", "delta"}
+	val, err := NewAttributeValueRaw(testData)
+	assert.Equal(t, val.Type(), pdata.AttributeValueARRAY)
+	assert.NotNil(t, val.ArrayVal())
+	assert.Equal(t, 4, val.ArrayVal().Len())
+	assert.NoError(t, err)
+	for i := 0; i < val.ArrayVal().Len(); i++ {
+		assert.Equal(t, pdata.NewAttributeValueString(testData[i].(string)), val.ArrayVal().At(i))
+	}
+
+	testData = []interface{}{int64(200), int64(203), int64(500)}
+	val, err = NewAttributeValueRaw(testData)
+	assert.Equal(t, val.Type(), pdata.AttributeValueARRAY)
+	assert.NotNil(t, val.ArrayVal())
+	assert.Equal(t, 3, val.ArrayVal().Len())
+	assert.NoError(t, err)
+	for i := 0; i < val.ArrayVal().Len(); i++ {
+		assert.Equal(t, pdata.NewAttributeValueInt(testData[i].(int64)), val.ArrayVal().At(i))
+	}
+
+	testData = []interface{}{float32(5341.129312), float32(888.102)}
+	val, err = NewAttributeValueRaw(testData)
+	assert.Equal(t, val.Type(), pdata.AttributeValueARRAY)
+	assert.NotNil(t, val.ArrayVal())
+	assert.Equal(t, 2, val.ArrayVal().Len())
+	assert.NoError(t, err)
+	for i := 0; i < val.ArrayVal().Len(); i++ {
+		assert.Equal(t, pdata.NewAttributeValueDouble(float64(testData[i].(float32))), val.ArrayVal().At(i))
+	}
+
+	testData = []interface{}{true}
+	val, err = NewAttributeValueRaw(testData)
+	assert.Equal(t, val.Type(), pdata.AttributeValueARRAY)
+	assert.NotNil(t, val.ArrayVal())
+	assert.Equal(t, 1, val.ArrayVal().Len())
+	assert.NoError(t, err)
+	for i := 0; i < val.ArrayVal().Len(); i++ {
+		assert.Equal(t, pdata.NewAttributeValueBool(testData[i].(bool)), val.ArrayVal().At(i))
+	}
+
+	var southWeather = make(map[string]interface{})
+	southWeather["NY"] = 15.9
+	southWeather["VT"] = 13.1
+	southWeather["NH"] = 18.0
+	val, err = NewAttributeValueRaw(southWeather)
+	assert.Equal(t, pdata.AttributeValue{}, val)
+	assert.Error(t, err)
+
+	var northWeather = make(map[string]interface{})
+	northWeather["AR"] = 45.7
+	northWeather["TX"] = 43.3
+	northWeather["MS"] = 41.1
+
+	val, err = NewAttributeValueRaw([]interface{}{southWeather, northWeather})
+	assert.Equal(t, pdata.AttributeValue{}, val)
+	assert.Error(t, err)
+}

internal/processor/filtermatcher/attributematcher.go

@@ -105,8 +105,22 @@ func (ma attributesMatcher) Match(attrs pdata.AttributeMap) bool {
 				return false
 			}
 		} else if property.AttributeValue != nil {
-			if !attr.Equal(*property.AttributeValue) {
+			propertyAttrValue := property.AttributeValue
+			switch propertyAttrValue.Type() {
+			// Case when Attribute Values are of list values.
+			case pdata.AttributeValueARRAY:
+				for i := 0; i < propertyAttrValue.ArrayVal().Len(); i++ {
+					// Check attr value is exists in the AttributeValue array.
+					// Equal checks for any of int, string, bool and double.
+					if attr.Equal(propertyAttrValue.ArrayVal().At(i)) {
+						return true
+					}
+				}
 				return false
+			default:
+				if !attr.Equal(*property.AttributeValue) {
+					return false
+				}
 			}
 		}
 	}

internal/processor/filterspan/filterspan_test.go

@@ -562,3 +562,72 @@ func TestServiceNameForResource(t *testing.T) {
 	resource.Attributes().InsertString(conventions.AttributeServiceName, "test-service")
 	require.Equal(t, serviceNameForResource(resource), "test-service")
 }
+
+// TestSpan_Matching_Array tests matcher.MatchSpan for attributes specification against a span
+// Attributes include array values and default values covering switch case in Properties matcher attributes.Match
+func TestSpan_Matching_Array(t *testing.T) {
+	// True case
+	cfg := &filterconfig.MatchProperties{
+		Config:   *createConfig(filterset.Strict),
+		Services: []string{"svc"},
+		Attributes: []filterconfig.Attribute{
+			{
+				Key:   "http.url",
+				Value: []interface{}{"https://play.golang.org/"},
+			},
+		},
+	}
+
+	span := pdata.NewSpan()
+	span.InitEmpty()
+	span.Attributes().InsertString("http.url", "https://play.golang.org/")
+	assert.NotNil(t, span)
+
+	matcher, err := NewMatcher(cfg)
+	spanRes := matcher.MatchSpan(span, resource("svc"), pdata.NewInstrumentationLibrary())
+	require.NoError(t, err)
+	assert.NotNil(t, matcher)
+	assert.True(t, spanRes)
+
+	// False case
+	cfg = &filterconfig.MatchProperties{
+		Config:   *createConfig(filterset.Strict),
+		Services: []string{"svc"},
+		Attributes: []filterconfig.Attribute{
+			{
+				Key:   "keyBool",
+				Value: []interface{}{false},
+			},
+		},
+	}
+
+	span.Attributes().InsertBool("keyBool", true)
+	assert.NotNil(t, span)
+
+	matcher, err = NewMatcher(cfg)
+	spanRes = matcher.MatchSpan(span, resource("svc"), pdata.NewInstrumentationLibrary())
+	require.NoError(t, err)
+	assert.NotNil(t, matcher)
+	assert.False(t, spanRes)
+
+	// Default case
+	cfg = &filterconfig.MatchProperties{
+		Config:   *createConfig(filterset.Strict),
+		Services: []string{"svc"},
+		Attributes: []filterconfig.Attribute{
+			{
+				Key:   "keyInt",
+				Value: 1243,
+			},
+		},
+	}
+
+	span.Attributes().InsertInt("keyInt", 1243)
+	assert.NotNil(t, span)
+
+	matcher, err = NewMatcher(cfg)
+	spanRes = matcher.MatchSpan(span, resource("svc"), pdata.NewInstrumentationLibrary())
+	require.NoError(t, err)
+	assert.NotNil(t, matcher)
+	assert.True(t, spanRes)
+}