updating PR comments and unit tests

contrib/IBM/sarama.v1/sarama.go

@@ -74,7 +74,9 @@ func WrapPartitionConsumer(pc sarama.PartitionConsumer, opts ...Option) sarama.P
 			// kafka supports headers, so try to extract a span context
 			carrier := NewConsumerMessageCarrier(msg)
 			if spanctx, err := tracer.Extract(carrier); err == nil {
-				if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+				// If there are span links as a result of context extraction, add them as a StartSpanOption
+				// and remove from the extracted context as they belong to the span being created, not the parent span
+				if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 					opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 					linksCtx.SetLinks(nil)
 				}
@@ -302,7 +304,9 @@ func startProducerSpan(cfg *config, version sarama.KafkaVersion, msg *sarama.Pro
 	}
 	// if there's a span context in the headers, use that as the parent
 	if spanctx, err := tracer.Extract(carrier); err == nil {
-		if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+		// If there are span links as a result of context extraction, add them as a StartSpanOption
+		// and remove from the extracted context as they belong to the span being created, not the parent span
+		if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 			opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 			linksCtx.SetLinks(nil)
 		}

contrib/Shopify/sarama/sarama.go

@@ -77,7 +77,9 @@ func WrapPartitionConsumer(pc sarama.PartitionConsumer, opts ...Option) sarama.P
 			// kafka supports headers, so try to extract a span context
 			carrier := NewConsumerMessageCarrier(msg)
 			if spanctx, err := tracer.Extract(carrier); err == nil {
-				if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+				// If there are span links as a result of context extraction, add them as a StartSpanOption
+				// and remove from the extracted context as they belong to the span being created, not the parent span
+				if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 					opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 					linksCtx.SetLinks(nil)
 				}
@@ -305,7 +307,9 @@ func startProducerSpan(cfg *config, version sarama.KafkaVersion, msg *sarama.Pro
 	}
 	// if there's a span context in the headers, use that as the parent
 	if spanctx, err := tracer.Extract(carrier); err == nil {
-		if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+		// If there are span links as a result of context extraction, add them as a StartSpanOption
+		// and remove from the extracted context as they belong to the span being created, not the parent span
+		if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 			opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 			linksCtx.SetLinks(nil)
 		}

contrib/cloud.google.com/go/pubsub.v1/internal/tracing/tracing.go

@@ -118,7 +118,9 @@ func TraceReceiveFunc(s Subscription, opts ...Option) func(ctx context.Context,
 		if cfg.measured {
 			opts = append(opts, tracer.Measured())
 		}
-		if linksCtx, err := parentSpanCtx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+		// If there are span links as a result of context extraction, add them as a StartSpanOption
+		// and remove from the extracted context as they belong to the span being created, not the parent span
+		if linksCtx, ok := parentSpanCtx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 			opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 			linksCtx.SetLinks(nil)
 		}

contrib/confluentinc/confluent-kafka-go/internal/tracing/consumer.go

