OpenTelemetry OTLP

https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/
Admin
OpenTelemetry OTLP is a Rust exporter crate that implements the OpenTelemetry Protocol for exporting...
Tokens:79,029
Snippets:784
Trust Score:9.1
Update:1 week ago
Show doc for...
Tokens:
Raw
### Example: with_compression

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/trait.WithTonicConfig.html

Shows how to set Gzip compression on a tonic-based span exporter builder.

```rust
use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
let exporter_builder = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_compression(opentelemetry_otlp::Compression::Gzip);
```

--------------------------------

### Run Prometheus with OTLP receiver

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Starts Prometheus with the OTLP receiver enabled, listening on port 9090. An empty prometheus.yml file is sufficient for this example.

```bash
docker run -p 9090:9090 -v ./prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus --config.file=/etc/prometheus/prometheus.yml --web.enable-otlp-receiver
```

--------------------------------

### Example: Multiple interceptors (chaining)

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/trait.WithTonicConfig.html

Shows how to chain multiple interceptors by wrapping them in a combined interceptor before passing to `with_interceptor`.

```rust
use tonic::{Request, Status};
use opentelemetry_otlp::WithTonicConfig;

fn auth_interceptor(mut req: Request<()>) -> Result<Request<()>, Status> {
    req.metadata_mut().insert("authorization", "Bearer token".parse().unwrap());
    Ok(req)
}

fn logging_interceptor(req: Request<()>) -> Result<Request<()>, Status> {
    println!("Sending gRPC request with metadata: {:?}", req.metadata());
    Ok(req)
}

// Chain interceptors by wrapping them
fn combined_interceptor(req: Request<()>) -> Result<Request<()>, Status> {
    let req = logging_interceptor(req)?;
    auth_interceptor(req)
}

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_interceptor(combined_interceptor)
    .build()?;
```

--------------------------------

### Example: with_metadata

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/trait.WithTonicConfig.html

Shows how to add custom metadata entries. The method is additive; calling it multiple times merges entries, with later values overriding earlier ones for the same key.

```rust
use tonic::metadata::MetadataMap;
use opentelemetry_otlp::WithTonicConfig;

let mut metadata1 = MetadataMap::new();
metadata1.insert("key1", "value1".parse().unwrap());

let mut metadata2 = MetadataMap::new();
metadata2.insert("key2", "value2".parse().unwrap());

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_metadata(metadata1)  // Adds key1=value1
    .with_metadata(metadata2)  // Adds key2=value2 (both are present)
    .build()?;
```

--------------------------------

### Example: using WithHttpConfig with SpanExporter builder

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/trait.WithHttpConfig.html

Shows how to use the `WithHttpConfig` trait to set headers on an OTLP span exporter builder. Requires importing `WithHttpConfig`.

```rust
use crate::opentelemetry_otlp::WithHttpConfig;
let exporter_builder = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_headers(std::collections::HashMap::new());
```

--------------------------------

### Configure OTLP exporters for traces, metrics, and logs in Rust

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Builds SpanExporter, MetricExporter, and LogExporter with Tonic, setting endpoint and timeout, then creates SDK providers with batch or periodic exporters. Requires the opentelemetry_otlp and opentelemetry_sdk crates. The example uses a shared resource with service name 'my-service'.

