Replace Jaeger SDK with OTEL SDK + OT Bridge

cmd/all-in-one/main.go

@@ -274,8 +274,8 @@ func startQuery(
 ) *queryApp.Server {
 	spanReader = storageMetrics.NewReadMetricsDecorator(spanReader, baseFactory.Namespace(metrics.NSOptions{Name: "query"}))
 	qs := querysvc.NewQueryService(spanReader, depReader, *queryOpts)
-	jtracer := jtracer.OT(opentracing.GlobalTracer())
-	server, err := queryApp.NewServer(svc.Logger, qs, metricsQueryService, qOpts, tm, jtracer)
+	tracer := jtracer.JTracer{OT: opentracing.GlobalTracer()}
+	server, err := queryApp.NewServer(svc.Logger, qs, metricsQueryService, qOpts, tm, tracer)
 	if err != nil {
 		svc.Logger.Fatal("Could not start jaeger-query service", zap.Error(err))
 	}

cmd/query/app/grpc_handler.go

@@ -73,7 +73,7 @@ func NewGRPCHandler(queryService *querysvc.QueryService,
 		options.Logger = zap.NewNop()
 	}
 
-	if options.Tracer.OT == nil {
+	if options.Tracer.OTEL == nil {
 		options.Tracer = jtracer.NoOp()
 	}
 

cmd/query/app/handler_options.go

@@ -64,7 +64,7 @@ func (handlerOptions) QueryLookbackDuration(queryLookbackDuration time.Duration)
 // Tracer creates a HandlerOption that initializes OpenTracing tracer
 func (handlerOptions) Tracer(tracer jtracer.JTracer) HandlerOption {
 	return func(apiHandler *APIHandler) {
-		apiHandler.tracer = tracer
+		apiHandler.tracer.OT = tracer.OT
 	}
 }
 

cmd/query/app/http_handler_test.go

@@ -35,7 +35,9 @@ import (
 	testHttp "github.com/stretchr/testify/http"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
-	"github.com/uber/jaeger-client-go"
+	otbridge "go.opentelemetry.io/otel/bridge/opentracing"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	"go.opentelemetry.io/otel/sdk/trace/tracetest"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 
@@ -303,10 +305,14 @@ func TestGetTrace(t *testing.T) {
 	for _, tc := range testCases {
 		testCase := tc // capture loop var
 		t.Run(testCase.suffix, func(t *testing.T) {
-			reporter := jaeger.NewInMemoryReporter()
-			jaegerTracer, jaegerCloser := jaeger.NewTracer("test", jaeger.NewConstSampler(true), reporter)
-			jTracer := jtracer.OT(jaegerTracer)
-			defer jaegerCloser.Close()
+			exporter := tracetest.NewInMemoryExporter()
+			tracerProvider := sdktrace.NewTracerProvider(
+				sdktrace.WithSyncer(exporter),
+				sdktrace.WithSampler(sdktrace.AlwaysSample()),
+			)
+			// Use the bridgeTracer as OpenTracing tracer(otTrace).
+			otTracer, _ := otbridge.NewTracerPair(tracerProvider.Tracer(""))
+			jTracer := jtracer.JTracer{OT: otTracer}
 
 			ts := initializeTestServer(HandlerOptions.Tracer(jTracer))
 			defer ts.server.Close()
@@ -319,8 +325,8 @@ func TestGetTrace(t *testing.T) {
 			assert.NoError(t, err)
 			assert.Len(t, response.Errors, 0)
 
-			assert.Len(t, reporter.GetSpans(), 1, "HTTP request was traced and span reported")
-			assert.Equal(t, "/api/traces/{traceID}", reporter.GetSpans()[0].(*jaeger.Span).OperationName())
+			assert.Len(t, exporter.GetSpans(), 1, "HTTP request was traced and span reported")
+			assert.Equal(t, "/api/traces/{traceID}", exporter.GetSpans()[0].Name)
 
 			traces := extractTraces(t, &response)
 			assert.Len(t, traces[0].Spans, 2)

cmd/query/main.go

@@ -20,11 +20,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/opentracing/opentracing-go"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	jaegerClientConfig "github.com/uber/jaeger-client-go/config"
-	jaegerClientZapLog "github.com/uber/jaeger-client-go/log/zap"
 	_ "go.uber.org/automaxprocs"
 	"go.uber.org/zap"
 
@@ -34,7 +31,6 @@ import (
 	"github.com/jaegertracing/jaeger/cmd/query/app"
 	"github.com/jaegertracing/jaeger/cmd/query/app/querysvc"
 	"github.com/jaegertracing/jaeger/cmd/status"
-	"github.com/jaegertracing/jaeger/internal/metrics/jlibadapter"
 	"github.com/jaegertracing/jaeger/pkg/bearertoken"
 	"github.com/jaegertracing/jaeger/pkg/config"
 	"github.com/jaegertracing/jaeger/pkg/jtracer"
@@ -76,28 +72,14 @@ func main() {
 			metricsFactory := baseFactory.Namespace(metrics.NSOptions{Name: "query"})
 			version.NewInfoMetrics(metricsFactory)
 
-			traceCfg := &jaegerClientConfig.Configuration{
-				ServiceName: "jaeger-query",
-				Sampler: &jaegerClientConfig.SamplerConfig{
-					Type:  "const",
-					Param: 1.0,
-				},
-				RPCMetrics: true,
-			}
-			traceCfg, err = traceCfg.FromEnv()
 			if err != nil {
 				logger.Fatal("Failed to read tracer configuration", zap.Error(err))
 			}
-			tracer, closer, err := traceCfg.NewTracer(
-				jaegerClientConfig.Metrics(jlibadapter.NewAdapter(svc.MetricsFactory)),
-				jaegerClientConfig.Logger(jaegerClientZapLog.NewLogger(logger)),
-			)
 			if err != nil {
 				logger.Fatal("Failed to initialize tracer", zap.Error(err))
 			}
-			defer closer.Close()
-			opentracing.SetGlobalTracer(tracer)
-			jtracer := jtracer.OT(tracer)
+
+			jtracer := jtracer.New()
 			queryOpts, err := new(app.QueryOptions).InitFromViper(v, logger)
 			if err != nil {
 				logger.Fatal("Failed to configure query service", zap.Error(err))

pkg/jtracer/jtracer.go

@@ -14,16 +14,77 @@
 
 package jtracer
 
-import "github.com/opentracing/opentracing-go"
+import (
+	"context"
+	"log"
+	"sync"
+
+	"github.com/opentracing/opentracing-go"
+	"go.opentelemetry.io/otel"
+	otbridge "go.opentelemetry.io/otel/bridge/opentracing"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+	"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.4.0"
+	"go.opentelemetry.io/otel/trace"
+)
 
 type JTracer struct {
-	OT opentracing.Tracer
+	OT   opentracing.Tracer
+	OTEL trace.TracerProvider
 }
 
-func OT(t opentracing.Tracer) JTracer {
-	return JTracer{OT: t}
+var once sync.Once
+
+func New() JTracer {
+	opentracingTracer, otelTracerProvider := initBoth()
+	return JTracer{OT: opentracingTracer, OTEL: otelTracerProvider}
 }
 
 func NoOp() JTracer {
-	return JTracer{OT: opentracing.NoopTracer{}}
+	return JTracer{OT: opentracing.NoopTracer{}, OTEL: trace.NewNoopTracerProvider()}
+}
+
+// initBoth initializes OpenTelemetry SDK and uses OTel-OpenTracing Bridge
+func initBoth() (opentracing.Tracer, trace.TracerProvider) {
+	opts := []otlptracehttp.Option{otlptracehttp.WithInsecure()}
+	traceExporter, err := otlptrace.New(
+		context.Background(),
+		otlptracehttp.NewClient(opts...),
+	)
+	if err != nil {
+		log.Fatal("failed to create exporter: %w", err)
+	}
+
+	// Register the trace exporter with a TracerProvider, using a batch
+	// span processor to aggregate spans before export.
+	bsp := sdktrace.NewBatchSpanProcessor(traceExporter)
+	tracerProvider := sdktrace.NewTracerProvider(
+		sdktrace.WithSpanProcessor(bsp),
+		sdktrace.WithResource(resource.NewWithAttributes(
+			semconv.SchemaURL,
+			semconv.ServiceNameKey.String("otlp"),
+		)),
+	)
+
+	once.Do(func() {
+		otel.SetTextMapPropagator(
+			propagation.NewCompositeTextMapPropagator(
+				propagation.TraceContext{},
+				propagation.Baggage{},
+			))
+	})
+
+	// Use the bridgeTracer as your OpenTracing tracer(otTrace).
+	otTracer, wrapperTracerProvider := otbridge.NewTracerPair(tracerProvider.Tracer(""))
+
+	// Shutdown the tracerProvider to clean up resources
+	err = tracerProvider.Shutdown(context.Background())
+	if err != nil {
+		log.Fatal("failed to shutdown tracerProvider: ", err)
+	}
+
+	return otTracer, wrapperTracerProvider
 }

pkg/jtracer/jtracer_test.go

@@ -14,18 +14,4 @@
 
 package jtracer_test
 
-import (
-	"testing"
-
-	"github.com/opentracing/opentracing-go"
-	"github.com/stretchr/testify/assert"
-
-	"github.com/jaegertracing/jaeger/pkg/jtracer"
-)
-
-func TestOT(t *testing.T) {
-	mockTracer := opentracing.NoopTracer{}
-	jtracer := jtracer.OT(opentracing.NoopTracer{})
-
-	assert.Equal(t, mockTracer, jtracer.OT)
-}
+// TODO

plugin/metrics/prometheus/metricsstore/reader.go

@@ -26,14 +26,15 @@ import (
 	"time"
 	"unicode"
 
-	"github.com/opentracing/opentracing-go"
-	ottag "github.com/opentracing/opentracing-go/ext"
-	otlog "github.com/opentracing/opentracing-go/log"
 	"github.com/prometheus/client_golang/api"
 	promapi "github.com/prometheus/client_golang/api/prometheus/v1"
+	"go.opentelemetry.io/otel/attribute"
+	semconv "go.opentelemetry.io/otel/semconv/v1.20.0"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/pkg/bearertoken"
+	"github.com/jaegertracing/jaeger/pkg/jtracer"
 	"github.com/jaegertracing/jaeger/pkg/prometheus/config"
 	"github.com/jaegertracing/jaeger/plugin/metrics/prometheus/metricsstore/dbmodel"
 	"github.com/jaegertracing/jaeger/proto-gen/api_v2/metrics"
@@ -54,6 +55,7 @@ type (
 		latencyMetricName string
 		callsMetricName   string
 		operationLabel    string
+		tracer            jtracer.JTracer
 	}
 
 	promQueryParams struct {
@@ -101,6 +103,7 @@ func NewMetricsReader(logger *zap.Logger, cfg config.Configuration) (*MetricsRea
 		callsMetricName:   buildFullCallsMetricName(cfg),
 		latencyMetricName: buildFullLatencyMetricName(cfg),
 		operationLabel:    operationLabel,
+		tracer:            jtracer.New(),
 	}
 
 	logger.Info("Prometheus reader initialized", zap.String("addr", cfg.ServerURL))
@@ -224,8 +227,8 @@ func (m MetricsReader) executeQuery(ctx context.Context, p metricsQueryParams) (
 	}
 	promQuery := m.buildPromQuery(p)
 
-	span, ctx := startSpanForQuery(ctx, p.metricName, promQuery)
-	defer span.Finish()
+	ctx, span := startSpanForQuery(ctx, p.metricName, promQuery, m.tracer.OTEL)
+	defer span.End()
 
 	queryRange := promapi.Range{
 		Start: p.EndTime.Add(-1 * *p.Lookback),
@@ -287,17 +290,18 @@ func promqlDurationString(d *time.Duration) string {
 	return string(b)
 }
 
-func startSpanForQuery(ctx context.Context, metricName, query string) (opentracing.Span, context.Context) {
-	span, ctx := opentracing.StartSpanFromContext(ctx, metricName)
-	ottag.DBStatement.Set(span, query)
-	ottag.DBType.Set(span, "prometheus")
-	ottag.Component.Set(span, "promql")
-	return span, ctx
+func startSpanForQuery(ctx context.Context, metricName, query string, tp trace.TracerProvider) (context.Context, trace.Span) {
+	ctx, span := tp.Tracer("prom-metrics-reader").Start(ctx, metricName)
+	span.SetAttributes(
+		attribute.Key(semconv.DBStatementKey).String(query),
+		attribute.Key("db.type").String("prometheus"),
+		attribute.Key("component").String("promql"),
+	)
+	return ctx, span
 }
 
-func logErrorToSpan(span opentracing.Span, err error) {
-	ottag.Error.Set(span, true)
-	span.LogFields(otlog.Error(err))
+func logErrorToSpan(span trace.Span, err error) {
+	span.AddEvent(err.Error(), trace.WithAttributes(semconv.OTelStatusCodeError))
 }
 
 func getHTTPRoundTripper(c *config.Configuration, logger *zap.Logger) (rt http.RoundTripper, err error) {