refactor: span_debug et al

Author: prestwich

src/macros.rs

@@ -7,6 +7,31 @@ macro_rules! span_scoped   {
     };
 }
 
+/// Helper macro to log a debug event within a span that is not currently
+/// entered.
+macro_rules! span_debug {
+    ($span:expr, $($arg:tt)*) => {
+        span_scoped!($span, debug!($($arg)*))
+    };
+}
+
+/// Helper macro to log an info event within a span that is not currently
+/// entered.
+macro_rules! span_info {
+    ($span:expr, $($arg:tt)*) => {
+        span_scoped!($span, info!($($arg)*))
+    };
+
+}
+
+/// Helper macro to log a warning event within a span that is not currently
+/// entered.
+macro_rules! span_error {
+    ($span:expr, $($arg:tt)*) => {
+        span_scoped!($span, error!($($arg)*))
+    };
+}
+
 /// Helper macro to unwrap a result or continue the loop with a tracing event.
 macro_rules! res_unwrap_or_continue {
     ($result:expr, $span:expr, $level:ident!($($arg:tt)*)) => {

src/tasks/block/sim.rs

@@ -207,7 +207,7 @@ impl Simulator {
             let Some(sim_env) = self.sim_env.borrow_and_update().clone() else { return };
 
             let span = sim_env.span();
-            span_scoped!(span, info!("new block environment received"));
+            span_info!(span, "new block environment received");
 
             // Calculate the deadline for this block simulation.
             // NB: This must happen _after_ taking a reference to the sim cache,
@@ -219,7 +219,7 @@ impl Simulator {
                 .handle_build(constants.clone(), sim_cache, finish_by, sim_env.block_env.clone())
                 .instrument(span.clone())
                 .await
-                .inspect_err(|err| span_scoped!(span, error!(%err, "error during block build")))
+                .inspect_err(|err| span_error!(span, %err, "error during block build"))
             else {
                 continue;
             };

src/tasks/env.rs

@@ -98,7 +98,7 @@ impl EnvTask {
         let mut headers = match self.ru_provider.subscribe_blocks().await {
             Ok(poller) => poller,
             Err(err) => {
-                span_scoped!(span, error!(%err, "Failed to subscribe to blocks"));
+                span_error!(span, %err, "Failed to subscribe to blocks");
                 return;
             }
         }

src/tasks/submit/builder_helper.rs

@@ -32,7 +32,7 @@ macro_rules! spawn_provider_send {
             let p = $provider.clone();
             let t = $tx.clone();
             tokio::spawn(async move {
-                p.send_tx_envelope(t).await.inspect_err(|e| {
+                p.send_tx_envelope(t).in_current_span().await.inspect_err(|e| {
                    warn!(%e, "error in transaction broadcast")
                 })
             }.instrument($span.clone()))
@@ -44,17 +44,13 @@ macro_rules! spawn_provider_send {
 macro_rules! check_slot_still_valid {
     ($self:expr, $initial_slot:expr, $span:expr) => {
         if !$self.slot_still_valid($initial_slot) {
-            $span.in_scope(|| {
-                debug!(
-                    current_slot = $self
-                        .config
-                        .slot_calculator
-                        .current_slot()
-                        .expect("host chain has started"),
-                    initial_slot = $initial_slot,
-                    "slot changed before submission - skipping block"
-                )
-            });
+            span_debug!(
+                $span,
+                current_slot =
+                    $self.config.slot_calculator.current_slot().expect("host chain has started"),
+                initial_slot = $initial_slot,
+                "slot changed before submission - skipping block"
+            );
             counter!("builder.slot_missed").increment(1);
             return Ok(ControlFlow::Skip);
         }
@@ -115,7 +111,7 @@ impl BuilderHelperTask {
         // Set up a span for the send operation. We'll add this to the spawned
         // tasks
         let span = debug_span!("BuilderHelperTask::send_transaction", tx_hash = %tx.hash());
-        span_scoped!(span, debug!("sending transaction to network"));
+        span_debug!(span, "sending transaction to network");
 
         // send the tx via the primary host_provider
         let fut = spawn_provider_send!(self.provider(), &tx, &span);
@@ -127,30 +123,29 @@ impl BuilderHelperTask {
 
         // send the in-progress transaction over the outbound_tx_channel
         if self.outbound_tx_channel.send(*tx.tx_hash()).is_err() {
-            span_scoped!(span, error!("receipts task gone"));
+            span_error!(span, "receipts task gone");
         }
 
         if let Err(error) = fut.await? {
             // Detect and handle transaction underprice errors
             if matches!(error, TransportError::ErrorResp(ref err) if err.code == -32603) {
-                span_scoped!(
+                span_debug!(
                     span,
-                    debug!(%error, "underpriced transaction error - retrying tx with gas bump")
+                    %error,
+                    "underpriced transaction error - retrying tx with gas bump"
                 );
                 return Ok(ControlFlow::Retry);
             }
 
             // Unknown error, log and skip
-            span_scoped!(span, error!(%error, "Primary tx broadcast failed"));
+            span_error!(span, %error, "Primary tx broadcast failed");
             return Ok(ControlFlow::Skip);
         }
 
-        span_scoped!(
+        span_info!(
             span,
-            info!(
                 tx_hash = %tx.tx_hash(),
                 "dispatched to network"
-            )
         );
 
         Ok(ControlFlow::Done)
@@ -190,9 +185,7 @@ impl BuilderHelperTask {
                 .send_transaction(req)
                 .instrument(span.clone())
                 .await
-                .inspect_err(|error| {
-                    span_scoped!(span, error!(%error, "error sending transaction"))
-                })
+                .inspect_err(|error| span_error!(span, %error, "error sending transaction"))
                 .unwrap_or(ControlFlow::Retry);
 
             let guard = span.entered();
@@ -261,11 +254,11 @@ impl BuilderHelperTask {
 
             let span = sim_result.sim_env.span.clone();
 
-            span_scoped!(span, debug!("submit channel received block"));
+            span_debug!(span, "submit channel received block");
 
             // Don't submit empty blocks
             if sim_result.block.is_empty() {
-                span_scoped!(span, debug!("received empty block - skipping"));
+                span_debug!(span, "received empty block - skipping");
                 continue;
             }