Demo Propagating Context

In this guide you’ll learn how to fix a common tracing problem: two services (payment and charge) producing separate traces for the same user request. The root cause is that the OpenTelemetry context (trace id, span, trace state) is not being propagated across the HTTP boundary. The solution is to inject the current context as headers on the client side and to extract and activate that context on the server side. Overview

Client (payment service): inject the current OpenTelemetry context into outgoing HTTP headers.
Server (charge service): extract the context from incoming headers, attach it for the request lifecycle, and detach it in teardown.

We inject the context into an HTTP carrier (headers) with inject(...) and retrieve it on the server with extract(...). Both utilities are available from opentelemetry.propagate.

Quick reference

Action	Function	Typical use
Inject context into outgoing carrier	`inject(headers)`	Client: add propagation fields to `requests` headers
Extract context from incoming carrier	`extract(request.headers)`	Server: read propagation fields from incoming request

Payment service (client) — inject context into request headers

Goals

Configure the tracer provider and exporter for the payment service.
Create a client span for the outgoing HTTP request.
Call inject(headers) before sending the request so propagation fields are added to the HTTP headers.
Pass headers to requests.get(..., headers=headers).

Example payment service (simplified):

# payment.py
import requests
from opentelemetry.propagate import inject
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, BatchSpanProcessor
# Optional OTLP exporter:
def configure_tracer():
    resource = Resource.create({
        "service.name": "payment service",
        "service.version": "0.2.0",
    })
    provider = TracerProvider(resource=resource)

    exporter = ConsoleSpanExporter()
    # exporter = OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")
    span_processor = BatchSpanProcessor(exporter)
    provider.add_span_processor(span_processor)

    trace.set_tracer_provider(provider)
    return trace.get_tracer(__name__)

tracer = configure_tracer()

@tracer.start_as_current_span("Charge Bank")
def charge_bank():
    print("charging bank")

    # Create a client span for the outgoing HTTP request
    with tracer.start_as_current_span("Request to Charge API", kind=trace.SpanKind.CLIENT) as span:
        url = "http://127.0.0.1:5000/charge"
        # Set useful attributes for the request span
        span.set_attribute("http.method", "GET")
        span.set_attribute("http.url", url)

        # Inject current context into headers
        headers = {}
        inject(headers)

        # Make the HTTP request with the propagated headers
        resp = requests.get(url, headers=headers)
        span.set_attribute("http.status_code", resp.status_code)

if __name__ == "__main__":
    charge_bank()

Key points

inject(headers) mutates your headers dictionary to include propagation fields (traceparent, tracestate, etc.).
Use headers=headers when calling requests.get() so the downstream service receives the context.

Charge service (server) — extract and attach context from incoming headers

Goals

Configure tracer provider and exporter for the charge service.
Extract the incoming context from request headers and attach it so the propagated trace becomes active for the request handler.
Save the returned token to request.environ and detach it in teardown_request to restore the previous context.

Important functions: opentelemetry.propagate.extract, opentelemetry.context.attach, and opentelemetry.context.detach. Example charge service:

# charge.py
from flask import Flask, request
from opentelemetry.propagate import extract
from opentelemetry import trace
from opentelemetry.context import attach, detach
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, BatchSpanProcessor
# Optional OTLP exporter:
def configure_tracer():
    resource = Resource.create({
        "service.name": "charge service",
        "service.version": "0.5.0",
    })
    provider = TracerProvider(resource=resource)

    exporter = ConsoleSpanExporter()
    # exporter = OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")
    span_processor = BatchSpanProcessor(exporter)
    provider.add_span_processor(span_processor)

    trace.set_tracer_provider(provider)
    return trace.get_tracer(__name__)

tracer = configure_tracer()
app = Flask(__name__)

@app.before_request
def before_request_func():
    # Extract the context from incoming request headers and make it active
    token = attach(extract(request.headers))
    # Save the token so we can detach in teardown
    request.environ["context_token"] = token

@app.teardown_request
def teardown_request_func(exc):
    # Detach previously attached context token to restore previous context
    token = request.environ.get("context_token", None)
    if token:
        detach(token)

@app.route("/charge")
@tracer.start_as_current_span("Charge Account", kind=trace.SpanKind.SERVER)
def charge():
    span = trace.get_current_span()
    span.set_attribute("http.method", request.method)
    span.set_attribute("client.ip", request.remote_addr)
    span.set_attribute("http.path", request.path)
    return "Charging Users Bank Account"

if __name__ == "__main__":
    app.run(debug=True)

Flask passes an exception argument to teardown_request. The teardown function must accept that parameter (for example def teardown_request_func(exc):) even if you don’t use it, otherwise Flask will raise an error.

Run and verify

Start the charge service (server): python charge.py
Start the payment service (client) and trigger the request: python payment.py
Observe the console output or your tracing backend. With the Console exporter you will see both client and server spans logged; with OTLP -> Jaeger you will see a single distributed trace containing both services.

Expected behavior

Both client and server spans should share the same trace_id.
The server span’s parent_id should match the client span’s span_id, indicating correct parent/child relationships.

Example of a client span (trimmed):

{
  "name": "Request to Charge API",
  "context": {
    "trace_id": "0x026ef7be217ce0d83fe16a255578eb4",
    "span_id": "0xafb59c6fb586f176",
    "trace_state": "[]"
  },
  "kind": "SpanKind.CLIENT",
  "attributes": {
    "http.method": "GET",
    "http.url": "http://127.0.0.1:5000/charge",
    "http.status_code": 200
  }
}

Corresponding server span (trimmed):

{
  "name": "Charge Account",
  "context": {
    "trace_id": "0x026ef7be217ce0d83fe16a255578eb4",
    "span_id": "0xbfdc2355760919cb",
    "trace_state": "[]"
  },
  "kind": "SpanKind.SERVER",
  "parent_id": "0xafb59c6fb586f176",
  "attributes": {
    "http.method": "GET",
    "client.ip": "127.0.0.1",
    "http.path": "/charge"
  }
}

Notice:

Shared trace_id confirms both spans belong to the same distributed trace.
parent_id on the server span matches the client span’s span_id, confirming the correct parent-child relationship.

If you use OTLP -> Jaeger or another backend, you should see a single trace containing both services (payment and charge). Example screenshot of Jaeger UI showing both services inside the same trace:

The image shows a Jaeger UI interface displaying a trace for a "payment service," detailing operations like "Starting Payment" and "Charge Account," along with timing information for each step.

With these propagation changes the two services are connected in the same trace, enabling end-to-end visibility across the request path. Links and references

Watch Video

Demo Connecting Two Services

Demo Events

​Payment service (client) — inject context into request headers

​Charge service (server) — extract and attach context from incoming headers

​Run and verify

Watch Video

Payment service (client) — inject context into request headers

Charge service (server) — extract and attach context from incoming headers

Run and verify