> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/open-telemetry/opentelemetry-rust/llms.txt
> Use this file to discover all available pages before exploring further.

# opentelemetry-jaeger-propagator

> Jaeger trace context propagation for OpenTelemetry

# opentelemetry-jaeger-propagator

**Version:** 0.31.0

The `opentelemetry-jaeger-propagator` crate provides the Jaeger propagation format for distributing trace context across service boundaries.

<Note>
  **For exporting traces to Jaeger**, use the [OTLP exporter](/api/opentelemetry-otlp) instead. Jaeger natively supports OTLP since version 1.35. This crate is specifically for **propagation format compatibility** with existing Jaeger deployments.
</Note>

## Installation

```toml theme={null}
[dependencies]
opentelemetry-jaeger-propagator = "0.31"
```

### Feature Flags

* `internal-logs`: Enable internal logging (enabled by default)

## What is Jaeger Propagation?

Jaeger propagation uses the **B3 propagation format** to transmit trace context via HTTP headers. This allows services instrumented with different SDKs to maintain trace continuity.

### B3 Header Formats

**Single Header (b3):**

```
b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
```

**Multiple Headers (X-B3-\*):**

```
X-B3-TraceId: {TraceId}
X-B3-SpanId: {SpanId}
X-B3-ParentSpanId: {ParentSpanId}
X-B3-Sampled: {SamplingState}
```

## Quick Start

### Set as Global Propagator

```rust theme={null}
use opentelemetry::global;
use opentelemetry_jaeger_propagator::Propagator;

// Set Jaeger propagator as global
global::set_text_map_propagator(Propagator::new());
```

### Sending Requests

```rust theme={null}
use opentelemetry::{global, trace::{Tracer, TraceContextExt}, Context};
use std::collections::HashMap;

let tracer = global::tracer("my-service");
let span = tracer.start("send_request");
let cx = Context::current_with_span(span);

// Inject context into HTTP headers
let mut headers = HashMap::new();
global::get_text_map_propagator(|propagator| {
    propagator.inject_context(&cx, &mut headers);
});

// headers now contains: b3: {trace-id}-{span-id}-1
// Send request with headers...
```

### Receiving Requests

```rust theme={null}
use opentelemetry::{global, trace::Tracer};
use std::collections::HashMap;

let headers: HashMap<String, String> = /* incoming headers */;

// Extract parent context from headers
let parent_cx = global::get_text_map_propagator(|propagator| {
    propagator.extract(&headers)
});

// Create child span with extracted parent
let tracer = global::tracer("my-service");
let span = tracer
    .span_builder("handle_request")
    .start_with_context(&tracer, &parent_cx);
```

## Core Types

<ParamField path="Propagator" type="struct">
  Jaeger/B3 trace context propagator
</ParamField>

```rust theme={null}
use opentelemetry_jaeger_propagator::Propagator;

// Create with default settings (multiple headers)
let propagator = Propagator::new();

// Or create with custom header name
let propagator = Propagator::with_custom_header("custom-trace-header");
```

## Configuration

### Default Propagator

Uses multiple B3 headers (`X-B3-*`):

```rust theme={null}
use opentelemetry_jaeger_propagator::Propagator;

let propagator = Propagator::new();
// Reads/writes: X-B3-TraceId, X-B3-SpanId, X-B3-Sampled, X-B3-ParentSpanId
```

### Custom Header Name

Use a custom header name:

```rust theme={null}
use opentelemetry_jaeger_propagator::Propagator;

let propagator = Propagator::with_custom_header("my-trace-header");
// Reads/writes: my-trace-header: {trace-id}-{span-id}-{sampled}
```

## Complete Example

### HTTP Client

```rust theme={null}
use opentelemetry::{global, trace::{Tracer, TraceContextExt}, Context};
use opentelemetry_jaeger_propagator::Propagator;
use std::collections::HashMap;

// Setup
global::set_text_map_propagator(Propagator::new());

let tracer = global::tracer("http-client");

// Before sending request
let mut span = tracer.start("GET /api/users");
let cx = Context::current_with_span(span);

let mut headers = HashMap::new();
global::get_text_map_propagator(|propagator| {
    propagator.inject_context(&cx, &mut headers);
});

// Send HTTP request with headers
// GET /api/users
// X-B3-TraceId: 80f198ee56343ba864fe8b2a57d3eff7
// X-B3-SpanId: e457b5a2e4d86bd1
// X-B3-Sampled: 1
```

### HTTP Server

