[hotROD] Upgrade hotrod to support otel tracer

examples/hotrod/cmd/frontend.go

@@ -45,7 +45,7 @@ var frontendCmd = &cobra.Command{
 		logger := log.NewFactory(zapLogger)
 		server := frontend.NewServer(
 			options,
-			tracing.Init("frontend", otelExporter, metricsFactory, logger),
+			tracing.InitOTEL("frontend", otelExporter, metricsFactory, logger),
 			logger,
 		)
 		return logError(zapLogger, server.Run())

examples/hotrod/cmd/route.go

@@ -37,7 +37,7 @@ var routeCmd = &cobra.Command{
 		logger := log.NewFactory(zapLogger)
 		server := route.NewServer(
 			net.JoinHostPort("0.0.0.0", strconv.Itoa(routePort)),
-			tracing.Init("route", otelExporter, metricsFactory, logger),
+			tracing.InitOTEL("route", otelExporter, metricsFactory, logger),
 			logger,
 		)
 		return logError(zapLogger, server.Run())

examples/hotrod/pkg/tracing/http.go

@@ -22,28 +22,37 @@
 	"io"
 	"net/http"
 
-	"github.com/opentracing-contrib/go-stdlib/nethttp"
-	"github.com/opentracing/opentracing-go"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+	"go.opentelemetry.io/otel/trace"
 )
 
 // HTTPClient wraps an http.Client with tracing instrumentation.
 type HTTPClient struct {
-	Tracer opentracing.Tracer
-	Client *http.Client
+	TracerProvider trace.TracerProvider
+	Client         *http.Client
+}
+
+func NewHTTPClient(tp trace.TracerProvider) *HTTPClient {
+	return &HTTPClient{
+		TracerProvider: tp,
+		Client: &http.Client{
+			Transport: otelhttp.NewTransport(
+				http.DefaultTransport,
+				otelhttp.WithTracerProvider(tp),
+			),
+		},
+	}
 }
 
 // GetJSON executes HTTP GET against specified url and tried to parse
 // the response into out object.
 func (c *HTTPClient) GetJSON(ctx context.Context, endpoint string, url string, out interface{}) error {
-	req, err := http.NewRequest(http.MethodGet, url, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return err
 	}
-	req = req.WithContext(ctx)
-	req, ht := nethttp.TraceRequest(c.Tracer, req, nethttp.OperationName("HTTP GET: "+endpoint))
-	defer ht.Finish()
 
 	res, err := c.Client.Do(req)
 	if err != nil {
 		return err
 	}
@@ -57,6 +66,7 @@
 		}
 		return errors.New(string(body))
 	}
+
 	decoder := json.NewDecoder(res.Body)
 	return decoder.Decode(out)
 }

examples/hotrod/pkg/tracing/init.go