@@ -77,7 +77,9 @@ func (tr *KafkaTracer) StartConsumeSpan(msg Message) ddtrace.Span {
 	// kafka supports headers, so try to extract a span context
 	carrier := MessageCarrier{msg: msg}
 	if spanctx, err := tracer.Extract(carrier); err == nil {
-		if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+		// If there are span links as a result of context extraction, add them as a StartSpanOption
+		// and remove from the extracted context as they belong to the span being created, not the parent span
+		if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 			opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 			linksCtx.SetLinks(nil)
 		}

contrib/confluentinc/confluent-kafka-go/internal/tracing/producer.go

@@ -67,7 +67,9 @@ func (tr *KafkaTracer) StartProduceSpan(msg Message) ddtrace.Span {
 	// if there's a span context in the headers, use that as the parent
 	carrier := NewMessageCarrier(msg)
 	if spanctx, err := tracer.Extract(carrier); err == nil {
-		if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+		// If there are span links as a result of context extraction, add them as a StartSpanOption
+		// and remove from the extracted context as they belong to the span being created, not the parent span
+		if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 			opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 			linksCtx.SetLinks(nil)
 		}

contrib/gofiber/fiber.v2/fiber.go

@@ -62,7 +62,9 @@ func Middleware(opts ...Option) func(c *fiber.Ctx) error {
 			}
 		}
 		if spanctx, err := tracer.Extract(tracer.HTTPHeadersCarrier(h)); err == nil {
-			if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+			// If there are span links as a result of context extraction, add them as a StartSpanOption
+			// and remove from the extracted context as they belong to the span being created, not the parent span
+			if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 				opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 				linksCtx.SetLinks(nil)
 			}

contrib/google.golang.org/grpc/grpc.go

@@ -71,7 +71,9 @@ func startSpanFromContext(
 	)
 	md, _ := metadata.FromIncomingContext(ctx) // nil is ok
 	if sctx, err := tracer.Extract(grpcutil.MDCarrier(md)); err == nil {
-		if linksCtx, err := sctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+		// If there are span links as a result of context extraction, add them as a StartSpanOption
+		// and remove from the extracted context as they belong to the span being created, not the parent span
+		if linksCtx, ok := sctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 			opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 			linksCtx.SetLinks(nil)
 		}

contrib/internal/httptrace/httptrace.go

@@ -51,7 +51,9 @@ func StartRequestSpan(r *http.Request, opts ...ddtrace.StartSpanOption) (tracer.
 				cfg.Tags["http.host"] = r.Host
 			}
 			if spanctx, err := tracer.Extract(tracer.HTTPHeadersCarrier(r.Header)); err == nil {
-				if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+				// If there are span links as a result of context extraction, add them as a StartSpanOption
+				// and remove from the extracted context as they belong to the span being created, not the parent span
+				if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 					opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 					linksCtx.SetLinks(nil)
 				}

contrib/segmentio/kafka.go.v0/internal/tracing/tracing.go

@@ -49,7 +49,9 @@ func (tr *Tracer) StartConsumeSpan(ctx context.Context, msg Message) ddtrace.Spa
 	// kafka supports headers, so try to extract a span context
 	carrier := NewMessageCarrier(msg)
 	if spanctx, err := tracer.Extract(carrier); err == nil {
-		if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+		// If there are span links as a result of context extraction, add them as a StartSpanOption
+		// and remove from the extracted context as they belong to the span being created, not the parent span
+		if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 			opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 			linksCtx.SetLinks(nil)
 		}

contrib/twitchtv/twirp/twirp.go

@@ -91,7 +91,9 @@ func (wc *wrappedClient) Do(req *http.Request) (*http.Response, error) {
 		opts = append(opts, tracer.Tag(ext.EventSampleRate, wc.cfg.analyticsRate))
 	}
 	if spanctx, err := tracer.Extract(tracer.HTTPHeadersCarrier(req.Header)); err == nil {
-		if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+		// If there are span links as a result of context extraction, add them as a StartSpanOption
+		// and remove from the extracted context as they belong to the span being created, not the parent span
+		if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 			opts = append(opts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 			linksCtx.SetLinks(nil)
 		}
@@ -144,7 +146,9 @@ func WrapServer(h http.Handler, opts ...Option) http.Handler {
 			spanOpts = append(spanOpts, tracer.Tag(ext.EventSampleRate, cfg.analyticsRate))
 		}
 		if spanctx, err := tracer.Extract(tracer.HTTPHeadersCarrier(r.Header)); err == nil {
-			if linksCtx, err := spanctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+			// If there are span links as a result of context extraction, add them as a StartSpanOption
+			// and remove from the extracted context as they belong to the span being created, not the parent span
+			if linksCtx, ok := spanctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 				spanOpts = append(spanOpts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 				linksCtx.SetLinks(nil)
 			}

contrib/valyala/fasthttp.v1/fasthttp.go

@@ -46,7 +46,9 @@ func WrapHandler(h fasthttp.RequestHandler, opts ...Option) fasthttp.RequestHand
 			ReqHeader: &fctx.Request.Header,
 		}
 		if sctx, err := tracer.Extract(fcc); err == nil {
-			if linksCtx, err := sctx.(ddtrace.SpanContextWithLinks); err && linksCtx.SpanLinks() != nil {
+			// If there are span links as a result of context extraction, add them as a StartSpanOption
+			// and remove from the extracted context as they belong to the span being created, not the parent span
+			if linksCtx, ok := sctx.(ddtrace.SpanContextWithLinks); ok && linksCtx.SpanLinks() != nil {
 				spanOpts = append(spanOpts, tracer.WithSpanLinks(linksCtx.SpanLinks()))
 				linksCtx.SetLinks(nil)
 			}

ddtrace/tracer/textmap.go

@@ -270,13 +270,13 @@ func (p *chainedPropagator) Inject(spanCtx ddtrace.SpanContext, carrier interfac
 // a previous propagator has already succeeded so long as the trace-ids match.
 // Furthermore, if we have already successfully extracted a trace context and a
 // subsequent trace context has conflicting trace information, such information will
-// be relayed in the original trace context with a SpanLink.
+// be relayed in the returned SpanContext with a SpanLink.
 func (p *chainedPropagator) Extract(carrier interface{}) (ddtrace.SpanContext, error) {
 	var ctx ddtrace.SpanContext // First valid trace context will be stored here
 	var links []ddtrace.SpanLink
 	for _, v := range p.extractors {
 		extractedCtx, err := v.Extract(carrier)
-		// Handling extraction errors. If it is the first extraction, return error. Else, ignore
+		// Handling extraction errors. If it is the first extraction, distributed tracing breaks and return error. Else, ignore
 		if err != nil {
 			if ctx == nil && err != ErrSpanContextNotFound {
 				return nil, err
@@ -287,7 +287,7 @@ func (p *chainedPropagator) Extract(carrier interface{}) (ddtrace.SpanContext, e
 		if ctx != nil { // A local trace context has already been extracted
 			propagatorType, err := getPropagatorType(v)
 			if err != nil { // Propagator is not one of the known, supported types. Ignore this extraction
-				log.Debug("Propagator type is unknown. Skipping extraction")
+				log.Debug("Trace propagator type %T is unknown. Skipping trace extraction", v)
 				continue
 			}
 			if extractedCtx.(ddtrace.SpanContextW3C).TraceID128() == ctx.(ddtrace.SpanContextW3C).TraceID128() {
@@ -303,7 +303,7 @@ func (p *chainedPropagator) Extract(carrier interface{}) (ddtrace.SpanContext, e
 						overrideDatadogParentID(ctx.(*spanContext), extractedCtx.(*spanContext), ddCtx)
 					}
 				}
-			} else {
+			} else { //handle non-w3c propagators
 				var flags uint32
 				if tracer := extractedCtx.(*spanContext).trace; tracer != nil {
 					if flags = uint32(*tracer.priority); flags > 0 { // Set the flags based on the sampling priority

ddtrace/tracer/textmap_test.go

@@ -1972,63 +1972,83 @@ func TestInvalidTraceSpanLinkCreation(t *testing.T) {
 		for k, v := range testEnv {
 			t.Setenv(k, v)
 		}
-		var test = []struct {
+		var test = struct {
 			in  TextMapCarrier
 			out []ddtrace.SpanLink
 			tid []traceID
 		}{
-			{
-				in: TextMapCarrier{
-					DefaultTraceIDHeader:  "1",
-					DefaultParentIDHeader: "1",
-					DefaultPriorityHeader: "3",
-					traceparentHeader:     "00-00000000000000000000000000000002-0000000000000002-01",
-					tracestateHeader:      "dd=s:1;o:rum;t.usr.id:baz64~~",
-				},
-				out: []ddtrace.SpanLink{{TraceID: 2, TraceIDHigh: 0, SpanID: 2, Tracestate: "dd=s:1;o:rum;t.usr.id:baz64~~", Flags: 1, Attributes: map[string]string{"reason": "terminated_context", "context_headers": "tracecontext"}}, {TraceID: 1, TraceIDHigh: 0, SpanID: 1, Flags: 1, Attributes: map[string]string{"reason": "terminated_context", "context_headers": "datadog"}}},
-				tid: []traceID{traceIDFrom64Bits(1), traceIDFrom64Bits(2)},
-			},
-			{
-				in: TextMapCarrier{
-					DefaultTraceIDHeader:  "1",
-					DefaultParentIDHeader: "1",
-					DefaultPriorityHeader: "3",
-					traceparentHeader:     "00-00000000000000000000000000000001-0000000000000002-01",
-					tracestateHeader:      "dd=s:1;o:rum;t.usr.id:baz64~~",
-				},
-				out: nil,
-				tid: []traceID{traceIDFrom64Bits(1), traceIDFrom64Bits(1)},
+			in: TextMapCarrier{
+				DefaultTraceIDHeader:  "1",
+				DefaultParentIDHeader: "1",
+				DefaultPriorityHeader: "3",
+				traceparentHeader:     "00-00000000000000000000000000000002-0000000000000002-01",
+				tracestateHeader:      "dd=s:1;o:rum;t.usr.id:baz64~~",
 			},
+			out: []ddtrace.SpanLink{{TraceID: 2, TraceIDHigh: 0, SpanID: 2, Tracestate: "dd=s:1;o:rum;t.usr.id:baz64~~", Flags: 1, Attributes: map[string]string{"reason": "terminated_context", "context_headers": "tracecontext"}}, {TraceID: 1, TraceIDHigh: 0, SpanID: 1, Flags: 1, Attributes: map[string]string{"reason": "terminated_context", "context_headers": "datadog"}}},
+			tid: []traceID{traceIDFrom64Bits(1), traceIDFrom64Bits(2)},
 		}
 		t.Run("InvalidTraceSpanLinkCreation", func(t *testing.T) {
 			tracer := newTracer(WithHTTPClient(c))
 			defer tracer.Stop()
 			assert := assert.New(t)
-			ctx, err := tracer.Extract(test[0].in)
+			ctx, err := tracer.Extract(test.in)
 			if err != nil {
 				t.Fatal(err)
 			}
 			sctx, ok := ctx.(*spanContext)
 			assert.True(ok)
 
-			assert.Equal(test[0].tid[i], sctx.traceID)
-			assert.Equal(test[0].out[i], sctx.spanLinks[0])
+			assert.Equal(test.tid[i], sctx.traceID)
+			assert.Equal(test.out[i], sctx.spanLinks[0])
 			assert.True(ok)
 		})
+	}
+}
+
+func TestValidTraceSpanLinkCreation(t *testing.T) {
+	var testEnvs []map[string]string
+	s, c := httpmem.ServerAndClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(404)
+	}))
+	defer s.Close()
+	testEnvs = []map[string]string{
+		{headerPropagationStyleExtract: "datadog,tracecontext"},
+		{headerPropagationStyleExtract: "tracecontext,datadog"},
+	}
+
+	for i, testEnv := range testEnvs {
+		for k, v := range testEnv {
+			t.Setenv(k, v)
+		}
+		var test = struct {
+			in  TextMapCarrier
+			out []ddtrace.SpanLink
+			tid []traceID
+		}{
+			in: TextMapCarrier{
+				DefaultTraceIDHeader:  "1",
+				DefaultParentIDHeader: "1",
+				DefaultPriorityHeader: "3",
+				traceparentHeader:     "00-00000000000000000000000000000001-0000000000000002-01",
+				tracestateHeader:      "dd=s:1;o:rum;t.usr.id:baz64~~",
+			},
+			out: nil,
+			tid: []traceID{traceIDFrom64Bits(1), traceIDFrom64Bits(1)},
+		}
 
 		t.Run("ValidTraceSpanLinkCreation", func(t *testing.T) {
 			tracer := newTracer(WithHTTPClient(c))
 			defer tracer.Stop()
 			assert := assert.New(t)
-			ctx, err := tracer.Extract(test[1].in)
+			ctx, err := tracer.Extract(test.in)
 			if err != nil {
 				t.Fatal(err)
 			}
 			sctx, ok := ctx.(*spanContext)
 			assert.True(ok)
 
-			assert.Equal(test[1].tid[i], sctx.traceID)
-			assert.Equal(test[1].out, sctx.spanLinks)
+			assert.Equal(test.tid[i], sctx.traceID)
+			assert.Equal(test.out, sctx.spanLinks)
 			assert.True(ok)
 		})
 	}