otelhttp: get tracer from current context if not set in constructor

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>

CHANGELOG.md

@@ -11,6 +11,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ### Changed
 
 - `otelmongodb` span attributes, name and span status now conform to specification. (#769)
+- The `Transport`, `Handler`, and HTTP client convenience wrappers in the `go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp` package now use the `TracerProvider` from the parent context if one exists and none was explicitly set when configuring the instrumentation. (#873)
 
 ## [0.22.0] - 2021-07-26
 

instrumentation/net/http/otelhttp/client_test.go

@@ -83,3 +83,35 @@ func TestConvenienceWrappers(t *testing.T) {
 	assert.Equal(t, "HTTP POST", spans[2].Name())
 	assert.Equal(t, "HTTP POST", spans[3].Name())
 }
+
+func TestClientWithTraceContext(t *testing.T) {
+	sr := new(oteltest.SpanRecorder)
+	provider := oteltest.NewTracerProvider(oteltest.WithSpanRecorder(sr))
+
+	tracer := provider.Tracer("")
+	ctx, span := tracer.Start(context.Background(), "http requests")
+
+	content := []byte("Hello, world!")
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if _, err := w.Write(content); err != nil {
+			t.Fatal(err)
+		}
+	}))
+	defer ts.Close()
+
+	res, err := Get(ctx, ts.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	res.Body.Close()
+
+	span.End()
+
+	spans := sr.Completed()
+	require.Equal(t, 2, len(spans))
+	assert.Equal(t, "HTTP GET", spans[0].Name())
+	assert.Equal(t, "http requests", spans[1].Name())
+	assert.NotEmpty(t, spans[0].ParentSpanID())
+	assert.Equal(t, spans[1].SpanContext().SpanID(), spans[0].ParentSpanID())
+}

instrumentation/net/http/otelhttp/common.go

@@ -17,7 +17,9 @@ package otelhttp
 import (
 	"net/http"
 
+	"go.opentelemetry.io/contrib"
 	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
 )
 
 // Attribute keys that can be added to a span.
@@ -39,3 +41,7 @@ const (
 // Filter is a predicate used to determine whether a given http.request should
 // be traced. A Filter must return true if the request should be traced.
 type Filter func(*http.Request) bool
+
+func newTracer(tp trace.TracerProvider) trace.Tracer {
+	return tp.Tracer(instrumentationName, trace.WithInstrumentationVersion(contrib.SemVersion()))
+}

instrumentation/net/http/otelhttp/config.go

@@ -59,18 +59,17 @@ func (o optionFunc) apply(c *config) {
 // newConfig creates a new config struct and applies opts to it.
 func newConfig(opts ...Option) *config {
 	c := &config{
-		Propagators:    otel.GetTextMapPropagator(),
-		TracerProvider: otel.GetTracerProvider(),
-		MeterProvider:  global.GetMeterProvider(),
+		Propagators:   otel.GetTextMapPropagator(),
+		MeterProvider: global.GetMeterProvider(),
 	}
 	for _, opt := range opts {
 		opt.apply(c)
 	}
 
-	c.Tracer = c.TracerProvider.Tracer(
-		instrumentationName,
-		trace.WithInstrumentationVersion(contrib.SemVersion()),
-	)
+	// Tracer is only initialized if manually specified. Otherwise, can be passed with the tracing context.
+	if c.TracerProvider != nil {
+		c.Tracer = newTracer(c.TracerProvider)
+	}
 	c.Meter = c.MeterProvider.Meter(
 		instrumentationName,
 		metric.WithInstrumentationVersion(contrib.SemVersion()),

instrumentation/net/http/otelhttp/handler.go

@@ -127,8 +127,18 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		trace.WithAttributes(semconv.HTTPServerAttributesFromHTTPRequest(h.operation, "", r)...),
 	}, h.spanStartOptions...) // start with the configured options
 
+	tracer := h.tracer
+
+	if tracer == nil {
+		if span := trace.SpanFromContext(r.Context()); span.SpanContext().IsValid() {
+			tracer = newTracer(span.TracerProvider())
+		} else {
+			tracer = newTracer(otel.GetTracerProvider())
+		}
+	}
+
 	ctx := h.propagators.Extract(r.Context(), propagation.HeaderCarrier(r.Header))
-	ctx, span := h.tracer.Start(ctx, h.spanNameFormatter(h.operation, r), opts...)
+	ctx, span := tracer.Start(ctx, h.spanNameFormatter(h.operation, r), opts...)
 	defer span.End()
 
 	readRecordFunc := func(int64) {}

instrumentation/net/http/otelhttp/handler_test.go

@@ -14,6 +14,7 @@
 package otelhttp
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -23,6 +24,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
@@ -203,3 +205,37 @@ func TestHandlerReadingNilBodySuccess(t *testing.T) {
 	h.ServeHTTP(rr, r)
 	assert.Equal(t, 200, rr.Result().StatusCode)
 }
+
+func TestHandlerRequestWithTraceContext(t *testing.T) {
+	rr := httptest.NewRecorder()
+
+	h := NewHandler(
+		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			_, err := w.Write([]byte("hello world"))
+			require.NoError(t, err)
+		}), "test_handler")
+
+	r, err := http.NewRequest(http.MethodGet, "http://localhost/", nil)
+	require.NoError(t, err)
+
+	spanRecorder := new(oteltest.SpanRecorder)
+	provider := oteltest.NewTracerProvider(
+		oteltest.WithSpanRecorder(spanRecorder),
+	)
+	tracer := provider.Tracer("")
+	ctx, span := tracer.Start(context.Background(), "test_request")
+	r = r.WithContext(ctx)
+
+	h.ServeHTTP(rr, r)
+	assert.Equal(t, 200, rr.Result().StatusCode)
+
+	span.End()
+
+	spans := spanRecorder.Completed()
+	require.Len(t, spans, 2)
+
+	assert.Equal(t, "test_handler", spans[0].Name())
+	assert.Equal(t, "test_request", spans[1].Name())
+	assert.NotEmpty(t, spans[0].ParentSpanID())
+	assert.Equal(t, spans[1].SpanContext().SpanID(), spans[0].ParentSpanID())
+}

