feat: propagate trace context through HTTP channel

- inject span context into outbound HTTP headers and extract it back onto responses
- add Context-aware HTTP response wrapper and corresponding tests
- require otel/trace to satisfy new imports

Author: frrist

go.mod

@@ -16,6 +16,8 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/stretchr/testify v1.9.0
 	github.com/ucan-wg/go-ucan v0.0.0-20240916120445-37f52863156c
+	go.opentelemetry.io/otel v1.30.0
+	go.opentelemetry.io/otel/trace v1.30.0
 )
 
 require (
@@ -71,9 +73,7 @@ require (
 	github.com/polydawn/refmt v0.89.1-0.20231129105047-37766d95467a // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	github.com/whyrusleeping/cbor-gen v0.1.2 // indirect
-	go.opentelemetry.io/otel v1.30.0 // indirect
 	go.opentelemetry.io/otel/metric v1.30.0 // indirect
-	go.opentelemetry.io/otel/trace v1.30.0 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.27.0 // indirect

transport/http/channel.go

@@ -8,6 +8,9 @@ import (
 
 	"slices"
 
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/propagation"
+
 	"github.com/storacha/go-ucanto/transport"
 )
 
@@ -67,6 +70,8 @@ func (c *Channel) Request(ctx context.Context, req transport.HTTPRequest) (trans
 	}
 
 	addAllHeaders(hr.Header, req.Headers(), c.headers)
+	injectTraceContext(ctx, hr)
+
 	res, err := c.client.Do(hr)
 	if err != nil {
 		return nil, fmt.Errorf("doing HTTP request: %w", err)
@@ -75,7 +80,8 @@ func (c *Channel) Request(ctx context.Context, req transport.HTTPRequest) (trans
 		return nil, NewHTTPError(fmt.Sprintf("HTTP Request failed. %s %s → %d", hr.Method, c.url.String(), res.StatusCode), res.StatusCode, res.Header)
 	}
 
-	return NewResponse(res.StatusCode, res.Body, res.Header), nil
+	ctx = extractTraceContext(ctx, res.Header)
+	return NewResponseWithContext(ctx, res.StatusCode, res.Body, res.Header), nil
 }
 
 func addAllHeaders(dst http.Header, srcs ...http.Header) {
@@ -88,6 +94,20 @@ func addAllHeaders(dst http.Header, srcs ...http.Header) {
 	}
 }
 
+func injectTraceContext(ctx context.Context, req *http.Request) {
+	if ctx == nil || req == nil {
+		return
+	}
+	otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(req.Header))
+}
+
+func extractTraceContext(ctx context.Context, headers http.Header) context.Context {
+	if ctx == nil || headers == nil {
+		return ctx
+	}
+	return otel.GetTextMapPropagator().Extract(ctx, propagation.HeaderCarrier(headers))
+}
+
 var _ transport.Channel = (*Channel)(nil)
 
 func NewChannel(url *url.URL, options ...Option) *Channel {

transport/http/channel_test.go

@@ -0,0 +1,106 @@
+package http
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/trace"
+)
+
+func TestChannelPropagatesTraceContext(t *testing.T) {
+	const (
+		requestTraceIDHex  = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+		requestSpanIDHex   = "bbbbbbbbbbbbbbbb"
+		responseTraceIDHex = "cccccccccccccccccccccccccccccccc"
+		responseSpanIDHex  = "dddddddddddddddd"
+		responseTrace      = "00-" + responseTraceIDHex + "-" + responseSpanIDHex + "-01"
+		expectedRequest    = "00-" + requestTraceIDHex + "-" + requestSpanIDHex + "-01"
+	)
+
+	var seenRequestTrace string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		seenRequestTrace = r.Header.Get("traceparent")
+		w.Header().Set("traceparent", responseTrace)
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	endpoint, err := url.Parse(server.URL)
+	if err != nil {
+		t.Fatalf("parsing server URL: %v", err)
+	}
+
+	channel := NewChannel(endpoint, WithClient(server.Client()))
+
+	restoreProp := setTraceContextPropagator()
+	t.Cleanup(restoreProp)
+
+	ctx := context.Background()
+	ctx = trace.ContextWithSpanContext(ctx, newSpanContext(t, requestTraceIDHex, requestSpanIDHex))
+
+	res, err := channel.Request(ctx, NewRequest(http.NoBody, nil))
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	t.Cleanup(func() { res.Body().Close() })
+
+	if seenRequestTrace != expectedRequest {
+		t.Fatalf("expected traceparent %q, got %q", expectedRequest, seenRequestTrace)
+	}
+
+	responseCtx, ok := res.(*Response)
+	if !ok {
+		t.Fatalf("expected *Response, got %T", res)
+	}
+	sc := trace.SpanContextFromContext(responseCtx.Context())
+	expectedTraceID := mustTraceIDFromHex(t, responseTraceIDHex)
+	if sc.TraceID() != expectedTraceID {
+		t.Fatalf("expected response trace ID %s, got %s", expectedTraceID, sc.TraceID())
+	}
+	expectedSpanID := mustSpanIDFromHex(t, responseSpanIDHex)
+	if sc.SpanID() != expectedSpanID {
+		t.Fatalf("expected response span ID %s, got %s", expectedSpanID, sc.SpanID())
+	}
+}
+
+func newSpanContext(t *testing.T, traceIDHex, spanIDHex string) trace.SpanContext {
+	t.Helper()
+	traceID := mustTraceIDFromHex(t, traceIDHex)
+	spanID := mustSpanIDFromHex(t, spanIDHex)
+	return trace.NewSpanContext(trace.SpanContextConfig{
+		TraceID:    traceID,
+		SpanID:     spanID,
+		TraceFlags: trace.FlagsSampled,
+	})
+}
+
+func mustTraceIDFromHex(t *testing.T, hex string) trace.TraceID {
+	t.Helper()
+	traceID, err := trace.TraceIDFromHex(hex)
+	if err != nil {
+		t.Fatalf("parsing trace ID: %v", err)
+	}
+	return traceID
+}
+
+func mustSpanIDFromHex(t *testing.T, hex string) trace.SpanID {
+	t.Helper()
+	spanID, err := trace.SpanIDFromHex(hex)
+	if err != nil {
+		t.Fatalf("parsing span ID: %v", err)
+	}
+	return spanID
+}
+
+func setTraceContextPropagator() func() {
+	prev := otel.GetTextMapPropagator()
+	otel.SetTextMapPropagator(propagation.TraceContext{})
+	return func() {
+		otel.SetTextMapPropagator(prev)
+	}
+}

transport/http/response.go

@@ -1,6 +1,7 @@
 package http
 
 import (
+	"context"
 	"io"
 	"net/http"
 	"net/url"
@@ -30,6 +31,7 @@ var _ transport.HTTPRequest = (*Request)(nil)
 var _ transport.InboundHTTPRequest = (*Request)(nil)
 
 type Response struct {
+	ctx    context.Context
 	status int
 	hdrs   http.Header
 	body   io.ReadCloser
@@ -47,10 +49,24 @@ func (res *Response) Body() io.ReadCloser {
 	return res.body
 }
 
+func (res *Response) Context() context.Context {
+	if res.ctx == nil {
+		return context.Background()
+	}
+	return res.ctx
+}
+
 var _ transport.HTTPResponse = (*Response)(nil)
 
 func NewResponse(status int, body io.ReadCloser, headers http.Header) *Response {
-	return &Response{status, headers, body}
+	return NewResponseWithContext(context.Background(), status, body, headers)
+}
+
+func NewResponseWithContext(ctx context.Context, status int, body io.ReadCloser, headers http.Header) *Response {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &Response{ctx: ctx, status: status, hdrs: headers, body: body}
 }
 
 // NewRequest creates a [transport.HTTPRequest]