From 31abb97808da59a2b7c8fe70cc2420de3c994f1f Mon Sep 17 00:00:00 2001 From: Gregor Zeitlinger Date: Sat, 10 Oct 2020 13:16:59 +0200 Subject: [PATCH] extract common tests from span and log filtering --- .../processor/filterlog/filterlog_test.go | 134 ------ internal/processor/filtermatcher/.nocover | 1 - .../filtermatcher/filtermatcher_test.go | 399 ++++++++++++++++++ .../processor/filterspan/filterspan_test.go | 305 +------------ 4 files changed, 402 insertions(+), 437 deletions(-) delete mode 100644 internal/processor/filtermatcher/.nocover create mode 100644 internal/processor/filtermatcher/filtermatcher_test.go diff --git a/internal/processor/filterlog/filterlog_test.go b/internal/processor/filterlog/filterlog_test.go index 75a1ce7fae2..d41ff94843a 100644 --- a/internal/processor/filterlog/filterlog_test.go +++ b/internal/processor/filterlog/filterlog_test.go @@ -87,18 +87,6 @@ func TestLogRecord_validateMatchesConfiguration_InvalidConfig(t *testing.T) { }, errorString: "error creating log record name filters: error parsing regexp: missing closing ]: `[`", }, - { - name: "empty_key_name_in_attributes_list", - property: filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Attributes: []filterconfig.Attribute{ - { - Key: "", - }, - }, - }, - errorString: "error creating attribute filters: can't have empty key in the list of attributes", - }, } for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { @@ -136,49 +124,11 @@ func TestLogRecord_Matching_False(t *testing.T) { Attributes: []filterconfig.Attribute{}, }, }, - - { - name: "wrong_property_value", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Attributes: []filterconfig.Attribute{ - { - Key: "keyInt", - Value: 1234, - }, - }, - }, - }, - { - name: "incompatible_property_value", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Attributes: []filterconfig.Attribute{ - { - Key: "keyInt", - Value: "123", - }, - }, - }, - }, - { - name: "property_key_does_not_exist", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Attributes: []filterconfig.Attribute{ - { - Key: "doesnotexist", - Value: nil, - }, - }, - }, - }, } lr := pdata.NewLogRecord() lr.InitEmpty() lr.SetName("logName") - lr.Attributes().InitFromMap(map[string]pdata.AttributeValue{"keyInt": pdata.NewAttributeValueInt(123)}) for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { matcher, err := NewMatcher(tc.properties) @@ -190,30 +140,6 @@ func TestLogRecord_Matching_False(t *testing.T) { } } -func TestLogRecord_MatchingCornerCases(t *testing.T) { - cfg := &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - LogNames: []string{"svcA"}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyOne", - Value: nil, - }, - }, - } - - mp, err := NewMatcher(cfg) - assert.Nil(t, err) - assert.NotNil(t, mp) - - emptyLogRecord := pdata.NewLogRecord() - emptyLogRecord.InitEmpty() - assert.False(t, mp.MatchLogRecord(emptyLogRecord, pdata.Resource{}, pdata.InstrumentationLibrary{})) - - emptyLogRecord.SetName("svcA") - assert.False(t, mp.MatchLogRecord(emptyLogRecord, pdata.Resource{}, pdata.InstrumentationLibrary{})) -} - func TestLogRecord_Matching_True(t *testing.T) { testcases := []struct { name string @@ -240,71 +166,11 @@ func TestLogRecord_Matching_True(t *testing.T) { Attributes: []filterconfig.Attribute{}, }, }, - { - name: "property_exact_value_match", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Attributes: []filterconfig.Attribute{ - { - Key: "keyString", - Value: "arithmetic", - }, - { - Key: "keyInt", - Value: 123, - }, - { - Key: "keyDouble", - Value: 3245.6, - }, - { - Key: "keyBool", - Value: true, - }, - }, - }, - }, - { - name: "property_exists", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Attributes: []filterconfig.Attribute{ - { - Key: "keyExists", - Value: nil, - }, - }, - }, - }, - { - name: "match_all_settings_exists", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - LogNames: []string{"logName"}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyExists", - Value: nil, - }, - { - Key: "keyString", - Value: "arithmetic", - }, - }, - }, - }, } lr := pdata.NewLogRecord() lr.InitEmpty() lr.SetName("logName") - lr.Attributes().InitFromMap(map[string]pdata.AttributeValue{ - "keyString": pdata.NewAttributeValueString("arithmetic"), - "keyInt": pdata.NewAttributeValueInt(123), - "keyDouble": pdata.NewAttributeValueDouble(3245.6), - "keyBool": pdata.NewAttributeValueBool(true), - "keyExists": pdata.NewAttributeValueString("present"), - }) for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { diff --git a/internal/processor/filtermatcher/.nocover b/internal/processor/filtermatcher/.nocover deleted file mode 100644 index 1f1c3f0444f..00000000000 --- a/internal/processor/filtermatcher/.nocover +++ /dev/null @@ -1 +0,0 @@ -Tested in filterspan package diff --git a/internal/processor/filtermatcher/filtermatcher_test.go b/internal/processor/filtermatcher/filtermatcher_test.go new file mode 100644 index 00000000000..20a1008dda9 --- /dev/null +++ b/internal/processor/filtermatcher/filtermatcher_test.go @@ -0,0 +1,399 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package filtermatcher + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "go.opentelemetry.io/collector/consumer/pdata" + "go.opentelemetry.io/collector/internal/processor/filterconfig" + "go.opentelemetry.io/collector/internal/processor/filterset" + "go.opentelemetry.io/collector/translator/conventions" +) + +func createConfig(matchType filterset.MatchType) *filterset.Config { + return &filterset.Config{ + MatchType: matchType, + } +} + +func TestSpan_validateMatchesConfiguration_InvalidConfig(t *testing.T) { + version := "[" + testcases := []struct { + name string + property filterconfig.MatchProperties + errorString string + }{ + { + name: "regexp_match_type_for_int_attribute", + property: filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + Attributes: []filterconfig.Attribute{ + {Key: "key", Value: 1}, + }, + }, + errorString: `error creating attribute filters: match_type=regexp for "key" only supports STRING, but found INT`, + }, + { + name: "unknown_attribute_value", + property: filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Attributes: []filterconfig.Attribute{ + {Key: "key", Value: []string{}}, + }, + }, + errorString: `error creating attribute filters: error unsupported value type "[]string"`, + }, + { + name: "invalid_regexp_pattern_attribute", + property: filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + SpanNames: []string{"["}, + Attributes: []filterconfig.Attribute{{Key: "key", Value: "["}}, + }, + errorString: "error creating attribute filters: error parsing regexp: missing closing ]: `[`", + }, + { + name: "invalid_regexp_pattern_resource", + property: filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + Resources: []filterconfig.Attribute{{Key: "key", Value: "["}}, + }, + errorString: "error creating resource filters: error parsing regexp: missing closing ]: `[`", + }, + { + name: "invalid_regexp_pattern_library_name", + property: filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + Libraries: []filterconfig.InstrumentationLibrary{{Name: "["}}, + }, + errorString: "error creating library name filters: error parsing regexp: missing closing ]: `[`", + }, + { + name: "invalid_regexp_pattern_library_version", + property: filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + Libraries: []filterconfig.InstrumentationLibrary{{Name: "lib", Version: &version}}, + }, + errorString: "error creating library version filters: error parsing regexp: missing closing ]: `[`", + }, + { + name: "empty_key_name_in_attributes_list", + property: filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{"a"}, + Attributes: []filterconfig.Attribute{ + { + Key: "", + }, + }, + }, + errorString: "error creating attribute filters: can't have empty key in the list of attributes", + }, + } + for _, tc := range testcases { + t.Run(tc.name, func(t *testing.T) { + output, err := NewMatcher(&tc.property) + assert.Zero(t, output) + assert.EqualError(t, err, tc.errorString) + }) + } +} + +func TestSpan_Matching_False(t *testing.T) { + version := "wrong" + testcases := []struct { + name string + properties *filterconfig.MatchProperties + }{ + { + name: "wrong_library_name", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{}, + Libraries: []filterconfig.InstrumentationLibrary{{Name: "wrong"}}, + }, + }, + { + name: "wrong_library_version", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{}, + Libraries: []filterconfig.InstrumentationLibrary{{Name: "lib", Version: &version}}, + }, + }, + + { + name: "wrong_attribute_value", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{}, + Attributes: []filterconfig.Attribute{ + { + Key: "keyInt", + Value: 1234, + }, + }, + }, + }, + { + name: "wrong_resource_value", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{}, + Resources: []filterconfig.Attribute{ + { + Key: "keyInt", + Value: 1234, + }, + }, + }, + }, + { + name: "incompatible_attribute_value", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{}, + Attributes: []filterconfig.Attribute{ + { + Key: "keyInt", + Value: "123", + }, + }, + }, + }, + { + name: "unsupported_attribute_value", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + Services: []string{}, + Attributes: []filterconfig.Attribute{ + { + Key: "keyMap", + Value: "123", + }, + }, + }, + }, + { + name: "property_key_does_not_exist", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{}, + Attributes: []filterconfig.Attribute{ + { + Key: "doesnotexist", + Value: nil, + }, + }, + }, + }, + } + + atts := pdata.NewAttributeMap().InitFromMap(map[string]pdata.AttributeValue{ + "keyInt": pdata.NewAttributeValueInt(123), + "keyMap": pdata.NewAttributeValueMap(), + }) + + library := pdata.NewInstrumentationLibrary() + library.InitEmpty() + library.SetName("lib") + library.SetVersion("ver") + + for _, tc := range testcases { + t.Run(tc.name, func(t *testing.T) { + matcher, err := NewMatcher(tc.properties) + require.NoError(t, err) + assert.NotNil(t, matcher) + + assert.False(t, matcher.Match(atts, resource("wrongSvc"), library)) + }) + } +} + +func TestSpan_MatchingCornerCases(t *testing.T) { + cfg := &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Attributes: []filterconfig.Attribute{ + { + Key: "keyOne", + Value: nil, + }, + }, + } + + mp, err := NewMatcher(cfg) + assert.Nil(t, err) + assert.NotNil(t, mp) + + assert.False(t, mp.Match(pdata.NewAttributeMap(), resource("svcA"), pdata.NewInstrumentationLibrary())) +} + +func TestSpan_Matching_True(t *testing.T) { + ver := "v.*" + + testcases := []struct { + name string + properties *filterconfig.MatchProperties + }{ + { + name: "library_match", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + Libraries: []filterconfig.InstrumentationLibrary{{Name: "li.*"}}, + Attributes: []filterconfig.Attribute{}, + }, + }, + { + name: "library_match_with_version", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + Libraries: []filterconfig.InstrumentationLibrary{{Name: "li.*", Version: &ver}}, + Attributes: []filterconfig.Attribute{}, + }, + }, + { + name: "attribute_exact_value_match", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{}, + Attributes: []filterconfig.Attribute{ + { + Key: "keyString", + Value: "arithmetic", + }, + { + Key: "keyInt", + Value: 123, + }, + { + Key: "keyDouble", + Value: 3245.6, + }, + { + Key: "keyBool", + Value: true, + }, + }, + }, + }, + { + name: "attribute_regex_value_match", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Regexp), + Attributes: []filterconfig.Attribute{ + { + Key: "keyString", + Value: "arith.*", + }, + { + Key: "keyInt", + Value: "12.*", + }, + { + Key: "keyDouble", + Value: "324.*", + }, + { + Key: "keyBool", + Value: "tr.*", + }, + }, + }, + }, + { + name: "resource_exact_value_match", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Resources: []filterconfig.Attribute{ + { + Key: "resString", + Value: "arithmetic", + }, + }, + }, + }, + { + name: "property_exists", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{"svcA"}, + Attributes: []filterconfig.Attribute{ + { + Key: "keyExists", + Value: nil, + }, + }, + }, + }, + { + name: "match_all_settings_exists", + properties: &filterconfig.MatchProperties{ + Config: *createConfig(filterset.Strict), + Services: []string{"svcA"}, + Attributes: []filterconfig.Attribute{ + { + Key: "keyExists", + Value: nil, + }, + { + Key: "keyString", + Value: "arithmetic", + }, + }, + }, + }, + } + + atts := pdata.NewAttributeMap().InitFromMap(map[string]pdata.AttributeValue{ + "keyString": pdata.NewAttributeValueString("arithmetic"), + "keyInt": pdata.NewAttributeValueInt(123), + "keyDouble": pdata.NewAttributeValueDouble(3245.6), + "keyBool": pdata.NewAttributeValueBool(true), + "keyExists": pdata.NewAttributeValueString("present"), + }) + + resource := pdata.NewResource() + resource.InitEmpty() + resource.Attributes().InitFromMap(map[string]pdata.AttributeValue{ + conventions.AttributeServiceName: pdata.NewAttributeValueString("svcA"), + "resString": pdata.NewAttributeValueString("arithmetic"), + }) + + library := pdata.NewInstrumentationLibrary() + library.InitEmpty() + library.SetName("lib") + library.SetVersion("ver") + + for _, tc := range testcases { + t.Run(tc.name, func(t *testing.T) { + mp, err := NewMatcher(tc.properties) + require.NoError(t, err) + assert.NotNil(t, mp) + + assert.True(t, mp.Match(atts, resource, library)) + }) + } +} + +func resource(service string) pdata.Resource { + r := pdata.NewResource() + r.InitEmpty() + r.Attributes().InitFromMap(map[string]pdata.AttributeValue{conventions.AttributeServiceName: pdata.NewAttributeValueString(service)}) + return r +} diff --git a/internal/processor/filterspan/filterspan_test.go b/internal/processor/filterspan/filterspan_test.go index 4a600b22698..9e624aeb18c 100644 --- a/internal/processor/filterspan/filterspan_test.go +++ b/internal/processor/filterspan/filterspan_test.go @@ -34,7 +34,6 @@ func createConfig(matchType filterset.MatchType) *filterset.Config { } func TestSpan_validateMatchesConfiguration_InvalidConfig(t *testing.T) { - version := "[" testcases := []struct { name string property filterconfig.MatchProperties @@ -74,26 +73,6 @@ func TestSpan_validateMatchesConfiguration_InvalidConfig(t *testing.T) { }, errorString: "error creating service name filters: unrecognized match_type: '', valid types are: [regexp strict]", }, - { - name: "regexp_match_type_for_int_attribute", - property: filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - Attributes: []filterconfig.Attribute{ - {Key: "key", Value: 1}, - }, - }, - errorString: `error creating attribute filters: match_type=regexp for "key" only supports STRING, but found INT`, - }, - { - name: "unknown_attribute_value", - property: filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Attributes: []filterconfig.Attribute{ - {Key: "key", Value: []string{}}, - }, - }, - errorString: `error creating attribute filters: error unsupported value type "[]string"`, - }, { name: "invalid_regexp_pattern_service", property: filterconfig.MatchProperties{ @@ -110,52 +89,6 @@ func TestSpan_validateMatchesConfiguration_InvalidConfig(t *testing.T) { }, errorString: "error creating span name filters: error parsing regexp: missing closing ]: `[`", }, - { - name: "invalid_regexp_pattern_attribute", - property: filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - SpanNames: []string{"["}, - Attributes: []filterconfig.Attribute{{Key: "key", Value: "["}}, - }, - errorString: "error creating attribute filters: error parsing regexp: missing closing ]: `[`", - }, - { - name: "invalid_regexp_pattern_resource", - property: filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - Resources: []filterconfig.Attribute{{Key: "key", Value: "["}}, - }, - errorString: "error creating resource filters: error parsing regexp: missing closing ]: `[`", - }, - { - name: "invalid_regexp_pattern_library_name", - property: filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - Libraries: []filterconfig.InstrumentationLibrary{{Name: "["}}, - }, - errorString: "error creating library name filters: error parsing regexp: missing closing ]: `[`", - }, - { - name: "invalid_regexp_pattern_library_version", - property: filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - Libraries: []filterconfig.InstrumentationLibrary{{Name: "lib", Version: &version}}, - }, - errorString: "error creating library version filters: error parsing regexp: missing closing ]: `[`", - }, - { - name: "empty_key_name_in_attributes_list", - property: filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{"a"}, - Attributes: []filterconfig.Attribute{ - { - Key: "", - }, - }, - }, - errorString: "error creating attribute filters: can't have empty key in the list of attributes", - }, } for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { @@ -167,7 +100,6 @@ func TestSpan_validateMatchesConfiguration_InvalidConfig(t *testing.T) { } func TestSpan_Matching_False(t *testing.T) { - version := "wrong" testcases := []struct { name string properties *filterconfig.MatchProperties @@ -211,103 +143,13 @@ func TestSpan_Matching_False(t *testing.T) { Attributes: []filterconfig.Attribute{}, }, }, - - { - name: "wrong_library_name", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{}, - Libraries: []filterconfig.InstrumentationLibrary{{Name: "wrong"}}, - }, - }, - { - name: "wrong_library_version", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{}, - Libraries: []filterconfig.InstrumentationLibrary{{Name: "lib", Version: &version}}, - }, - }, - - { - name: "wrong_attribute_value", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyInt", - Value: 1234, - }, - }, - }, - }, - { - name: "wrong_resource_value", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{}, - Resources: []filterconfig.Attribute{ - { - Key: "keyInt", - Value: 1234, - }, - }, - }, - }, - { - name: "incompatible_attribute_value", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyInt", - Value: "123", - }, - }, - }, - }, - { - name: "unsupported_attribute_value", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - Services: []string{}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyMap", - Value: "123", - }, - }, - }, - }, - { - name: "property_key_does_not_exist", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{}, - Attributes: []filterconfig.Attribute{ - { - Key: "doesnotexist", - Value: nil, - }, - }, - }, - }, } span := pdata.NewSpan() span.InitEmpty() span.SetName("spanName") - span.Attributes().InitFromMap(map[string]pdata.AttributeValue{ - "keyInt": pdata.NewAttributeValueInt(123), - "keyMap": pdata.NewAttributeValueMap(), - }) - library := pdata.NewInstrumentationLibrary() - library.InitEmpty() - library.SetName("lib") - library.SetVersion("ver") + resource := pdata.NewResource() for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { @@ -315,39 +157,11 @@ func TestSpan_Matching_False(t *testing.T) { require.NoError(t, err) assert.NotNil(t, matcher) - assert.False(t, matcher.MatchSpan(span, resource("wrongSvc"), library)) + assert.False(t, matcher.MatchSpan(span, resource, library)) }) } } -func resource(service string) pdata.Resource { - r := pdata.NewResource() - r.InitEmpty() - r.Attributes().InitFromMap(map[string]pdata.AttributeValue{conventions.AttributeServiceName: pdata.NewAttributeValueString(service)}) - return r -} - -func TestSpan_MatchingCornerCases(t *testing.T) { - cfg := &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{"svcA"}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyOne", - Value: nil, - }, - }, - } - - mp, err := NewMatcher(cfg) - assert.Nil(t, err) - assert.NotNil(t, mp) - - emptySpan := pdata.NewSpan() - emptySpan.InitEmpty() - assert.False(t, mp.MatchSpan(emptySpan, resource("svcA"), pdata.NewInstrumentationLibrary())) -} - func TestSpan_MissingServiceName(t *testing.T) { cfg := &filterconfig.MatchProperties{ Config: *createConfig(filterset.Regexp), @@ -360,12 +174,10 @@ func TestSpan_MissingServiceName(t *testing.T) { emptySpan := pdata.NewSpan() emptySpan.InitEmpty() - assert.False(t, mp.MatchSpan(emptySpan, resource(""), pdata.NewInstrumentationLibrary())) + assert.False(t, mp.MatchSpan(emptySpan, pdata.NewResource(), pdata.NewInstrumentationLibrary())) } func TestSpan_Matching_True(t *testing.T) { - ver := "v.*" - testcases := []struct { name string properties *filterconfig.MatchProperties @@ -386,22 +198,6 @@ func TestSpan_Matching_True(t *testing.T) { Attributes: []filterconfig.Attribute{}, }, }, - { - name: "library_match", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - Libraries: []filterconfig.InstrumentationLibrary{{Name: "li.*"}}, - Attributes: []filterconfig.Attribute{}, - }, - }, - { - name: "library_match_with_version", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - Libraries: []filterconfig.InstrumentationLibrary{{Name: "li.*", Version: &ver}}, - Attributes: []filterconfig.Attribute{}, - }, - }, { name: "span_name_match", properties: &filterconfig.MatchProperties{ @@ -423,97 +219,6 @@ func TestSpan_Matching_True(t *testing.T) { Attributes: []filterconfig.Attribute{}, }, }, - { - name: "attribute_exact_value_match", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyString", - Value: "arithmetic", - }, - { - Key: "keyInt", - Value: 123, - }, - { - Key: "keyDouble", - Value: 3245.6, - }, - { - Key: "keyBool", - Value: true, - }, - }, - }, - }, - { - name: "attribute_regex_value_match", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Regexp), - Attributes: []filterconfig.Attribute{ - { - Key: "keyString", - Value: "arith.*", - }, - { - Key: "keyInt", - Value: "12.*", - }, - { - Key: "keyDouble", - Value: "324.*", - }, - { - Key: "keyBool", - Value: "tr.*", - }, - }, - }, - }, - { - name: "resource_exact_value_match", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Resources: []filterconfig.Attribute{ - { - Key: "resString", - Value: "arithmetic", - }, - }, - }, - }, - { - name: "property_exists", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{"svcA"}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyExists", - Value: nil, - }, - }, - }, - }, - { - name: "match_all_settings_exists", - properties: &filterconfig.MatchProperties{ - Config: *createConfig(filterset.Strict), - Services: []string{"svcA"}, - Attributes: []filterconfig.Attribute{ - { - Key: "keyExists", - Value: nil, - }, - { - Key: "keyString", - Value: "arithmetic", - }, - }, - }, - }, } span := pdata.NewSpan() @@ -532,13 +237,9 @@ func TestSpan_Matching_True(t *testing.T) { resource.InitEmpty() resource.Attributes().InitFromMap(map[string]pdata.AttributeValue{ conventions.AttributeServiceName: pdata.NewAttributeValueString("svcA"), - "resString": pdata.NewAttributeValueString("arithmetic"), }) library := pdata.NewInstrumentationLibrary() - library.InitEmpty() - library.SetName("lib") - library.SetVersion("ver") for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) {