23004672494

Committed 12 Mar 2026 01:32PM UTC coverage: 88.412% (+0.8%) from 87.577%

Build # 23004672494

Build Type

push

github

Committed by

nbari

Commit Message

3.2.0

Coverage Stats

597 of 654 new or added lines in 6 files covered. (91.28%)

1 existing line in 1 file now uncovered.

3151 of 3564 relevant lines covered (88.41%)

58.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

42.34

/src/cli/telemetry.rs

use anyhow::Result;
use opentelemetry::{KeyValue, global, trace::TracerProvider as _};
use opentelemetry_otlp::WithExportConfig;
use opentelemetry_sdk::{
    Resource,
    trace::{SdkTracerProvider, Tracer},
};
use std::{
    env,
    sync::atomic::{AtomicBool, Ordering},
    time::Duration,
};
use tracing::Level;
use tracing_subscriber::{EnvFilter, Registry, fmt, layer::SubscriberExt};

static PRETTY_LOGS_ENABLED: AtomicBool = AtomicBool::new(false);

fn init_tracer() -> Result<Tracer> {
    let tracer_provider = SdkTracerProvider::builder()
        .with_batch_exporter(
            opentelemetry_otlp::SpanExporter::builder()
                .with_tonic()
                .with_timeout(Duration::from_secs(3))
                .build()?,
        )
        .with_resource(
            Resource::builder_empty()
                .with_attributes(vec![
                    KeyValue::new("service.name", env!("CARGO_PKG_NAME")),
                    KeyValue::new("service.version", env!("CARGO_PKG_VERSION")),
                ])
                .build(),
        )
        .build();

    global::set_tracer_provider(tracer_provider.clone());

    Ok(tracer_provider.tracer(env!("CARGO_PKG_NAME")))
}

fn otlp_enabled() -> bool {
    if matches!(
        env::var("OTEL_SDK_DISABLED"),
        Ok(value) if value.eq_ignore_ascii_case("true")
    ) {
        return false;
    }

    env::var_os("OTEL_EXPORTER_OTLP_ENDPOINT").is_some()
        || env::var_os("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT").is_some()
}

pub(crate) fn pretty_logs_enabled() -> bool {
    PRETTY_LOGS_ENABLED.load(Ordering::Relaxed)
}

/// Start the telemetry layer
/// # Errors
/// Will return an error if the telemetry layer fails to start
pub fn init(verbosity_level: Option<Level>, json_logs: bool) -> Result<()> {
    let verbosity_level = verbosity_level.unwrap_or(Level::ERROR);
    PRETTY_LOGS_ENABLED.store(!json_logs, Ordering::Relaxed);

    // RUST_LOG=
    let filter = EnvFilter::builder()
        .with_default_directive(verbosity_level.into())
        .from_env_lossy()
        .add_directive("hyper=error".parse()?)
        .add_directive("tokio=error".parse()?)
        .add_directive("reqwest=error".parse()?);

    if json_logs {
        let fmt_layer = fmt::layer()
            .with_file(false)
            .with_line_number(false)
            .with_thread_ids(false)
            .with_thread_names(false)
            .with_target(false)
            .json();

        let subscriber = Registry::default().with(fmt_layer).with(filter);

        if otlp_enabled() {
            let tracer = init_tracer()?;
            let otel_tracer_layer = tracing_opentelemetry::layer().with_tracer(tracer);

            return Ok(tracing::subscriber::set_global_default(
                subscriber.with(otel_tracer_layer),
            )?);
        }

        return Ok(tracing::subscriber::set_global_default(subscriber)?);
    }

    let fmt_layer = fmt::layer()
        .pretty()
        .with_file(false)
        .with_line_number(false)
        .with_thread_ids(false)
        .with_thread_names(false)
        .with_target(false);

    let subscriber = Registry::default().with(fmt_layer).with(filter);

    if otlp_enabled() {
        let tracer = init_tracer()?;
        let otel_tracer_layer = tracing_opentelemetry::layer().with_tracer(tracer);

        return Ok(tracing::subscriber::set_global_default(
            subscriber.with(otel_tracer_layer),
        )?);
    }

    Ok(tracing::subscriber::set_global_default(subscriber)?)
}

#[cfg(test)]
#[allow(clippy::panic)]
mod tests {
    use super::otlp_enabled;
    use std::sync::Mutex;

