Dispatch：全局与线程局部

#[derive(Clone)]
pub struct Dispatch {
    subscriber: Kind<Arc<dyn Subscriber + Send + Sync>>,
}

#[derive(Clone)]
pub struct WeakDispatch {
    subscriber: Kind<Weak<dyn Subscriber + Send + Sync>>,
}

#[derive(Clone)]
enum Kind<T> {
    Global(&'static (dyn Subscriber + Send + Sync)),
    Scoped(T),
}

static mut GLOBAL_DISPATCH: Dispatch = Dispatch {
    subscriber: Kind::Global(&NO_SUBSCRIBER),
};
static NONE: Dispatch = Dispatch {
    subscriber: Kind::Global(&NO_SUBSCRIBER),
};
static NO_SUBSCRIBER: NoSubscriber = NoSubscriber::new();

static EXISTS: AtomicBool = AtomicBool::new(false);
static GLOBAL_INIT: AtomicUsize = AtomicUsize::new(UNINITIALIZED);

const UNINITIALIZED: usize = 0;
const INITIALIZING: usize = 1;
const INITIALIZED: usize = 2;

pub fn set_global_default(dispatcher: Dispatch) -> Result<(), SetGlobalDefaultError> {
    // if `compare_exchange` returns Result::Ok(_), then `new` has been set and
    // `current`—now the prior value—has been returned in the `Ok()` branch.
    if GLOBAL_INIT
        .compare_exchange(
            UNINITIALIZED,
            INITIALIZING,
            Ordering::SeqCst,
            Ordering::SeqCst,
        )
        .is_ok()
    {
        let subscriber = {
            let subscriber = match dispatcher.subscriber {
                Kind::Global(s) => s,
                Kind::Scoped(s) => unsafe {
                    // safety: this leaks the subscriber onto the heap. the
                    // reference count will always be at least 1, because the
                    // global default will never be dropped.
                    &*Arc::into_raw(s)
                },
            };
            Kind::Global(subscriber)
        };
        unsafe {
            GLOBAL_DISPATCH = Dispatch { subscriber };
        }
        GLOBAL_INIT.store(INITIALIZED, Ordering::SeqCst);
        EXISTS.store(true, Ordering::Release);
        Ok(())
    } else {
        Err(SetGlobalDefaultError { _no_construct: () })
    }
}

[dependencies]
tracing = "=0.1.44"

use std::fmt;
use tracing::field::Field;
use tracing::span::{Attributes, Id, Record};
use tracing::{Event, Metadata, Subscriber};

/// 把收到的每条事件连同自己的名字、所在线程打印出来。
pub struct Named(pub &'static str);

impl Subscriber for Named {
  fn enabled(&self, _: &Metadata<'_>) -> bool {
    true
  }
  fn new_span(&self, _: &Attributes<'_>) -> Id {
    Id::from_u64(1)
  }
  fn record(&self, _: &Id, _: &Record<'_>) {}
  fn record_follows_from(&self, _: &Id, _: &Id) {}
  fn event(&self, event: &Event<'_>) {
    let mut msg = String::new();
    event.record(&mut |f: &Field, v: &dyn fmt::Debug| {
      if f.name() == "message" {
        msg = format!("{v:?}");
      }
    });
    let thread = std::thread::current();
    println!("  [{}] 线程 {}：{}", self.0, thread.name().unwrap_or("?"), msg);
  }
  fn enter(&self, _: &Id) {}
  fn exit(&self, _: &Id) {}
}

impl Drop for Named {
  fn drop(&mut self) {
    println!("  （{} 被 drop）", self.0);
  }
}

use tracing::info;

fn main() {
  let first = tracing::subscriber::set_global_default(Named("first"));
  println!("第一次：{first:?}");
  let err = tracing::subscriber::set_global_default(Named("second")).unwrap_err();
  println!("第二次 Display：{err}");
  println!("第二次 Debug：{err:?}");
  let err = tracing_subscriber::fmt().try_init().unwrap_err();
  println!("fmt().try_init() Display：{err}");
  println!("fmt().try_init() Debug：{err:?}");
  info!("谁收到这条？");
}

第一次：Ok(())
  （second 被 drop）
第二次 Display：a global default trace dispatcher has already been set
第二次 Debug：SetGlobalDefaultError("a global default trace dispatcher has already been set")
fmt().try_init() Display：a global default trace dispatcher has already been set
fmt().try_init() Debug：SetGlobalDefaultError("a global default trace dispatcher has already been set")
  [first] 线程 main：谁收到这条？

std::thread_local! {
    static CURRENT_STATE: State = const {
        State {
            default: RefCell::new(None),
            can_enter: Cell::new(true),
        }
    };
}

#[cfg(feature = "std")]
static SCOPED_COUNT: AtomicUsize = AtomicUsize::new(0);

    fn set_default(new_dispatch: Dispatch) -> DefaultGuard {
        let prior = CURRENT_STATE
            .try_with(|state| {
                state.can_enter.set(true);
                state.default.replace(Some(new_dispatch))
            })
            .ok()
            .flatten();
        EXISTS.store(true, Ordering::Release);
        SCOPED_COUNT.fetch_add(1, Ordering::Release);
        DefaultGuard(prior)
    }

impl Drop for DefaultGuard {
    #[inline]
    fn drop(&mut self) {
        // Replace the dispatcher and then drop the old one outside
        // of the thread-local context. Dropping the dispatch may
        // lead to the drop of a subscriber which, in the process,
        // could then also attempt to access the same thread local
        // state -- causing a clash.
        let prev = CURRENT_STATE.try_with(|state| state.default.replace(self.0.take()));
        SCOPED_COUNT.fetch_sub(1, Ordering::Release);
        drop(prev)
    }
}

use std::thread;
use tracing::info;

fn main() {
  let _guard = tracing::subscriber::set_default(Named("A"));
  info!("主线程，A 已设为线程默认");

  thread::Builder::new()
    .name("worker".into())
    .spawn(|| {
      println!("worker 开始");
      info!("worker，什么都没设");
      tracing::subscriber::with_default(Named("B"), || {
        info!("worker，with_default(B) 里面");
      });
      info!("worker，with_default 返回之后");
      println!("worker 结束");
    })
    .unwrap()
    .join()
    .unwrap();

  info!("主线程，join 之后");
}

  [A] 线程 main：主线程，A 已设为线程默认
worker 开始
  [B] 线程 worker：worker，with_default(B) 里面
  （B 被 drop）
worker 结束
  [A] 线程 main：主线程，join 之后
  （A 被 drop）

use tracing::info;
use tracing::subscriber::set_default;

fn main() {
  println!("1. let _ = set_default(..)");
  let _ = set_default(Named("A"));
  info!("一");

  println!("2. let _guard = set_default(..)");
  let _guard = set_default(Named("B"));
  info!("二");
  drop(_guard);

  println!("3. 嵌套，后建的先 drop");
  let g1 = set_default(Named("C"));
  let g2 = set_default(Named("D"));
  info!("三：两个守卫都在");
  drop(g2);
  info!("三：drop g2 之后");
  drop(g1);
  info!("三：drop g1 之后");
}

1. let _ = set_default(..)
  （A 被 drop）
2. let _guard = set_default(..)
  [B] 线程 main：二
  （B 被 drop）
3. 嵌套，后建的先 drop
  [D] 线程 main：三：两个守卫都在
  （D 被 drop）
  [C] 线程 main：三：drop g2 之后
  （C 被 drop）

warning: unused return value of `tracing::subscriber::set_default` that must be used
 --> src/bin/must_use.rs:4:3
  |
4 |   tracing::subscriber::set_default(Named("A"));
  |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: Dropping the guard unregisters the subscriber.
  = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
  |
4 |   let _ = tracing::subscriber::set_default(Named("A"));
  |   +++++++

pub fn get_default<T, F>(mut f: F) -> T
where
    F: FnMut(&Dispatch) -> T,
{
    if SCOPED_COUNT.load(Ordering::Acquire) == 0 {
        // fast path if no scoped dispatcher has been set; just use the global
        // default.
        return f(get_global());
    }

    CURRENT_STATE
        .try_with(|state| {
            if let Some(entered) = state.enter() {
                return f(&entered.current());
            }

            f(&NONE)
        })
        .unwrap_or_else(|_| f(&NONE))
}

    fn enter(&self) -> Option<Entered<'_>> {
        if self.can_enter.replace(false) {
            Some(Entered(self))
        } else {
            None
        }
    }

use std::cell::Cell;
use std::fmt;
use tracing::field::Field;
use tracing::span::{Attributes, Id, Record};
use tracing::{Event, Metadata, Subscriber, info};

thread_local! {
  static DEPTH: Cell<usize> = const { Cell::new(0) };
}

/// 在自己的 event 里再打一条日志；深度到 3 就停，免得真的栈溢出。
struct Chatty;

impl Subscriber for Chatty {
  fn enabled(&self, _: &Metadata<'_>) -> bool {
    true
  }
  fn new_span(&self, _: &Attributes<'_>) -> Id {
    Id::from_u64(1)
  }
  fn record(&self, _: &Id, _: &Record<'_>) {}
  fn record_follows_from(&self, _: &Id, _: &Id) {}
  fn event(&self, event: &Event<'_>) {
    let mut msg = String::new();
    event.record(&mut |f: &Field, v: &dyn fmt::Debug| {
      if f.name() == "message" {
        msg = format!("{v:?}");
      }
    });
    let depth = DEPTH.with(|d| d.get());
    println!("  event 深度 {depth}：{msg}");
    if depth < 3 {
      DEPTH.with(|d| d.set(depth + 1));
      info!("subscriber 自己打的日志");
      DEPTH.with(|d| d.set(depth));
    }
  }
  fn enter(&self, _: &Id) {}
  fn exit(&self, _: &Id) {}
}

fn main() {
  println!("线程默认（set_default）：");
  {
    let _guard = tracing::subscriber::set_default(Chatty);
    info!("用户的日志");
  }
  println!("全局默认（set_global_default）：");
  tracing::subscriber::set_global_default(Chatty).unwrap();
  info!("用户的日志");
}

线程默认（set_default）：
  event 深度 0：用户的日志
全局默认（set_global_default）：
  event 深度 0：用户的日志
  event 深度 1：subscriber 自己打的日志
  event 深度 2：subscriber 自己打的日志
  event 深度 3：subscriber 自己打的日志

use tracing::info;
use tracing::level_filters::LevelFilter;
use tracing_core::subscriber::NoSubscriber;

fn side_effect() -> u32 {
  println!("  字段表达式被求值了");
  42
}

fn main() {
  println!("LevelFilter::current() = {}", LevelFilter::current());
  info!(x = side_effect(), "没有 subscriber");
  let is_none = tracing::dispatcher::get_default(|d| d.is::<NoSubscriber>());
  println!("get_default 给的是 NoSubscriber：{is_none}");
}

LevelFilter::current() = off
get_default 给的是 NoSubscriber：true

impl Kind<Weak<dyn Subscriber + Send + Sync>> {
    fn upgrade(&self) -> Option<Kind<Arc<dyn Subscriber + Send + Sync>>> {
        match self {
            Kind::Global(s) => Some(Kind::Global(*s)),
            Kind::Scoped(ref s) => Some(Kind::Scoped(s.upgrade()?)),
        }
    }
}

  （F 被 drop）
main 结束
  （E 被 drop）

  （F 被 drop）
  [E] 线程 main：别的线程持有守卫时
  （G 被 drop）
  （E 被 drop）