diff --git a/.chloggen/ptracetest_options.yaml b/.chloggen/ptracetest_options.yaml new file mode 100644 index 000000000000..cf21e30e0b08 --- /dev/null +++ b/.chloggen/ptracetest_options.yaml @@ -0,0 +1,27 @@ +# Use this changelog template to create an entry for release notes. + +# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' +change_type: enhancement + +# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver) +component: ptracetest + +# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`). +note: Add support for ignore scope span instrumentation scope information + +# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists. +issues: [32852] + +# (Optional) One or more lines of additional information to render under the primary note. +# These lines will be padded with 2 spaces and then inserted directly into the document. +# Use pipe (|) for multiline entries. +subtext: + +# If your change doesn't affect end users or the exported elements of any package, +# you should instead start your pull request title with [chore] or use the "Skip Changelog" label. +# Optional: The change log or logs in which this entry should be included. +# e.g. '[user]' or '[user, api]' +# Include 'user' if the change is relevant to end users. +# Include 'api' if there is a change to a library API. +# Default: '[user]' +change_logs: [] diff --git a/pkg/pdatatest/ptracetest/options.go b/pkg/pdatatest/ptracetest/options.go index 08e829463e26..ff4bdb1d1feb 100644 --- a/pkg/pdatatest/ptracetest/options.go +++ b/pkg/pdatatest/ptracetest/options.go @@ -174,6 +174,62 @@ func maskSpanAttributeValue(traces ptrace.Traces, attributeName string) { } } +// IgnoreScopeSpanInstrumentationScopeName is a CompareTracesOption that clears value of the scope span instrumentation scope name. +func IgnoreScopeSpanInstrumentationScopeName() CompareTracesOption { + return compareTracesOptionFunc(func(expected, actual ptrace.Traces) { + maskScopeSpanInstrumentationScopeName(expected) + maskScopeSpanInstrumentationScopeName(actual) + }) +} + +func maskScopeSpanInstrumentationScopeName(traces ptrace.Traces) { + for i := 0; i < traces.ResourceSpans().Len(); i++ { + rs := traces.ResourceSpans().At(i) + for j := 0; j < rs.ScopeSpans().Len(); j++ { + ss := rs.ScopeSpans().At(j) + ss.Scope().SetName("") + } + } +} + +// IgnoreScopeSpanInstrumentationScopeVersion is a CompareTracesOption that clears value of the scope span instrumentation scope version. +func IgnoreScopeSpanInstrumentationScopeVersion() CompareTracesOption { + return compareTracesOptionFunc(func(expected, actual ptrace.Traces) { + maskScopeSpanInstrumentationScopeVersion(expected) + maskScopeSpanInstrumentationScopeVersion(actual) + }) +} + +func maskScopeSpanInstrumentationScopeVersion(traces ptrace.Traces) { + for i := 0; i < traces.ResourceSpans().Len(); i++ { + rs := traces.ResourceSpans().At(i) + for j := 0; j < rs.ScopeSpans().Len(); j++ { + ss := rs.ScopeSpans().At(j) + ss.Scope().SetVersion("") + } + } +} + +// IgnoreScopeSpanInstrumentationScopeAttributeValue is a CompareTracesOption that clears value of the scope span instrumentation scope name. +func IgnoreScopeSpanInstrumentationScopeAttributeValue(attributeName string) CompareTracesOption { + return compareTracesOptionFunc(func(expected, actual ptrace.Traces) { + maskScopeSpanInstrumentationScopeAttributeValue(expected, attributeName) + maskScopeSpanInstrumentationScopeAttributeValue(actual, attributeName) + }) +} + +func maskScopeSpanInstrumentationScopeAttributeValue(traces ptrace.Traces, attributeName string) { + for i := 0; i < traces.ResourceSpans().Len(); i++ { + rs := traces.ResourceSpans().At(i) + for j := 0; j < rs.ScopeSpans().Len(); j++ { + ss := rs.ScopeSpans().At(j) + if _, ok := ss.Scope().Attributes().Get(attributeName); ok { + ss.Scope().Attributes().PutStr(attributeName, "*") + } + } + } +} + // IgnoreStartTimestamp is a CompareTracesOption that clears StartTimestamp fields on all spans. func IgnoreStartTimestamp() CompareTracesOption { return compareTracesOptionFunc(func(expected, actual ptrace.Traces) { diff --git a/pkg/pdatatest/ptracetest/testdata/scopespans-scope-attributes-mismatch/actual.yaml b/pkg/pdatatest/ptracetest/testdata/scopespans-scope-attributes-mismatch/actual.yaml new file mode 100644 index 000000000000..88c4cd96fb95 --- /dev/null +++ b/pkg/pdatatest/ptracetest/testdata/scopespans-scope-attributes-mismatch/actual.yaml @@ -0,0 +1,17 @@ +resourceSpans: + - resource: + attributes: + - key: host.name + value: + stringValue: host1 + scopeSpans: + - scope: + name: scope1 + version: v0.1.0 + attributes: + - key: key1 + value: + stringValue: value1 + - scope: + name: scope2 + version: v0.1.0 diff --git a/pkg/pdatatest/ptracetest/testdata/scopespans-scope-attributes-mismatch/expected.yaml b/pkg/pdatatest/ptracetest/testdata/scopespans-scope-attributes-mismatch/expected.yaml new file mode 100644 index 000000000000..7fd159938beb --- /dev/null +++ b/pkg/pdatatest/ptracetest/testdata/scopespans-scope-attributes-mismatch/expected.yaml @@ -0,0 +1,17 @@ +resourceSpans: + - resource: + attributes: + - key: host.name + value: + stringValue: host1 + scopeSpans: + - scope: + name: scope1 + version: v0.1.0 + attributes: + - key: key1 + value: + stringValue: value2 + - scope: + name: scope2 + version: v0.1.0 diff --git a/pkg/pdatatest/ptracetest/traces_test.go b/pkg/pdatatest/ptracetest/traces_test.go index 606339fcb3a4..d1615327fed3 100644 --- a/pkg/pdatatest/ptracetest/traces_test.go +++ b/pkg/pdatatest/ptracetest/traces_test.go @@ -122,12 +122,30 @@ func TestCompareTraces(t *testing.T) { withoutOptions: multierr.Combine( errors.New("resource \"map[host.name:host1]\": missing expected scope: scope3; resource \"map[host.name:host1]\": unexpected scope: scope2"), ), + compareOptions: []CompareTracesOption{ + IgnoreScopeSpanInstrumentationScopeName(), + }, + withOptions: nil, }, { name: "scopespans-scope-version-mismatch", withoutOptions: multierr.Combine( errors.New("resource \"map[host.name:host1]\": scope \"scope2\": version doesn't match expected: v0.2.0, actual: v0.1.0"), ), + compareOptions: []CompareTracesOption{ + IgnoreScopeSpanInstrumentationScopeVersion(), + }, + withOptions: nil, + }, + { + name: "scopespans-scope-attributes-mismatch", + withoutOptions: multierr.Combine( + errors.New("resource \"map[host.name:host1]\": scope \"scope1\": attributes don't match expected: map[key1:value2], actual: map[key1:value1]"), + ), + compareOptions: []CompareTracesOption{ + IgnoreScopeSpanInstrumentationScopeAttributeValue("key1"), + }, + withOptions: nil, }, { name: "scopespans-spans-amount-unequal", @@ -462,6 +480,34 @@ func TestCompareScopeSpans(t *testing.T) { }(), err: errors.New("name doesn't match expected: scope1, actual: scope2"), }, + { + name: "scope-version-mismatch", + expected: func() ptrace.ScopeSpans { + ss := ptrace.NewScopeSpans() + ss.Scope().SetVersion("1") + return ss + }(), + actual: func() ptrace.ScopeSpans { + ss := ptrace.NewScopeSpans() + ss.Scope().SetVersion("2") + return ss + }(), + err: errors.New("version doesn't match expected: 1, actual: 2"), + }, + { + name: "scope-attributes-mismatch", + expected: func() ptrace.ScopeSpans { + ss := ptrace.NewScopeSpans() + ss.Scope().Attributes().PutStr("foo", "bar") + return ss + }(), + actual: func() ptrace.ScopeSpans { + ss := ptrace.NewScopeSpans() + ss.Scope().Attributes().PutStr("foo", "foobar") + return ss + }(), + err: errors.New("attributes don't match expected: map[foo:bar], actual: map[foo:foobar]"), + }, { name: "spans-number-mismatch", expected: func() ptrace.ScopeSpans {