Make tracing optional

Author: taiki-e

.github/workflows/ci.yml

@@ -48,10 +48,12 @@ jobs:
       - name: Install Rust
         # --no-self-update is necessary because the windows environment cannot self-update rustup.exe.
         run: rustup update ${{ matrix.rust }} --no-self-update && rustup default ${{ matrix.rust }}
+      - name: Install cargo-hack
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-hack
       - run: cargo build --all --all-features --all-targets
-      - name: Run cargo check (without dev-dependencies to catch missing feature flags)
-        if: startsWith(matrix.rust, 'nightly')
-        run: cargo check -Z features=dev_dep
+      - run: cargo hack build --feature-powerset --no-dev-deps
       - name: Add rust-src
         if: startsWith(matrix.rust, 'nightly') && startsWith(matrix.os, 'ubuntu')
         run: rustup component add rust-src

Cargo.toml

@@ -35,7 +35,7 @@ parking = "2.0.0"
 polling = "3.0.0"
 rustix = { version = "1.0.7", default-features = false, features = ["fs", "net", "std"] }
 slab = "0.4.2"
-tracing = { version = "0.1.37", default-features = false }
+tracing = { version = "0.1.37", default-features = false, optional = true }
 
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.59.0", features = ["Win32_Foundation"] }

src/driver.rs

