Merge branch 'main' into cijothomas/internallogs2

Author: cijothomas

opentelemetry/Cargo.toml

@@ -21,19 +21,18 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
-futures-core = { workspace = true }
-futures-sink = "0.3"
-once_cell = { workspace = true }
+futures-core = { workspace = true, optional = true }
+futures-sink = { version = "0.3", optional = true }
 pin-project-lite = { workspace = true, optional = true }
-thiserror = { workspace = true }
+thiserror = { workspace = true, optional = true}
 tracing = {workspace = true, optional = true} # optional for opentelemetry internal logging
 
 [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies]
 js-sys = "0.3.63"
 
 [features]
 default = ["trace", "metrics", "logs"]
-trace = ["pin-project-lite"]
+trace = ["pin-project-lite", "futures-sink", "futures-core", "thiserror"]
 metrics = []
 testing = ["trace", "metrics"]
 logs = []

opentelemetry/src/baggage.rs

@@ -15,16 +15,22 @@
 //!
 //! [W3C Baggage]: https://w3c.github.io/baggage
 use crate::{Context, Key, KeyValue, Value};
-use once_cell::sync::Lazy;
 use std::collections::{hash_map, HashMap};
 use std::fmt;
+use std::sync::OnceLock;
 
-static DEFAULT_BAGGAGE: Lazy<Baggage> = Lazy::new(Baggage::default);
+static DEFAULT_BAGGAGE: OnceLock<Baggage> = OnceLock::new();
 
 const MAX_KEY_VALUE_PAIRS: usize = 180;
 const MAX_BYTES_FOR_ONE_PAIR: usize = 4096;
 const MAX_LEN_OF_ALL_PAIRS: usize = 8192;
 
+/// Returns the default baggage, ensuring it is initialized only once.
+#[inline]
+fn get_default_baggage() -> &'static Baggage {
+    DEFAULT_BAGGAGE.get_or_init(Baggage::default)
+}
+
 /// A set of name/value pairs describing user-defined properties.
 ///
 /// ### Baggage Names
@@ -399,7 +405,7 @@ impl BaggageExt for Context {
     }
 
     fn baggage(&self) -> &Baggage {
-        self.get::<Baggage>().unwrap_or(&DEFAULT_BAGGAGE)
+        self.get::<Baggage>().unwrap_or(get_default_baggage())
     }
 }
 

opentelemetry/src/global/metrics.rs

@@ -1,29 +1,33 @@
 use crate::metrics::{self, Meter, MeterProvider};
 use crate::InstrumentationScope;
-use once_cell::sync::Lazy;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, OnceLock, RwLock};
 
 type GlobalMeterProvider = Arc<dyn MeterProvider + Send + Sync>;
 
 /// The global `MeterProvider` singleton.
-static GLOBAL_METER_PROVIDER: Lazy<RwLock<GlobalMeterProvider>> =
-    Lazy::new(|| RwLock::new(Arc::new(crate::metrics::noop::NoopMeterProvider::new())));
+static GLOBAL_METER_PROVIDER: OnceLock<RwLock<GlobalMeterProvider>> = OnceLock::new();
+
+#[inline]
+fn global_meter_provider() -> &'static RwLock<GlobalMeterProvider> {
+    GLOBAL_METER_PROVIDER
+        .get_or_init(|| RwLock::new(Arc::new(crate::metrics::noop::NoopMeterProvider::new())))
+}
 
 /// Sets the given [`MeterProvider`] instance as the current global meter
 /// provider.
 pub fn set_meter_provider<P>(new_provider: P)
 where
     P: metrics::MeterProvider + Send + Sync + 'static,
 {
-    let mut global_provider = GLOBAL_METER_PROVIDER
+    let mut global_provider = global_meter_provider()
         .write()
         .expect("GLOBAL_METER_PROVIDER RwLock poisoned");
     *global_provider = Arc::new(new_provider);
 }
 
 /// Returns an instance of the currently configured global [`MeterProvider`].
 pub fn meter_provider() -> GlobalMeterProvider {
-    GLOBAL_METER_PROVIDER
+    global_meter_provider()
         .read()
         .expect("GLOBAL_METER_PROVIDER RwLock poisoned")
         .clone()

opentelemetry/src/global/propagation.rs

@@ -1,19 +1,29 @@
 use crate::propagation::TextMapPropagator;
 use crate::trace::noop::NoopTextMapPropagator;
-use once_cell::sync::Lazy;
-use std::sync::RwLock;
+use std::sync::{OnceLock, RwLock};
 
 /// The current global `TextMapPropagator` propagator.
-static GLOBAL_TEXT_MAP_PROPAGATOR: Lazy<RwLock<Box<dyn TextMapPropagator + Send + Sync>>> =
-    Lazy::new(|| RwLock::new(Box::new(NoopTextMapPropagator::new())));
+static GLOBAL_TEXT_MAP_PROPAGATOR: OnceLock<RwLock<Box<dyn TextMapPropagator + Send + Sync>>> =
+    OnceLock::new();
 
 /// The global default `TextMapPropagator` propagator.
-static DEFAULT_TEXT_MAP_PROPAGATOR: Lazy<NoopTextMapPropagator> =
-    Lazy::new(NoopTextMapPropagator::new);
+static DEFAULT_TEXT_MAP_PROPAGATOR: OnceLock<NoopTextMapPropagator> = OnceLock::new();
+
+/// Ensures the `GLOBAL_TEXT_MAP_PROPAGATOR` is initialized with a `NoopTextMapPropagator`.
+#[inline]
+fn global_text_map_propagator() -> &'static RwLock<Box<dyn TextMapPropagator + Send + Sync>> {
+    GLOBAL_TEXT_MAP_PROPAGATOR.get_or_init(|| RwLock::new(Box::new(NoopTextMapPropagator::new())))
+}
+
+/// Ensures the `DEFAULT_TEXT_MAP_PROPAGATOR` is initialized.
+#[inline]
+fn default_text_map_propagator() -> &'static NoopTextMapPropagator {
+    DEFAULT_TEXT_MAP_PROPAGATOR.get_or_init(NoopTextMapPropagator::new)
+}
 
 /// Sets the given [`TextMapPropagator`] propagator as the current global propagator.
 pub fn set_text_map_propagator<P: TextMapPropagator + Send + Sync + 'static>(propagator: P) {
