[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
+ })
+}