feat: Replace OnceLock + helper function patterns with LazyLock

Resolves 6 TODO comments in opentelemetry-sdk that were waiting for
LazyLock stabilization (stable since Rust 1.80). Each OnceLock paired
with a getter function is now a single LazyLock static declaration.

Signed-off-by: Bryant Biggs <bryantbiggs@gmail.com>

Author: bryantbiggs

opentelemetry-sdk/src/logs/logger_provider.rs

@@ -8,23 +8,17 @@ use std::{
     borrow::Cow,
     sync::{
         atomic::{AtomicBool, Ordering},
-        Arc, OnceLock,
+        Arc, LazyLock,
     },
 };
 
-// a no nop 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();
-
-#[inline]
-fn noop_logger_provider() -> &'static SdkLoggerProvider {
-    NOOP_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 the provider is shutdown
+static NOOP_LOGGER_PROVIDER: LazyLock<SdkLoggerProvider> = LazyLock::new(|| SdkLoggerProvider {
+    inner: Arc::new(LoggerProviderInner {
+        processors: Vec::new(),
+        is_shutdown: AtomicBool::new(true),
+    }),
+});
 
 #[derive(Debug, Clone)]
 /// Handles the creation and coordination of [`Logger`]s.
@@ -59,7 +53,7 @@ impl opentelemetry::logs::LoggerProvider for SdkLoggerProvider {
                 name: "LoggerProvider.NoOpLoggerReturned",
                 logger_name = scope.name(),
             );
-            return SdkLogger::new(scope, noop_logger_provider().clone());
+            return SdkLogger::new(scope, NOOP_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.");

opentelemetry-sdk/src/metrics/internal/exponential_histogram.rs

@@ -1,7 +1,7 @@
 use std::{f64::consts::LOG2_E, mem::replace, ops::DerefMut, sync::Mutex};
 
 use opentelemetry::{otel_debug, KeyValue};
-use std::sync::OnceLock;
+use std::sync::LazyLock;
 
 use crate::metrics::{
     data::{self, AggregatedMetrics, MetricData},
@@ -134,7 +134,7 @@ impl<T: Number> ExpoHistogramDataPoint<T> {
             }
             return (exp - correction) >> -self.scale;
         }
-        (exp << self.scale) + (frac.ln() * scale_factors()[self.scale as usize]) as i32 - 1
+        (exp << self.scale) + (frac.ln() * SCALE_FACTORS[self.scale as usize]) as i32 - 1
     }
 }
 
@@ -168,38 +168,32 @@ fn scale_change(max_size: i32, bin: i32, start_bin: i32, length: i32) -> u32 {
     count
 }
 