```rust
use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
use opentelemetry_sdk::{
    trace::SdkTracerProvider,
    metrics::SdkMeterProvider,
    logs::SdkLoggerProvider,
    Resource,
};
use std::time::Duration;

let resource = Resource::builder()
    .with_service_name("my-service")
    .build();

// Traces
let span_exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_endpoint("http://my-collector:4317")
    .with_timeout(Duration::from_secs(5))
    .build()
    .expect("Failed to build SpanExporter");
let tracer_provider = SdkTracerProvider::builder()
    .with_resource(resource.clone())
    .with_batch_exporter(span_exporter)
    .build();

// Metrics
let metric_exporter = opentelemetry_otlp::MetricExporter::builder()
    .with_tonic()
    .with_endpoint("http://my-collector:4317")
    .with_timeout(Duration::from_secs(5))
    .build()
    .expect("Failed to build MetricExporter");
let meter_provider = SdkMeterProvider::builder()
    .with_resource(resource.clone())
    .with_periodic_exporter(metric_exporter)
    .build();

// Logs
let log_exporter = opentelemetry_otlp::LogExporter::builder()
    .with_tonic()
    .with_endpoint("http://my-collector:4317")
    .with_timeout(Duration::from_secs(5))
    .build()
    .expect("Failed to build LogExporter");
let logger_provider = SdkLoggerProvider::builder()
    .with_resource(resource)
    .with_batch_exporter(log_exporter)
    .build();
```

--------------------------------

### Configure TLS for gRPC exporter (with_tls_config, ClientTlsConfig)

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Shows how to set up TLS for a gRPC OTLP exporter using `with_tls_config` with a `ClientTlsConfig`. Requires the `tls-ring` or `tls-aws-lc` feature, optionally `tls-roots` or `tls-webpki-roots` for automatic CA roots. The example sets a domain name and shows commented-out options for CA certificate and client identity for mTLS.

```rust
use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
use opentelemetry_otlp::tonic_types::transport::ClientTlsConfig;

let tls = ClientTlsConfig::new()
    .domain_name("my-collector.example.com")
    // Optionally verify the server with a CA certificate:
    // .ca_certificate(tonic::transport::Certificate::from_pem(CA_PEM))
    // Or present a client identity for mutual TLS (mTLS):
    // .identity(tonic::transport::Identity::from_pem(CERT_PEM, KEY_PEM))
    ;

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_endpoint("https://my-collector.example.com:4317")
    .with_tls_config(tls)
    .build()
    .expect("Failed to build SpanExporter");
```

--------------------------------

### Configure gRPC OTLP exporter without tokio::main

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Sets up a SpanExporter using gRPC (Tonic) without the #[tokio::main] attribute by manually creating a Tokio runtime and blocking on the async setup. The runtime must remain active until the program ends.

```rust
use opentelemetry::{global, trace::Tracer};

fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    // Initialize OTLP exporter using gRPC (Tonic)
    let rt = tokio::runtime::Runtime::new()?;
    let tracer_provider = rt.block_on(async {
        let exporter = opentelemetry_otlp::SpanExporter::builder()
            .with_tonic()
            .build()
            .expect("Failed to create span exporter");
        opentelemetry_sdk::trace::SdkTracerProvider::builder()
            .with_batch_exporter(exporter)
            .build()
    });

    // Set it as the global provider
    global::set_tracer_provider(tracer_provider);

    // Get a tracer and create spans
    let tracer = global::tracer("my_tracer");
    tracer.in_span("doing_work", |_cx| {
        // Your application logic here...
    });

    // Ensure the runtime (`rt`) remains active until the program ends
    Ok(())
}
```

--------------------------------

### Run OpenTelemetry Collector for HTTP transport (port 4318)

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Starts the OpenTelemetry Collector container listening on port 4318 for HTTP OTLP traffic.

```bash
$ docker run -p 4318:4318 otel/opentelemetry-collector:latest
```

--------------------------------

### Configure gRPC retry policy (with_retry_policy, RetryPolicy)

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Shows how to customize the retry policy for failed exports using `with_retry_policy`. The default policy uses exponential backoff and jitter; this example sets max retries, initial delay, max delay, and max jitter.

```rust
use opentelemetry_otlp::{WithTonicConfig, RetryPolicy};
use std::time::Duration;

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_retry_policy(
        RetryPolicy::default()
            .with_max_retries(5)
            .with_initial_delay(Duration::from_millis(500))
            .with_max_delay(Duration::from_secs(30))
            .with_max_jitter(Duration::from_millis(100)),
    )
    .build()
    .expect("Failed to build SpanExporter");
```

