Struct Telemetry 

pub struct Telemetry { /* private fields */ }

Unified telemetry management for traces, metrics, and logs.

This struct holds the OpenTelemetry providers and ensures proper shutdown when dropped. Create an instance at application startup and keep it alive for the duration of your application.

Lifecycle

• Create at application startup using Telemetry::new() or Telemetry::builder()
• Keep the instance alive (e.g., in your main function or as application state)
• Providers automatically shut down when Telemetry is dropped
• For explicit shutdown control, call Telemetry::shutdown()

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};

// Initialize at startup
let telemetry = Telemetry::new(OpenTelemetryConfig::default())?;

// Access providers if needed
if let Some(tracer_provider) = telemetry.tracer_provider() {
    // Use the tracer provider directly
}

// Telemetry shuts down automatically when dropped

Implementations

impl Telemetry

pub fn none() -> Self

Create a no-op telemetry instance with no providers or output.

This returns a Telemetry instance that does nothing: no providers are created, no global providers are set, and no data is exported. This is useful for:

• Tests: When you need a Telemetry instance but don’t want actual telemetry overhead or output.
• Disabled telemetry: When you want to completely disable telemetry without going through configuration parsing.

pub fn builder(config: OpenTelemetryConfig) -> TelemetryBuilder

Create a builder for configuring telemetry.

Use the builder when you need to add custom exporters, processors, or views programmatically.

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};

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

pub fn new(config: OpenTelemetryConfig) -> Result<Self, InitError>

Create telemetry with full integration from configuration.

This method sets up OpenTelemetry with all integrations enabled:

• Global tracer provider: Enables opentelemetry::global::tracer() anywhere
• Global meter provider: Enables opentelemetry::global::meter() anywhere
• Log bridge: Routes log::info!() etc. to OpenTelemetry logs
• Tracing bridge: Routes tracing::info!() etc. to OpenTelemetry logs

This is the recommended way to initialize telemetry for most applications, as it provides seamless integration with the Rust logging ecosystem.

When to use builder() instead

Use Telemetry::builder() if you need:

• Custom exporters or processors
• To disable specific bridges (e.g., if you have your own tracing subscriber)
• Fine-grained control over which integrations are enabled

Effects on your application

• Sets the global logger: Only one logger can be set per process. This will fail if another logger (e.g., env_logger) is already installed.
• Sets the global tracing subscriber: Only one subscriber can be set per process. This will fail if another subscriber is already installed.
• Filters apply: Both bridges respect RUST_LOG for filtering (defaults to info).

Example

use apollo_opentelemetry::{OpenTelemetryConfig, Telemetry};

let config = OpenTelemetryConfig::default();
let telemetry = Telemetry::new(config)?;

// Now all logging goes through OpenTelemetry
log::info!("This becomes an OpenTelemetry log record");

pub fn tracer_provider(&self) -> Option<&SdkTracerProvider>

Get a reference to the tracer provider, if tracing is enabled.

Returns None if no tracer configuration was provided and no span exporters were added programmatically.

pub fn meter_provider(&self) -> Option<&SdkMeterProvider>

Get a reference to the meter provider, if metrics are enabled.

Returns None if no meter configuration was provided and no metric views were added programmatically.

pub fn logger_provider(&self) -> Option<&SdkLoggerProvider>

Get a reference to the logger provider, if logging is enabled.

Returns None if no logger configuration was provided and no log exporters were added programmatically.

pub fn shutdown(&mut self)

Explicitly shut down all telemetry providers.

This flushes any buffered telemetry data and releases resources. It is called automatically when the Telemetry instance is dropped, but can be called explicitly for more control over shutdown timing.

If the providers were registered as global providers, the global provider will continue to reference the shut-down provider, which will act as a no-op for any subsequent operations.

After calling shutdown(), the providers are no longer available and subsequent calls to tracer_provider(), meter_provider(), and logger_provider() will return None.

Trait Implementations

impl Drop for Telemetry

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.