Fix OpenTelemetry service name

Co-authored-by: Kevin Pollet <pollet.kevin@gmail.com>

pkg/tracing/opentelemetry/opentelemetry.go

@@ -16,7 +16,9 @@ import (
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
 	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/sdk/resource"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
 	"go.opentelemetry.io/otel/trace"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/encoding/gzip"
@@ -60,7 +62,20 @@ func (c *Config) Setup(componentName string) (opentracing.Tracer, io.Closer, err
 	bt.SetOpenTelemetryTracer(otel.Tracer(componentName, trace.WithInstrumentationVersion(version.Version)))
 	opentracing.SetGlobalTracer(bt)
 
-	tracerProvider := sdktrace.NewTracerProvider(sdktrace.WithBatcher(exporter))
+	res, err := resource.New(context.Background(),
+		resource.WithAttributes(semconv.ServiceNameKey.String("traefik")),
+		resource.WithAttributes(semconv.ServiceVersionKey.String(version.Version)),
+		resource.WithFromEnv(),
+		resource.WithTelemetrySDK(),
+	)
+	if err != nil {
+		return nil, nil, fmt.Errorf("building resource: %w", err)
+	}
+
+	tracerProvider := sdktrace.NewTracerProvider(
+		sdktrace.WithResource(res),
+		sdktrace.WithBatcher(exporter),
+	)
 	otel.SetTracerProvider(tracerProvider)
 
 	log.Debug().Msg("OpenTelemetry tracer configured")

pkg/tracing/opentelemetry/opentelemetry_test.go

@@ -9,6 +9,7 @@ import (
 	"net/http/httptest"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -17,10 +18,39 @@ import (
 	"go.opentelemetry.io/collector/pdata/ptrace/ptraceotlp"
 )
 
-func TestTraceContextPropagation(t *testing.T) {
-	t.Parallel()
+func TestTracing(t *testing.T) {
+	tests := []struct {
+		desc     string
+		headers  map[string]string
+		assertFn func(*testing.T, string)
+	}{
+		{
+			desc: "service name and version",
+			assertFn: func(t *testing.T, trace string) {
+				t.Helper()
 
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				assert.Regexp(t, `({"key":"service.name","value":{"stringValue":"traefik"}})`, trace)
+				assert.Regexp(t, `({"key":"service.version","value":{"stringValue":"dev"}})`, trace)
+			},
+		},
+		{
+			desc: "context propagation",
+			headers: map[string]string{
+				"traceparent": "00-00000000000000000000000000000001-0000000000000001-01",
+				"tracestate":  "foo=bar",
+			},
+			assertFn: func(t *testing.T, trace string) {
+				t.Helper()
+
+				assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
+				assert.Regexp(t, `("parentSpanId":"0000000000000001")`, trace)
+				assert.Regexp(t, `("traceState":"foo=bar")`, trace)
+			},
+		},
+	}
+
+	traceCh := make(chan string)
+	collector := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		gzr, err := gzip.NewReader(r.Body)
 		require.NoError(t, err)
 
@@ -34,34 +64,38 @@ func TestTraceContextPropagation(t *testing.T) {
 		marshalledReq, err := json.Marshal(req)
 		require.NoError(t, err)
 
-		bodyStr := string(marshalledReq)
-		assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, bodyStr)
-		assert.Regexp(t, `("parentSpanId":"0000000000000001")`, bodyStr)
-		assert.Regexp(t, `("traceState":"foo=bar")`, bodyStr)
+		traceCh <- string(marshalledReq)
 	}))
-	defer ts.Close()
+	t.Cleanup(collector.Close)
 
-	cfg := Config{
-		Address:  strings.TrimPrefix(ts.URL, "http://"),
+	newTracing, err := tracing.NewTracing("", 0, &Config{
 		Insecure: true,
-	}
-
-	newTracing, err := tracing.NewTracing("", 0, &cfg)
-	require.NoError(t, err)
-	defer newTracing.Close()
-
-	req := httptest.NewRequest(http.MethodGet, "http://www.test.com", nil)
-	req.Header.Set("traceparent", "00-00000000000000000000000000000001-0000000000000001-00")
-	req.Header.Set("tracestate", "foo=bar")
-	rw := httptest.NewRecorder()
-
-	var forwarded bool
-	next := http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
-		forwarded = true
+		Address:  strings.TrimPrefix(collector.URL, "http://"),
 	})
+	require.NoError(t, err)
+	t.Cleanup(newTracing.Close)
 
-	handler := mtracing.NewEntryPoint(context.Background(), newTracing, "test", next)
-	handler.ServeHTTP(rw, req)
+	epHandler := mtracing.NewEntryPoint(context.Background(), newTracing, "test", http.NotFoundHandler())
 
-	require.True(t, forwarded)
+	for _, test := range tests {
+		t.Run(test.desc, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, "http://www.test.com", nil)
+			for k, v := range test.headers {
+				req.Header.Set(k, v)
+			}
+
+			rw := httptest.NewRecorder()
+
+			epHandler.ServeHTTP(rw, req)
+
+			select {
+			case <-time.After(10 * time.Second):
+				t.Error("Trace not exported")
+
+			case trace := <-traceCh:
+				assert.Equal(t, http.StatusNotFound, rw.Code)
+				test.assertFn(t, trace)
+			}
+		})
+	}
 }