feat: add support for OTEL_SDK_DISABLED environment variable

Signed-off-by: Saurav Sharma <[email protected]>

Author: iamsauravsharma

opentelemetry-sdk/CHANGELOG.md

@@ -6,6 +6,8 @@
   - *Fix* SpanProcessor::on_start is no longer called on non recording spans
 - **Fix**: Restore true parallel exports in the async-native `BatchSpanProcessor` by honoring `OTEL_BSP_MAX_CONCURRENT_EXPORTS` ([#2959](https://github.com/open-telemetry/opentelemetry-rust/pull/3028)). A regression in [#2685](https://github.com/open-telemetry/opentelemetry-rust/pull/2685) inadvertently awaited the `export()` future directly in `opentelemetry-sdk/src/trace/span_processor_with_async_runtime.rs` instead of spawning it on the runtime, forcing all exports to run sequentially.
 - **Feature**: Added `Clone` implementation to `SdkLogger` for API consistency with `SdkTracer` ([#3058](https://github.com/open-telemetry/opentelemetry-rust/issues/3058)).
+- **Feature**: Add support for `OTEL_SDK_DISABLED` environment variable ([#3088](https://github.com/open-telemetry/opentelemetry-rust/pull/3088))
+
 
 ## 0.30.0
 

opentelemetry-sdk/src/logs/logger_provider.rs

@@ -12,19 +12,33 @@ use std::{
     },
 };
 
-// a no nop logger provider used as placeholder when the provider is shutdown
+// a no op logger provider used as placeholder when the provider is shutdown
 // TODO - replace it with LazyLock once it is stable
-static NOOP_LOGGER_PROVIDER: OnceLock<SdkLoggerProvider> = OnceLock::new();
+static SHUTDOWN_LOGGER_PROVIDER: OnceLock<SdkLoggerProvider> = OnceLock::new();
 
 #[inline]
-fn noop_logger_provider() -> &'static SdkLoggerProvider {
-    NOOP_LOGGER_PROVIDER.get_or_init(|| SdkLoggerProvider {
+fn shutdown_logger_provider() -> &'static SdkLoggerProvider {
+    SHUTDOWN_LOGGER_PROVIDER.get_or_init(|| SdkLoggerProvider {
         inner: Arc::new(LoggerProviderInner {
             processors: Vec::new(),
             is_shutdown: AtomicBool::new(true),
         }),
     })
 }
+// a no op logger provider used as placeholder when sdk is disabled with
+// help of environment variable `OTEL_SDK_DISABLED`
+// TODO - replace it with LazyLock once it is stable
+static DISABLED_LOGGER_PROVIDER: OnceLock<SdkLoggerProvider> = OnceLock::new();
+
+#[inline]
+fn disabled_logger_provider() -> &'static SdkLoggerProvider {
+    DISABLED_LOGGER_PROVIDER.get_or_init(|| SdkLoggerProvider {
+        inner: Arc::new(LoggerProviderInner {
+            processors: Vec::new(),
+            is_shutdown: AtomicBool::new(false),
+        }),
+    })
+}
 
 #[derive(Debug, Clone)]
 /// Handles the creation and coordination of [`Logger`]s.
@@ -53,13 +67,21 @@ impl opentelemetry::logs::LoggerProvider for SdkLoggerProvider {
     }
 
     fn logger_with_scope(&self, scope: InstrumentationScope) -> Self::Logger {
-        // If the provider is shutdown, new logger will refer a no-op logger provider.
+        // If the provider is shutdown, new logger will refer a shutdown no-op logger provider.
         if self.inner.is_shutdown.load(Ordering::Relaxed) {
             otel_debug!(
                 name: "LoggerProvider.NoOpLoggerReturned",
                 logger_name = scope.name(),
             );
-            return SdkLogger::new(scope, noop_logger_provider().clone());
+            return SdkLogger::new(scope, shutdown_logger_provider().clone());
+        }
+        // If the provider is disabled, new logger will refer a disabled no-op logger provider.
+        if std::env::var("OTEL_SDK_DISABLED").is_ok_and(|var| var.to_lowercase() == "true") {
+            otel_debug!(
+                name: "LoggerProvider.NoOpLoggerReturned",
+                logger_name = scope.name(),
+            );
+            return SdkLogger::new(scope, disabled_logger_provider().clone());
         }
         if scope.name().is_empty() {
             otel_info!(name: "LoggerNameEmpty",  message = "Logger name is empty; consider providing a meaningful name. Logger will function normally and the provided name will be used as-is.");
@@ -773,6 +795,48 @@ mod tests {
         assert!(!*flush_called.lock().unwrap());
     }
 
+    #[test]
+    #[ignore = "modifies OTEL_SDK_DISABLED env var which can affect other test"]
+    fn otel_sdk_disabled_env() {
+        temp_env::with_var("OTEL_SDK_DISABLED", Some("true"), || {
+            let exporter = InMemoryLogExporter::default();
+            let logger_provider = SdkLoggerProvider::builder()
+                .with_simple_exporter(exporter.clone())
+                .build();
+            let logger = logger_provider.logger("noop");
+            let mut record = logger.create_log_record();
+            record.set_body("Testing sdk disabled logger".into());
+            logger.emit(record);
+            let mut record = logger.create_log_record();
+            record.set_body("Testing sdk disabled logger".into());
+            logger.emit(record);
+            let mut record = logger.create_log_record();
+            record.set_body("Testing sdk disabled logger".into());
+            logger.emit(record);
+            let emitted_logs = exporter.get_emitted_logs().unwrap();
+            assert_eq!(emitted_logs.len(), 0);
+        });
+
+        temp_env::with_var("OTEL_SDK_DISABLED", Some("false"), || {
+            let exporter = InMemoryLogExporter::default();
+            let logger_provider = SdkLoggerProvider::builder()
+                .with_simple_exporter(exporter.clone())
+                .build();
+            let logger = logger_provider.logger("noop");
+            let mut record = logger.create_log_record();
+            record.set_body("Testing sdk disabled logger".into());
+            logger.emit(record);
+            let mut record = logger.create_log_record();
+            record.set_body("Testing sdk disabled logger".into());
+            logger.emit(record);
+            let mut record = logger.create_log_record();
+            record.set_body("Testing sdk disabled logger".into());
+            logger.emit(record);
+            let emitted_logs = exporter.get_emitted_logs().unwrap();
+            assert_eq!(emitted_logs.len(), 3);
+        });
+    }
+
     #[test]
     fn drop_after_shutdown_test_with_multiple_providers() {
         let shutdown_called = Arc::new(Mutex::new(0)); // Count the number of times shutdown is called

opentelemetry-sdk/src/metrics/meter_provider.rs

@@ -189,7 +189,9 @@ impl MeterProvider for SdkMeterProvider {
     }
 
     fn meter_with_scope(&self, scope: InstrumentationScope) -> Meter {
-        if self.inner.shutdown_invoked.load(Ordering::Relaxed) {
+        if self.inner.shutdown_invoked.load(Ordering::Relaxed)
+            || std::env::var("OTEL_SDK_DISABLED").is_ok_and(|var| var.to_lowercase() == "true")
+        {
             otel_debug!(
                 name: "MeterProvider.NoOpMeterReturned",
                 meter_name = scope.name(),
@@ -729,4 +731,30 @@ mod tests {
         );
         assert_eq!(resource.schema_url(), Some("http://example.com"));
     }
+
+    #[test]
+    #[ignore = "modifies OTEL_SDK_DISABLED env var which can affect other test"]
+    fn otel_sdk_disabled_env() {
+        temp_env::with_var("OTEL_SDK_DISABLED", Some("true"), || {
+            let meter_provider = super::SdkMeterProvider::builder().build();
+            let _ = meter_provider.meter("noop1");
+            let _ = meter_provider.meter("noop2");
+            let _ = meter_provider.meter("noop3");
+            let _ = meter_provider.meter("noop4");
+            let _ = meter_provider.meter("noop5");
+
+            assert_eq!(meter_provider.inner.meters.lock().unwrap().len(), 0);
+        });
+
+        temp_env::with_var("OTEL_SDK_DISABLED", Some("false"), || {
+            let meter_provider = super::SdkMeterProvider::builder().build();
+            let _ = meter_provider.meter("noop1");
+            let _ = meter_provider.meter("noop2");
+            let _ = meter_provider.meter("noop3");
+            let _ = meter_provider.meter("noop4");
+            let _ = meter_provider.meter("noop5");
+
+            assert_eq!(meter_provider.inner.meters.lock().unwrap().len(), 5);
+        });
+    }
 }

opentelemetry-sdk/src/trace/provider.rs

@@ -79,12 +79,12 @@ use std::time::Duration;
 
 static PROVIDER_RESOURCE: OnceLock<Resource> = OnceLock::new();
 
-// a no nop tracer provider used as placeholder when the provider is shutdown
+// a no op tracer provider used as placeholder when the provider is shutdown
 // TODO Replace with LazyLock once it is stable
-static NOOP_TRACER_PROVIDER: OnceLock<SdkTracerProvider> = OnceLock::new();
+static SHUTDOWN_TRACER_PROVIDER: OnceLock<SdkTracerProvider> = OnceLock::new();
 #[inline]
-fn noop_tracer_provider() -> &'static SdkTracerProvider {
-    NOOP_TRACER_PROVIDER.get_or_init(|| {
+fn shutdown_tracer_provider() -> &'static SdkTracerProvider {
+    SHUTDOWN_TRACER_PROVIDER.get_or_init(|| {
         SdkTracerProvider {
             inner: Arc::new(TracerProviderInner {
                 processors: Vec::new(),
@@ -101,6 +101,29 @@ fn noop_tracer_provider() -> &'static SdkTracerProvider {
     })
 }
 
+// a no op tracer provider used as placeholder when sdk is disabled with
+// help of environment variable `OTEL_SDK_DISABLED`
+// TODO Replace with LazyLock once it is stable
+static DISABLED_TRACER_PROVIDER: OnceLock<SdkTracerProvider> = OnceLock::new();
+#[inline]
+fn disabled_tracer_provider() -> &'static SdkTracerProvider {
+    DISABLED_TRACER_PROVIDER.get_or_init(|| {
+        SdkTracerProvider {
+            inner: Arc::new(TracerProviderInner {
+                processors: Vec::new(),
+                config: Config {
+                    // cannot use default here as the default resource is not empty
+                    sampler: Box::new(Sampler::ParentBased(Box::new(Sampler::AlwaysOn))),
+                    id_generator: Box::<RandomIdGenerator>::default(),
+                    span_limits: SpanLimits::default(),
+                    resource: Cow::Owned(Resource::empty()),
+                },
+                is_shutdown: AtomicBool::new(false),
+            }),
+        }
+    })
+}
+
 /// TracerProvider inner type
 #[derive(Debug)]
 pub(crate) struct TracerProviderInner {
@@ -286,7 +309,10 @@ impl opentelemetry::trace::TracerProvider for SdkTracerProvider {
 
     fn tracer_with_scope(&self, scope: InstrumentationScope) -> Self::Tracer {
         if self.inner.is_shutdown.load(Ordering::Relaxed) {
-            return SdkTracer::new(scope, noop_tracer_provider().clone());
+            return SdkTracer::new(scope, shutdown_tracer_provider().clone());
+        }
+        if std::env::var("OTEL_SDK_DISABLED").is_ok_and(|var| var.to_lowercase() == "true") {
+            return SdkTracer::new(scope, disabled_tracer_provider().clone());
         }
         if scope.name().is_empty() {
             otel_info!(name: "TracerNameEmpty",  message = "Tracer name is empty; consider providing a meaningful name. Tracer will function normally and the provided name will be used as-is.");
@@ -740,6 +766,52 @@ mod tests {
         assert!(test_tracer_1.provider().is_shutdown());
     }
 
+    #[test]
+    #[ignore = "modifies OTEL_SDK_DISABLED env var which can affect other test"]
+    fn otel_sdk_disabled_env() {
+        temp_env::with_var("OTEL_SDK_DISABLED", Some("true"), || {
+            let processor = TestSpanProcessor::new(false);
+            let assert_handle = processor.assert_info();
+            let tracer_provider = super::SdkTracerProvider::new(TracerProviderInner {
+                processors: vec![Box::from(processor)],
+                config: Default::default(),
+                is_shutdown: AtomicBool::new(false),
+            });
+
+            assert!(assert_handle.started_span_count(0));
+            let noop_tracer = tracer_provider.tracer("noop");
+
+            // noop tracer cannot start anything
+            let _ = noop_tracer.start("test");
+            let _ = noop_tracer.start("test2");
+            let _ = noop_tracer.start("test3");
+            assert!(assert_handle.started_span_count(0));
+
+            // noop tracer should have 0 processor
+            assert_eq!(noop_tracer.provider().span_processors().len(), 0)
+        });
+
+        temp_env::with_var("OTEL_SDK_DISABLED", Some("false"), || {
+            let processor = TestSpanProcessor::new(false);
+            let assert_handle = processor.assert_info();
+            let tracer_provider = super::SdkTracerProvider::new(TracerProviderInner {
+                processors: vec![Box::from(processor)],
+                config: Default::default(),
+                is_shutdown: AtomicBool::new(false),
+            });
+
+            assert!(assert_handle.started_span_count(0));
+            let noop_tracer = tracer_provider.tracer("noop");
+
+            let _ = noop_tracer.start("test");
+            let _ = noop_tracer.start("test1");
+            let _ = noop_tracer.start("test2");
+            assert!(assert_handle.started_span_count(3));
+
+            assert_eq!(noop_tracer.provider().span_processors().len(), 1)
+        });
+    }
+
     #[test]
     fn with_resource_multiple_calls_ensure_additive() {
         let resource = SdkTracerProvider::builder()

scripts/test.sh

@@ -20,6 +20,9 @@ cargo test --manifest-path=opentelemetry/Cargo.toml --no-default-features --lib
 echo "Running tests for opentelemetry-prometheus with --all-features"
 (cd opentelemetry-prometheus && cargo test --all-features --lib)
 
+# Run test which set environment variable ``
+cargo test --package opentelemetry_sdk --lib --all-features -- otel_sdk_disabled_env --ignored
+
 # Run global tracer provider test in single thread
 # //TODO: This tests were not running for a while. Need to find out how to run
 # run them. Using --ignored will run other tests as well, so that cannot be used.