Crate opentelemetry_otlp 

OpenTelemetry OTLP Exporter

The OTLP Exporter enables exporting telemetry data (logs, metrics, and traces) in the OpenTelemetry Protocol (OTLP) format to compatible backends. These backends include:

• OpenTelemetry Collector
• Open-source observability tools (Prometheus, Jaeger, etc.)
• Vendor-specific monitoring platforms

This crate supports sending OTLP data via:

• gRPC
• HTTP (binary protobuf or JSON)

Quickstart with OpenTelemetry Collector

The examples below show traces, but the same pattern applies to metrics (MetricExporter) and logs (LogExporter) — just swap the exporter builder and the corresponding SDK provider.

HTTP Transport (Port 4318)

Run the OpenTelemetry Collector:

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

Configure your application to export traces via HTTP:

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(())
}

gRPC Transport (Port 4317)

Run the OpenTelemetry Collector:

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

Configure your application to export traces via gRPC (the tonic client requires a Tokio runtime):

• With [tokio::main]

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(())
}

• Without [tokio::main]

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(())
}

Using with Jaeger

Jaeger natively supports the OTLP protocol, making it easy to send traces directly:

$ docker run -p 16686:16686 -p 4317:4317 -e COLLECTOR_OTLP_ENABLED=true jaegertracing/all-in-one:latest

After running your application configured with the OTLP exporter, view traces at: http://localhost:16686

Using with Prometheus

Prometheus natively supports accepting metrics via the OTLP protocol (HTTP/protobuf). You can run Prometheus with the following command:

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

(An empty prometheus.yml file is sufficient for this example.)

Modify your application to export metrics via OTLP:

use opentelemetry::global;
use opentelemetry::metrics::Meter;
use opentelemetry::KeyValue;
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 exporter = opentelemetry_otlp::MetricExporter::builder()
        .with_http()
        .with_protocol(Protocol::HttpBinary)
        .with_endpoint("http://localhost:9090/api/v1/otlp/v1/metrics")
        .build()?;

    // Create a meter provider with the OTLP Metric exporter
    let meter_provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder()
        .with_periodic_exporter(exporter)
        .build();
    global::set_meter_provider(meter_provider.clone());

    // Get a meter
    let meter = global::meter("my_meter");

    // Create a metric
    let counter = meter.u64_counter("my_counter").build();
    counter.add(1, &[KeyValue::new("key", "value")]);

    // Shutdown the meter provider. This will trigger an export of all metrics.
    meter_provider.shutdown()?;

    Ok(())
}

After running your application configured with the OTLP exporter, view metrics at: http://localhost:9090

Environment Variables

The OTLP exporter respects the following environment variables, as defined by the OpenTelemetry specification. Programmatic configuration via builder methods takes precedence over environment variables. Signal-specific variables take precedence over the generic OTEL_EXPORTER_OTLP_* variables.

General (all signals)

Variable	Description	Default
OTEL_EXPORTER_OTLP_ENDPOINT	Target URL for the exporter. For HTTP, signal paths (/v1/traces, /v1/metrics, /v1/logs) are appended automatically.	http://localhost:4318 (HTTP), http://localhost:4317 (gRPC)
OTEL_EXPORTER_OTLP_PROTOCOL	Transport protocol. Valid values: grpc, http/protobuf, http/json. Requires the corresponding crate feature.	Feature-dependent
OTEL_EXPORTER_OTLP_TIMEOUT	Maximum wait time (in milliseconds) for the backend to process each batch.	10000
OTEL_EXPORTER_OTLP_HEADERS	Key-value pairs for request headers. Format: key1=value1,key2=value2. Values are URL-decoded.	(none)
OTEL_EXPORTER_OTLP_COMPRESSION	Compression algorithm. Valid values: gzip, zstd.	(none)

Traces

