Migrate to opentelemetry

pkg/middlewares/tracing/entrypoint.go

@@ -5,57 +5,53 @@ import (
 	"net/http"
 
 	"github.com/containous/alice"
-	"github.com/opentracing/opentracing-go"
-	"github.com/opentracing/opentracing-go/ext"
 	"github.com/traefik/traefik/v3/pkg/middlewares"
 	"github.com/traefik/traefik/v3/pkg/tracing"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
 )
 
 const (
 	entryPointTypeName = "TracingEntryPoint"
 )
 
-// NewEntryPoint creates a new middleware that the incoming request.
-func NewEntryPoint(ctx context.Context, t *tracing.Tracing, entryPointName string, next http.Handler) http.Handler {
-	middlewares.GetLogger(ctx, "tracing", entryPointTypeName).Debug().Msg("Creating middleware")
-
-	return &entryPointMiddleware{
-		entryPoint: entryPointName,
-		Tracing:    t,
-		next:       next,
-	}
-}
-
-type entryPointMiddleware struct {
-	*tracing.Tracing
+type entryPointTracing struct {
+	tracer     trace.Tracer
 	entryPoint string
 	next       http.Handler
 }
 
-func (e *entryPointMiddleware) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
-	spanCtx, err := e.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))
-	if err != nil {
-		middlewares.GetLogger(req.Context(), "tracing", entryPointTypeName).
-			Debug().Err(err).Msg("Failed to extract the context")
+// WrapEntryPointHandler Wraps tracing to alice.Constructor.
+func WrapEntryPointHandler(ctx context.Context, tracer trace.Tracer, entryPointName string) alice.Constructor {
+	return func(next http.Handler) (http.Handler, error) {
+		return newEntryPoint(ctx, tracer, entryPointName, next), nil
 	}
+}
 
-	span, req, finish := e.StartSpanf(req, ext.SpanKindRPCServerEnum, "EntryPoint", []string{e.entryPoint, req.Host}, " ", ext.RPCServerOption(spanCtx))
-	defer finish()
+// newEntryPoint creates a new tracing middleware for incoming requests.
+func newEntryPoint(ctx context.Context, tracer trace.Tracer, entryPointName string, next http.Handler) http.Handler {
+	middlewares.GetLogger(ctx, "tracing", entryPointTypeName).Debug().Msg("Creating middleware")
 
-	ext.Component.Set(span, e.ServiceName)
-	tracing.LogRequest(span, req)
+	return &entryPointTracing{
+		entryPoint: entryPointName,
+		tracer:     tracer,
+		next:       next,
+	}
+}
 
-	req = req.WithContext(tracing.WithTracing(req.Context(), e.Tracing))
+func (e *entryPointTracing) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	tracingCtx := tracing.ExtractCarrierIntoContext(req.Context(), req.Header)
+	tracingCtx, span := e.tracer.Start(tracingCtx, "EntryPoint", trace.WithSpanKind(trace.SpanKindServer))
+	defer span.End()
+
+	req = req.WithContext(tracingCtx)
+
+	span.SetAttributes(attribute.String("entry_point", e.entryPoint))
+
+	tracing.LogServerRequest(span, req)
 
 	recorder := newStatusCodeRecorder(rw, http.StatusOK)
 	e.next.ServeHTTP(recorder, req)
 
-	tracing.LogResponseCode(span, recorder.Status())
-}
-
-// WrapEntryPointHandler Wraps tracing to alice.Constructor.
-func WrapEntryPointHandler(ctx context.Context, tracer *tracing.Tracing, entryPointName string) alice.Constructor {
-	return func(next http.Handler) (http.Handler, error) {
-		return NewEntryPoint(ctx, tracer, entryPointName, next), nil
-	}
+	tracing.LogResponseCode(span, recorder.Status(), trace.SpanKindServer)
 }