    static ENV_LOCK: Mutex<()> = Mutex::new(());

    #[test]
    fn test_otlp_disabled_by_default() {
        let _lock = match ENV_LOCK.lock() {
            Ok(lock) => lock,
            Err(error) => panic!("failed to lock env: {error}"),
        };
        unsafe {
            std::env::remove_var("OTEL_SDK_DISABLED");
            std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");
            std::env::remove_var("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT");
        }

        assert!(!otlp_enabled());
    }

    #[test]
    fn test_otlp_enabled_with_endpoint() {
        let _lock = match ENV_LOCK.lock() {
            Ok(lock) => lock,
            Err(error) => panic!("failed to lock env: {error}"),
        };
        unsafe {
            std::env::remove_var("OTEL_SDK_DISABLED");
            std::env::set_var("OTEL_EXPORTER_OTLP_ENDPOINT", "http://127.0.0.1:4317");
        }

        assert!(otlp_enabled());

        unsafe {
            std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");
        }
    }

    #[test]
    fn test_otlp_disabled_explicitly() {
        let _lock = match ENV_LOCK.lock() {
            Ok(lock) => lock,
            Err(error) => panic!("failed to lock env: {error}"),
        };
        unsafe {
            std::env::set_var("OTEL_SDK_DISABLED", "true");
            std::env::set_var("OTEL_EXPORTER_OTLP_ENDPOINT", "http://127.0.0.1:4317");
        }

        assert!(!otlp_enabled());

        unsafe {
            std::env::remove_var("OTEL_SDK_DISABLED");
            std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");
        }
    }
}

