OpenTelemetry Jaeger Propagator

Warnings

• gotcha Forgetting to register the propagator globally. The `JaegerPropagator` must be registered using `set_global_textmap(JaegerPropagator())` for it to be used automatically by OpenTelemetry's context propagation mechanisms (e.g., in HTTP instrumentations). If not set, OpenTelemetry will default to using `W3CTraceContextPropagator` and `W3CBaggagePropagator`.
  Fix: Ensure `from opentelemetry.propagate import set_global_textmap; set_global_textmap(JaegerPropagator())` is called early in your application's startup process.
• gotcha Mixing Jaeger and W3C Trace Context. Jaeger uses a specific header format (`uber-trace-id`, `jaeger-trace-id`). W3C Trace Context uses `traceparent` and `tracestate`. If your system interacts with services using both, you'll need to use a `CompositePropagator` to handle multiple formats.
  Fix: Use `from opentelemetry.propagate import CompositePropagator, set_global_textmap; set_global_textmap(CompositePropagator([JaegerPropagator(), W3CTraceContextPropagator(), W3CBaggagePropagator()]))` to support multiple propagation formats.
• breaking Changes to `NoOpTracer` behavior in `opentelemetry-sdk` v1.40.0. The `start_span` and `start_as_current_span` methods in `NoOpTracer` no longer strictly return an `INVALID_SPAN` if there is a valid span context as the current span context. Instead, they propagate the span context properly even without the SDK installed. While this is a core SDK change, it's relevant if your application logic or testing relies on the previous `NoOpTracer` behavior when no SDK is configured, which could subtly impact how propagators perceive the 'current' context.
  Fix: Review any code that explicitly checks for `INVALID_SPAN` when no SDK is installed or that relies on `NoOpTracer` not propagating context. Adjust logic to account for context propagation even without an SDK if a valid context is present.

Install

• pip install opentelemetry-propagator-jaeger Install Jaeger Propagator
• pip install 'opentelemetry-sdk' 'opentelemetry-api' 'opentelemetry-exporter-otlp' Install core OTel components (recommended)

Imports

• JaegerPropagator

  from opentelemetry.propagators.jaeger import JaegerPropagator

Quickstart

This quickstart demonstrates how to initialize the `JaegerPropagator` and register it as the global text map propagator. This tells OpenTelemetry to use Jaeger's specific header format (e.g., `uber-trace-id` or `jaeger-trace-id`) when injecting and extracting trace context from HTTP headers or other text-based carriers. It includes a basic setup for a `TracerProvider` to make the example runnable and illustrate how context would be injected.

from opentelemetry import trace
from opentelemetry.propagate import set_global_textmap
from opentelemetry.propagators.jaeger import JaegerPropagator
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor

# 1. Set up a TracerProvider (required for actual tracing)
resource = Resource.create({"service.name": "my-jaeger-service"})
tracer_provider = TracerProvider(resource=resource)
simple_processor = SimpleSpanProcessor(ConsoleSpanExporter())
tracer_provider.add_span_processor(simple_processor)
trace.set_tracer_provider(tracer_provider)

# 2. Register the JaegerPropagator globally
set_global_textmap(JaegerPropagator())

# 3. Get a tracer
tracer = trace.get_tracer(__name__)

# 4. Create a span and demonstrate context propagation (conceptually)
with tracer.start_as_current_span("my-jaeger-span") as span:
    print(f"Current span ID: {span.context.span_id:x}")
    print(f"Current trace ID: {span.context.trace_id:x}")
    # In a real application, context would be injected/extracted over network requests.
    # For example, injecting into a dictionary for a mock HTTP request:
    carrier = {}
    JaegerPropagator().inject(carrier)
    print(f"Injected context: {carrier}")

print("JaegerPropagator registered and used for context injection.")