[v2] Implement sanitizers to operate on OTLP data

cmd/collector/app/sanitizer_v2/empty_service_name_sanitizer.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer_v2
+
+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() SanitizeSpan {
+	return sanitizeEmptyServiceName
+}
+
+// sanitizeEmptyServiceName sanitizes the service names in the span attributes.
+func sanitizeEmptyServiceName(span ptrace.Span) ptrace.Span {
+	attributes := span.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 span
+}

cmd/collector/app/sanitizer_v2/empty_service_name_sanitizer_test.go

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

cmd/collector/app/sanitizer_v2/package_test.go

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

cmd/collector/app/sanitizer_v2/sanitizer.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer_v2
+
+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 SanitizeSpan func(span ptrace.Span) ptrace.Span
+
+// NewStandardSanitizers are automatically applied by SpanProcessor.
+func NewStandardSanitizers() []SanitizeSpan {
+	return []SanitizeSpan{
+		NewEmptyServiceNameSanitizer(),
+	}
+}
+
+// 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 ...SanitizeSpan) SanitizeSpan {
+	if len(sanitizers) == 1 {
+		return sanitizers[0]
+	}
+	return func(span ptrace.Span) ptrace.Span {
+		for _, s := range sanitizers {
+			span = s(span)
+		}
+		return span
+	}
+}

cmd/collector/app/sanitizer_v2/service_name_sanitizer.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer_v2
+
+import (
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+// Cache interface similar to the one in V1
+type Cache interface {
+	Get(alias string) string
+	IsEmpty() bool
+}
+
+// NewServiceNameSanitizer creates a service name sanitizer with a given cache.
+func NewServiceNameSanitizer(cache Cache) SanitizeSpan {
+	sanitizer := serviceNameSanitizer{cache: cache}
+	return sanitizer.Sanitize
+}
+
+// serviceNameSanitizer sanitizes the service names in span annotations given a source of truth alias to service cache.
+type serviceNameSanitizer struct {
+	cache Cache
+}
+
+// Sanitize sanitizes the service names in the span annotations.
+func (s serviceNameSanitizer) Sanitize(span ptrace.Span) ptrace.Span {
+	if s.cache.IsEmpty() {
+		return span
+	}
+
+	attributes := span.Attributes()
+	serviceNameAttr, exists := attributes.Get("service.name")
+	if !exists || serviceNameAttr.Type() != pcommon.ValueTypeStr {
+		return span
+	}
+
+	alias := serviceNameAttr.Str()
+	serviceName := s.cache.Get(alias)
+	if serviceName != "" {
+		attributes.PutStr("service.name", serviceName)
+	}
+
+	return span
+}

cmd/collector/app/sanitizer_v2/utf8_sanitizer.go

@@ -0,0 +1,57 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer_v2
+
+import (
+	"fmt"
+	"unicode/utf8"
+
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+	"go.uber.org/zap"
+)
+
+const (
+	invalidOperation = "InvalidOperationName"
+	invalidService   = "InvalidServiceName"
+	invalidTagKey    = "InvalidTagKey"
+)
+
+// UTF8Sanitizer sanitizes all strings in spans.
+type UTF8Sanitizer struct {
+	logger *zap.Logger
+}
+
+// NewUTF8Sanitizer creates a UTF8 sanitizer with logging functionality.
+func NewUTF8Sanitizer(logger *zap.Logger) SanitizeSpan {
+	return UTF8Sanitizer{logger: logger}.Sanitize
+}
+
+// Sanitize sanitizes the UTF8 in the spans.
+func (s UTF8Sanitizer) Sanitize(span ptrace.Span) ptrace.Span {
+	if !utf8.ValidString(span.Name()) {
+		s.logger.Info("Invalid utf8 operation name", zap.String("operation_name", span.Name()))
+		span.SetName(invalidOperation)
+	}
+
+	attributes := span.Attributes()
+	serviceNameAttr, ok := attributes.Get("service.name")
+	if ok && !utf8.ValidString(serviceNameAttr.Str()) {
+		s.logger.Info("Invalid utf8 service name", zap.String("service_name", serviceNameAttr.Str()))
+		attributes.PutStr("service.name", invalidService)
+	}
+
+	sanitizeAttributes(attributes)
+	return span
+}
+
+// sanitizeAttributes sanitizes attributes to ensure UTF8 validity.
+func sanitizeAttributes(attributes pcommon.Map) {
+	attributes.Range(func(k string, v pcommon.Value) bool {
+		if v.Type() == pcommon.ValueTypeStr && !utf8.ValidString(v.Str()) {
+			attributes.PutStr(k, fmt.Sprintf("%s:%s", k, v.Str()))
+		}
+		return true
+	})
+}