The id has to ride along — context propagation with the traceparent header

The caller writes the trace id and its own span id into an outbound header and the callee reads them back out, so any hop that builds a request without copying that header starts a brand-new trace — and both halves still look complete.

Previously

Scene 02 assumed each hop already knew the trace id. Nothing gives a service that id unless the caller hands it over on the way in.

Scene 03

The id has to ride along

Watch
Try it
Predict
Capture

What to watch for

How does the second service know which request it is part of? Nobody tells it — the first service has to write the ids into the request it sends, and the receiver reads them back out. Read the hop-by-hop rail on the left: the blue stretch of what went out is identical on every hop, and the violet tail changes at every one. Then watch what happens when checkout builds a fresh request to payments and copies nothing into it.

Top: the Shopfront request path, gateway → checkout → payments → ledger, with the header each caller puts on the wire drawn on every arrow.
Left: that header opened up into its parts, and a hop-by-hop rail of what actually went out — the blue stretch is the piece that is identical on every hop, the violet tail is the piece each caller rewrites with its own span id.
This act of copying the ids from an inbound request onto every outbound one is context propagation, and the W3C header that carries them is called traceparent.
Right: the trace (or traces) the store ends up holding, rose framing marking a second trace nobody asked for.
Bottom left: which wire format this path speaks.
Bottom right: a handoff inside a single process, no network involved.
Top right: time-to-culprit, the minutes from page to naming the guilty service — every value here is an example.

Implementation

Highlighted lines are the ones running in the diagram right now.

Checkout.call_payments

the outbound request the ids have to ride on

1def call_payments(order):
2    span = tracer.start_span("POST /charge", CLIENT)
3    ctx = set_span_in_context(span, current_context())
4    req = build_request("POST", "/charge", order)
5    if client_is_instrumented:
6        propagator.inject(ctx, req.headers)
7    send(req)
8    span.end()

Propagator.inject

the caller writes the ids onto the wire

1def inject(ctx, headers):
2    s = ctx.current_span
3    if s is None:
4        return
5    headers["traceparent"] = "-".join([
6        "00",
7        s.trace_id,      # minted once per request
8        s.span_id,       # the caller's own span
9        s.flags,
10    ])
11    if writes_b3:        # composite propagator
12        write_b3_headers(headers, s)

Propagator.extract

the receiver reads them back, or does not

1def extract(headers):
2    tp = headers.get("traceparent")
3    if reads_w3c and tp and len(tp) >= 55:
4        _, trace_id, parent_id, flags = tp.split("-")
5        return remote_context(trace_id, parent_id, flags)
6    if reads_b3 and "X-B3-TraceId" in headers:
7        return b3_context(headers)
8    return EMPTY_CONTEXT
9 
10def on_request(headers):
11    parent = extract(headers)
12    return tracer.start_span(name, parent)  # empty -> root

Context.attach

the ids inside one process, with no wire involved

1def attach(ctx):
2    token = execution_unit.current
3    execution_unit.current = ctx   # Context is immutable
4    return token                   # detach(token) undoes it
5 
6def apply_loyalty_points(order, ctx):
7    if hands_off_to_pool:
8        pool.submit(lambda: apply(order))
9    else:
10        token = attach(ctx)
11        apply(order)
12        detach(token)

Sources

Where this sits in Build a distributed tracing system (Jaeger / Zipkin style)

Scene 03 of 17, in the Carry it act — The header, the queue that drops it, what rides along.. The caller writes the trace id and its own span id into an outbound header and the callee reads them back. Any hop that builds a request without copying it starts a brand-new trace — and both halves still look complete.

Up next. The id rides in a header on an outbound request. So what happens at a hop where there is no outbound request to put a header on?

All 17 scenes in Build a distributed tracing system (Jaeger / Zipkin style) · Every curriculum

Built with Arqly

Every scene in Build a distributed tracing system (Jaeger / Zipkin style) builds on the one before it.All 17 Build a distributed tracing system (Jaeger / Zipkin style) scenes