Migrate to opentelemetry

pkg/middlewares/tracing/entrypoint_test.go

@@ -6,81 +6,69 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/opentracing/opentracing-go/ext"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/traefik/traefik/v3/pkg/tracing"
+	"go.opentelemetry.io/otel/attribute"
 )
 
 func TestEntryPointMiddleware(t *testing.T) {
 	type expected struct {
-		Tags          map[string]interface{}
-		OperationName string
+		name       string
+		attributes []attribute.KeyValue
 	}
 
 	testCases := []struct {
-		desc          string
-		entryPoint    string
-		spanNameLimit int
-		tracing       *trackingBackenMock
-		expected      expected
+		desc       string
+		entryPoint string
+		expected   expected
 	}{
 		{
-			desc:          "no truncation test",
-			entryPoint:    "test",
-			spanNameLimit: 0,
-			tracing: &trackingBackenMock{
-				tracer: &MockTracer{Span: &MockSpan{Tags: make(map[string]interface{})}},
-			},
+			desc:       "basic test",
+			entryPoint: "test",
 			expected: expected{
-				Tags: map[string]interface{}{
-					"span.kind":   ext.SpanKindRPCServerEnum,
-					"http.method": http.MethodGet,
-					"component":   "",
-					"http.url":    "http://www.test.com",
-					"http.host":   "www.test.com",
+				name: "EntryPoint",
+				attributes: []attribute.KeyValue{
+					attribute.String("span.kind", "server"),
+					attribute.String("entry_point", "test"),
+					attribute.String("http.request.method", "GET"),
+					attribute.String("network.protocol.version", "1.1"),
+					attribute.Int64("http.request.body.size", int64(0)),
+					attribute.String("url.path", "/search"),
+					attribute.String("url.query", "q=Opentelemetry"),
+					attribute.String("url.scheme", "http"),
+					attribute.String("user_agent.original", "entrypoint-test"),
+					attribute.String("server.address", "www.test.com"),
+					attribute.String("network.peer.address", "10.0.0.1"),
+					attribute.String("network.peer.port", "1234"),
+					attribute.String("client.address", "10.0.0.1"),
+					attribute.Int64("client.port", int64(1234)),
+					attribute.String("client.socket.address", ""),
+					attribute.Int64("http.response.status_code", int64(404)),
 				},
-				OperationName: "EntryPoint test www.test.com",
-			},
-		},
-		{
-			desc:          "basic test",
-			entryPoint:    "test",
-			spanNameLimit: 25,
-			tracing: &trackingBackenMock{
-				tracer: &MockTracer{Span: &MockSpan{Tags: make(map[string]interface{})}},
-			},
-			expected: expected{
-				Tags: map[string]interface{}{
-					"span.kind":   ext.SpanKindRPCServerEnum,
-					"http.method": http.MethodGet,
-					"component":   "",
-					"http.url":    "http://www.test.com",
-					"http.host":   "www.test.com",
-				},
-				OperationName: "EntryPoint te... ww... 0c15301b",
 			},
 		},
 	}
 
 	for _, test := range testCases {
 		t.Run(test.desc, func(t *testing.T) {
-			newTracing, err := tracing.NewTracing("", test.spanNameLimit, test.tracing)
-			require.NoError(t, err)
-
-			req := httptest.NewRequest(http.MethodGet, "http://www.test.com", nil)
+			req := httptest.NewRequest(http.MethodGet, "http://www.test.com/search?q=Opentelemetry", nil)
 			rw := httptest.NewRecorder()
+			req.RemoteAddr = "10.0.0.1:1234"
+			req.Header.Set("User-Agent", "entrypoint-test")
+			req.Header.Set("X-Forwarded-Proto", "http")
 
-			next := http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
-				span := test.tracing.tracer.(*MockTracer).Span
-
-				tags := span.Tags
-				assert.Equal(t, test.expected.Tags, tags)
-				assert.Equal(t, test.expected.OperationName, span.OpName)
+			next := http.HandlerFunc(func(rw http.ResponseWriter, _ *http.Request) {
+				rw.WriteHeader(http.StatusNotFound)
 			})
 
-			handler := NewEntryPoint(context.Background(), newTracing, test.entryPoint, next)
+			tracer := &mockTracer{}
+
+			handler := newEntryPoint(context.Background(), tracer, test.entryPoint, next)
 			handler.ServeHTTP(rw, req)
+
+			for _, span := range tracer.spans {
+				assert.Equal(t, test.expected.name, span.name)
+				assert.Equal(t, test.expected.attributes, span.attributes)
+			}
 		})
 	}
 }