eba4fd1
use std::sync::OnceLock;
use opentelemetry::trace::TracerProvider as _;
use opentelemetry_sdk::trace::SdkTracerProvider;
use tracing::{info, warn};
use tracing_subscriber::EnvFilter;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
/// Installed tracer provider, kept so shutdown can flush the batch processor.
static TRACER_PROVIDER: OnceLock<SdkTracerProvider> = OnceLock::new();
pub fn init_tracing() {
// The filter is installed on the registry rather than on the fmt layer so it
// governs span *creation*: without it every debug-level span in the process
// (hyper/tower internals) becomes an exported span.
let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
let subscriber = tracing_subscriber::registry()
.with(tracing_subscriber::fmt::layer())
.with(filter);
match tracer_provider() {
Some(provider) => {
let _ = TRACER_PROVIDER.set(provider.clone());
subscriber
.with(tracing_opentelemetry::layer().with_tracer(provider.tracer("gitdata")))
.init();
info!("opentelemetry trace export enabled");
}
None => subscriber.init(),
}
}
/// Traces are opt-in through the standard OTLP environment variables: setting
/// `OTEL_EXPORTER_OTLP_ENDPOINT` turns export on, anything else (including a bad
/// endpoint) only downgrades to log-only. Telemetry must never stop a host from
/// booting, so every failure path here logs and returns `None`.
fn tracer_provider() -> Option<SdkTracerProvider> {
if std::env::var("OTEL_EXPORTER_OTLP_ENDPOINT")
.unwrap_or_default()
.is_empty()
{
return None;
}
let exporter = match opentelemetry_otlp::SpanExporter::builder()
.with_http()
.build()
{
Ok(exporter) => exporter,
Err(err) => {
eprintln!("failed to build otlp span exporter, traces disabled: {err}");
return None;
}
};
Some(
SdkTracerProvider::builder()
.with_batch_exporter(exporter)
.build(),
)
}
pub async fn shutdown_signal() {
let ctrl_c = async {
if let Err(err) = tokio::signal::ctrl_c().await {
warn!(error = %err, "failed to install ctrl_c handler");
}
};
#[cfg(unix)]
let terminate = async {
use tokio::signal::unix::{SignalKind, signal};
match signal(SignalKind::terminate()) {
Ok(mut s) => {
s.recv().await;
}
Err(err) => {
warn!(error = %err, "failed to install SIGTERM handler");
}
}
};
#[cfg(not(unix))]
let terminate = std::future::pending::<()>();
tokio::select! {
_ = ctrl_c => info!("received SIGINT"),
_ = terminate => info!("received SIGTERM"),
}
flush_traces();
}
/// Drains spans queued in the batch processor. Without this the tail of every
/// deployment's trace output is lost on rollout, which is exactly when you look
/// at traces.
pub fn flush_traces() {
if let Some(provider) = TRACER_PROVIDER.get()
&& let Err(err) = provider.shutdown()
{
warn!(error = %err, "failed to flush tracer provider");
}
}