fix(tracing): demote spans to trace level + add slot field to slot processing logs

Author: PJColombo

src/main.rs

@@ -57,11 +57,6 @@ async fn main() -> Result<()> {
                     num_chunks
                 };
 
-                info!(
-                    "Processing slots from {} to {}, partitioned into {} chunks…",
-                    current_slot, latest_slot, num_chunks
-                );
-
                 for i in 0..num_chunks {
                     let slots_in_current_chunk = if i == num_chunks - 1 {
                         current_max_slots_size + remaining_slots
@@ -92,22 +87,21 @@ async fn main() -> Result<()> {
                         },
                         |e, duration: Duration| {
                             let duration = duration.as_secs();
-                            warn!("Failed to update latest slot to {}. Retrying in {duration} seconds… (Reason: {e})", chunk_final_slot - 1);
+                            warn!(latest_slot = chunk_final_slot - 1, "Failed to update latest slot. Retrying in {duration} seconds… (Reason: {e})");
                         },
                     ).await {
                         Ok(_) => (),
                         Err(err) => {
-                            error!("Failed to update latest slot to {}", chunk_final_slot - 1);
+                            error!(latest_slot = chunk_final_slot - 1, "Failed to update latest slot");
                             return Err(err.into());
                         }
                     };
 
                     info!(
-                        "Chunk {} of {} ({} slots) processed successfully!. Latest slot updated to {}.",
-                        i+1,
+                        "Chunk {} of {}: {} slots processed successfully!.",
+                        i + 1,
                         num_chunks,
                         chunk_final_slot - chunk_initial_slot,
-                        chunk_final_slot - 1
                     );
                 }
 

src/slots_processor/mod.rs

@@ -68,7 +68,7 @@ impl SlotsProcessor {
             let thread_initial_slot = start_slot + i * slots_per_thread;
             let thread_final_slot = thread_initial_slot + slots_in_current_thread;
 
-            let thread_slots_span = tracing::debug_span!(
+            let thread_slots_span = tracing::trace_span!(
                 "slots_chunk_processor",
                 chunk_initial_slot = thread_initial_slot,
                 chunk_final_slot = thread_final_slot
@@ -79,15 +79,15 @@ impl SlotsProcessor {
                     let slot_processor = SlotProcessor::new(thread_context);
 
                     for current_slot in thread_initial_slot..thread_final_slot {
-                        let slot_span = tracing::info_span!("slot_processor", slot = current_slot);
+                        let slot_span = tracing::trace_span!("slot_processor");
 
                         let result = slot_processor
                             .process_slot(current_slot)
                             .instrument(slot_span)
                             .await;
 
                         if let Err(error) = result {
-                            error!("Failed to process slot {current_slot}: {error}");
+                            error!(current_slot, "Failed to process slot: {error}");
 
                             return Err(SlotsChunkThreadError::FailedChunkProcessing {
                                 initial_slot: thread_initial_slot,

src/slots_processor/slot_processor/mod.rs

@@ -35,7 +35,10 @@ impl SlotProcessor {
             || async move { self._process_slot(slot).await },
             |e, duration: Duration| {
                 let duration = duration.as_secs();
-                warn!("Failed to process slot. Retrying in {duration} seconds… (Reason: {e})");
+                warn!(
+                    slot,
+                    "Failed to process slot. Retrying in {duration} seconds… (Reason: {e})"
+                );
             },
         )
         .await
@@ -55,7 +58,7 @@ impl SlotProcessor {
         {
             Some(block) => block,
             None => {
-                info!("Skipping as there is no beacon block");
+                info!(slot, "Skipping as there is no beacon block");
 
                 return Ok(());
             }
@@ -64,7 +67,10 @@ impl SlotProcessor {
         let execution_payload = match beacon_block.body.execution_payload {
             Some(payload) => payload,
             None => {
-                info!("Skipping as beacon block doesn't contain execution payload");
+                info!(
+                    slot,
+                    "Skipping as beacon block doesn't contain execution payload"
+                );
 
                 return Ok(());
             }
@@ -73,7 +79,10 @@ impl SlotProcessor {
         match beacon_block.body.blob_kzg_commitments {
             Some(commitments) => commitments,
             None => {
-                info!("Skipping as beacon block doesn't contain blob kzg commitments");
+                info!(
+                    slot,
+                    "Skipping as beacon block doesn't contain blob kzg commitments"
+                );
 
                 return Ok(());
             }
@@ -94,7 +103,7 @@ impl SlotProcessor {
             .map_err(|err| BackoffError::permanent(SlotProcessorError::Other(err)))?;
 
         if tx_hash_to_versioned_hashes.is_empty() {
-            info!("Skipping as execution block doesn't contain blob txs");
+            info!(slot, "Skipping as execution block doesn't contain blob txs");
 
             return Ok(());
         }
@@ -108,15 +117,15 @@ impl SlotProcessor {
         {
             Some(blobs) => {
                 if blobs.is_empty() {
-                    info!("Skipping as blobs sidecar is empty");
+                    info!(slot, "Skipping as blobs sidecar is empty");
 
                     return Ok(());
                 } else {
                     blobs
                 }
             }
             None => {
-                info!("Skipping as there is no blobs sidecar");
+                info!(slot, "Skipping as there is no blobs sidecar");
 
                 return Ok(());
             }
@@ -152,7 +161,7 @@ impl SlotProcessor {
             .await
             .map_err(SlotProcessorError::BlobscanClient)?;
 
-        info!("Block, txs and blobs indexed successfully");
+        info!(slot, "Block, txs and blobs indexed successfully");
 
         Ok(())
     }