--------------------------------

### Example: Setting Endpoint on SpanExporter Builder

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/trait.WithExportConfig.html

Shows how to use WithExportConfig to set the endpoint on a SpanExporter builder. Requires importing WithExportConfig and using with_tonic() before with_endpoint().

```rust
use crate::opentelemetry_otlp::WithExportConfig;
let exporter_builder = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_endpoint("http://localhost:7201");
```

--------------------------------

### Example: Single interceptor

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/trait.WithTonicConfig.html

Shows how to use a single interceptor to modify outbound gRPC requests, e.g., to inject auth tokens. Calling `with_interceptor` multiple times replaces the previous interceptor.

```rust
use tonic::{Request, Status};
use opentelemetry_otlp::WithTonicConfig;

fn auth_interceptor(mut req: Request<()>) -> Result<Request<()>, Status> {
    req.metadata_mut().insert("authorization", "Bearer token".parse().unwrap());
    Ok(req)
}

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_interceptor(auth_interceptor)
    .build()?;
```

--------------------------------

### HTTP — all configuration options

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Shows how to configure an OTLP HTTP exporter with endpoint, timeout, protocol, headers, compression, and max request body size using the builder methods.

```APIDOC
## HTTP — all configuration options

### Description
Configure an OTLP HTTP exporter with all available options: endpoint, timeout, protocol, headers, compression, and max request body size.

### Methods
- `with_endpoint` - Sets the target URL, used verbatim. Defaults to `http://localhost:4318/v1/traces`.
- `with_timeout` - Sets per-export timeout. Defaults to 10 s.
- `with_protocol` - Sets transport encoding. `HttpBinary` (protobuf) is default; `HttpJson` requires `http-json` feature.
- `with_headers` - Sets custom HTTP headers. Values are URL-decoded when read from environment variables.
- `with_compression` - Sets compression. Requires `gzip-http` or `zstd-http` feature.
- `with_max_request_body_size` - Sets maximum serialized HTTP request size before and after compression. Defaults to 64 MiB.

### Example
```rust
use opentelemetry_otlp::{WithExportConfig, WithHttpConfig, Protocol, Compression};
use std::time::Duration;
use std::collections::HashMap;

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_endpoint("http://my-collector:4318/v1/traces")
    .with_timeout(Duration::from_secs(5))
    .with_protocol(Protocol::HttpBinary)
    .with_headers(HashMap::from([
        ("x-api-key".to_string(), "secret".to_string()),
    ]))
    .with_compression(Compression::Gzip)
    .with_max_request_body_size(64 * 1024 * 1024)
    .build()
    .expect("Failed to build SpanExporter");
```

### Environment Variables
- `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` - Used verbatim.
- `OTEL_EXPORTER_OTLP_ENDPOINT` - Base URL, appends `/v1/traces` automatically.
- `OTEL_EXPORTER_OTLP_TRACES_TIMEOUT` or `OTEL_EXPORTER_OTLP_TIMEOUT` - Timeout.
- `OTEL_EXPORTER_OTLP_PROTOCOL` - Protocol.
- `OTEL_EXPORTER_OTLP_TRACES_HEADERS` or `OTEL_EXPORTER_OTLP_HEADERS` - Headers.
- `OTEL_EXPORTER_OTLP_TRACES_COMPRESSION` or `OTEL_EXPORTER_OTLP_COMPRESSION` - Compression.
```

--------------------------------

### Run OpenTelemetry Collector for gRPC transport (port 4317)

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Starts the OpenTelemetry Collector container listening on port 4317 for gRPC OTLP traffic.

```bash
$ docker run -p 4317:4317 otel/opentelemetry-collector:latest
```

--------------------------------

### Configure gRPC OTLP exporter with tokio::main

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Sets up a SpanExporter using gRPC (Tonic) inside an async main with #[tokio::main]. Requires a Tokio runtime.

```rust
use opentelemetry::{global, trace::Tracer};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    // Initialize OTLP exporter using gRPC (Tonic)
    let otlp_exporter = opentelemetry_otlp::SpanExporter::builder()
        .with_tonic()
        .build()?;

    // Create a tracer provider with the exporter
    let tracer_provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
        .with_batch_exporter(otlp_exporter)
        .build();

    // Set it as the global provider
    global::set_tracer_provider(tracer_provider);

    // Get a tracer and create spans
    let tracer = global::tracer("my_tracer");
    tracer.in_span("doing_work", |_cx| {
        // Your application logic here...
    });

    Ok(())
}
```

--------------------------------

### WithTonicConfig::with_interceptor

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/struct.LogExporterBuilder.html?search=

Uses a custom interceptor to modify each outbound request. This can be used to modify the gRPC metadata, for example to inject auth tokens. Available on crate feature `grpc-tonic` only.

```APIDOC
## with_interceptor

