Struct TelemetryBuilder 

pub struct TelemetryBuilder { /* private fields */ }

Builder for configuring and creating a Telemetry instance.

Use this builder to combine configuration-based setup with programmatic customization. Exporters and processors added via the builder are used in addition to those specified in the configuration.

You can register telemetry providers globally using:

• with_global_tracer_provider()
• with_global_meter_provider()
• with_log_bridge()
• with_tracing_bridge()
• with_global_propagator()

Or use with_globals() to enable all of them at once.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};

let config = OpenTelemetryConfig::default();
let telemetry = Telemetry::builder(config).with_globals().build()?;

Implementations

impl TelemetryBuilder

pub fn new(config: OpenTelemetryConfig) -> Self

Create a new builder with the given configuration.

By default, nothing is registered globally. Use with_globals() to opt in to all global registrations, or individual methods to opt in selectively.

pub fn with_global_tracer_provider(self) -> Self

Register the tracer provider as the global tracer provider.

When enabled, you can use opentelemetry::global::tracer() to obtain tracers anywhere in your application.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};
use opentelemetry::global;

let telemetry = Telemetry::builder(OpenTelemetryConfig::default())
    .with_global_tracer_provider()
    .build()?;

// Now you can get tracers from anywhere
let tracer = global::tracer("my-component");

pub fn with_global_meter_provider(self) -> Self

Register the meter provider as the global meter provider.

When enabled, you can use opentelemetry::global::meter() to obtain meters anywhere in your application.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};
use opentelemetry::global;

let telemetry = Telemetry::builder(OpenTelemetryConfig::default())
    .with_global_meter_provider()
    .build()?;

// Now you can get meters from anywhere
let meter = global::meter("my-component");

pub fn with_global_propagator(self) -> Self

Register the propagator configuration as the global text map propagator.

When enabled, tower middleware such as http_server_propagation() and http_client_propagation() automatically use the configured propagator.

pub fn with_globals(self) -> Self

Enable all global registrations at once.

Equivalent to calling with_global_tracer_provider(), with_global_meter_provider(), with_log_bridge(), with_tracing_bridge(), and with_global_propagator().

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};

let telemetry = Telemetry::builder(OpenTelemetryConfig::default())
    .with_globals()
    .build()?;

pub fn with_log_bridge(self) -> Self

Enable the log bridge to route log crate macros to OpenTelemetry.

When enabled, calls to log::info!(), log::error!(), etc. will be exported as OpenTelemetry log records through the configured logger provider.

The bridge respects the RUST_LOG environment variable for filtering. If RUST_LOG is not set, defaults to info level.

Note: This sets the global logger, so it can only be called once per process. Calling build() will fail if another logger is already installed.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};

let telemetry = Telemetry::builder(OpenTelemetryConfig::default())
    .with_log_bridge()
    .build()?;

// Now log macros are routed to OpenTelemetry
log::info!("This goes to OpenTelemetry");

pub fn with_tracing_bridge(self) -> Self

Enable the tracing bridge to route tracing crate spans and events to OpenTelemetry.

When enabled, tracing::info!(), tracing::span!(), etc. will be exported as OpenTelemetry log records and traces through the configured providers.

The bridge respects the RUST_LOG environment variable for filtering. If RUST_LOG is not set, defaults to info level.

Note: This sets the global tracing subscriber, so it can only be called once per process. Calling build() will fail if another subscriber is already installed.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};

let telemetry = Telemetry::builder(OpenTelemetryConfig::logs_to_stderr())
    .with_tracing_bridge()
    .build()?;

// Now tracing macros are routed to OpenTelemetry
tracing::info!("This goes to OpenTelemetry");

pub fn with_resource_builder(self, builder: ResourceBuilder) -> Self

Set the resource builder for configuring resource attributes.

Resource attributes provide identifying information about the entity producing telemetry (e.g., service name, version, deployment environment).

Attributes from the builder are merged with any resource configuration from the config file. On conflicts, builder values take precedence, allowing you to override specific attributes like service.name while keeping other config-defined attributes.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};
use opentelemetry_sdk::Resource;
use opentelemetry::KeyValue;