@@ -45,11 +45,11 @@ import (
 var once sync.Once
 
 // InitOTEL initializes OpenTelemetry SDK.
-func InitOTEL(serviceName string, exporterType string, metricsFactory metrics.Factory, logger log.Factory) trace.Tracer {
+func InitOTEL(serviceName string, exporterType string, metricsFactory metrics.Factory, logger log.Factory) trace.TracerProvider {
 	_, oteltp := initBOTH(serviceName, exporterType, metricsFactory, logger)
 
 	logger.Bg().Debug("Created OTEL tracer", zap.String("service-name", serviceName))
-	return oteltp.Tracer(serviceName)
+	return oteltp
 }
 
 // Init returns OTel-OpenTracing Bridge.

examples/hotrod/pkg/tracing/mux.go

@@ -18,17 +18,15 @@ package tracing
 import (
 	"net/http"
 
-	"github.com/opentracing-contrib/go-stdlib/nethttp"
-	"github.com/opentracing/opentracing-go"
-	"go.opentelemetry.io/otel/baggage"
-	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/examples/hotrod/pkg/log"
 )
 
 // NewServeMux creates a new TracedServeMux.
-func NewServeMux(copyBaggage bool, tracer opentracing.Tracer, logger log.Factory) *TracedServeMux {
+func NewServeMux(copyBaggage bool, tracer trace.TracerProvider, logger log.Factory) *TracedServeMux {
 	return &TracedServeMux{
 		mux:         http.NewServeMux(),
 		copyBaggage: copyBaggage,
@@ -41,51 +39,23 @@ func NewServeMux(copyBaggage bool, tracer opentracing.Tracer, logger log.Factory
 type TracedServeMux struct {
 	mux         *http.ServeMux
 	copyBaggage bool
-	tracer      opentracing.Tracer
+	tracer      trace.TracerProvider
 	logger      log.Factory
 }
 
 // Handle implements http.ServeMux#Handle, which is used to register new handler.
 func (tm *TracedServeMux) Handle(pattern string, handler http.Handler) {
 	tm.logger.Bg().Debug("registering traced handler", zap.String("endpoint", pattern))
 
-	middleware := nethttp.Middleware(
-		tm.tracer,
-		handler,
-		nethttp.OperationNameFunc(func(r *http.Request) string {
-			return "HTTP " + r.Method + " " + pattern
-		}),
-		// Jaeger SDK was able to accept `jaeger-baggage` header even for requests without am active trace.
-		// OTEL Bridge does not support that, so we use Baggage propagator to manually extract the baggage
-		// into Context (in otelBaggageExtractor handler below), and once the Bridge creates a Span,
-		// we use this SpanObserver to copy OTEL baggage from Context into the Span.
-		nethttp.MWSpanObserver(func(span opentracing.Span, r *http.Request) {
-			if !tm.copyBaggage {
-				return
-			}
-			bag := baggage.FromContext(r.Context())
-			for _, m := range bag.Members() {
-				if b := span.BaggageItem(m.Key()); b == "" {
-					span.SetBaggageItem(m.Key(), m.Value())
-				}
-			}
-		}),
-	)
-	tm.mux.Handle(pattern, otelBaggageExtractor(middleware))
+	middleware := otelhttp.NewHandler(
+		otelhttp.WithRouteTag(pattern, handler),
+		pattern,
+		otelhttp.WithTracerProvider(tm.tracer))
+
+	tm.mux.Handle(pattern, middleware)
 }
 
 // ServeHTTP implements http.ServeMux#ServeHTTP.
 func (tm *TracedServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	tm.mux.ServeHTTP(w, r)
 }
-
-// Used with nethttp.MWSpanObserver above.
-func otelBaggageExtractor(next http.Handler) http.Handler {
-	propagator := propagation.Baggage{}
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		carrier := propagation.HeaderCarrier(r.Header)
-		ctx := propagator.Extract(r.Context(), carrier)
-		r = r.WithContext(ctx)
-		next.ServeHTTP(w, r)
-	})
-}

examples/hotrod/services/customer/client.go

@@ -18,10 +18,8 @@ package customer
 import (
 	"context"
 	"fmt"
-	"net/http"
 
-	"github.com/opentracing-contrib/go-stdlib/nethttp"
-	"github.com/opentracing/opentracing-go"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/examples/hotrod/pkg/log"
@@ -30,21 +28,16 @@ import (
 
 // Client is a remote client that implements customer.Interface
 type Client struct {
-	tracer   opentracing.Tracer
 	logger   log.Factory
 	client   *tracing.HTTPClient
 	hostPort string
 }
 
 // NewClient creates a new customer.Client
-func NewClient(tracer opentracing.Tracer, logger log.Factory, hostPort string) *Client {
+func NewClient(tracer trace.TracerProvider, logger log.Factory, hostPort string) *Client {
 	return &Client{
-		tracer: tracer,
-		logger: logger,
-		client: &tracing.HTTPClient{
-			Client: &http.Client{Transport: &nethttp.Transport{}},
-			Tracer: tracer,
-		},
+		logger:   logger,
+		client:   tracing.NewHTTPClient(tracer),
 		hostPort: hostPort,
 	}
 }

examples/hotrod/services/customer/server.go

@@ -19,7 +19,7 @@ import (
 	"encoding/json"
 	"net/http"
 
-	"github.com/opentracing/opentracing-go"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/examples/hotrod/pkg/httperr"
@@ -31,7 +31,7 @@ import (
 // Server implements Customer service
 type Server struct {
 	hostPort string
-	tracer   opentracing.Tracer
+	tracer   trace.TracerProvider
 	logger   log.Factory
 	database *database
 }
@@ -40,7 +40,7 @@ type Server struct {
 func NewServer(hostPort string, otelExporter string, metricsFactory metrics.Factory, logger log.Factory) *Server {
 	return &Server{
 		hostPort: hostPort,
-		tracer:   tracing.Init("customer", otelExporter, metricsFactory, logger),
+		tracer:   tracing.InitOTEL("customer", otelExporter, metricsFactory, logger),
 		logger:   logger,
 		database: newDatabase(
 			tracing.Init("mysql", otelExporter, metricsFactory, logger),

examples/hotrod/services/driver/client.go

@@ -19,8 +19,8 @@ import (
 	"context"
 	"time"
 
-	otgrpc "github.com/opentracing-contrib/go-grpc"
-	"github.com/opentracing/opentracing-go"
+	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
@@ -30,25 +30,23 @@ import (
 
 // Client is a remote client that implements driver.Interface
 type Client struct {
-	tracer opentracing.Tracer
 	logger log.Factory
 	client DriverServiceClient
 }
 
 // NewClient creates a new driver.Client
-func NewClient(tracer opentracing.Tracer, logger log.Factory, hostPort string) *Client {
+func NewClient(tracerProvider trace.TracerProvider, logger log.Factory, hostPort string) *Client {
 	conn, err := grpc.Dial(hostPort, grpc.WithTransportCredentials(insecure.NewCredentials()),
 		grpc.WithUnaryInterceptor(
-			otgrpc.OpenTracingClientInterceptor(tracer)),
+			otelgrpc.UnaryClientInterceptor(otelgrpc.WithTracerProvider(tracerProvider))),
 		grpc.WithStreamInterceptor(
-			otgrpc.OpenTracingStreamClientInterceptor(tracer)))
+			otelgrpc.StreamClientInterceptor(otelgrpc.WithTracerProvider(tracerProvider))))
 	if err != nil {
 		logger.Bg().Fatal("Cannot create gRPC connection", zap.Error(err))
 	}
 
 	client := NewDriverServiceClient(conn)
 	return &Client{
-		tracer: tracer,
 		logger: logger,
 		client: client,
 	}

examples/hotrod/services/driver/redis.go

@@ -42,8 +42,9 @@ type Redis struct {
 }
 
 func newRedis(otelExporter string, metricsFactory metrics.Factory, logger log.Factory) *Redis {
+	tp := tracing.InitOTEL("redis-manual", otelExporter, metricsFactory, logger)
 	return &Redis{
-		tracer: tracing.InitOTEL("redis-manual", otelExporter, metricsFactory, logger),
+		tracer: tp.Tracer("redis-manual"),
 		logger: logger,
 	}
 }

examples/hotrod/services/frontend/best_eta.go

@@ -22,7 +22,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/opentracing/opentracing-go"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/baggage"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/examples/hotrod/pkg/log"
@@ -47,7 +49,7 @@ type Response struct {
 	ETA    time.Duration
 }
 
-func newBestETA(tracer opentracing.Tracer, logger log.Factory, options ConfigOptions) *bestETA {
+func newBestETA(tracer trace.TracerProvider, logger log.Factory, options ConfigOptions) *bestETA {
 	return &bestETA{
 		customer: customer.NewClient(
 			tracer,
@@ -76,9 +78,10 @@ func (eta *bestETA) Get(ctx context.Context, customerID string) (*Response, erro
 	}
 	eta.logger.For(ctx).Info("Found customer", zap.Any("customer", customer))
 
-	if span := opentracing.SpanFromContext(ctx); span != nil {
-		span.SetBaggageItem("customer", customer.Name)
-	}
+	span := trace.SpanFromContext(ctx)
+	bag := baggage.FromContext(ctx)
+	m := bag.Member(customer.Name)
+	span.SetAttributes(attribute.Key(m.Key()).String(m.Value()))
 
 	drivers, err := eta.driver.FindNearest(ctx, customer.Location)
 	if err != nil {

examples/hotrod/services/frontend/server.go

@@ -21,7 +21,7 @@ import (
 	"net/http"
 	"path"
 
-	"github.com/opentracing/opentracing-go"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/examples/hotrod/pkg/httperr"
@@ -36,7 +36,7 @@ var assetFS embed.FS
 // Server implements jaeger-demo-frontend service
 type Server struct {
 	hostPort string
-	tracer   opentracing.Tracer
+	tracer   trace.TracerProvider
 	logger   log.Factory
 	bestETA  *bestETA
 	assetFS  http.FileSystem
@@ -56,7 +56,7 @@ type ConfigOptions struct {
 }
 
 // NewServer creates a new frontend.Server
-func NewServer(options ConfigOptions, tracer opentracing.Tracer, logger log.Factory) *Server {
+func NewServer(options ConfigOptions, tracer trace.TracerProvider, logger log.Factory) *Server {
 	return &Server{
 		hostPort: options.FrontendHostPort,
 		tracer:   tracer,

examples/hotrod/services/route/client.go

@@ -17,11 +17,9 @@ package route
 
 import (
 	"context"
-	"net/http"
 	"net/url"
 
-	"github.com/opentracing-contrib/go-stdlib/nethttp"
-	"github.com/opentracing/opentracing-go"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/examples/hotrod/pkg/log"
@@ -30,21 +28,16 @@ import (
 
 // Client is a remote client that implements route.Interface
 type Client struct {
-	tracer   opentracing.Tracer
 	logger   log.Factory
 	client   *tracing.HTTPClient
 	hostPort string
 }
 
 // NewClient creates a new route.Client
-func NewClient(tracer opentracing.Tracer, logger log.Factory, hostPort string) *Client {
+func NewClient(tracer trace.TracerProvider, logger log.Factory, hostPort string) *Client {
 	return &Client{
-		tracer: tracer,
-		logger: logger,
-		client: &tracing.HTTPClient{
-			Client: &http.Client{Transport: &nethttp.Transport{}},
-			Tracer: tracer,
-		},
+		logger:   logger,
+		client:   tracing.NewHTTPClient(tracer),
 		hostPort: hostPort,
 	}
 }