Variable	Description
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT	Signal-specific endpoint for trace exports.
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL	Signal-specific protocol for trace exports. Valid values: grpc, http/protobuf, http/json.
OTEL_EXPORTER_OTLP_TRACES_TIMEOUT	Signal-specific timeout (in milliseconds) for trace exports.
OTEL_EXPORTER_OTLP_TRACES_HEADERS	Signal-specific headers for trace exports.
OTEL_EXPORTER_OTLP_TRACES_COMPRESSION	Signal-specific compression for trace exports.

Metrics

Variable	Description
OTEL_EXPORTER_OTLP_METRICS_ENDPOINT	Signal-specific endpoint for metrics exports.
OTEL_EXPORTER_OTLP_METRICS_PROTOCOL	Signal-specific protocol for metrics exports. Valid values: grpc, http/protobuf, http/json.
OTEL_EXPORTER_OTLP_METRICS_TIMEOUT	Signal-specific timeout (in milliseconds) for metrics exports.
OTEL_EXPORTER_OTLP_METRICS_HEADERS	Signal-specific headers for metrics exports.
OTEL_EXPORTER_OTLP_METRICS_COMPRESSION	Signal-specific compression for metrics exports.
OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE	Temporality preference for metrics. Valid values: cumulative, delta, lowmemory (case-insensitive).

Logs

Variable	Description
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT	Signal-specific endpoint for log exports.
OTEL_EXPORTER_OTLP_LOGS_PROTOCOL	Signal-specific protocol for log exports. Valid values: grpc, http/protobuf, http/json.
OTEL_EXPORTER_OTLP_LOGS_TIMEOUT	Signal-specific timeout (in milliseconds) for log exports.
OTEL_EXPORTER_OTLP_LOGS_HEADERS	Signal-specific headers for log exports.
OTEL_EXPORTER_OTLP_LOGS_COMPRESSION	Signal-specific compression for log exports.

Feature Flags

The following feature flags can enable exporters for different telemetry signals:

• trace: Includes the trace exporters.
• metrics: Includes the metrics exporters.
• logs: Includes the logs exporters.

The following feature flags generate additional code and types:

• serialize: Enables serialization support for type defined in this crate via serde.

The following feature flags offer additional configurations on gRPC:

For users using tonic as grpc layer:

• grpc-tonic: Use tonic as grpc layer.
• gzip-tonic: Use gzip compression for tonic grpc layer.
• zstd-tonic: Use zstd compression for tonic grpc layer.
• tls-ring: Enable rustls TLS support using ring for tonic.
• tls-aws-lc: Enable rustls TLS support using aws-lc for tonic.
• tls-provider-agnostic: Provider-agnostic TLS — enables TLS code paths without bundling a specific crypto provider. Use this when you install a CryptoProvider globally (e.g., via rustls-openssl for FIPS/OpenSSL environments).
• tls (deprecated): Use tls-ring or tls-aws-lc instead.
• tls-roots: Adds system trust roots to rustls-based gRPC clients using the rustls-native-certs crate (use with tls-ring or tls-aws-lc).
• tls-webpki-roots: Embeds Mozilla’s trust roots to rustls-based gRPC clients using the webpki-roots crate (use with tls-ring or tls-aws-lc).

The following feature flags offer additional configurations on http:

• http-proto: Use http as transport layer, protobuf as body format. This feature is enabled by default.
• gzip-http: Use gzip compression for HTTP transport.
• zstd-http: Use zstd compression for HTTP transport.
• reqwest-blocking-client: Use reqwest blocking http client. This feature is enabled by default.
• reqwest-client: Use reqwest http client.
• reqwest-rustls: Use reqwest with TLS with system trust roots via rustls-native-certs crate.
• reqwest-rustls-webpki-roots: Use reqwest with TLS with Mozilla’s trust roots via webpki-roots crate.

The following feature flags enable experimental retry support:

• experimental-grpc-retry: Enable automatic retry with exponential backoff for gRPC exports. Requires a Tokio runtime (rt-tokio SDK feature is enabled transitively).
• experimental-http-retry: Enable automatic retry with exponential backoff for HTTP exports. Requires a Tokio runtime (rt-tokio SDK feature is enabled transitively).

Full Configuration Reference

There are two layers of configuration for the OTLP exporter:

1. Exporter configuration – controls how telemetry is sent (endpoint, transport, headers, TLS, compression, timeout). Built via the signal-specific builder: SpanExporter::builder(), MetricExporter::builder(), LogExporter::builder().
2. Provider/SDK configuration – controls how telemetry is collected and batched (sampling, batch size, resource, etc.). Built via opentelemetry_sdk::trace::SdkTracerProvider::builder(), opentelemetry_sdk::metrics::SdkMeterProvider::builder(), or opentelemetry_sdk::logs::SdkLoggerProvider::builder().

Configuration precedence (highest wins):

1. Programmatic configuration via builder methods — always wins when set
2. Signal-specific environment variables (e.g. OTEL_EXPORTER_OTLP_TRACES_ENDPOINT) — used when no programmatic value is set
3. Generic environment variables (e.g. OTEL_EXPORTER_OTLP_ENDPOINT) — used when neither programmatic nor signal-specific env var is set
4. Built-in defaults — used when nothing else is configured

gRPC (tonic) — all configuration options

Requires the grpc-tonic feature. The methods below come from two traits:

• WithExportConfig: with_endpoint, with_timeout (shared with HTTP)
• WithTonicConfig: with_metadata, with_compression, with_tls_config, with_channel, with_interceptor

The examples here use SpanExporter, but the same builder methods are available on MetricExporter and LogExporter.

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");

TLS (grpc-tonic)

Requires the tls-ring or tls-aws-lc feature (plus optionally tls-roots or tls-webpki-roots to load CA roots automatically).

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");

Pre-built tonic channel

Use with_channel when you need full control over the transport (e.g. Unix sockets, custom load-balancing). Note: with_channel overrides any TLS config set via with_tls_config, and you are responsible for matching the channel timeout to the exporter timeout.

use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
use std::time::Duration;

let channel = tonic::transport::Channel::from_static("http://localhost:4317")
    .timeout(Duration::from_secs(5))
    .connect_lazy();

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_channel(channel)
    .with_timeout(Duration::from_secs(5)) // keep in sync with channel timeout above
    .build()
    .expect("Failed to build SpanExporter");

gRPC interceptors

Use with_interceptor to modify every outbound gRPC request — useful for injecting auth tokens or dynamic metadata. Only one interceptor can be set; chain multiple together before passing them in.

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

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

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_interceptor(auth_interceptor)
    .build()
    .expect("Failed to build SpanExporter");

gRPC retry policy

Requires the experimental-grpc-retry feature. When enabled, failed exports are retried with exponential backoff and jitter. Without this feature, failed exports are not retried.

use opentelemetry_otlp::{WithTonicConfig, RetryPolicy};

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_tonic()
    .with_retry_policy(RetryPolicy {
        max_retries: 5,        // number of attempts after the first failure
        initial_delay_ms: 500, // delay before the first retry
        max_delay_ms: 30_000,  // cap on the delay between retries
        jitter_ms: 100,        // upper bound for random jitter added by the exporter
    })
    .build()
    .expect("Failed to build SpanExporter");

HTTP — all configuration options

Requires the http-proto (default) or http-json feature. The methods below come from:

• WithExportConfig: with_endpoint, with_timeout, with_protocol
• WithHttpConfig: with_headers, with_compression, with_http_client

The examples here use SpanExporter, but the same builder methods are available on MetricExporter and LogExporter.

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

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    // Target base URL. Defaults to http://localhost:4318.
    // The path /v1/traces (or /v1/metrics, /v1/logs) is appended automatically.
    // Env var: OTEL_EXPORTER_OTLP_TRACES_ENDPOINT (or OTEL_EXPORTER_OTLP_ENDPOINT).
    .with_endpoint("http://my-collector:4318")
    // 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)
    .build()
    .expect("Failed to build SpanExporter");

Custom HTTP client

By default the exporter uses a reqwest blocking client (reqwest-blocking-client feature, enabled by default). Supply your own client to control TLS, proxies, connection pooling, etc. The client must implement the opentelemetry_http::HttpClient trait.

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");

