main
use opentelemetry::global;
use opentelemetry_sdk::logs::SdkLoggerProvider;
use opentelemetry_sdk::metrics::SdkMeterProvider;
use opentelemetry_sdk::trace::SdkTracerProvider;
use super::config::TelemetryConfig;
use super::error::TelemetryError;
use super::{logs, metrics, propagation, resource, subscriber, traces};
#[derive(Debug, Clone)]
pub struct Telemetry {
tracer_provider: SdkTracerProvider,
meter_provider: SdkMeterProvider,
logger_provider: SdkLoggerProvider,
warnings: Vec<String>,
}
impl Telemetry {
pub fn tracer_provider(&self) -> &SdkTracerProvider {
&self.tracer_provider
}
pub fn meter_provider(&self) -> &SdkMeterProvider {
&self.meter_provider
}
pub fn logger_provider(&self) -> &SdkLoggerProvider {
&self.logger_provider
}
pub fn warnings(&self) -> &[String] {
&self.warnings
}
pub fn force_flush(&self) -> Result<(), TelemetryError> {
first_error([
self.tracer_provider
.force_flush()
.map_err(TelemetryError::exporter),
self.meter_provider
.force_flush()
.map_err(TelemetryError::exporter),
self.logger_provider
.force_flush()
.map_err(TelemetryError::exporter),
])
}
pub fn shutdown(&self) -> Result<(), TelemetryError> {
first_error([
self.tracer_provider
.shutdown()
.map_err(TelemetryError::shutdown),
self.meter_provider
.shutdown()
.map_err(TelemetryError::shutdown),
self.logger_provider
.shutdown()
.map_err(TelemetryError::shutdown),
])
}
pub fn guard(&self) -> TelemetryGuard<'_> {
TelemetryGuard { telemetry: self }
}
}
pub struct TelemetryGuard<'a> {
telemetry: &'a Telemetry,
}
impl Drop for TelemetryGuard<'_> {
fn drop(&mut self) {
if let Err(error) = self.telemetry.shutdown() {
tracing::warn!(%error, "flushing telemetry failed");
}
}
}
fn first_error(errors: [Result<(), TelemetryError>; 3]) -> Result<(), TelemetryError> {
match errors.into_iter().find(Result::is_err) {
Some(error) => error,
None => Ok(()),
}
}
pub fn install(config: &TelemetryConfig) -> Telemetry {
let resource = resource::build(config);
let mut warnings = Vec::new();
let tracer_provider = traces::build(config, resource.clone(), &mut warnings);
let meter_provider = metrics::build(config, resource.clone(), &mut warnings);
let logger_provider = logs::build(config, resource, &mut warnings);
global::set_tracer_provider(tracer_provider.clone());
global::set_meter_provider(meter_provider.clone());
propagation::install();
Telemetry {
tracer_provider,
meter_provider,
logger_provider,
warnings,
}
}
pub fn init(config: &TelemetryConfig) -> Telemetry {
let telemetry = install(config);
subscriber::install(config, &telemetry);
telemetry
}