-// TODO - replace it with LazyLock once it is stable
-static SCALE_FACTORS: OnceLock<[f64; 21]> = OnceLock::new();
-
-/// returns constants used in calculating the logarithm index.
-#[inline]
-fn scale_factors() -> &'static [f64; 21] {
-    SCALE_FACTORS.get_or_init(|| {
-        [
-            LOG2_E * 2f64.powi(0),
-            LOG2_E * 2f64.powi(1),
-            LOG2_E * 2f64.powi(2),
-            LOG2_E * 2f64.powi(3),
-            LOG2_E * 2f64.powi(4),
-            LOG2_E * 2f64.powi(5),
-            LOG2_E * 2f64.powi(6),
-            LOG2_E * 2f64.powi(7),
-            LOG2_E * 2f64.powi(8),
-            LOG2_E * 2f64.powi(9),
-            LOG2_E * 2f64.powi(10),
-            LOG2_E * 2f64.powi(11),
-            LOG2_E * 2f64.powi(12),
-            LOG2_E * 2f64.powi(13),
-            LOG2_E * 2f64.powi(14),
-            LOG2_E * 2f64.powi(15),
-            LOG2_E * 2f64.powi(16),
-            LOG2_E * 2f64.powi(17),
-            LOG2_E * 2f64.powi(18),
-            LOG2_E * 2f64.powi(19),
-            LOG2_E * 2f64.powi(20),
-        ]
-    })
-}
+/// Constants used in calculating the logarithm index.
+static SCALE_FACTORS: LazyLock<[f64; 21]> = LazyLock::new(|| {
+    [
+        LOG2_E * 2f64.powi(0),
+        LOG2_E * 2f64.powi(1),
+        LOG2_E * 2f64.powi(2),
+        LOG2_E * 2f64.powi(3),
+        LOG2_E * 2f64.powi(4),
+        LOG2_E * 2f64.powi(5),
+        LOG2_E * 2f64.powi(6),
+        LOG2_E * 2f64.powi(7),
+        LOG2_E * 2f64.powi(8),
+        LOG2_E * 2f64.powi(9),
+        LOG2_E * 2f64.powi(10),
+        LOG2_E * 2f64.powi(11),
+        LOG2_E * 2f64.powi(12),
+        LOG2_E * 2f64.powi(13),
+        LOG2_E * 2f64.powi(14),
+        LOG2_E * 2f64.powi(15),
+        LOG2_E * 2f64.powi(16),
+        LOG2_E * 2f64.powi(17),
+        LOG2_E * 2f64.powi(18),
+        LOG2_E * 2f64.powi(19),
+        LOG2_E * 2f64.powi(20),
+    ]
+});
 
 /// Breaks the number into a normalized fraction and a base-2 exponent.
 ///

opentelemetry-sdk/src/metrics/internal/mod.rs

@@ -15,7 +15,7 @@ use std::ops::{Add, AddAssign, DerefMut, Sub};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 #[cfg(target_has_atomic = "64")]
 use std::sync::atomic::{AtomicI64, AtomicU64};
-use std::sync::{Arc, OnceLock, RwLock};
+use std::sync::{Arc, LazyLock, OnceLock, RwLock};
 
 pub(crate) use aggregate::{AggregateBuilder, AggregateFns, ComputeAggregation, Measure};
 pub(crate) use exponential_histogram::{EXPO_MAX_SCALE, EXPO_MIN_SCALE};
@@ -24,13 +24,8 @@ use opentelemetry::{otel_warn, KeyValue};
 use super::data::{AggregatedMetrics, MetricData};
 use super::pipeline::DEFAULT_CARDINALITY_LIMIT;
 
-// TODO Replace it with LazyLock once it is stable
-pub(crate) static STREAM_OVERFLOW_ATTRIBUTES: OnceLock<Vec<KeyValue>> = OnceLock::new();
-
-#[inline]
-fn stream_overflow_attributes() -> &'static Vec<KeyValue> {
-    STREAM_OVERFLOW_ATTRIBUTES.get_or_init(|| vec![KeyValue::new("otel.metric.overflow", true)])
-}
+pub(crate) static STREAM_OVERFLOW_ATTRIBUTES: LazyLock<Vec<KeyValue>> =
+    LazyLock::new(|| vec![KeyValue::new("otel.metric.overflow", true)]);
 
 pub(crate) trait Aggregator {
     /// A static configuration that is needed in order to initialize aggregator.
@@ -157,12 +152,12 @@ where
             trackers.insert(sorted_attrs, new_tracker);
 
             self.count.fetch_add(1, Ordering::SeqCst);
-        } else if let Some(overflow_value) = trackers.get(stream_overflow_attributes().as_slice()) {
+        } else if let Some(overflow_value) = trackers.get(STREAM_OVERFLOW_ATTRIBUTES.as_slice()) {
             overflow_value.update(value);
         } else {
             let new_tracker = A::create(&self.config);
             new_tracker.update(value);
-            trackers.insert(stream_overflow_attributes().clone(), Arc::new(new_tracker));
+            trackers.insert(STREAM_OVERFLOW_ATTRIBUTES.clone(), Arc::new(new_tracker));
         }
     }
 