### Description
Uses a custom interceptor to modify each outbound request. This can be used to modify the gRPC metadata, for example to inject auth tokens. Available on crate feature `grpc-tonic` only.

### Method
with_interceptor

### Signature
fn with_interceptor<I>(self, interceptor: I) -> B where I: Interceptor + Clone + Send + Sync + 'static

### Parameters
- **interceptor** (I: Interceptor + Clone + Send + Sync + 'static) - Required - The interceptor to use.

### Returns
- **B** - The builder instance with interceptor configured.
```

--------------------------------

### SpanExporter::builder().with_http() - All Configuration Options

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to configure an OTLP HTTP exporter with endpoint, timeout, protocol, headers, compression, and max request body size.

```APIDOC
## SpanExporter::builder().with_http()

### Description
Configures an OTLP HTTP exporter with all available options: endpoint, timeout, protocol, headers, compression, and max request body size.

### Method
Builder method chain

### Parameters
- **with_endpoint** (string) - Required - Target URL used verbatim, including signal path (e.g., /v1/traces). Defaults to http://localhost:4318/v1/traces.
- **with_timeout** (Duration) - Optional - Per-export timeout. Defaults to 10 s.
- **with_protocol** (Protocol) - Optional - Transport encoding. HttpBinary (protobuf) is default; HttpJson requires `http-json` feature.
- **with_headers** (HashMap<String, String>) - Optional - Custom HTTP headers. Values are URL-decoded when read from environment variables.
- **with_compression** (Compression) - Optional - Compression algorithm. Requires `gzip-http` or `zstd-http` feature.
- **with_max_request_body_size** (usize) - Optional - Maximum serialized HTTP request size before and after compression. Defaults to 64 MiB.

### Request Example
```rust
use opentelemetry_otlp::{WithExportConfig, WithHttpConfig, Protocol, Compression};
use std::time::Duration;
use std::collections::HashMap;

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_endpoint("http://my-collector:4318/v1/traces")
    .with_timeout(Duration::from_secs(5))
    .with_protocol(Protocol::HttpBinary)
    .with_headers(HashMap::from([
        ("x-api-key".to_string(), "secret".to_string()),
    ]))
    .with_compression(Compression::Gzip)
    .with_max_request_body_size(64 * 1024 * 1024)
    .build()
    .expect("Failed to build SpanExporter");
```

### Response
Returns a `SpanExporter` instance on success, or an error if building fails.
```

--------------------------------

### Run Jaeger with OTLP support

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Starts a Jaeger container with OTLP support on ports 16686 (UI) and 4317 (gRPC). After running your application, view traces at http://localhost:16686.

```bash
$ docker run -p 16686:16686 -p 4317:4317 jaegertracing/jaeger:latest
```

--------------------------------

### Configure OTLP HTTP exporter with all options

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Shows all configuration options for the OTLP HTTP exporter using `SpanExporter`. Requires the `http-proto` (default) or `http-json` feature. Methods come from `WithExportConfig` and `WithHttpConfig`. Defaults: endpoint `http://localhost:4318/v1/traces`, timeout 10s, protocol HttpBinary, max request body size 64 MiB. Environment variables override settings.

```rust
use opentelemetry_otlp::{WithExportConfig, WithHttpConfig, Protocol, Compression};
use std::time::Duration;
use std::collections::HashMap;

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    // Target URL, used verbatim: include the signal path, e.g. /v1/traces.
    // OTEL_EXPORTER_OTLP_TRACES_ENDPOINT is also used verbatim.
    // OTEL_EXPORTER_OTLP_ENDPOINT is a base URL and appends /v1/traces automatically.
    // Defaults to http://localhost:4318/v1/traces.
    .with_endpoint("http://my-collector:4318/v1/traces")
    // Per-export timeout. Defaults to 10 s.
    // Env var: OTEL_EXPORTER_OTLP_TRACES_TIMEOUT (or OTEL_EXPORTER_OTLP_TIMEOUT).
    .with_timeout(Duration::from_secs(5))
    // Transport encoding. HttpBinary (protobuf) is the default.
    // HttpJson requires the `http-json` feature.
    // Env var: OTEL_EXPORTER_OTLP_PROTOCOL.
    .with_protocol(Protocol::HttpBinary)
    // Custom HTTP headers (auth tokens, routing headers, …).
    // Values are URL-decoded when read from environment variables.
    // Env var: OTEL_EXPORTER_OTLP_TRACES_HEADERS (or OTEL_EXPORTER_OTLP_HEADERS).
    .with_headers(HashMap::from([
        ("x-api-key".to_string(), "secret".to_string()),
    ]))
    // Compression. Requires the `gzip-http` or `zstd-http` feature.
    // Env var: OTEL_EXPORTER_OTLP_TRACES_COMPRESSION (or OTEL_EXPORTER_OTLP_COMPRESSION).
    .with_compression(Compression::Gzip)
    // Maximum serialized HTTP request size before and after compression.
    // Defaults to the OTLP-recommended 64 MiB.
    .with_max_request_body_size(64 * 1024 * 1024)
    .build()
    .expect("Failed to build SpanExporter");
```

--------------------------------

### with_interceptor

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/trait.WithTonicConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Uses a custom interceptor to modify each outbound request, for example to inject auth tokens. Calling this method multiple times replaces the previous interceptor; chain interceptors together before passing.

```APIDOC
## with_interceptor

### Description
Uses a custom interceptor to modify each outbound request, for example to inject auth tokens. Calling this method multiple times replaces the previous interceptor; chain interceptors together before passing.

### Method
with_interceptor

### Signature
fn with_interceptor<I>(self, interceptor: I) -> Self
where I: Interceptor + Clone + Send + Sync + 'static

### Parameters
- **interceptor** (I) - Required - Interceptor to modify outbound requests. Must implement Interceptor, Clone, Send, Sync, and 'static.

### Returns
Self - The builder with the interceptor applied.

### Example
```rust
use tonic::{Request, Status};
use opentelemetry_otlp::WithTonicConfig;

fn auth_interceptor(mut req: Request<()>) -> Result<Request<()>, Status> {
    req.metadata_mut().insert("authorization", "Bearer token".parse().unwrap());
    Ok(req)
}

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_interceptor(auth_interceptor)
    .build()?;
```
```

--------------------------------

### Configure gRPC exporter with all options (with_tonic, with_endpoint, with_timeout, with_metadata, with_compression)

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Shows how to build a `SpanExporter` with gRPC transport, setting endpoint, timeout, metadata, and compression. Requires the `grpc-tonic` feature and optionally `gzip-tonic` or `zstd-tonic` for compression. Defaults: endpoint `http://localhost:4317`, timeout 10s. Environment variables override: `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, `OTEL_EXPORTER_OTLP_TRACES_TIMEOUT`, `OTEL_EXPORTER_OTLP_TRACES_HEADERS`, `OTEL_EXPORTER_OTLP_TRACES_COMPRESSION` (or the non-traces variants). `with_metadata` is additive.

```rust
use opentelemetry_otlp::{WithExportConfig, WithTonicConfig, Compression};
use std::time::Duration;
use tonic::metadata::MetadataMap;

// ── gRPC metadata (custom request headers) ───────────────────────────────
// MetadataMap carries per-call key/value pairs sent as HTTP/2 headers.
// with_metadata() is additive: calling it multiple times merges entries.
let mut metadata = MetadataMap::with_capacity(3);
metadata.insert("x-host", "example.com".parse().unwrap());
metadata.insert("x-api-key", "secret".parse().unwrap());
metadata.insert_bin("trace-proto-bin", tonic::metadata::MetadataValue::from_bytes(b"[bin]"));

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    // Target gRPC endpoint. Defaults to http://localhost:4317.
    // Env var: OTEL_EXPORTER_OTLP_TRACES_ENDPOINT (or OTEL_EXPORTER_OTLP_ENDPOINT).
    .with_endpoint("http://my-collector:4317")
    // Per-export timeout. Defaults to 10 s.
    // Env var: OTEL_EXPORTER_OTLP_TRACES_TIMEOUT (or OTEL_EXPORTER_OTLP_TIMEOUT).
    .with_timeout(Duration::from_secs(5))
    // Custom gRPC metadata (auth tokens, routing headers, …).
    // Env var: OTEL_EXPORTER_OTLP_TRACES_HEADERS (or OTEL_EXPORTER_OTLP_HEADERS).
    .with_metadata(metadata)
    // Compression. Requires the `gzip-tonic` or `zstd-tonic` feature.
    // Env var: OTEL_EXPORTER_OTLP_TRACES_COMPRESSION (or OTEL_EXPORTER_OTLP_COMPRESSION).
    .with_compression(Compression::Gzip)
    .build()
    .expect("Failed to build SpanExporter");
```

--------------------------------

### LogExporterBuilder::new

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/struct.LogExporterBuilder.html?search=

Creates a new LogExporterBuilder with default settings.

```APIDOC
## LogExporterBuilder::new

### Description
Creates a new LogExporterBuilder with default settings.

### Method
new

### Signature
pub fn new() -> Self

### Parameters
None

### Returns
- **Self** - A new LogExporterBuilder instance with no transport set.

```

--------------------------------

### Configure HTTP OTLP exporter for traces in Rust

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Sets up a SpanExporter using HTTP binary protocol, creates a tracer provider with batch exporter, and sets it as global. Use for traces; swap with MetricExporter or LogExporter for other signals.

```rust
use opentelemetry::global;
use opentelemetry::trace::Tracer;
use opentelemetry_otlp::Protocol;
use opentelemetry_otlp::WithExportConfig;

fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    // Initialize OTLP exporter using HTTP binary protocol
    let otlp_exporter = opentelemetry_otlp::SpanExporter::builder()
        .with_http()
        .with_protocol(Protocol::HttpBinary)
        .build()?;

    // Create a tracer provider with the exporter
    let tracer_provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
        .with_batch_exporter(otlp_exporter)
        .build();

    // Set it as the global provider
    global::set_tracer_provider(tracer_provider);

    // Get a tracer and create spans
    let tracer = global::tracer("my_tracer");
    tracer.in_span("doing_work", |_cx| {
        // Your application logic here...
    });

    Ok(())
}
```

--------------------------------

### with_tonic() builder configuration

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html?search=u32+-%3E+bool

Configures the OTLP exporter to use gRPC (tonic) transport with endpoint, timeout, metadata, and compression.

```APIDOC
## with_tonic() builder configuration

