refactor: streamline OTLP configuration and remove dead var (#82)

* chore: bump tracing-opentelemetry and otlp deps to compatible version

* refactor: streamline tracing and use env filter

* fix: ajj to published version

* fix: don't double filter

* chore: simplify init a bit

Author: prestwich

Cargo.toml

@@ -4,7 +4,7 @@ name = "init4-bin-base"
 description = "Internal utilities for binaries produced by the init4 team"
 keywords = ["init4", "bin", "base"]
 
-version = "0.13.1"
+version = "0.14.0"
 edition = "2021"
 rust-version = "1.85"
 authors = ["init4", "James Prestwich", "evalir"]
@@ -28,11 +28,11 @@ tracing-core = "0.1.33"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter", "json", "registry"] }
 
 # OTLP
-opentelemetry_sdk = "0.29.0"
-opentelemetry = "0.29.0"
-opentelemetry-otlp = "0.29.0"
-opentelemetry-semantic-conventions = { version = "0.29.0", features = ["semconv_experimental"] }
-tracing-opentelemetry = "0.30.0"
+opentelemetry_sdk = "0.30.0"
+opentelemetry = "0.30.0"
+opentelemetry-otlp = "0.30.0"
+opentelemetry-semantic-conventions = { version = "0.30.0", features = ["semconv_experimental"] }
+tracing-opentelemetry = "0.31.0"
 url = "2.5.4"
 
 # Metrics
@@ -61,7 +61,7 @@ reqwest = { version = "0.12.15", optional = true }
 rustls = { version = "0.23.31", optional = true }
 
 [dev-dependencies]
-ajj = "0.3.1"
+ajj = { version = "0.4.1", features = ["axum", "ws", "ipc"] }
 axum = "0.8.1"
 eyre = "0.6.12"
 serial_test = "3.2.0"

src/utils/otlp.rs

@@ -1,19 +1,15 @@
 use crate::utils::from_env::{EnvItemInfo, FromEnv, FromEnvErr, FromEnvVar};
 use opentelemetry::{trace::TracerProvider, KeyValue};
-use opentelemetry_sdk::trace::SdkTracerProvider;
-use opentelemetry_sdk::Resource;
+use opentelemetry_sdk::{trace::SdkTracerProvider, Resource};
 use opentelemetry_semantic_conventions::{
     attribute::{DEPLOYMENT_ENVIRONMENT_NAME, SERVICE_NAME, SERVICE_VERSION},
     SCHEMA_URL,
 };
-use std::time::Duration;
-use tracing::level_filters::LevelFilter;
-use tracing_subscriber::Layer;
+use tracing_subscriber::{EnvFilter, Layer};
 use url::Url;
 
 const OTEL_ENDPOINT: &str = "OTEL_EXPORTER_OTLP_ENDPOINT";
 const OTEL_LEVEL: &str = "OTEL_LEVEL";
-const OTEL_TIMEOUT: &str = "OTEL_TIMEOUT";
 const OTEL_ENVIRONMENT: &str = "OTEL_ENVIRONMENT_NAME";
 
 /// Drop guard for the Otel provider. This will shutdown the provider when
@@ -33,7 +29,7 @@ const OTEL_ENVIRONMENT: &str = "OTEL_ENVIRONMENT_NAME";
 /// # }
 /// ```
 #[derive(Debug)]
-pub struct OtelGuard(SdkTracerProvider, tracing::Level);
+pub struct OtelGuard(SdkTracerProvider, EnvFilter);
 
 impl OtelGuard {
     /// Get a tracer from the provider.
@@ -49,7 +45,7 @@ impl OtelGuard {
         let tracer = self.tracer("tracing-otel-subscriber");
         tracing_opentelemetry::layer()
             .with_tracer(tracer)
-            .with_filter(LevelFilter::from_level(self.1))
+            .with_filter(self.1.clone())
     }
 }
 
@@ -68,7 +64,7 @@ impl Drop for OtelGuard {
 ///   should be some valid URL. If not specified, then [`OtelConfig::load`]
 ///   will return [`None`].
 /// - OTEL_LEVEL - optional. Specifies the minimum [`tracing::Level`] to
-///   export. Defaults to [`tracing::Level::DEBUG`].
+///   export in the [`EnvFilter`] format. Defaults to [`tracing::Level::DEBUG`].
 /// - OTEL_TIMEOUT - optional. Specifies the timeout for the exporter in
 ///   **milliseconds**. Defaults to 1000ms, which is equivalent to 1 second.
 /// - OTEL_ENVIRONMENT_NAME - optional. Value for the `deployment.environment.
@@ -81,10 +77,7 @@ pub struct OtelConfig {
     pub endpoint: Url,
 
     /// Defaults to DEBUG.
-    pub level: tracing::Level,
-
-    /// Defaults to 1 second. Specified in Milliseconds.
-    pub timeout: Duration,
+    pub level: EnvFilter,
 
     /// OTEL convenition `deployment.environment.name`
     pub environment: String,
@@ -103,12 +96,7 @@ impl FromEnv for OtelConfig {
             },
             &EnvItemInfo {
                 var: OTEL_LEVEL,
-                description: "OTLP level to export, defaults to DEBUG. Permissible values are: TRACE, DEBUG, INFO, WARN, ERROR, OFF",
-                optional: true,
-            },
-            &EnvItemInfo {
-                var: OTEL_TIMEOUT,
-                description: "OTLP timeout in milliseconds",
+                description: "OTLP level to export. Follows the RUST_LOG env filter format. e.g. `OTEL_LEVEL=warn,my_crate=info`. Defaults to the value of `RUST_LOG` if not present.",
                 optional: true,
             },
             &EnvItemInfo {
@@ -123,16 +111,22 @@ impl FromEnv for OtelConfig {
         // load endpoint from env. ignore empty values (shortcut return None), parse, and print the error if any using inspect_err
         let endpoint = Url::from_env_var(OTEL_ENDPOINT)?;
 
-        let level = tracing::Level::from_env_var(OTEL_LEVEL).unwrap_or(tracing::Level::DEBUG);
-
-        let timeout = Duration::from_env_var(OTEL_TIMEOUT).unwrap_or(Duration::from_millis(1000));
+        let level = if std::env::var(OTEL_LEVEL)
+            .as_ref()
+            .map(String::len)
+            .unwrap_or_default()
+            > 0
+        {
+            EnvFilter::from_env(OTEL_LEVEL)
+        } else {
+            EnvFilter::from_default_env()
+        };
 
         let environment = String::from_env_var(OTEL_ENVIRONMENT).unwrap_or("unknown".into());
 
         Ok(Self {
             endpoint,
             level,
-            timeout,
             environment,
         })
     }
@@ -184,7 +178,19 @@ impl OtelConfig {
             .with_batch_exporter(exporter)
             .build();
 
-        OtelGuard(provider, self.level)
+        OtelGuard(provider, self.level.clone())
+    }
+
+    /// Create a new Otel provider, returning both the guard and a tracing
+    /// layer that can be added to a subscriber.
+    ///
+    pub fn into_guard_and_layer<S>(self) -> (OtelGuard, impl Layer<S>)
+    where
+        S: tracing::Subscriber + for<'span> tracing_subscriber::registry::LookupSpan<'span>,
+    {
+        let guard = self.provider();
+        let layer = guard.layer();
+        (guard, layer)
     }
 }
 
@@ -197,7 +203,6 @@ mod test {
     fn clear_env() {
         std::env::remove_var(OTEL_ENDPOINT);
         std::env::remove_var(OTEL_LEVEL);
-        std::env::remove_var(OTEL_TIMEOUT);
         std::env::remove_var(OTEL_ENVIRONMENT);
     }
 
@@ -215,11 +220,14 @@ mod test {
     fn test_env_read() {
         run_clear_env(|| {
             std::env::set_var(OTEL_ENDPOINT, URL);
+            std::env::set_var(OTEL_LEVEL, "debug");
 
             let cfg = OtelConfig::load().unwrap();
             assert_eq!(cfg.endpoint, URL.parse().unwrap());
-            assert_eq!(cfg.level, tracing::Level::DEBUG);
-            assert_eq!(cfg.timeout, std::time::Duration::from_millis(1000));
+            assert_eq!(
+                cfg.level.max_level_hint(),
+                Some(tracing::Level::DEBUG.into())
+            );
             assert_eq!(cfg.environment, "unknown");
         })
     }
@@ -229,22 +237,13 @@ mod test {
     fn test_env_read_level() {
         run_clear_env(|| {
             std::env::set_var(OTEL_ENDPOINT, URL);
-            std::env::set_var(OTEL_LEVEL, "WARN");
-
-            let cfg = OtelConfig::load().unwrap();
-            assert_eq!(cfg.level, tracing::Level::WARN);
-        })
-    }
-
-    #[test]
-    #[serial_test::serial]
-    fn test_env_read_timeout() {
-        run_clear_env(|| {
-            std::env::set_var(OTEL_ENDPOINT, URL);
-            std::env::set_var(OTEL_TIMEOUT, "500");
+            std::env::set_var(OTEL_LEVEL, "warn,my_app=info");
 
             let cfg = OtelConfig::load().unwrap();
-            assert_eq!(cfg.timeout, std::time::Duration::from_millis(500));
+            let s = cfg.level.to_string();
+            let iter = s.split(",");
+            assert!(iter.clone().any(|x| x == "warn"));
+            assert!(iter.clone().any(|x| x == "my_app=info"));
         })
     }
 

src/utils/tracing.rs

@@ -18,13 +18,12 @@ macro_rules! install_fmt {
         let fmt = tracing_subscriber::fmt::layer().with_filter($filter);
         $registry.with(fmt).init();
     }};
-    ($registry:ident) => {{
+    ($registry:ident, $filter:ident) => {{
         let json = bool::from_env_var(TRACING_LOG_JSON).unwrap_or(false);
-        let filter = EnvFilter::from_default_env();
         if json {
-            install_fmt!(json @ $registry, filter);
+            install_fmt!(json @ $registry, $filter);
         } else {
-            install_fmt!(log @ $registry, filter);
+            install_fmt!(log @ $registry, $filter);
         }
     }};
 }
@@ -48,14 +47,15 @@ macro_rules! install_fmt {
 /// [`OtelConfig`]: crate::utils::otlp::OtelConfig
 pub fn init_tracing() -> Option<OtelGuard> {
     let registry = tracing_subscriber::registry();
+    let filter = EnvFilter::from_default_env();
 
     if let Some(cfg) = OtelConfig::load() {
-        let guard = cfg.provider();
-        let registry = registry.with(guard.layer());
-        install_fmt!(registry);
+        let (guard, layer) = cfg.into_guard_and_layer();
+        let registry = registry.with(layer);
+        install_fmt!(registry, filter);
         Some(guard)
     } else {
-        install_fmt!(registry);
+        install_fmt!(registry, filter);
         tracing::debug!(
             "No OTEL config found or error while loading otel config, using default tracing"
         );