no-std mostly works without alloc now

Signed-off-by: Eliza Weisman <eliza@buoyant.io>

Author: hawkw

tracing-core/src/callsite.rs

@@ -205,7 +205,15 @@ mod inner {
     /// [`Interest::sometimes()`]: super::subscriber::Interest::sometimes
     /// [`Subscriber`]: super::subscriber::Subscriber
     pub fn rebuild_interest_cache() {
-        rebuild_interest(&REGISTRY, crate::dispatcher::get_global());
+        let dispatcher = crate::dispatcher::get_global();
+        let mut max_level = LevelFilter::OFF;
+        // If the subscriber did not provide a max level hint, assume
+        // that it may enable every level.
+        let level_hint = dispatcher.max_level_hint().unwrap_or(LevelFilter::TRACE);
+
+        REGISTRY.for_each(|reg| rebuild_callsite_interest(dispatcher, reg.callsite));
+
+        LevelFilter::set_max(max_level);
     }
 
     /// Register a new `Callsite` with the global registry.
@@ -222,17 +230,6 @@ mod inner {
 
         callsite.set_interest(dispatcher.register_callsite(meta))
     }
-
-    fn rebuild_interest(callsites: &Callsites, dispatcher: &dyn Subscriber) {
-        let mut max_level = LevelFilter::OFF;
-        // If the subscriber did not provide a max level hint, assume
-        // that it may enable every level.
-        let level_hint = dispatcher.max_level_hint().unwrap_or(LevelFilter::TRACE);
-
-        callsites.for_each(|reg| rebuild_callsite_interest(dispatcher, reg.callsite));
-
-        LevelFilter::set_max(max_level);
-    }
 }
 
 // ===== impl Identifier =====

tracing-core/src/dispatcher.rs

@@ -184,10 +184,16 @@ const INITIALIZING: usize = 1;
 const INITIALIZED: usize = 2;
 
 static mut GLOBAL_DISPATCH: Dispatch = Dispatch {
+    #[cfg(feature = "std")]
     subscriber: Kind::Global(&NO_SUBSCRIBER),
+    #[cfg(not(feature = "std"))]
+    subscriber: &NO_SUBSCRIBER,
 };
 static NONE: Dispatch = Dispatch {
+    #[cfg(feature = "std")]
     subscriber: Kind::Global(&NO_SUBSCRIBER),
+    #[cfg(not(feature = "std"))]
+    subscriber: &NO_SUBSCRIBER,
 };
 static NO_SUBSCRIBER: NoSubscriber = NoSubscriber;
 
@@ -396,34 +402,34 @@ where
         .unwrap_or_else(|_| f(&Dispatch::none()))
 }
 
-/// Executes a closure with a reference to this thread's current [dispatcher].
-///
-/// Note that calls to `get_default` should not be nested; if this function is
-/// called while inside of another `get_default`, that closure will be provided
-/// with `Dispatch::none` rather than the previously set dispatcher.
-///
-/// [dispatcher]: super::dispatcher::Dispatch
-#[cfg(feature = "std")]
-#[doc(hidden)]
-#[inline(never)]
-pub fn get_current<T>(f: impl FnOnce(&Dispatch) -> T) -> Option<T> {
-    CURRENT_STATE
-        .try_with(|state| {
-            let entered = state.enter()?;
-            Some(f(&*entered.current()))
-        })
-        .ok()?
-}
-
-/// Executes a closure with a reference to the current [dispatcher].
-///
-/// [dispatcher]: super::dispatcher::Dispatch
-#[cfg(not(feature = "std"))]
-#[doc(hidden)]
-pub fn get_current<T>(f: impl FnOnce(&Dispatch) -> T) -> Option<T> {
-    let dispatch = get_global()?;
-    Some(f(&dispatch))
-}
+// /// Executes a closure with a reference to this thread's current [dispatcher].
+// ///
+// /// Note that calls to `get_default` should not be nested; if this function is
+// /// called while inside of another `get_default`, that closure will be provided
+// /// with `Dispatch::none` rather than the previously set dispatcher.
+// ///
+// /// [dispatcher]: super::dispatcher::Dispatch
+// #[cfg(feature = "std")]
+// #[doc(hidden)]
+// #[inline(never)]
+// pub fn get_current<T>(f: impl FnOnce(&Dispatch) -> T) -> Option<T> {
+//     CURRENT_STATE
+//         .try_with(|state| {
+//             let entered = state.enter()?;
+//             Some(f(&*entered.current()))
+//         })
+//         .ok()?
+// }
+
+// /// Executes a closure with a reference to the current [dispatcher].
+// ///
+// /// [dispatcher]: super::dispatcher::Dispatch
+// #[cfg(not(feature = "std"))]
+// #[doc(hidden)]
+// pub fn get_current<T>(f: impl FnOnce(&Dispatch) -> T) -> Option<T> {
+//     let dispatch = get_global()?;
+//     Some(f(&dispatch))
+// }
 
 /// Executes a closure with a reference to the current [dispatcher].
 ///
@@ -752,6 +758,7 @@ impl fmt::Debug for Dispatch {
     }
 }
 
+#[cfg(feature = "std")]
 impl<S> From<S> for Dispatch
 where
     S: Subscriber + Send + Sync + 'static,
@@ -788,6 +795,7 @@ impl Subscriber for NoSubscriber {
     fn exit(&self, _span: &span::Id) {}
 }
 
+#[cfg(feature = "std")]
 impl Registrar {
     pub(crate) fn upgrade(&self) -> Option<Dispatch> {
         match self.0 {
@@ -889,13 +897,13 @@ mod test {
 
     #[test]
     fn dispatch_is() {
-        let dispatcher = Dispatch::new(NoSubscriber);
+        let dispatcher = Dispatch::from_static(&NO_SUBSCRIBER);
         assert!(dispatcher.is::<NoSubscriber>());
     }
 
     #[test]
     fn dispatch_downcasts() {
-        let dispatcher = Dispatch::new(NoSubscriber);
+        let dispatcher = Dispatch::from_static(&NO_SUBSCRIBER);
         assert!(dispatcher.downcast_ref::<NoSubscriber>().is_some());
     }
 

tracing-core/src/field.rs

@@ -828,7 +828,6 @@ impl_valid_len! {
 mod test {
     use super::*;
     use crate::metadata::{Kind, Level, Metadata};
-    use alloc::{borrow::ToOwned, string::String};
 
     struct TestCallsite1;
     static TEST_CALLSITE_1: TestCallsite1 = TestCallsite1;
@@ -957,6 +956,7 @@ mod test {
     }
 
     #[test]
+    #[cfg(feature = "std")]
     fn record_debug_fn() {
         let fields = TEST_META_1.fields();
         let values = &[
@@ -970,6 +970,6 @@ mod test {
             use core::fmt::Write;
             write!(&mut result, "{:?}", value).unwrap();
         });
-        assert_eq!(result, "123".to_owned());
+        assert_eq!(result, String::from("123"));
     }
 }

tracing-core/tests/global_dispatch.rs

@@ -4,7 +4,8 @@ use common::*;
 use tracing_core::dispatcher::*;
 #[test]
 fn global_dispatch() {
-    set_global_default(Dispatch::new(TestSubscriberA)).expect("global dispatch set failed");
+    static TEST: TestSubscriberA = TestSubscriberA;
+    set_global_default(Dispatch::from_static(&TEST)).expect("global dispatch set failed");
     get_default(|current| {
         assert!(
             current.is::<TestSubscriberA>(),
@@ -29,6 +30,6 @@ fn global_dispatch() {
         )
     });
 
-    set_global_default(Dispatch::new(TestSubscriberA))
+    set_global_default(Dispatch::from_static(&TEST))
         .expect_err("double global dispatch set succeeded");
 }