[jaeger-v2] Implement empty service name sanitizer for OTLP (jaegertracing#6077)

## Which problem is this PR solving?
- Towards jaegertracing#5545

## Description of the changes
- Created a new `Sanitizer` type for sanitizing traces in OTLP format 
- Implemented the empty service name sanitizer; I'll open a separate PR
for the UTF-8 sanitizer

## How was this change tested?
- Unit tests

## Checklist
- [x] I have read
https://github.com/jaegertracing/jaeger/blob/master/CONTRIBUTING_GUIDELINES.md
- [x] I have signed all commits
- [x] I have added unit tests for the new functionality
- [x] I have run lint and test steps successfully
  - for `jaeger`: `make lint test`
  - for `jaeger-ui`: `yarn lint` and `yarn test`

---------

Signed-off-by: Mahad Zaryab <[email protected]>

Author: mahadzaryab1

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

@@ -12,19 +12,24 @@ import (
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegerstorage"
+	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/sanitizer"
 	"github.com/jaegertracing/jaeger/storage_v2/spanstore"
 )
 
 type storageExporter struct {
 	config      *Config
 	logger      *zap.Logger
 	traceWriter spanstore.Writer
+	sanitizer   sanitizer.Func
 }
 
 func newExporter(config *Config, otel component.TelemetrySettings) *storageExporter {
 	return &storageExporter{
 		config: config,
 		logger: otel.Logger,
+		sanitizer: sanitizer.NewChainedSanitizer(
+			sanitizer.NewStandardSanitizers()...,
+		),
 	}
 }
 
@@ -47,5 +52,5 @@ func (*storageExporter) close(_ context.Context) error {
 }
 
 func (exp *storageExporter) pushTraces(ctx context.Context, td ptrace.Traces) error {
-	return exp.traceWriter.WriteTraces(ctx, td)
+	return exp.traceWriter.WriteTraces(ctx, exp.sanitizer(td))
 }

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

@@ -157,6 +157,9 @@ func TestExporter(t *testing.T) {
 	requiredTrace, err := spanReader.GetTrace(ctx, requiredTraceID)
 	require.NoError(t, err)
 	assert.Equal(t, spanID.String(), requiredTrace.Spans[0].SpanID.String())
+
+	// check that the service name attribute was added by the sanitizer
+	require.Equal(t, "missing-service-name", requiredTrace.Spans[0].Process.ServiceName)
 }
 
 func makeStorageExtension(t *testing.T, memstoreName string) component.Host {

cmd/jaeger/internal/sanitizer/emptyservicename.go

@@ -0,0 +1,41 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer
+
+import (
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+
+	"github.com/jaegertracing/jaeger/pkg/otelsemconv"
+)
+
+const (
+	emptyServiceName     = "empty-service-name"
+	serviceNameWrongType = "service-name-wrong-type"
+	missingServiceName   = "missing-service-name"
+)
+
+// NewEmptyServiceNameSanitizer returns a sanitizer function that replaces
+// empty and missing service names with placeholder strings.
+func NewEmptyServiceNameSanitizer() Func {
+	return sanitizeEmptyServiceName
+}
+
+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()
+		serviceName, ok := attributes.Get(string(otelsemconv.ServiceNameKey))
+		switch {
+		case !ok:
+			attributes.PutStr(string(otelsemconv.ServiceNameKey), missingServiceName)
+		case serviceName.Type() != pcommon.ValueTypeStr:
+			attributes.PutStr(string(otelsemconv.ServiceNameKey), serviceNameWrongType)
+		case serviceName.Str() == "":
+			attributes.PutStr(string(otelsemconv.ServiceNameKey), emptyServiceName)
+		}
+	}
+	return traces
+}

cmd/jaeger/internal/sanitizer/emptyservicename_test.go

@@ -0,0 +1,80 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+func TestEmptyServiceNameSanitizer_SubstitutesCorrectlyForStrings(t *testing.T) {
+	emptyServiceName := ""
+	nonEmptyServiceName := "hello"
+	tests := []struct {
+		name                string
+		serviceName         *string
+		expectedServiceName string
+	}{
+		{
+			name:                "no service name",
+			expectedServiceName: "missing-service-name",
+		},
+		{
+			name:                "empty service name",
+			serviceName:         &emptyServiceName,
+			expectedServiceName: "empty-service-name",
+		},
+		{
+			name:                "non-empty service name",
+			serviceName:         &nonEmptyServiceName,
+			expectedServiceName: "hello",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			traces := ptrace.NewTraces()
+			attributes := traces.
+				ResourceSpans().
+				AppendEmpty().
+				Resource().
+				Attributes()
+			if test.serviceName != nil {
+				attributes.PutStr("service.name", *test.serviceName)
+			}
+			sanitizer := NewEmptyServiceNameSanitizer()
+			sanitized := sanitizer(traces)
+			serviceName, ok := sanitized.
+				ResourceSpans().
+				At(0).
+				Resource().
+				Attributes().
+				Get("service.name")
+			require.True(t, ok)
+			require.Equal(t, test.expectedServiceName, serviceName.Str())
+		})
+	}
+}
+
+func TestEmptyServiceNameSanitizer_SubstitutesCorrectlyForNonStringType(t *testing.T) {
+	traces := ptrace.NewTraces()
+	traces.
+		ResourceSpans().
+		AppendEmpty().
+		Resource().
+		Attributes().
+		PutInt("service.name", 1)
+	sanitizer := NewEmptyServiceNameSanitizer()
+	sanitized := sanitizer(traces)
+	serviceName, ok := sanitized.
+		ResourceSpans().
+		At(0).
+		Resource().
+		Attributes().
+		Get("service.name")
+	require.True(t, ok)
+	require.Equal(t, "service-name-wrong-type", serviceName.Str())
+}

cmd/jaeger/internal/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/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"
+)
+
+// Func is a function that performs enrichment, clean-up, or normalization of trace data.
+type Func func(traces ptrace.Traces) ptrace.Traces
+
+// NewStandardSanitizers returns a list of all the sanitizers that are used by the
+// storage exporter.
+func NewStandardSanitizers() []Func {
+	return []Func{
+		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 ...Func) Func {
+	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/sanitizer/sanitizer_test.go

@@ -0,0 +1,57 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package sanitizer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+func TestNewStandardSanitizers(t *testing.T) {
+	sanitizers := NewStandardSanitizers()
+	require.Len(t, sanitizers, 1)
+}
+
+func TestNewChainedSanitizer(t *testing.T) {
+	var s1 Func = func(traces ptrace.Traces) ptrace.Traces {
+		traces.
+			ResourceSpans().
+			AppendEmpty().
+			Resource().
+			Attributes().
+			PutStr("hello", "world")
+		return traces
+	}
+	var s2 Func = func(traces ptrace.Traces) ptrace.Traces {
+		traces.
+			ResourceSpans().
+			At(0).
+			Resource().
+			Attributes().
+			PutStr("hello", "goodbye")
+		return traces
+	}
+	c1 := NewChainedSanitizer(s1)
+	t1 := c1(ptrace.NewTraces())
+	hello, ok := t1.
+		ResourceSpans().
+		At(0).
+		Resource().
+		Attributes().
+		Get("hello")
+	require.True(t, ok)
+	require.Equal(t, "world", hello.Str())
+	c2 := NewChainedSanitizer(s1, s2)
+	t2 := c2(ptrace.NewTraces())
+	hello, ok = t2.
+		ResourceSpans().
+		At(0).
+		Resource().
+		Attributes().
+		Get("hello")
+	require.True(t, ok)
+	require.Equal(t, "goodbye", hello.Str())
+}