Add InjectSpanContext ClientOption. (#44)

* Add InjectSpanContext ClientOption. Fixes #43.

* Document default behaviour.

* Add TestInjectSpanContext

* Fix doc

nethttp/client.go

@@ -31,10 +31,11 @@ type Transport struct {
 }
 
 type clientOptions struct {
-	operationName      string
-	componentName      string
-	disableClientTrace bool
-	spanObserver       func(span opentracing.Span, r *http.Request)
+	operationName            string
+	componentName            string
+	disableClientTrace       bool
+	disableInjectSpanContext bool
+	spanObserver             func(span opentracing.Span, r *http.Request)
 }
 
 // ClientOption contols the behavior of TraceRequest.
@@ -64,6 +65,16 @@ func ClientTrace(enabled bool) ClientOption {
 	}
 }
 
+// InjectSpanContext returns a ClientOption that turns on or off
+// injection of the Span context in the request HTTP headers.
+// If this option is not used, the default behaviour is to
+// inject the span context.
+func InjectSpanContext(enabled bool) ClientOption {
+	return func(options *clientOptions) {
+		options.disableInjectSpanContext = !enabled
+	}
+}
+
 // ClientSpanObserver returns a ClientOption that observes the span
 // for the client-side span.
 func ClientSpanObserver(f func(span opentracing.Span, r *http.Request)) ClientOption {
@@ -151,8 +162,11 @@ func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
 	ext.HTTPUrl.Set(tracer.sp, req.URL.String())
 	tracer.opts.spanObserver(tracer.sp, req)
 
-	carrier := opentracing.HTTPHeadersCarrier(req.Header)
-	tracer.sp.Tracer().Inject(tracer.sp.Context(), opentracing.HTTPHeaders, carrier)
+	if !tracer.opts.disableInjectSpanContext {
+		carrier := opentracing.HTTPHeadersCarrier(req.Header)
+		tracer.sp.Tracer().Inject(tracer.sp.Context(), opentracing.HTTPHeaders, carrier)
+	}
+
 	resp, err := rt.RoundTrip(req)
 
 	if err != nil {

nethttp/client_test.go

@@ -134,6 +134,72 @@ func TestTracerFromRequest(t *testing.T) {
 	}
 }
 
+func TestInjectSpanContext(t *testing.T) {
+	tests := []struct {
+		name                     string
+		expectContextPropagation bool
+		opts                     []ClientOption
+	}{
+		{name: "Default", expectContextPropagation: true, opts: nil},
+		{name: "True", expectContextPropagation: true, opts: []ClientOption{InjectSpanContext(true)}},
+		{name: "False", expectContextPropagation: false, opts: []ClientOption{InjectSpanContext(false)}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var handlerCalled bool
+			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				handlerCalled = true
+				srvTr := mocktracer.New()
+				ctx, err := srvTr.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(r.Header))
+
+				if err != nil && tt.expectContextPropagation {
+					t.Fatal(err)
+				}
+
+				if tt.expectContextPropagation {
+					if err != nil || ctx == nil {
+						t.Fatal("expected propagation but unable to extract")
+					}
+				} else {
+					// Expect "opentracing: SpanContext not found in Extract carrier" when not injected
+					// Can't check ctx directly, because it gets set to emptyContext
+					if err == nil {
+						t.Fatal("unexpected propagation")
+					}
+				}
+			}))
+
+			tr := mocktracer.New()
+			span := tr.StartSpan("root")
+
+			req, err := http.NewRequest("GET", srv.URL, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			req = req.WithContext(opentracing.ContextWithSpan(req.Context(), span))
+
+			req, ht := TraceRequest(tr, req, tt.opts...)
+
+			client := &http.Client{Transport: &Transport{}}
+			resp, err := client.Do(req)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_ = resp.Body.Close()
+
+			ht.Finish()
+			span.Finish()
+
+			srv.Close()
+
+			if !handlerCalled {
+				t.Fatal("server handler never called")
+			}
+		})
+	}
+}
+
 func makeTags(keyVals ...interface{}) map[string]interface{} {
 	result := make(map[string]interface{}, len(keyVals)/2)
 	for i := 0; i < len(keyVals)-1; i += 2 {