[v2] Implement sanitizers to operate on OTLP data

cmd/jaeger/README.md

@@ -2,3 +2,9 @@
 
 This is experimental Jaeger V2 based on OpenTelemetry collector.
 See https://github.com/jaegertracing/jaeger/issues/4843.
+
+## Compatibility
+
+### Service Name Sanitizer
+
+In v1, there was a `serviceNameSanitizer` that sanitized the service names in span annotations using a source of truth alias to service cache. This functionality has been removed in v2. If your implementation relies on this sanitizer, you will need to find a different way to integrate this functionality, such as implementing a custom processor.

cmd/jaeger/internal/exporters/storageexporter/sanitizer/empty_service_name_sanitizer.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer
+
+import (
+ "go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+// Constants for the replacement names
+const (
+ serviceNameReplacement = "empty-service-name"
+ nullProcessServiceName = "null-process-and-service-name"
+)
+
+// NewEmptyServiceNameSanitizer returns a function that replaces empty service names
+// with a predefined string.
+func NewEmptyServiceNameSanitizer() SanitizeTraces {
+ return sanitizeEmptyServiceName
+}
+
+// sanitizeEmptyServiceName sanitizes the service names in the resource attributes.
+func sanitizeEmptyServiceName(traces ptrace.Traces) ptrace.Traces {
+ resourceSpans := traces.ResourceSpans()
+ for i := 0; i < resourceSpans.Len(); i++ {
+ resourceSpan := resourceSpans.At(i)
+ attributes := resourceSpan.Resource().Attributes()
+ serviceNameAttr, ok := attributes.Get("service.name")
+ if !ok {
+ // If service.name is missing, set it to nullProcessServiceName
+ attributes.PutStr("service.name", nullProcessServiceName)
+ } else if serviceNameAttr.Str() == "" {
+ // If service.name is empty, replace it with serviceNameReplacement
+ attributes.PutStr("service.name", serviceNameReplacement)
+ }
+ }
+ return traces
+}

cmd/jaeger/internal/exporters/storageexporter/sanitizer/empty_service_name_sanitizer_test.go

@@ -0,0 +1,4 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer

cmd/jaeger/internal/exporters/storageexporter/sanitizer/package_test.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer
+
+import (
+ "testing"
+
+ "github.com/jaegertracing/jaeger/pkg/testutils"
+)
+
+func TestMain(m *testing.M) {
+ testutils.VerifyGoLeaks(m)
+}

cmd/jaeger/internal/exporters/storageexporter/sanitizer/sanitizer.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer
+
+import (
+ "go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+// SanitizeSpan sanitizes/normalizes spans. Any business logic that needs to be applied to normalize the contents of a
+// span should implement this interface.
+type SanitizeTraces func(traces ptrace.Traces) ptrace.Traces
+
+// NewStandardSanitizers are automatically applied by SpanProcessor.
+func NewStandardSanitizers() []SanitizeTraces {
+ return []SanitizeTraces{
+ NewEmptyServiceNameSanitizer(),
+ NewUTF8Sanitizer(),
+ }
+}
+
+// NewChainedSanitizer creates a Sanitizer from the variadic list of passed Sanitizers.
+// If the list only has one element, it is returned directly to minimize indirection.
+func NewChainedSanitizer(sanitizers ...SanitizeTraces) SanitizeTraces {
+ if len(sanitizers) == 1 {
+ return sanitizers[0]
+ }
+ return func(traces ptrace.Traces) ptrace.Traces {
+ for _, s := range sanitizers {
+ traces = s(traces)
+ }
+ return traces
+ }
+}

cmd/jaeger/internal/exporters/storageexporter/sanitizer/utf8_sanitizer.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer
+
+import (
+ "unicode/utf8"
+
+ "go.opentelemetry.io/collector/pdata/pcommon"
+ "go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+const (
+ invalidOperation = "InvalidOperationName"
+ invalidService = "InvalidServiceName"
+ invalidTagKey = "InvalidTagKey"
+ badUTF8Prefix = "bad_utf8_"
+)
+
+// NewUTF8Sanitizer creates a UTF8 sanitizer.
+func NewUTF8Sanitizer() SanitizeTraces {
+ return sanitizeUF8
+}
+
+// sanitizeUTF8 sanitizes the UTF8 in the spans.
+func sanitizeUF8(traces ptrace.Traces) ptrace.Traces {
+ resourceSpans := traces.ResourceSpans()
+ for i := 0; i < resourceSpans.Len(); i++ {
+ resourceSpan := resourceSpans.At(i)
+ scopeSpans := resourceSpan.ScopeSpans()
+ for j := 0; j < scopeSpans.Len(); j++ {
+ spans := scopeSpans.At(j).Spans()
+ for k := 0; k < spans.Len(); k++ {
+ span := spans.At(k)
+ // Sanitize operation name
+ if !utf8.ValidString(span.Name()) {
+ originalName := span.Name()
+ span.SetName(invalidOperation)
+ byteSlice := span.Attributes().PutEmptyBytes(badUTF8Prefix + "operation_name")
+ byteSlice.FromRaw([]byte(originalName))
+ }
+
+ // Sanitize service name attribute
+ attributes := span.Attributes()
+ serviceNameAttr, ok := attributes.Get("service.name")
+ if ok && !utf8.ValidString(serviceNameAttr.Str()) {
+ originalServiceName := serviceNameAttr.Str()
+ attributes.PutStr("service.name", invalidService)
+ byteSlice := attributes.PutEmptyBytes(badUTF8Prefix + "service.name")
+ byteSlice.FromRaw([]byte(originalServiceName))
+ }
+
+ sanitizeAttributes(attributes)
+ }
+ }
+ }
+ return traces
+}
+
+// sanitizeAttributes sanitizes attributes to ensure UTF8 validity.
+func sanitizeAttributes(attributes pcommon.Map) {
+ attributes.Range(func(k string, v pcommon.Value) bool {
+ // Handle invalid UTF8 in attribute keys
+ if !utf8.ValidString(k) {
+ originalKey := k
+ attributes.PutStr(invalidTagKey, k)
+ byteSlice := attributes.PutEmptyBytes(badUTF8Prefix + originalKey)
+ byteSlice.FromRaw([]byte(originalKey))
+ } else if v.Type() == pcommon.ValueTypeStr && !utf8.ValidString(v.Str()) {
+ // Handle invalid UTF8 in attribute values
+ originalValue := v.Str()
+ attributes.PutStr(k, invalidTagKey)
+ byteSlice := attributes.PutEmptyBytes(badUTF8Prefix + k)
+ byteSlice.FromRaw([]byte(originalValue))
+ }
+ return true
+ })
+}