-    let _lock = GLOBAL_TEXT_MAP_PROPAGATOR
+    let _lock = global_text_map_propagator()
         .write()
         .map(|mut global_propagator| *global_propagator = Box::new(propagator));
 }
@@ -23,8 +33,11 @@ pub fn get_text_map_propagator<T, F>(mut f: F) -> T
 where
     F: FnMut(&dyn TextMapPropagator) -> T,
 {
-    GLOBAL_TEXT_MAP_PROPAGATOR
+    global_text_map_propagator()
         .read()
         .map(|propagator| f(&**propagator))
-        .unwrap_or_else(|_| f(&*DEFAULT_TEXT_MAP_PROPAGATOR as &dyn TextMapPropagator))
+        .unwrap_or_else(|_| {
+            let default_propagator = default_text_map_propagator();
+            f(default_propagator as &dyn TextMapPropagator)
+        })
 }

opentelemetry/src/global/trace.rs

@@ -1,11 +1,10 @@
 use crate::trace::{noop::NoopTracerProvider, SpanContext, Status};
 use crate::InstrumentationScope;
 use crate::{trace, trace::TracerProvider, Context, KeyValue};
-use once_cell::sync::Lazy;
 use std::borrow::Cow;
 use std::fmt;
 use std::mem;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, OnceLock, RwLock};
 use std::time::SystemTime;
 
 /// Allows a specific [`crate::trace::Span`] to be used generically by [`BoxedSpan`]
@@ -360,19 +359,21 @@ impl trace::TracerProvider for GlobalTracerProvider {
 }
 
 /// The global `Tracer` provider singleton.
-static GLOBAL_TRACER_PROVIDER: Lazy<RwLock<GlobalTracerProvider>> = Lazy::new(|| {
-    RwLock::new(GlobalTracerProvider::new(
-        trace::noop::NoopTracerProvider::new(),
-    ))
-});
+static GLOBAL_TRACER_PROVIDER: OnceLock<RwLock<GlobalTracerProvider>> = OnceLock::new();
+
+#[inline]
+fn global_tracer_provider() -> &'static RwLock<GlobalTracerProvider> {
+    GLOBAL_TRACER_PROVIDER
+        .get_or_init(|| RwLock::new(GlobalTracerProvider::new(NoopTracerProvider::new())))
+}
 
 /// Returns an instance of the currently configured global [`TracerProvider`] through
 /// [`GlobalTracerProvider`].
 ///
 /// [`TracerProvider`]: crate::trace::TracerProvider
 /// [`GlobalTracerProvider`]: crate::global::GlobalTracerProvider
 pub fn tracer_provider() -> GlobalTracerProvider {
-    GLOBAL_TRACER_PROVIDER
+    global_tracer_provider()
         .read()
         .expect("GLOBAL_TRACER_PROVIDER RwLock poisoned")
         .clone()
@@ -428,7 +429,7 @@ where
     T: trace::Tracer<Span = S> + Send + Sync + 'static,
     P: trace::TracerProvider<Tracer = T> + Send + Sync + 'static,
 {
-    let mut tracer_provider = GLOBAL_TRACER_PROVIDER
+    let mut tracer_provider = global_tracer_provider()
         .write()
         .expect("GLOBAL_TRACER_PROVIDER RwLock poisoned");
     mem::replace(
@@ -440,7 +441,7 @@ where
 /// Shut down the current tracer provider. This will invoke the shutdown method on all span processors.
 /// span processors should export remaining spans before return
 pub fn shutdown_tracer_provider() {
-    let mut tracer_provider = GLOBAL_TRACER_PROVIDER
+    let mut tracer_provider = global_tracer_provider()
         .write()
         .expect("GLOBAL_TRACER_PROVIDER RwLock poisoned");