```rust theme={null}
use opentelemetry::{global, trace::Tracer};
use opentelemetry_jaeger_propagator::Propagator;
use std::collections::HashMap;

// Setup
global::set_text_map_propagator(Propagator::new());

fn handle_request(headers: HashMap<String, String>) {
    // Extract parent context
    let parent_cx = global::get_text_map_propagator(|propagator| {
        propagator.extract(&headers)
    });

    // Create span with parent context
    let tracer = global::tracer("http-server");
    let span = tracer
        .span_builder("handle_request")
        .start_with_context(&tracer, &parent_cx);
    
    // Process request with active span...
}
```

## Integration with HTTP Frameworks

### With opentelemetry-http

```rust theme={null}
use opentelemetry::{global, trace::Tracer};
use opentelemetry_http::{HeaderExtractor, HeaderInjector};
use opentelemetry_jaeger_propagator::Propagator;
use http::HeaderMap;

// Set propagator
global::set_text_map_propagator(Propagator::new());

// Extract from HTTP request
let headers: HeaderMap = /* ... */;
let parent_cx = global::get_text_map_propagator(|propagator| {
    propagator.extract(&HeaderExtractor(&headers))
});

// Inject into HTTP request
let mut headers = HeaderMap::new();
let cx = /* current context */;
global::get_text_map_propagator(|propagator| {
    propagator.inject_context(&cx, &mut HeaderInjector(&mut headers));
});
```

## When to Use Jaeger Propagator

<CardGroup cols={2}>
  <Card title="Legacy Systems" icon="clock-rotate-left">
    Interoperating with services using Jaeger's B3 format
  </Card>

  <Card title="Mixed Environments" icon="network-wired">
    Services using different instrumentation libraries
  </Card>

  <Card title="Migration" icon="arrow-right-arrow-left">
    Transitioning from Jaeger to OpenTelemetry
  </Card>

  <Card title="Compatibility" icon="handshake">
    Need to maintain compatibility with existing Jaeger infrastructure
  </Card>
</CardGroup>

## Alternative Propagators

OpenTelemetry supports multiple propagation formats:

* **W3C Trace Context** (recommended): `opentelemetry::propagation::TraceContextPropagator`
* **W3C Baggage**: `opentelemetry_sdk::propagation::BaggagePropagator`
* **Jaeger**: This crate
* **Zipkin B3**: `opentelemetry_zipkin::Propagator`

```rust theme={null}
use opentelemetry::global;
use opentelemetry_sdk::propagation::TraceContextPropagator;

// Use W3C Trace Context (recommended for new deployments)
global::set_text_map_propagator(TraceContextPropagator::new());
```

## Composite Propagators

Use multiple propagators for compatibility:

```rust theme={null}
use opentelemetry::{global, propagation::TextMapCompositePropagator};
use opentelemetry_sdk::propagation::{
    TraceContextPropagator, 
    BaggagePropagator
};
use opentelemetry_jaeger_propagator::Propagator as JaegerPropagator;

let composite = TextMapCompositePropagator::new(vec![
    Box::new(TraceContextPropagator::new()),
    Box::new(BaggagePropagator::new()),
    Box::new(JaegerPropagator::new()),
]);

global::set_text_map_propagator(composite);
```

## Exporting to Jaeger

<Warning>
  This crate only handles **propagation**. To export traces to Jaeger, use the [OTLP exporter](/api/opentelemetry-otlp):
</Warning>

```rust theme={null}
use opentelemetry::global;
use opentelemetry_otlp::SpanExporter;
use opentelemetry_jaeger_propagator::Propagator;

// Propagator for context propagation
global::set_text_map_propagator(Propagator::new());

// OTLP exporter for sending traces to Jaeger
let exporter = SpanExporter::builder()
    .with_tonic()
    .with_endpoint("http://localhost:4317") // Jaeger OTLP endpoint
    .build()?;

let provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
    .with_batch_exporter(exporter)
    .build();
```

## Related Crates

* **[opentelemetry](/api/opentelemetry)** - Core API with propagation traits
* **[opentelemetry-otlp](/api/opentelemetry-otlp)** - Export to Jaeger via OTLP
* **[opentelemetry-http](/api/opentelemetry-http)** - HTTP propagation helpers
* **[opentelemetry-zipkin](/api/opentelemetry-zipkin)** - Zipkin exporter with B3 propagator

## Documentation

<Card title="Full API Documentation" icon="book" href="https://docs.rs/opentelemetry-jaeger-propagator/0.31.0">
  View complete API reference on docs.rs
</Card>

<Card title="Jaeger Propagation Format" icon="arrow-up-right-from-square" href="https://www.jaegertracing.io/docs/1.18/client-libraries/#propagation-format">
  Official Jaeger propagation documentation
</Card>

## Minimum Rust Version

**MSRV:** 1.75.0