22927139061

Committed 10 Mar 2026 10:27PM UTC coverage: 83.979% (-0.5%) from 84.429%

Build # 22927139061

Build Type

push

github

Committed by

nbari

Commit Message

3.0.4

Coverage Stats

76 of 109 new or added lines in 3 files covered. (69.72%)

1 existing line in 1 file now uncovered.

1887 of 2247 relevant lines covered (83.98%)

87.86 hits per line

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

47.5

/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, time::Duration};
use tracing::Level;
use tracing_subscriber::{EnvFilter, Registry, fmt, layer::SubscriberExt};

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()
}

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

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

    // 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()?);

    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)]
mod tests {
    use super::otlp_enabled;

    #[test]
    fn test_otlp_disabled_by_default() {
        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() {
        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() {
        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::{env, time::Duration};
9	use tracing::Level;
10	use tracing_subscriber::{EnvFilter, Registry, fmt, layer::SubscriberExt};
11
12	fn init_tracer() -> Result<Tracer> {	×
13	let tracer_provider = SdkTracerProvider::builder()	×
14	.with_batch_exporter(	×
15	opentelemetry_otlp::SpanExporter::builder()	×
16	.with_tonic()	×
17	.with_timeout(Duration::from_secs(3))	×
18	.build()?,	×
19	)
20	.with_resource(	×
21	Resource::builder_empty()	×
22	.with_attributes(vec![	×
23	KeyValue::new("service.name", env!("CARGO_PKG_NAME")),	×
24	KeyValue::new("service.version", env!("CARGO_PKG_VERSION")),	×
25	])
26	.build(),	×
27	)
28	.build();	×
29
30	global::set_tracer_provider(tracer_provider.clone());	×
31
32	Ok(tracer_provider.tracer(env!("CARGO_PKG_NAME")))	×
33	}	×
34
35	fn otlp_enabled() -> bool {	3✔
36	if matches!(	1✔
37	env::var("OTEL_SDK_DISABLED"),	3✔
38	Ok(value) if value.eq_ignore_ascii_case("true")	1✔
39	) {
40	return false;	1✔
41	}	2✔
42
43	env::var_os("OTEL_EXPORTER_OTLP_ENDPOINT").is_some()	2✔
44	\|\| env::var_os("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT").is_some()	1✔
45	}	3✔
46
47	/// Start the telemetry layer
48	/// # Errors
49	/// Will return an error if the telemetry layer fails to start
50	pub fn init(verbosity_level: Option<Level>) -> Result<()> {	×
51	let verbosity_level = verbosity_level.unwrap_or(Level::ERROR);	×
52
53	let fmt_layer = fmt::layer()	×
UNCOV 54	.with_file(false)	×
55	.with_line_number(false)	×
56	.with_thread_ids(false)	×
57	.with_thread_names(false)	×
58	.with_target(false)	×
59	.json();	×
60
61	// RUST_LOG=
62	let filter = EnvFilter::builder()	×
63	.with_default_directive(verbosity_level.into())	×
64	.from_env_lossy()	×
65	.add_directive("hyper=error".parse()?)	×
66	.add_directive("tokio=error".parse()?)	×
67	.add_directive("reqwest=error".parse()?);	×
68
NEW 69	let subscriber = Registry::default().with(fmt_layer).with(filter);	×
70
NEW 71	if otlp_enabled() {	×
NEW 72	let tracer = init_tracer()?;	×
NEW 73	let otel_tracer_layer = tracing_opentelemetry::layer().with_tracer(tracer);	×
74
NEW 75	return Ok(tracing::subscriber::set_global_default(	×
NEW 76	subscriber.with(otel_tracer_layer),	×
NEW 77	)?);	×
NEW 78	}	×
79
80	Ok(tracing::subscriber::set_global_default(subscriber)?)	×
81	}	×
82
83	#[cfg(test)]
84	mod tests {
85	use super::otlp_enabled;
86
87	#[test]
88	fn test_otlp_disabled_by_default() {	1✔
89	unsafe {	1✔
90	std::env::remove_var("OTEL_SDK_DISABLED");	1✔
91	std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");	1✔
92	std::env::remove_var("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT");	1✔
93	}	1✔
94
95	assert!(!otlp_enabled());	1✔
96	}	1✔
97
98	#[test]
99	fn test_otlp_enabled_with_endpoint() {	1✔
100	unsafe {	1✔
101	std::env::remove_var("OTEL_SDK_DISABLED");	1✔
102	std::env::set_var("OTEL_EXPORTER_OTLP_ENDPOINT", "http://127.0.0.1:4317");	1✔
103	}	1✔
104
105	assert!(otlp_enabled());	1✔
106
107	unsafe {	1✔
108	std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");	1✔
109	}	1✔
110	}	1✔
111
112	#[test]
113	fn test_otlp_disabled_explicitly() {	1✔
114	unsafe {	1✔
115	std::env::set_var("OTEL_SDK_DISABLED", "true");	1✔
116	std::env::set_var("OTEL_EXPORTER_OTLP_ENDPOINT", "http://127.0.0.1:4317");	1✔
117	}	1✔
118
119	assert!(!otlp_enabled());	1✔
120
121	unsafe {	1✔
122	std::env::remove_var("OTEL_SDK_DISABLED");	1✔
123	std::env::remove_var("OTEL_EXPORTER_OTLP_ENDPOINT");	1✔
124	}	1✔
125	}	1✔
126	}

epazote / epazote / 22927139061

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