Add a new SharedSpanHandle::Inactive variant

It's expected that most of the spans are not sampled. We still clone
and stack them, which adds up. Let's add a new variant for unsampled
spans that is cheaper to clone.

Author: bobrik

foundations/src/telemetry/tracing/internal.rs

@@ -9,38 +9,39 @@ use parking_lot::RwLock;
 use rand::{self, Rng};
 use std::borrow::Cow;
 use std::error::Error;
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 
 pub(crate) type Tracer = cf_rustracing::Tracer<BoxSampler<SpanContextState>, SpanContextState>;
 
+static INACTIVE_SPAN: LazyLock<RwLock<Span>> = LazyLock::new(|| RwLock::new(Span::inactive()));
+
 /// Shared span with mutability and additional reference tracking for
 /// ad-hoc inspection.
 #[derive(Clone, Debug)]
 pub(crate) enum SharedSpanHandle {
     Tracked(Arc<LiveReferenceHandle<Arc<RwLock<Span>>>>),
     Untracked(Arc<RwLock<Span>>),
+    Inactive,
 }
 
 impl SharedSpanHandle {
     pub(crate) fn new(span: Span) -> Self {
-        let is_sampled = span.is_sampled();
-
-        TracingHarness::get()
-            .active_roots
-            .track(Arc::new(RwLock::new(span)), is_sampled)
+        TracingHarness::get().active_roots.track(span)
     }
 
     pub(crate) fn read(&self) -> parking_lot::RwLockReadGuard<'_, Span> {
         match self {
             SharedSpanHandle::Tracked(handle) => handle.read(),
             SharedSpanHandle::Untracked(rw_lock) => rw_lock.read(),
+            SharedSpanHandle::Inactive => (*INACTIVE_SPAN).read(),
         }
     }
 
     pub(crate) fn write(&self) -> parking_lot::RwLockWriteGuard<'_, Span> {
         match self {
             SharedSpanHandle::Tracked(handle) => handle.write(),
             SharedSpanHandle::Untracked(rw_lock) => rw_lock.write(),
+            SharedSpanHandle::Inactive => (*INACTIVE_SPAN).write(),
         }
     }
 }
@@ -50,6 +51,7 @@ impl From<SharedSpanHandle> for Arc<RwLock<Span>> {
         match value {
             SharedSpanHandle::Tracked(handle) => Arc::clone(&handle),
             SharedSpanHandle::Untracked(rw_lock) => Arc::clone(&rw_lock),
+            SharedSpanHandle::Inactive => Arc::new(RwLock::new(Span::inactive())),
         }
     }
 }

foundations/src/telemetry/tracing/live/mod.rs

@@ -39,11 +39,15 @@ impl ActiveRoots {
         event_output::spans_to_trace_events(self.start, &self.roots.get_live_references())
     }
 
-    pub(crate) fn track(&self, value: Arc<RwLock<Span>>, is_sampled: bool) -> SharedSpanHandle {
+    pub(crate) fn track(&self, span: Span) -> SharedSpanHandle {
+        let is_sampled = span.is_sampled();
+
         if self.settings.enabled && (self.settings.track_all_spans || is_sampled) {
-            SharedSpanHandle::Tracked(self.roots.track(value))
+            SharedSpanHandle::Tracked(self.roots.track(Arc::new(RwLock::new(span))))
+        } else if is_sampled {
+            SharedSpanHandle::Untracked(Arc::new(RwLock::new(span)))
         } else {
-            SharedSpanHandle::Untracked(value)
+            SharedSpanHandle::Inactive
         }
     }
 }