[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,33 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer
+
+import (
+	"go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+// SanitizeTraces is a function that performs enrichment, clean-up, or normalization of trace data.
+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
+	})
+}