### Description
Configures the OTLP exporter to use gRPC (tonic) transport with endpoint, timeout, metadata, and compression.

### Method
Builder method

### Endpoint
N/A (builder configuration)

### Parameters
- **with_endpoint** (string) - Optional - Target gRPC endpoint. Defaults to http://localhost:4317. Env var: OTEL_EXPORTER_OTLP_TRACES_ENDPOINT (or OTEL_EXPORTER_OTLP_ENDPOINT).
- **with_timeout** (Duration) - Optional - Per-export timeout. Defaults to 10 s. Env var: OTEL_EXPORTER_OTLP_TRACES_TIMEOUT (or OTEL_EXPORTER_OTLP_TIMEOUT).
- **with_metadata** (MetadataMap) - Optional - Custom gRPC metadata (auth tokens, routing headers, …). Additive: calling multiple times merges entries. Env var: OTEL_EXPORTER_OTLP_TRACES_HEADERS (or OTEL_EXPORTER_OTLP_HEADERS).
- **with_compression** (Compression) - Optional - Compression. Requires the `gzip-tonic` or `zstd-tonic` feature. Env var: OTEL_EXPORTER_OTLP_TRACES_COMPRESSION (or OTEL_EXPORTER_OTLP_COMPRESSION).

### Request Example
```rust
use opentelemetry_otlp::{WithExportConfig, WithTonicConfig, Compression};
use std::time::Duration;
use tonic::metadata::MetadataMap;

let mut metadata = MetadataMap::with_capacity(3);
metadata.insert("x-host", "example.com".parse().unwrap());
metadata.insert("x-api-key", "secret".parse().unwrap());
metadata.insert_bin("trace-proto-bin", tonic::metadata::MetadataValue::from_bytes(b"[bin]"));

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_endpoint("http://my-collector:4317")
    .with_timeout(Duration::from_secs(5))
    .with_metadata(metadata)
    .with_compression(Compression::Gzip)
    .build()
    .expect("Failed to build SpanExporter");
```

### Response
#### Success Response
- **exporter** (SpanExporter) - The configured exporter.

#### Response Example
```rust
let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_endpoint("http://my-collector:4317")
    .with_timeout(Duration::from_secs(5))
    .with_metadata(metadata)
    .with_compression(Compression::Gzip)
    .build()
    .expect("Failed to build SpanExporter");
```
```

--------------------------------

### Custom HTTP client for OTLP exporter

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Shows how to supply a custom HTTP client to the OTLP exporter. By default, a `reqwest` blocking client is used. The client must implement `opentelemetry_http::HttpClient`. Avoid async clients with default batch processors or periodic reader.

```rust
use opentelemetry_otlp::WithHttpConfig;

// reqwest async client (requires the `reqwest-client` feature)
let http_client = reqwest::Client::builder()
    .timeout(std::time::Duration::from_secs(5))
    // .danger_accept_invalid_certs(true) // for testing only
    .build()
    .expect("Failed to build reqwest client");

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_http_client(http_client)
    .build()
    .expect("Failed to build SpanExporter");
```

--------------------------------

### MetricExporterBuilder::new

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/struct.MetricExporterBuilder.html?search=

Creates a new MetricExporterBuilder with default settings.

```APIDOC
## MetricExporterBuilder::new

### Description
Creates a new MetricExporterBuilder with default settings.