HTTP retry policy

Requires the experimental-http-retry feature. When enabled, failed exports are retried with exponential backoff and jitter. Without this feature, failed exports are not retried.

use opentelemetry_otlp::{WithHttpConfig, RetryPolicy};

let exporter = opentelemetry_otlp::SpanExporter::builder()
    .with_http()
    .with_retry_policy(RetryPolicy {
        max_retries: 5,        // number of attempts after the first failure
        initial_delay_ms: 500, // delay before the first retry
        max_delay_ms: 30_000,  // cap on the delay between retries
        jitter_ms: 100,        // upper bound for random jitter added by the exporter
    })
    .build()
    .expect("Failed to build SpanExporter");

All three signals (Traces, Metrics, Logs)

The same exporter configuration options apply to all three signals. The only differences are:

• The builder entry point: SpanExporter::builder(), MetricExporter::builder(), LogExporter::builder()
• The signal-specific environment variables (e.g. OTEL_EXPORTER_OTLP_TRACES_* vs OTEL_EXPORTER_OTLP_METRICS_*)
• Metrics has an additional OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE variable

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();

Re-exports

pub use retry::RetryPolicy;experimental-http-retry or experimental-grpc-retry

Modules

retrygrpc-tonic or experimental-http-retry

Retry logic for exporting telemetry data. This module provides functionality for retrying operations with exponential backoff and jitter.

retry_classificationgrpc-tonic or experimental-http-retry

Error classification for OTLP exporters with protocol-specific throttling support.

tonic_typesgrpc-tonic

Re-exported types from the tonic crate.

Structs

HttpExporterBuilderhttp-proto or http-json

Configuration for the OTLP HTTP exporter.

HttpExporterBuilderSethttp-proto or http-json

Type to hold the HttpExporterBuilder and indicate it has been set.

LogExporterlogs and (http-proto or http-json or grpc-tonic)

OTLP exporter that sends log data

LogExporterBuilderlogs and (http-proto or http-json or grpc-tonic)

Builder for creating a new LogExporter.

MetricExportermetrics and (http-proto or http-json or grpc-tonic)

Export metrics in OTEL format.

MetricExporterBuildermetrics and (http-proto or http-json or grpc-tonic)

A builder for creating a new MetricExporter.

NoExporterBuilderSet

Type to indicate the builder does not have a client set.

SpanExportertrace and (http-proto or http-json or grpc-tonic)

OTLP exporter that sends tracing data

SpanExporterBuildertrace and (http-proto or http-json or grpc-tonic)

OTLP span exporter builder

TonicExporterBuildergrpc-tonic

Configuration for the tonic OTLP GRPC exporter.

TonicExporterBuilderSetgrpc-tonic

Type to hold the TonicExporterBuilder and indicate it has been set.

Enums

Compression

The compression algorithm to use when sending data.

ExporterBuildError

Errors that can occur while building an exporter.

Protocol

The communication protocol to use when exporting data.

Constants

OTEL_EXPORTER_OTLP_COMPRESSION

Compression algorithm to use, defaults to none.

OTEL_EXPORTER_OTLP_ENDPOINT

Target to which the exporter is going to send signals, defaults to https://localhost:4317. Learn about the relationship between this constant and metrics/spans/logs at https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#endpoint-urls-for-otlphttp

OTEL_EXPORTER_OTLP_ENDPOINT_DEFAULT

Default target to which the exporter is going to send signals.

OTEL_EXPORTER_OTLP_HEADERS

Key-value pairs to be used as headers associated with gRPC or HTTP requests Example: k1=v1,k2=v2 Note: as of now, this is only supported for HTTP requests.

OTEL_EXPORTER_OTLP_LOGS_COMPRESSIONlogs and (http-proto or http-json or grpc-tonic)

Compression algorithm to use, defaults to none.

OTEL_EXPORTER_OTLP_LOGS_ENDPOINTlogs and (http-proto or http-json or grpc-tonic)

Target to which the exporter is going to send logs