let telemetry = Telemetry::builder(OpenTelemetryConfig::default())
    .with_resource_builder(
        Resource::builder()
            .with_service_name("my-service")
            .with_attributes([
                KeyValue::new("service.version", "1.0.0"),
                KeyValue::new("deployment.environment", "production"),
            ])
    )
    .build()?;

pub fn with_span_processor<T: SpanProcessor + 'static>( self, processor: T, ) -> Self

Add a custom span processor to the tracer provider.

Span processors receive spans as they are started and ended, allowing for custom processing logic such as filtering, enrichment, or routing to multiple exporters.

This is added in addition to any processors configured via the configuration file.

pub fn with_batch_span_exporter<T: SpanExporter + 'static>( self, exporter: T, ) -> Self

Add a span exporter with batch processing.

Batch processing buffers spans and exports them in batches, which is more efficient for production use. This is the recommended approach for most applications.

This is added in addition to any exporters configured via the configuration file.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};
use opentelemetry_otlp::SpanExporter;

let exporter = SpanExporter::builder()
    .with_http()
    .with_endpoint("http://localhost:4318")
    .build()
    .unwrap();

let telemetry = Telemetry::builder(OpenTelemetryConfig::default())
    .with_batch_span_exporter(exporter)
    .build()
    .unwrap();

pub fn with_simple_span_exporter<T: SpanExporter + 'static>( self, exporter: T, ) -> Self

Add a span exporter with simple (synchronous) processing.

Simple processing exports spans immediately as they complete. This is useful for development and debugging but may impact performance in production.

This is added in addition to any exporters configured via the configuration file.

pub fn with_view<F>(self, view: F) -> Self

where F: Fn(&Instrument) -> Option<Stream> + Send + Sync + 'static,

Add a metric view for customizing metric aggregation.

Views allow you to customize how metrics are collected and reported. The view function receives instrument metadata and can return a Stream configuration to modify the instrument’s behavior.

Return Some(Stream) to apply customizations, or None to use the default behavior.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};
use opentelemetry_sdk::metrics::{Instrument, Stream};

let telemetry = Telemetry::builder(OpenTelemetryConfig::default())
    .with_view(|instrument: &Instrument| {
        // Customize high-cardinality metrics
        if instrument.name().contains("debug") {
            Some(Stream::default())
        } else {
            None // Use default behavior
        }
    })
    .build()?;

pub fn with_periodic_reader<E>(self, reader: PeriodicReader<E>) -> Self

where E: PushMetricExporter,

Add a periodic reader for push-based metric export.

A PeriodicReader collects metrics at regular intervals and pushes them to the configured exporter. Use PeriodicReaderBuilder for custom interval and timeout settings.

This is added in addition to any readers configured via the configuration file.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};
use opentelemetry_sdk::metrics::PeriodicReader;
use opentelemetry_otlp::MetricExporter;
use std::time::Duration;

let exporter = MetricExporter::builder().with_http().build()?;
let reader = PeriodicReader::builder(exporter)
    .with_interval(Duration::from_secs(30))
    .build();

let telemetry = Telemetry::builder(OpenTelemetryConfig::default())
    .with_periodic_reader(reader)
    .build()?;

pub fn with_batch_log_exporter<T>(self, exporter: T) -> Self

where T: LogExporter + 'static,

Add a log exporter with batch processing.

Batch processing buffers log records and exports them in batches, which is more efficient for production use.

This is added in addition to any exporters configured via the configuration file.

pub fn with_simple_log_exporter<T>(self, exporter: T) -> Self

where T: LogExporter + 'static,

Add a log exporter with simple (synchronous) processing.

Simple processing exports log records immediately. This is useful for development and debugging but may impact performance in production.

This is added in addition to any exporters configured via the configuration file.

pub fn build(self) -> Result<Telemetry, InitError>

Build the Telemetry instance.

This initializes the OpenTelemetry providers based on the configuration and any programmatic customizations. Providers are only created if they are configured or have programmatic additions.

Errors

Returns an error if exporter initialization fails (e.g., invalid endpoint, missing credentials, or required feature not enabled).