### Method
Constructor

### Signature
```rust
pub fn new() -> Self
```

### Parameters
None

### Returns
- `Self` - A new MetricExporterBuilder instance.

```

--------------------------------

### with_endpoint

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html?search=

Sets the target URL for the OTLP HTTP exporter. The URL is used verbatim and should include the signal path (e.g., /v1/traces). Defaults to http://localhost:4318/v1/traces.

```APIDOC
## with_endpoint

### Description
Sets the target URL for the OTLP HTTP exporter. The URL is used verbatim and should include the signal path (e.g., /v1/traces). Defaults to http://localhost:4318/v1/traces.

### Method
Builder method

### Parameters
- **endpoint** (string) - Required - The full URL including the signal path.

### Request Example
```rust
.with_endpoint("http://my-collector:4318/v1/traces")
```

### Response
Returns the builder for chaining.
```

--------------------------------

### with_compression

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Sets the compression algorithm for gRPC requests. Requires the `gzip-tonic` or `zstd-tonic` feature. Can be overridden by the OTEL_EXPORTER_OTLP_TRACES_COMPRESSION or OTEL_EXPORTER_OTLP_COMPRESSION environment variables.

```APIDOC
## with_compression

### Description
Sets the compression algorithm for gRPC requests. Requires the `gzip-tonic` or `zstd-tonic` feature. Can be overridden by the OTEL_EXPORTER_OTLP_TRACES_COMPRESSION or OTEL_EXPORTER_OTLP_COMPRESSION environment variables.