@@ -44,7 +44,9 @@ pub(crate) fn init() {
 
 /// The main loop for the "async-io" thread.
 fn main_loop(parker: parking::Parker) {
+    #[cfg(feature = "tracing")]
     let span = tracing::trace_span!("async_io::main_loop");
+    #[cfg(feature = "tracing")]
     let _enter = span.enter();
 
     // The last observed reactor tick.
@@ -65,6 +67,7 @@ fn main_loop(parker: parking::Parker) {
             };
 
             if let Some(mut reactor_lock) = reactor_lock {
+                #[cfg(feature = "tracing")]
                 tracing::trace!("waiting on I/O");
                 reactor_lock.react(None).ok();
                 last_tick = Reactor::get().ticker();
@@ -80,8 +83,10 @@ fn main_loop(parker: parking::Parker) {
                 .get(sleeps as usize)
                 .unwrap_or(&10_000);
 
+            #[cfg(feature = "tracing")]
             tracing::trace!("sleeping for {} us", delay_us);
             if parker.park_timeout(Duration::from_micros(*delay_us)) {
+                #[cfg(feature = "tracing")]
                 tracing::trace!("notified");
 
                 // If notified before timeout, reset the last tick and the sleep counter.
@@ -109,7 +114,9 @@ fn main_loop(parker: parking::Parker) {
 /// });
 /// ```
 pub fn block_on<T>(future: impl Future<Output = T>) -> T {
+    #[cfg(feature = "tracing")]
     let span = tracing::trace_span!("async_io::block_on");
+    #[cfg(feature = "tracing")]
     let _enter = span.enter();
 
     // Increment `BLOCK_ON_COUNT` so that the "async-io" thread becomes less aggressive.
@@ -200,12 +207,14 @@ pub fn block_on<T>(future: impl Future<Output = T>) -> T {
                 // Ensure the cached parker is reset to the unnotified state for future block_on calls,
                 // in case this future called wake and then immediately returned Poll::Ready.
                 p.park_timeout(Duration::from_secs(0));
+                #[cfg(feature = "tracing")]
                 tracing::trace!("completed");
                 return t;
             }
 
             // Check if a notification was received.
             if p.park_timeout(Duration::from_secs(0)) {
+                #[cfg(feature = "tracing")]
                 tracing::trace!("notified");
 
                 // Try grabbing a lock on the reactor to process I/O events.
@@ -239,22 +248,26 @@ pub fn block_on<T>(future: impl Future<Output = T>) -> T {
                     // Check if a notification has been received before `io_blocked` was updated
                     // because in that case the reactor won't receive a wakeup.
                     if p.park_timeout(Duration::from_secs(0)) {
+                        #[cfg(feature = "tracing")]
                         tracing::trace!("notified");
                         break;
                     }
 
                     // Wait for I/O events.
+                    #[cfg(feature = "tracing")]
                     tracing::trace!("waiting on I/O");
                     reactor_lock.react(None).ok();
 
                     // Check if a notification has been received.
                     if p.park_timeout(Duration::from_secs(0)) {
+                        #[cfg(feature = "tracing")]
                         tracing::trace!("notified");
                         break;
                     }
 
                     // Check if this thread been handling I/O events for a long time.
                     if start.elapsed() > Duration::from_micros(500) {
+                        #[cfg(feature = "tracing")]
                         tracing::trace!("stops hogging the reactor");
 
                         // This thread is clearly processing I/O events for some other threads
@@ -274,6 +287,7 @@ pub fn block_on<T>(future: impl Future<Output = T>) -> T {
                 }
             } else {
                 // Wait for an actual notification.
+                #[cfg(feature = "tracing")]
                 tracing::trace!("sleep until notification");
                 p.park();
             }

src/reactor.rs

@@ -204,7 +204,9 @@ impl Reactor {
     ///
     /// Returns the duration until the next timer before this method was called.
     fn process_timers(&self, wakers: &mut Vec<Waker>) -> Option<Duration> {
+        #[cfg(feature = "tracing")]
         let span = tracing::trace_span!("process_timers");
+        #[cfg(feature = "tracing")]
         let _enter = span.enter();
 
         let mut timers = self.timers.lock().unwrap();
@@ -235,6 +237,7 @@ impl Reactor {
         drop(timers);
 
         // Add wakers to the list.
+        #[cfg(feature = "tracing")]
         tracing::trace!("{} ready wakers", ready.len());
 
         for (_, waker) in ready {
@@ -271,7 +274,9 @@ pub(crate) struct ReactorLock<'a> {
 impl ReactorLock<'_> {
     /// Processes new events, blocking until the first event or the timeout.
     pub(crate) fn react(&mut self, timeout: Option<Duration>) -> io::Result<()> {
+        #[cfg(feature = "tracing")]
         let span = tracing::trace_span!("react");
+        #[cfg(feature = "tracing")]
         let _enter = span.enter();
 
         let mut wakers = Vec::new();
@@ -353,6 +358,7 @@ impl ReactorLock<'_> {
         };
 
         // Wake up ready tasks.
+        #[cfg(feature = "tracing")]
         tracing::trace!("{} ready wakers", wakers.len());
         for waker in wakers {
             // Don't let a panicking waker blow everything up.
@@ -518,6 +524,7 @@ impl<T> Future for Readable<'_, T> {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         ready!(Pin::new(&mut self.0).poll(cx))?;
+        #[cfg(feature = "tracing")]
         tracing::trace!(fd = ?self.0.handle.source.registration, "readable");
         Poll::Ready(Ok(()))
     }
@@ -538,6 +545,7 @@ impl<T> Future for ReadableOwned<T> {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         ready!(Pin::new(&mut self.0).poll(cx))?;
+        #[cfg(feature = "tracing")]
         tracing::trace!(fd = ?self.0.handle.source.registration, "readable_owned");
         Poll::Ready(Ok(()))
     }
@@ -558,6 +566,7 @@ impl<T> Future for Writable<'_, T> {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         ready!(Pin::new(&mut self.0).poll(cx))?;
+        #[cfg(feature = "tracing")]
         tracing::trace!(fd = ?self.0.handle.source.registration, "writable");
         Poll::Ready(Ok(()))
     }
@@ -578,6 +587,7 @@ impl<T> Future for WritableOwned<T> {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         ready!(Pin::new(&mut self.0).poll(cx))?;
+        #[cfg(feature = "tracing")]
         tracing::trace!(fd = ?self.0.handle.source.registration, "writable_owned");
         Poll::Ready(Ok(()))
     }