Registry

pub struct Registry {
    spans: Pool<DataInner>,
    current_spans: ThreadLocal<RefCell<SpanStack>>,
    next_filter_id: u8,
}

struct DataInner {
    filter_map: FilterMap,
    metadata: &'static Metadata<'static>,
    parent: Option<Id>,
    ref_count: AtomicUsize,
    // The span's `Extensions` typemap. Allocations for the `HashMap` backing
    // this are pooled and reused in place.
    pub(crate) extensions: RwLock<ExtensionsInner>,
}

    fn clear(&mut self) {
        // A span is not considered closed until all of its children have closed.
        // ...
        if self.parent.is_some() {
            // ...
            let subscriber = dispatcher::get_default(Dispatch::clone);
            if let Some(parent) = self.parent.take() {
                let _ = subscriber.try_close(parent);
            }
        }

        // Clear (but do not deallocate!) the pooled `HashMap` for the span's extensions.
        self.extensions
            .get_mut()
            // ...
            .clear();

        self.filter_map = FilterMap::new();
    }

    fn new_span(&self, attrs: &span::Attributes<'_>) -> span::Id {
        let parent = if attrs.is_root() {
            None
        } else if attrs.is_contextual() {
            self.current_span().id().map(|id| self.clone_span(id))
        } else {
            attrs.parent().map(|id| self.clone_span(id))
        };

        let id = self
            .spans
            // Check out a `DataInner` entry from the pool for the new span. If
            // there are free entries already allocated in the pool, this will
            // preferentially reuse one; otherwise, a new `DataInner` is
            // allocated and added to the pool.
            .create_with(|data| {
                data.metadata = attrs.metadata();
                data.parent = parent;
                data.filter_map = crate::filter::FILTERING.with(|filtering| filtering.filter_map());
                // ...
                let refs = data.ref_count.get_mut();
                debug_assert_eq!(*refs, 0);
                *refs = 1;
            })
            .expect("Unable to allocate another span");
        idx_to_id(id)
    }

#[inline]
fn idx_to_id(idx: usize) -> Id {
    Id::from_u64(idx as u64 + 1)
}

#[inline]
fn id_to_idx(id: &Id) -> usize {
    id.into_u64() as usize - 1
}

tracing = "=0.1.44"
tracing-subscriber = "=0.3.23"

use tracing::Span;
use tracing_subscriber::layer::SubscriberExt;

// sharded-slab 0.1.7 DefaultConfig（64 位）：低 38 位地址，13 位线程号，再往上是代数
fn show(label: &str, span: &Span) {
  let id = span.id().expect("span 没被过滤").into_u64();
  let key = id - 1;
  let addr = key & ((1 << 38) - 1);
  let tid = (key >> 38) & ((1 << 13) - 1);
  let generation = key >> 51;
  println!("{label:<16} Id({id:<16}) 地址 {addr:<2} 线程 {tid} 代数 {generation}");
}

fn main() {
  let sub = tracing_subscriber::registry().with(tracing_subscriber::layer::Identity::new());
  tracing::subscriber::set_global_default(sub).unwrap();

  let a = tracing::info_span!("a");
  show("a", &a);
  let b = tracing::info_span!(parent: &a, "b");
  show("b (a 的子)", &b);
  let c = tracing::info_span!("c");
  show("c", &c);

  drop(c);
  let d = tracing::info_span!("d");
  show("d (c 关闭后)", &d);
  drop(d);
  let e = tracing::info_span!("e");
  show("e (d 关闭后)", &e);

  let a2 = a.clone();
  drop(a);
  let f = tracing::info_span!("f");
  show("f (a 还有克隆)", &f);
  drop(a2);
  drop(b); // b 是最后一个引用 a 的地方，a 在这之后才真正关闭
  let g = tracing::info_span!("g");
  show("g (a、b 关闭后)", &g);

  std::thread::spawn(|| {
    let t = tracing::info_span!("t");
    show("t (另一个线程)", &t);
  })
  .join()
  .unwrap();
}

a                Id(1               ) 地址 0  线程 0 代数 0
b (a 的子)         Id(2               ) 地址 1  线程 0 代数 0
c                Id(3               ) 地址 2  线程 0 代数 0
d (c 关闭后)        Id(2251799813685251) 地址 2  线程 0 代数 1
e (d 关闭后)        Id(4503599627370499) 地址 2  线程 0 代数 2
f (a 还有克隆)       Id(4               ) 地址 3  线程 0 代数 0
g (a、b 关闭后)      Id(2251799813685250) 地址 1  线程 0 代数 1
t (另一个线程)        Id(274877906945    ) 地址 0  线程 1 代数 0

type AnyMap = HashMap<TypeId, Box<dyn Any + Send + Sync>, BuildHasherDefault<IdHasher>>;

    pub fn insert<T: Send + Sync + 'static>(&mut self, val: T) {
        assert!(self.replace(val).is_none())
    }

#[derive(Debug)]
struct ContextId {
    id: Id,
    duplicate: bool,
}
// ...
pub(crate) struct SpanStack {
    stack: Vec<ContextId>,
}

impl SpanStack {
    #[inline]
    pub(super) fn push(&mut self, id: Id) {
        let duplicate = self.stack.iter().any(|i| i.id == id);
        self.stack.push(ContextId { id, duplicate });
    }

    #[inline]
    pub(super) fn pop(&mut self, expected_id: &Id) -> bool {
        if let Some((idx, _)) = self
            .stack
            .iter()
            .enumerate()
            .rev()
            .find(|(_, ctx_id)| ctx_id.id == *expected_id)
        {
            let ContextId { id: _, duplicate } = self.stack.remove(idx);
            return !duplicate;
        }
        false
    }

    #[inline]
    pub(crate) fn iter(&self) -> impl Iterator<Item = &Id> {
        self.stack
            .iter()
            .rev()
            .filter_map(|ContextId { id, duplicate }| if !*duplicate { Some(id) } else { None })
    }

    #[inline]
    pub(crate) fn current(&self) -> Option<&Id> {
        self.iter().next()
    }
}

    fn enter(&self, id: &span::Id) {
        self.current_spans
            .get_or_default()
            .borrow_mut()
            .push(id.clone());
    }

    fn exit(&self, id: &span::Id) {
        if let Some(spans) = self.current_spans.get() {
            spans.borrow_mut().pop(id);
        }
    }

        let refs = span.ref_count.fetch_add(1, Ordering::Relaxed);
        assert_ne!(
            refs, 0,
            "tried to clone a span ({:?}) that already closed",
            id
        );

    fn try_close(&self, id: span::Id) -> bool {
        let span = match self.get(&id) {
            Some(span) => span,
            None if std::thread::panicking() => return false,
            None => panic!("tried to drop a ref to {:?}, but no such span exists!", id),
        };

        let refs = span.ref_count.fetch_sub(1, Ordering::Release);
        if !std::thread::panicking() {
            assert!(refs < usize::MAX, "reference count overflow!");
        }
        if refs > 1 {
            return false;
        }

        // Synchronize if we are actually removing the span (stolen
        // from std::Arc); this ensures that all other `try_close` calls on
        // other threads happen-before we actually remove the span.
        fence(Ordering::Acquire);
        true
    }

impl Drop for CloseGuard<'_> {
    fn drop(&mut self) {
        // ...
        let _ = CLOSE_COUNT.try_with(|count| {
            let c = count.get();
            // Decrement the count to indicate that _this_ guard's
            // `on_close` callback has completed.
            //
            // Note that we *must* do this before we actually remove the span
            // from the registry, since dropping the `DataInner` may trigger a
            // new close, if this span is the last reference to a parent span.
            count.set(c - 1);

            // If the current close count is 1, this stack frame is the last
            // `on_close` call. If the span is closing, it's okay to remove the
            // span.
            if c == 1 && self.is_closing {
                self.registry.spans.clear(id_to_idx(&self.id));
            }
        });
    }
}