### Method
Builder method

### Endpoint
N/A (SDK builder method)

### Parameters
- **compression** (Compression) - Required - The compression algorithm (e.g., Compression::Gzip).

### Request Example
```rust
.with_compression(Compression::Gzip)
```

### Response
#### Success Response
Returns the builder instance for chaining.

#### Response Example
```rust
let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_compression(Compression::Gzip)
    .build()
    .expect("Failed to build SpanExporter");
```
```

--------------------------------

### with_compression

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html?search=

Sets the compression algorithm for the HTTP request body. Requires the `gzip-http` or `zstd-http` feature. Can be overridden by environment variables OTEL_EXPORTER_OTLP_TRACES_COMPRESSION or OTEL_EXPORTER_OTLP_COMPRESSION.

```APIDOC
## with_compression

### Description
Sets the compression algorithm for the HTTP request body. Requires the `gzip-http` or `zstd-http` feature. Can be overridden by environment variables OTEL_EXPORTER_OTLP_TRACES_COMPRESSION or OTEL_EXPORTER_OTLP_COMPRESSION.

### Method
Builder method

### Parameters
- **compression** (Compression) - Required - The compression algorithm (e.g., Gzip).

### Request Example
```rust
.with_compression(Compression::Gzip)
```

### Response
Returns the builder for chaining.
```

--------------------------------

### RetryPolicy::recommended()

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/struct.RetryPolicy.html?search=

Returns the recommended policy: 3 retries with exponential backoff (100ms initial, 1600ms maximum, and up to 100ms jitter).

```APIDOC
## RetryPolicy::recommended()

### Description
Returns the recommended policy: 3 retries with exponential backoff (100ms initial, 1600ms maximum, and up to 100ms jitter).

### Method
Constructor

### Signature
rust
pub fn recommended() -> Self


### Parameters
None

### Returns
- **Self** - A RetryPolicy with recommended settings.

### Example
rust
let policy = RetryPolicy::recommended();

```

--------------------------------

### Custom HTTP client

Source: https://docs.rs/opentelemetry-otlp/latest/opentelemetry_otlp/index.html

Shows how to supply a custom HTTP client to control TLS, proxies, connection pooling, etc. The client must implement the `opentelemetry_http::HttpClient` trait.

```APIDOC
## Custom HTTP client

### Description
Supply your own HTTP client to control TLS, proxies, connection pooling, etc. The client must implement the `opentelemetry_http::HttpClient` trait.

### Method
- `with_http_client` - Sets a custom HTTP client.

### Example
```rust
use opentelemetry_otlp::WithHttpConfig;

let http_client = reqwest::Client::builder()
    .timeout(std::time::Duration::from_secs(5))
    .build()
    .expect("Failed to build reqwest client");

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_http_client(http_client)
    .build()
    .expect("Failed to build SpanExporter");
```

### Notes
- Default client is `reqwest` blocking client (`reqwest-blocking-client` feature, enabled by default).
- Async clients (`reqwest-client`, `hyper-client`) should not be used with default batch processors or periodic reader.
```
Tokens:
Raw