Use macro wrappers for feature-gated tracing macros, turning all of them "off" by default (#270)

Co-authored-by: Leo <[email protected]>

Author: 0xNeshi

Cargo.toml

@@ -74,3 +74,4 @@ workspace = true
 
 [features]
 test-utils = []
+tracing = []

src/block_range_scanner.rs

@@ -76,10 +76,9 @@ use crate::{
 use alloy::{
     consensus::BlockHeader,
     eips::{BlockId, BlockNumberOrTag},
-    network::{BlockResponse, Network, primitives::HeaderResponse},
+    network::{BlockResponse, Network},
     primitives::BlockNumber,
 };
-use tracing::{error, info, warn};
 
 mod common;
 mod range_iterator;
@@ -295,7 +294,7 @@ impl<N: Network> Service<N> {
                 cmd = self.command_receiver.recv() => {
                     if let Some(command) = cmd {
                         if let Err(e) = self.handle_command(command).await {
-                            error!("Command handling error: {}", e);
+                            error!(error = %e, "Command handling error");
                             self.error_count += 1;
                         }
                     } else {
@@ -545,7 +544,7 @@ impl<N: Network> Service<N> {
         let common_ancestor = common_ancestor.header().number();
         info!(
             block_number = %tip_number,
-            hash = %tip.header().hash(),
+            hash = %alloy::network::primitives::HeaderResponse::hash(tip.header()),
             common_ancestor = %common_ancestor,
             "Reorg detected"
         );

src/block_range_scanner/common.rs

@@ -13,7 +13,6 @@ use alloy::{
     network::{BlockResponse, Network},
     primitives::BlockNumber,
 };
-use tracing::{error, info, warn};
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) async fn stream_live_blocks<N: Network>(

src/block_range_scanner/range_iterator.rs

@@ -1,6 +1,5 @@
 use alloy::primitives::BlockNumber;
 use std::{marker::PhantomData, ops::RangeInclusive};
-use tracing::debug;
 
 pub struct Forward;
 pub struct Reverse;

src/block_range_scanner/reorg_handler.rs

@@ -4,7 +4,6 @@ use alloy::{
     network::{BlockResponse, Ethereum, Network, primitives::HeaderResponse},
     primitives::BlockHash,
 };
-use tracing::{info, warn};
 
 use crate::{
     ScannerError,

src/block_range_scanner/sync_handler.rs

@@ -1,6 +1,5 @@
 use alloy::{eips::BlockId, network::Network, primitives::BlockNumber};
 use tokio::sync::mpsc;
-use tracing::{error, info};
 
 use crate::{
     Notification, ScannerError,

src/event_scanner/scanner/common.rs

@@ -20,7 +20,6 @@ use tokio::{
     task::JoinSet,
 };
 use tokio_stream::{Stream, wrappers::ReceiverStream};
-use tracing::{debug, error, info, trace, warn};
 
 #[derive(Copy, Clone, Debug)]
 pub(crate) enum ConsumerMode {
@@ -155,7 +154,7 @@ fn spawn_log_consumers_in_stream_mode<N: Network>(
                         break;
                     }
                     Err(RecvError::Lagged(skipped)) => {
-                        debug!("Channel lagged, skipped {skipped} messages");
+                        debug!(skipped_messages = skipped, "Channel lagged");
                     }
                 }
             }
@@ -301,7 +300,7 @@ fn spawn_log_consumers_in_collection_mode<N: Network>(
                         break;
                     }
                     Err(RecvError::Lagged(skipped)) => {
-                        debug!("Channel lagged, skipped {skipped} messages");
+                        debug!(skipped_messages = skipped, "Channel lagged");
                     }
                 }
             }

src/event_scanner/scanner/sync/from_latest.rs

@@ -1,7 +1,5 @@
 use alloy::{eips::BlockNumberOrTag, network::Network};
 
-use tracing::{error, info};
-
 use crate::{
     EventScannerBuilder, ScannerError,
     event_scanner::{

src/lib.rs

@@ -1,5 +1,7 @@
-pub mod block_range_scanner;
+#[macro_use]
+mod logging;
 
+pub mod block_range_scanner;
 pub mod robust_provider;
 #[cfg(any(test, feature = "test-utils"))]
 pub mod test_utils;

src/logging.rs

@@ -0,0 +1,104 @@
+#[cfg(feature = "tracing")]
+#[allow(unused_macros)]
+macro_rules! error {
+    ($($arg:tt)*) => {
+        tracing::error!($($arg)*)
+    };
+}
+
+#[cfg(not(feature = "tracing"))]
+#[allow(unused_macros)]
+macro_rules! error {
+    ($($arg:tt)*) => {
+        $crate::__trace_consume!($($arg)*)
+    };
+}
+
+#[cfg(feature = "tracing")]
+#[allow(unused_macros)]
+macro_rules! warn {
+    ($($arg:tt)*) => {
+        tracing::warn!($($arg)*)
+    };
+}
+
+#[cfg(not(feature = "tracing"))]
+#[allow(unused_macros)]
+macro_rules! warn {
+    ($($arg:tt)*) => {
+        $crate::__trace_consume!($($arg)*)
+    };
+}
+
+#[cfg(feature = "tracing")]
+#[allow(unused_macros)]
+macro_rules! info {
+    ($($arg:tt)*) => {
+        tracing::info!($($arg)*)
+    };
+}
+
+#[cfg(not(feature = "tracing"))]
+#[allow(unused_macros)]
+macro_rules! info {
+    ($($arg:tt)*) => {
+        $crate::__trace_consume!($($arg)*)
+    };
+}
+
+#[cfg(feature = "tracing")]
+#[allow(unused_macros)]
+macro_rules! debug {
+    ($($arg:tt)*) => {
+        tracing::debug!($($arg)*)
+    };
+}
+
+#[cfg(not(feature = "tracing"))]
+#[allow(unused_macros)]
+macro_rules! debug {
+    ($($arg:tt)*) => {
+        $crate::__trace_consume!($($arg)*)
+    };
+}
+
+#[cfg(feature = "tracing")]
+#[allow(unused_macros)]
+macro_rules! trace {
+    ($($arg:tt)*) => {
+        tracing::trace!($($arg)*)
+    };
+}
+
+#[cfg(not(feature = "tracing"))]
+#[allow(unused_macros)]
+macro_rules! trace {
+    ($($arg:tt)*) => {
+        $crate::__trace_consume!($($arg)*)
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+#[cfg(not(feature = "tracing"))]
+#[allow(unused_macros)]
+macro_rules! __trace_consume {
+    // field = %expr, rest...
+    ($field:ident = % $value:expr, $($rest:tt)*) => {
+        { let _ = &$value; $crate::__trace_consume!($($rest)*); }
+    };
+    // field = ?expr, rest...
+    ($field:ident = ? $value:expr, $($rest:tt)*) => {
+        { let _ = &$value; $crate::__trace_consume!($($rest)*); }
+    };
+    // field = expr, rest...
+    ($field:ident = $value:expr, $($rest:tt)*) => {
+        { let _ = &$value; $crate::__trace_consume!($($rest)*); }
+    };
+    // String literal or other tokens - ignore
+    ($lit:literal $($rest:tt)*) => {
+        $crate::__trace_consume!($($rest)*)
+    };
+    // Base case - empty
+    () => {};
+}