1	use anyhow::Result;
2	use opentelemetry::{KeyValue, global, trace::TracerProvider as _};
3	use opentelemetry_otlp::WithExportConfig;
4	use opentelemetry_sdk::{
5	Resource,
6	trace::{SdkTracerProvider, Tracer},
7	};
8	use std::{
9	env,
10	sync::atomic::{AtomicBool, Ordering},
11	time::Duration,
12	};
13	use tracing::Level;
14	use tracing_subscriber::{EnvFilter, Registry, fmt, layer::SubscriberExt};
15
16	static PRETTY_LOGS_ENABLED: AtomicBool = AtomicBool::new(false);
17
18	fn init_tracer() -> Result<Tracer> {	×
19	let tracer_provider = SdkTracerProvider::builder()	×
20	.with_batch_exporter(	×
21	opentelemetry_otlp::SpanExporter::builder()	×
22	.with_tonic()	×
23	.with_timeout(Duration::from_secs(3))	×
24	.build()?,	×
25	)
26	.with_resource(	×
27	Resource::builder_empty()	×
28	.with_attributes(vec![	×
29	KeyValue::new("service.name", env!("CARGO_PKG_NAME")),	×
30	KeyValue::new("service.version", env!("CARGO_PKG_VERSION")),	×
31	])
32	.build(),	×
33	)
34	.build();	×
35
36	global::set_tracer_provider(tracer_provider.clone());	×
37
38	Ok(tracer_provider.tracer(env!("CARGO_PKG_NAME")))	×
39	}	×
40
41	fn otlp_enabled() -> bool {	3✔
42	if matches!(	1✔
43	env::var("OTEL_SDK_DISABLED"),	3✔
44	Ok(value) if value.eq_ignore_ascii_case("true")	1✔
45	) {
46	return false;	1✔
47	}	2✔
48
49	env::var_os("OTEL_EXPORTER_OTLP_ENDPOINT").is_some()	2✔
50	\|\| env::var_os("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT").is_some()	1✔
51	}	3✔
52
53	pub(crate) fn pretty_logs_enabled() -> bool {	33✔
54	PRETTY_LOGS_ENABLED.load(Ordering::Relaxed)	33✔
55	}	33✔
56
57	/// Start the telemetry layer
58	/// # Errors
59	/// Will return an error if the telemetry layer fails to start
NEW 60	pub fn init(verbosity_level: Option<Level>, json_logs: bool) -> Result<()> {	×
61	let verbosity_level = verbosity_level.unwrap_or(Level::ERROR);	×
NEW 62	PRETTY_LOGS_ENABLED.store(!json_logs, Ordering::Relaxed);	×
63
64	// RUST_LOG=
65	let filter = EnvFilter::builder()	×
66	.with_default_directive(verbosity_level.into())	×
67	.from_env_lossy()	×
68	.add_directive("hyper=error".parse()?)	×
69	.add_directive("tokio=error".parse()?)	×
70	.add_directive("reqwest=error".parse()?);	×
71
NEW 72	if json_logs {	×
NEW 73	let fmt_layer = fmt::layer()	×
NEW 74	.with_file(false)	×
NEW 75	.with_line_number(false)	×
NEW 76	.with_thread_ids(false)	×
NEW 77	.with_thread_names(false)	×
NEW 78	.with_target(false)	×
NEW 79	.json();	×
80
NEW 81	let subscriber = Registry::default().with(fmt_layer).with(filter);	×
82
NEW 83	if otlp_enabled() {	×
NEW 84	let tracer = init_tracer()?;	×
NEW 85	let otel_tracer_layer = tracing_opentelemetry::layer().with_tracer(tracer);	×
86
NEW 87	return Ok(tracing::subscriber::set_global_default(	×
NEW 88	subscriber.with(otel_tracer_layer),	×
NEW 89	)?);	×
NEW 90	}	×
91
NEW 92	return Ok(tracing::subscriber::set_global_default(subscriber)?);	×
NEW 93	}	×
94
NEW 95	let fmt_layer = fmt::layer()	×
NEW 96	.pretty()	×
NEW 97	.with_file(false)	×
NEW 98	.with_line_number(false)	×
NEW 99	.with_thread_ids(false)	×
NEW 100	.with_thread_names(false)	×
NEW 101	.with_target(false);	×
102
UNCOV 103	let subscriber = Registry::default().with(fmt_layer).with(filter);	×
104
105	if otlp_enabled() {	×
106	let tracer = init_tracer()?;	×
107	let otel_tracer_layer = tracing_opentelemetry::layer().with_tracer(tracer);	×
108
109	return Ok(tracing::subscriber::set_global_default(	×
110	subscriber.with(otel_tracer_layer),	×
111	)?);	×
112	}	×
113
114	Ok(tracing::subscriber::set_global_default(subscriber)?)	×
115	}	×
116
117	#[cfg(test)]
118	#[allow(clippy::panic)]
119	mod tests {
120	use super::otlp_enabled;
121	use std::sync::Mutex;
122
123	static ENV_LOCK: Mutex<()> = Mutex::new(());
124
125	#[test]
126	fn test_otlp_disabled_by_default() {	1✔
127	let _lock = match ENV_LOCK.lock() {	1✔
128	Ok(lock) => lock,	1✔
NEW 129	Err(error) => panic!("failed to lock env: {error}"),	×
130	};
131	unsafe {	1✔
132	std::env::remove_var("OTEL_SDK_DISABLED");	1✔
133	std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");	1✔
134	std::env::remove_var("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT");	1✔
135	}	1✔
136
137	assert!(!otlp_enabled());	1✔
138	}	1✔
139
140	#[test]
141	fn test_otlp_enabled_with_endpoint() {	1✔
142	let _lock = match ENV_LOCK.lock() {	1✔
143	Ok(lock) => lock,	1✔
NEW 144	Err(error) => panic!("failed to lock env: {error}"),	×
145	};
146	unsafe {	1✔
147	std::env::remove_var("OTEL_SDK_DISABLED");	1✔
148	std::env::set_var("OTEL_EXPORTER_OTLP_ENDPOINT", "http://127.0.0.1:4317");	1✔
149	}	1✔
150
151	assert!(otlp_enabled());	1✔
152
153	unsafe {	1✔
154	std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");	1✔
155	}	1✔
156	}	1✔
157
158	#[test]
159	fn test_otlp_disabled_explicitly() {	1✔
160	let _lock = match ENV_LOCK.lock() {	1✔
161	Ok(lock) => lock,	1✔
NEW 162	Err(error) => panic!("failed to lock env: {error}"),	×
163	};
164	unsafe {	1✔
165	std::env::set_var("OTEL_SDK_DISABLED", "true");	1✔
166	std::env::set_var("OTEL_EXPORTER_OTLP_ENDPOINT", "http://127.0.0.1:4317");	1✔
167	}	1✔
168
169	assert!(!otlp_enabled());	1✔
170
171	unsafe {	1✔
172	std::env::remove_var("OTEL_SDK_DISABLED");	1✔
173	std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");	1✔
174	}	1✔
175	}	1✔
176	}

epazote / epazote / 23004672494

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous