chore: revert #943

tracing-core/src/dispatcher.rs

@@ -149,7 +149,7 @@ use crate::stdlib::{
 
 #[cfg(feature = "std")]
 use crate::stdlib::{
-    cell::{Cell, RefCell, RefMut},
+    cell::{Cell, RefCell},
     error,
 };
 
@@ -193,12 +193,6 @@ struct State {
     can_enter: Cell<bool>,
 }
 
-/// While this guard is active, additional calls to subscriber functions on
-/// the default dispatcher will not be able to access the dispatch context.
-/// Dropping the guard will allow the dispatch context to be re-entered.
-#[cfg(feature = "std")]
-struct Entered<'a>(&'a State);
-
 /// A guard that resets the current default dispatcher to the prior
 /// default dispatcher when dropped.
 #[cfg(feature = "std")]
@@ -331,46 +325,38 @@ pub fn get_default<T, F>(mut f: F) -> T
 where
     F: FnMut(&Dispatch) -> T,
 {
+    // While this guard is active, additional calls to subscriber functions on
+    // the default dispatcher will not be able to access the dispatch context.
+    // Dropping the guard will allow the dispatch context to be re-entered.
+    struct Entered<'a>(&'a Cell<bool>);
+    impl<'a> Drop for Entered<'a> {
+        #[inline]
+        fn drop(&mut self) {
+            self.0.set(true);
+        }
+    }
+
     CURRENT_STATE
         .try_with(|state| {
-            if let Some(entered) = state.enter() {
-                return f(&*entered.current());
+            if state.can_enter.replace(false) {
+                let _guard = Entered(&state.can_enter);
+
+                let mut default = state.default.borrow_mut();
+
+                if default.is::<NoSubscriber>() {
+                    if let Some(global) = get_global() {
+                        // don't redo this call on the next check
+                        *default = global.clone();
+                    }
+                }
+                f(&*default)
+            } else {
+                f(&Dispatch::none())
             }
-
-            f(&Dispatch::none())
         })
         .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]: ../dispatcher/struct.Dispatch.html
-#[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]: ../dispatcher/struct.Dispatch.html
-#[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].
 ///
 /// [dispatcher]: ../dispatcher/struct.Dispatch.html
@@ -725,42 +711,6 @@ impl State {
         EXISTS.store(true, Ordering::Release);
         DefaultGuard(prior)
     }
-
-    #[inline]
-    fn enter(&self) -> Option<Entered<'_>> {
-        if self.can_enter.replace(false) {
-            Some(Entered(&self))
-        } else {
-            None
-        }
-    }
-}
-
-// ===== impl Entered =====
-
-#[cfg(feature = "std")]
-impl<'a> Entered<'a> {
-    #[inline]
-    fn current(&self) -> RefMut<'a, Dispatch> {
-        let mut default = self.0.default.borrow_mut();
-
-        if default.is::<NoSubscriber>() {
-            if let Some(global) = get_global() {
-                // don't redo this call on the next check
-                *default = global.clone();
-            }
-        }
-
-        default
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'a> Drop for Entered<'a> {
-    #[inline]
-    fn drop(&mut self) {
-        self.0.can_enter.set(true);
-    }
 }
 
 // ===== impl DefaultGuard =====

tracing/Cargo.toml

@@ -27,7 +27,7 @@ keywords = ["logging", "tracing", "metrics", "async"]
 edition = "2018"
 
 [dependencies]
-tracing-core = { path = "../tracing-core", version = "0.1.15", default-features = false }
+tracing-core = { path = "../tracing-core", version = "0.1.14", default-features = false }
 log = { version = "0.4", optional = true }
 tracing-attributes = { path = "../tracing-attributes", version = "0.1.10", optional = true }
 cfg-if = "0.1.10"

tracing/src/lib.rs

@@ -921,9 +921,9 @@ pub mod subscriber;
 
 #[doc(hidden)]
 pub mod __macro_support {
-    pub use crate::callsite::Callsite;
+    pub use crate::callsite::Callsite as _;
     use crate::stdlib::sync::atomic::{AtomicUsize, Ordering};
-    use crate::{subscriber::Interest, Metadata};
+    use crate::{subscriber::Interest, Callsite, Metadata};
     use tracing_core::Once;
 
     /// Callsite implementation used by macro-generated code.
@@ -952,90 +952,58 @@ pub mod __macro_support {
         /// without warning.
         pub const fn new(meta: &'static Metadata<'static>) -> Self {
             Self {
-                interest: AtomicUsize::new(0xDEADFACED),
+                interest: AtomicUsize::new(0),
                 meta,
                 registration: Once::new(),
             }
         }
 
-        /// Registers this callsite with the global callsite registry.
-        ///
-        /// If the callsite is already registered, this does nothing.
+        /// Returns `true` if the callsite is enabled by a cached interest, or
+        /// by the current `Dispatch`'s `enabled` method if the cached
+        /// `Interest` is `sometimes`.
         ///
         /// /!\ WARNING: This is *not* a stable API! /!\
         /// This method, and all code contained in the `__macro_support` module, is
         /// a *private* API of `tracing`. It is exposed publicly because it is used
         /// by the `tracing` macros, but it is not part of the stable versioned API.
         /// Breaking changes to this module may occur in small-numbered versions
         /// without warning.
-        #[inline(never)]
-        // This only happens once (or if the cached interest value was corrupted).
-        #[cold]
-        pub fn register(&'static self) -> Interest {
-            self.registration
-                .call_once(|| crate::callsite::register(self));
-            match self.interest.load(Ordering::Relaxed) {
-                0 => Interest::never(),
-                2 => Interest::always(),
-                _ => Interest::sometimes(),
+        #[inline(always)]
+        pub fn is_enabled(&self) -> bool {
+            let interest = self.interest();
+            if interest.is_always() {
+                return true;
+            }
+            if interest.is_never() {
+                return false;
             }
+
+            crate::dispatcher::get_default(|current| current.enabled(self.meta))
         }
 
-        /// Returns the callsite's cached Interest, or registers it for the
-        /// first time if it has not yet been registered.
+        /// Registers this callsite with the global callsite registry.
+        ///
+        /// If the callsite is already registered, this does nothing.
         ///
         /// /!\ WARNING: This is *not* a stable API! /!\
         /// This method, and all code contained in the `__macro_support` module, is
         /// a *private* API of `tracing`. It is exposed publicly because it is used
         /// by the `tracing` macros, but it is not part of the stable versioned API.
         /// Breaking changes to this module may occur in small-numbered versions
         /// without warning.
-        #[inline]
-        pub fn interest(&'static self) -> Interest {
+        #[inline(always)]
+        pub fn register(&'static self) {
+            self.registration
+                .call_once(|| crate::callsite::register(self));
+        }
+
+        #[inline(always)]
+        fn interest(&self) -> Interest {
             match self.interest.load(Ordering::Relaxed) {
                 0 => Interest::never(),
-                1 => Interest::sometimes(),
                 2 => Interest::always(),
-                _ => self.register(),
-            }
-        }
-
-        pub fn dispatch_event(&'static self, interest: Interest, f: impl FnOnce(&crate::Dispatch)) {
-            tracing_core::dispatcher::get_current(|current| {
-                if interest.is_always() || current.enabled(self.meta) {
-                    f(current)
-                }
-            });
-        }
-
-        #[inline]
-        #[cfg(feature = "log")]
-        pub fn disabled_span(&self) -> crate::Span {
-            crate::Span::new_disabled(self.meta)
-        }
-
-        #[inline]
-        #[cfg(not(feature = "log"))]
-        pub fn disabled_span(&self) -> crate::Span {
-            crate::Span::none()
-        }
-
-        pub fn dispatch_span(
-            &'static self,
-            interest: Interest,
-            f: impl FnOnce(&crate::Dispatch) -> crate::Span,
-        ) -> crate::Span {
-            if interest.is_never() {
-                return self.disabled_span();
+                _ => Interest::sometimes(),
             }
-
-            tracing_core::dispatcher::get_current(|current| {
-                if interest.is_always() || current.enabled(self.meta) {
-                    return f(current);
-                }
-                self.disabled_span()
-            })
-            .unwrap_or_else(|| self.disabled_span())
         }
     }