instrumentation/net/http/otelhttp/transport.go

@@ -19,6 +19,7 @@ import (
 	"io"
 	"net/http"
 
+	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/propagation"
 	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
 	"go.opentelemetry.io/otel/trace"
@@ -86,9 +87,19 @@ func (t *Transport) RoundTrip(r *http.Request) (*http.Response, error) {
 		}
 	}
 
+	tracer := t.tracer
+
+	if tracer == nil {
+		if span := trace.SpanFromContext(r.Context()); span.SpanContext().IsValid() {
+			tracer = newTracer(span.TracerProvider())
+		} else {
+			tracer = newTracer(otel.GetTracerProvider())
+		}
+	}
+
 	opts := append([]trace.SpanStartOption{}, t.spanStartOptions...) // start with the configured options
 
-	ctx, span := t.tracer.Start(r.Context(), t.spanNameFormatter("", r), opts...)
+	ctx, span := tracer.Start(r.Context(), t.spanNameFormatter("", r), opts...)
 
 	r = r.WithContext(ctx)
 	span.SetAttributes(semconv.HTTPClientAttributesFromHTTPRequest(r)...)

instrumentation/net/http/otelhttp/transport_test.go

@@ -16,12 +16,16 @@ package otelhttp
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"go.opentelemetry.io/otel/oteltest"
 	"go.opentelemetry.io/otel/propagation"
 	"go.opentelemetry.io/otel/trace"
@@ -243,3 +247,48 @@ func TestTransportUsesFormatter(t *testing.T) {
 	}
 
 }
+
+func TestTransportRequestWithTraceContext(t *testing.T) {
+	spanRecorder := new(oteltest.SpanRecorder)
+	provider := oteltest.NewTracerProvider(
+		oteltest.WithSpanRecorder(spanRecorder),
+	)
+	content := []byte("Hello, world!")
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := w.Write(content)
+		require.NoError(t, err)
+	}))
+	defer ts.Close()
+
+	tracer := provider.Tracer("")
+	ctx, span := tracer.Start(context.Background(), "test_span")
+
+	r, err := http.NewRequest(http.MethodGet, ts.URL, nil)
+	require.NoError(t, err)
+
+	r = r.WithContext(ctx)
+
+	tr := NewTransport(
+		http.DefaultTransport,
+	)
+
+	c := http.Client{Transport: tr}
+	res, err := c.Do(r)
+	require.NoError(t, err)
+
+	span.End()
+
+	body, err := ioutil.ReadAll(res.Body)
+	require.NoError(t, err)
+
+	require.Equal(t, content, body)
+
+	spans := spanRecorder.Completed()
+	require.Len(t, spans, 2)
+
+	assert.Equal(t, "test_span", spans[0].Name())
+	assert.Equal(t, "HTTP GET", spans[1].Name())
+	assert.NotEmpty(t, spans[1].ParentSpanID())
+	assert.Equal(t, spans[0].SpanContext().SpanID(), spans[1].ParentSpanID())
+}