use tracing::span::{Attributes, Id};
use tracing::{Dispatch, Subscriber};
use tracing_subscriber::layer::{Context, Layer, SubscriberExt};
use tracing_subscriber::registry::{LookupSpan, Registry};

// 挂在 span 的 Extensions 里的数据：进入了几次
struct Enters(u32);

struct Check(&'static str);

impl<S: Subscriber + for<'a> LookupSpan<'a>> Layer<S> for Check {
  fn on_new_span(&self, _: &Attributes<'_>, id: &Id, ctx: Context<'_, S>) {
    if self.0 == "A" {
      ctx.span(id).unwrap().extensions_mut().insert(Enters(0));
    }
  }
  fn on_enter(&self, id: &Id, ctx: Context<'_, S>) {
    if self.0 == "A" {
      ctx.span(id).unwrap().extensions_mut().get_mut::<Enters>().unwrap().0 += 1;
    }
  }
  fn on_close(&self, id: Id, ctx: Context<'_, S>) {
    match ctx.span(&id) {
      Some(span) => {
        let parent = span.parent().map(|p| p.name()).unwrap_or("-");
        let enters = span.extensions().get::<Enters>().map(|e| e.0);
        println!(
          "  {} on_close {:?}: 查得到 {}，父 {}，进入 {:?} 次",
          self.0,
          id,
          span.name(),
          parent,
          enters
        );
      }
      None => println!("  {} on_close {:?}: 查不到", self.0, id),
    }
  }
}

fn main() {
  let dispatch = Dispatch::new(
    tracing_subscriber::registry()
      .with(Check("A"))
      .with(Check("B"))
      .with(Check("C")),
  );
  tracing::dispatcher::with_default(&dispatch, || {
    let parent = tracing::info_span!("parent");
    let child = tracing::info_span!(parent: &parent, "child");
    for _ in 0..3 {
      let _g = child.enter();
    }
    let parent_id = parent.id().unwrap();
    let child_id = child.id().unwrap();

    println!("-- drop(parent)");
    drop(parent);
    println!("-- drop(child)");
    drop(child);

    let registry = dispatch.downcast_ref::<Registry>().unwrap();
    println!("-- 关闭之后再查");
    println!("  parent {:?}: {}", parent_id, registry.span(&parent_id).is_some());
    println!("  child  {:?}: {}", child_id, registry.span(&child_id).is_some());
  });
}

-- drop(parent)
-- drop(child)
  A on_close Id(2): 查得到 child，父 parent，进入 Some(3) 次
  B on_close Id(2): 查得到 child，父 parent，进入 Some(3) 次
  C on_close Id(2): 查得到 child，父 parent，进入 Some(3) 次
  A on_close Id(1): 查得到 parent，父 -，进入 Some(0) 次
  B on_close Id(1): 查得到 parent，父 -，进入 Some(0) 次
  C on_close Id(1): 查得到 parent，父 -，进入 Some(0) 次
-- 关闭之后再查
  parent Id(1): false
  child  Id(2): false

pub trait LookupSpan<'a> {
    type Data: SpanData<'a>;

    fn span_data(&'a self, id: &Id) -> Option<Self::Data>;

    fn span(&'a self, id: &Id) -> Option<SpanRef<'a, Self>>
    where
        Self: Sized,
    { /* ... */ }
    // ...
}

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            let curr = self.registry.span(self.next.as_ref()?)?;

            #[cfg(all(feature = "registry", feature = "std"))]
            let curr = curr.with_filter(self.filter);
            self.next = curr.data.parent().cloned();

            // If the `Scope` is filtered, check if the current span is enabled
            // by the selected filter ID.

            #[cfg(all(feature = "registry", feature = "std"))]
            {
                if !curr.is_enabled_for(self.filter) {
                    // The current span in the chain is disabled for this
                    // filter. Try its parent.
                    continue;
                }
            }

            return Some(curr);
        }
    }

进 a、b 后    所在 span 链：["b"]
再进 a 后     所在 span 链：["b"]
Span::current() = b
出第二个 a 后   所在 span 链：["b"]
Span::current() = b