opentelemetry-sdk/src/propagation/baggage.rs

@@ -6,17 +6,12 @@ use opentelemetry::{
 };
 use percent_encoding::{percent_decode_str, utf8_percent_encode, AsciiSet, CONTROLS};
 use std::iter;
-use std::sync::OnceLock;
+use std::sync::LazyLock;
 
 static BAGGAGE_HEADER: &str = "baggage";
 const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b';').add(b',').add(b'=');
 
-// TODO Replace this with LazyLock once it is stable.
-static BAGGAGE_FIELDS: OnceLock<[String; 1]> = OnceLock::new();
-#[inline]
-fn baggage_fields() -> &'static [String; 1] {
-    BAGGAGE_FIELDS.get_or_init(|| [BAGGAGE_HEADER.to_owned()])
-}
+static BAGGAGE_FIELDS: LazyLock<[String; 1]> = LazyLock::new(|| [BAGGAGE_HEADER.to_owned()]);
 
 /// Propagates name-value pairs in [W3C Baggage] format.
 ///
@@ -158,7 +153,7 @@ impl TextMapPropagator for BaggagePropagator {
     }
 
     fn fields(&self) -> FieldIter<'_> {
-        FieldIter::new(baggage_fields())
+        FieldIter::new(&*BAGGAGE_FIELDS)
     }
 }
 

opentelemetry-sdk/src/propagation/trace_context.rs

@@ -7,20 +7,15 @@ use opentelemetry::{
     Context,
 };
 use std::str::FromStr;
-use std::sync::OnceLock;
+use std::sync::LazyLock;
 
 const SUPPORTED_VERSION: u8 = 0;
 const MAX_VERSION: u8 = 254;
 const TRACEPARENT_HEADER: &str = "traceparent";
 const TRACESTATE_HEADER: &str = "tracestate";
 
-// TODO Replace this with LazyLock once it is stable.
-static TRACE_CONTEXT_HEADER_FIELDS: OnceLock<[String; 2]> = OnceLock::new();
-
-fn trace_context_header_fields() -> &'static [String; 2] {
-    TRACE_CONTEXT_HEADER_FIELDS
-        .get_or_init(|| [TRACEPARENT_HEADER.to_owned(), TRACESTATE_HEADER.to_owned()])
-}
+static TRACE_CONTEXT_HEADER_FIELDS: LazyLock<[String; 2]> =
+    LazyLock::new(|| [TRACEPARENT_HEADER.to_owned(), TRACESTATE_HEADER.to_owned()]);
 
 /// Propagates `SpanContext`s in [W3C TraceContext] format under `traceparent` and `tracestate` header.
 ///
@@ -151,7 +146,7 @@ impl TextMapPropagator for TraceContextPropagator {
     }
 
     fn fields(&self) -> FieldIter<'_> {
-        FieldIter::new(trace_context_header_fields())
+        FieldIter::new(&*TRACE_CONTEXT_HEADER_FIELDS)
     }
 }
 

opentelemetry-sdk/src/trace/provider.rs

@@ -74,32 +74,25 @@ use opentelemetry::otel_debug;
 use opentelemetry::{otel_info, InstrumentationScope};
 use std::borrow::Cow;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, OnceLock};
+use std::sync::{Arc, LazyLock, OnceLock};
 use std::time::Duration;
 
 static PROVIDER_RESOURCE: OnceLock<Resource> = OnceLock::new();
 
-// a no nop 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();
-#[inline]
-fn noop_tracer_provider() -> &'static SdkTracerProvider {
-    NOOP_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(true),
-            }),
-        }
-    })
-}
+// a no-op tracer provider used as placeholder when the provider is shutdown
+static NOOP_TRACER_PROVIDER: LazyLock<SdkTracerProvider> = LazyLock::new(|| 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(true),
+    }),
+});
 
 /// TracerProvider inner type
 #[derive(Debug)]
@@ -286,7 +279,7 @@ 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, NOOP_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.");