OTEL_EXPORTER_OTLP_LOGS_HEADERSlogs and (http-proto or http-json or grpc-tonic)

Key-value pairs to be used as headers associated with gRPC or HTTP requests for sending logs. Example: k1=v1,k2=v2 Note: this is only supported for HTTP.

OTEL_EXPORTER_OTLP_LOGS_PROTOCOLlogs and (http-proto or http-json or grpc-tonic)

Protocol to use for log exports. Valid values: grpc, http/protobuf, http/json.

OTEL_EXPORTER_OTLP_LOGS_TIMEOUTlogs and (http-proto or http-json or grpc-tonic)

Maximum time the OTLP exporter will wait for each batch logs export.

OTEL_EXPORTER_OTLP_METRICS_COMPRESSIONmetrics and (http-proto or http-json or grpc-tonic)

Compression algorithm to use, defaults to none.

OTEL_EXPORTER_OTLP_METRICS_ENDPOINTmetrics and (http-proto or http-json or grpc-tonic)

Target to which the exporter is going to send metrics, defaults to https://localhost:4317/v1/metrics. Learn about the relationship between this constant and default/spans/logs at https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#endpoint-urls-for-otlphttp

OTEL_EXPORTER_OTLP_METRICS_HEADERSmetrics and (http-proto or http-json or grpc-tonic)

Key-value pairs to be used as headers associated with gRPC or HTTP requests for sending metrics. Example: k1=v1,k2=v2 Note: this is only supported for HTTP.

OTEL_EXPORTER_OTLP_METRICS_PROTOCOLmetrics and (http-proto or http-json or grpc-tonic)

Protocol to use for metrics exports. Valid values: grpc, http/protobuf, http/json.

OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCEmetrics and (http-proto or http-json or grpc-tonic)

Temporality preference for metrics, defaults to cumulative.

OTEL_EXPORTER_OTLP_METRICS_TIMEOUTmetrics and (http-proto or http-json or grpc-tonic)

Max waiting time for the backend to process each metrics batch, defaults to 10s.

OTEL_EXPORTER_OTLP_PROTOCOL

Protocol the exporter will use. Either http/protobuf or grpc.

OTEL_EXPORTER_OTLP_PROTOCOL_GRPC

Protocol value for gRPC

OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_JSON

Protocol value for HTTP with JSON encoding

OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_PROTOBUF

Protocol value for HTTP with protobuf encoding

OTEL_EXPORTER_OTLP_TIMEOUT

Max waiting time for the backend to process each signal batch, defaults to 10 seconds.

OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT

Default max waiting time for the backend to process each signal batch.

OTEL_EXPORTER_OTLP_TRACES_COMPRESSIONtrace and (http-proto or http-json or grpc-tonic)

Compression algorithm to use, defaults to none.

OTEL_EXPORTER_OTLP_TRACES_ENDPOINTtrace and (http-proto or http-json or grpc-tonic)

Target to which the exporter is going to send spans, defaults to https://localhost:4317/v1/traces. Learn about the relationship between this constant and default/metrics/logs at https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#endpoint-urls-for-otlphttp

OTEL_EXPORTER_OTLP_TRACES_HEADERStrace and (http-proto or http-json or grpc-tonic)

Key-value pairs to be used as headers associated with gRPC or HTTP requests for sending spans. Example: k1=v1,k2=v2 Note: this is only supported for HTTP.

OTEL_EXPORTER_OTLP_TRACES_PROTOCOLtrace and (http-proto or http-json or grpc-tonic)

Protocol to use for trace exports. Valid values: grpc, http/protobuf, http/json.

OTEL_EXPORTER_OTLP_TRACES_TIMEOUTtrace and (http-proto or http-json or grpc-tonic)

Max waiting time for the backend to process each spans batch, defaults to 10s.

Traits

WithExportConfig

Expose methods to set export configuration on exporter builders.

WithHttpConfighttp-proto or http-json

Expose methods to override HTTP-specific configuration.

WithTonicConfiggrpc-tonic

Expose methods to override tonic-specific configuration.