Merge pull request #61 from gattaca-com/ltitanb/logs

chore: builder api logs

crates/api/src/builder/simulator/mock_simulator.rs

@@ -2,7 +2,6 @@ use async_trait::async_trait;
 use tokio::sync::mpsc::Sender;
 
 use helix_common::{simulator::BlockSimError, BuilderInfo};
-use uuid::Uuid;
 
 use crate::builder::{traits::BlockSimulator, BlockSimRequest, DbInfo};
 
@@ -23,7 +22,6 @@ impl BlockSimulator for MockSimulator {
         _builder_info: &BuilderInfo,
         _is_top_bid: bool,
         _sim_result_saver_sender: Sender<DbInfo>,
-        _request_id: Uuid,
     ) -> Result<bool, BlockSimError> {
         Ok(true)
     }

crates/api/src/builder/simulator/multi_simulator.rs

@@ -5,7 +5,6 @@ use std::sync::{
     Arc,
 };
 use tokio::sync::mpsc::Sender;
-use uuid::Uuid;
 
 use crate::builder::DbInfo;
 
@@ -35,7 +34,6 @@ impl<B: BlockSimulator + Send + Sync> BlockSimulator for MultiSimulator<B> {
         builder_info: &BuilderInfo,
         is_top_bid: bool,
         sim_result_saver_sender: Sender<DbInfo>,
-        request_id: Uuid,
     ) -> Result<bool, BlockSimError> {
         // Load balancing: round-robin selection
         let index = self
@@ -48,8 +46,6 @@ impl<B: BlockSimulator + Send + Sync> BlockSimulator for MultiSimulator<B> {
         let simulator = &self.simulators[index];
 
         // Process the request with the selected simulator
-        simulator
-            .process_request(request, builder_info, is_top_bid, sim_result_saver_sender, request_id)
-            .await
+        simulator.process_request(request, builder_info, is_top_bid, sim_result_saver_sender).await
     }
 }

crates/api/src/builder/simulator/optimistic_simulator.rs

@@ -4,8 +4,7 @@ use async_trait::async_trait;
 use ethereum_consensus::primitives::{BlsPublicKey, Hash32};
 use reqwest::Client;
 use tokio::sync::{mpsc::Sender, RwLock};
-use tracing::{debug, error, warn};
-use uuid::Uuid;
+use tracing::{debug, error, warn, Instrument};
 
 use helix_common::{metrics::SimulatorMetrics, simulator::BlockSimError, BuilderInfo};
 use helix_database::DatabaseService;
@@ -58,22 +57,14 @@ impl<A: Auctioneer + 'static, DB: DatabaseService + 'static> OptimisticSimulator
         is_top_bid: bool,
         sim_result_saver_sender: Sender<DbInfo>,
         builder_info: BuilderInfo,
-        request_id: Uuid,
     ) -> Result<(), BlockSimError> {
         if let Err(err) = self
             .simulator
-            .process_request(
-                request.clone(),
-                &builder_info,
-                is_top_bid,
-                sim_result_saver_sender,
-                request_id,
-            )
+            .process_request(request.clone(), &builder_info, is_top_bid, sim_result_saver_sender)
             .await
         {
             if builder_info.is_optimistic {
                 warn!(
-                    request_id=%request_id,
                     builder=%request.message.builder_public_key,
                     block_hash=%request.execution_payload.block_hash(),
                     err=%err,
@@ -156,37 +147,37 @@ impl<A: Auctioneer, DB: DatabaseService> BlockSimulator for OptimisticSimulator<
         builder_info: &BuilderInfo,
         is_top_bid: bool,
         sim_result_saver_sender: Sender<DbInfo>,
-        request_id: Uuid,
     ) -> Result<bool, BlockSimError> {
         if self.should_process_optimistically(&request, builder_info).await {
             SimulatorMetrics::sim_count(true);
 
             debug!(
-                request_id=%request_id,
                 block_hash=%request.execution_payload.block_hash(),
                 "optimistically processing request"
             );
 
             let cloned_self = self.clone_for_async();
             let builder_info = builder_info.clone();
-            tokio::spawn(async move {
-                cloned_self
-                    .handle_simulation(
-                        request,
-                        is_top_bid,
-                        sim_result_saver_sender,
-                        builder_info,
-                        request_id,
-                    )
-                    .await
-            });
+            tokio::spawn(
+                async move {
+                    cloned_self
+                        .handle_simulation(
+                            request,
+                            is_top_bid,
+                            sim_result_saver_sender,
+                            builder_info,
+                        )
+                        .await
+                }
+                .in_current_span(),
+            );
 
             Ok(true)
         } else {
             SimulatorMetrics::sim_count(false);
 
             debug!(
-                request_id=%request_id,
+
                 block_hash=?request.execution_payload.block_hash(),
                 block_parent_hash=?request.execution_payload.parent_hash(),
                 block_number=%request.execution_payload.block_number(),
@@ -198,7 +189,6 @@ impl<A: Auctioneer, DB: DatabaseService> BlockSimulator for OptimisticSimulator<
                 is_top_bid,
                 sim_result_saver_sender,
                 builder_info.clone(),
-                request_id,
             )
             .await
             .map(|_| false)

crates/api/src/builder/simulator/optimistic_simulator_tests.rs

@@ -24,7 +24,6 @@ mod simulator_tests {
     use reth_primitives::hex;
     use serde_json::json;
     use std::sync::{atomic::AtomicBool, Arc};
-    use uuid::Uuid;
 
     // ++++ HELPERS ++++
     fn get_optimistic_simulator(
@@ -109,9 +108,8 @@ mod simulator_tests {
             builder_demoted.clone(),
         );
 
-        let result = simulator
-            .process_request(get_sim_req(), &builder_info, true, sim_res_sender, Uuid::new_v4())
-            .await;
+        let result =
+            simulator.process_request(get_sim_req(), &builder_info, true, sim_res_sender).await;
 
         // give the simulator time to process the request
         tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
@@ -140,9 +138,8 @@ mod simulator_tests {
             builder_demoted.clone(),
         );
 
-        let result = simulator
-            .process_request(get_sim_req(), &builder_info, true, sim_res_sender, Uuid::new_v4())
-            .await;
+        let result =
+            simulator.process_request(get_sim_req(), &builder_info, true, sim_res_sender).await;
 
         // give the simulator time to process the request
         tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
@@ -171,9 +168,8 @@ mod simulator_tests {
             builder_demoted.clone(),
         );
 
-        let result = simulator
-            .process_request(get_sim_req(), &builder_info, true, sim_res_sender, Uuid::new_v4())
-            .await;
+        let result =
+            simulator.process_request(get_sim_req(), &builder_info, true, sim_res_sender).await;
 
         // give the simulator time to process the request
         tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
@@ -202,9 +198,8 @@ mod simulator_tests {
             builder_demoted.clone(),
         );
 
-        let result = simulator
-            .process_request(get_sim_req(), &builder_info, true, sim_res_sender, Uuid::new_v4())
-            .await;
+        let result =
+            simulator.process_request(get_sim_req(), &builder_info, true, sim_res_sender).await;
 
         // give the simulator time to process the request
         tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;

crates/api/src/builder/simulator/rpc_simulator.rs

@@ -9,7 +9,6 @@ use tokio::sync::mpsc::Sender;
 use tracing::{debug, error};
 
 use helix_common::simulator::BlockSimError;
-use uuid::Uuid;
 
 use crate::builder::{traits::BlockSimulator, BlockSimRequest, DbInfo};
 
@@ -94,14 +93,12 @@ impl BlockSimulator for RpcSimulator {
         _builder_info: &BuilderInfo,
         is_top_bid: bool,
         sim_result_saver_sender: Sender<DbInfo>,
-        request_id: Uuid,
     ) -> Result<bool, BlockSimError> {
         let timer = SimulatorMetrics::timer();
 
         let block_hash = request.execution_payload.block_hash().clone();
         debug!(
-            request_id = %request_id,
-            block_hash = %block_hash,
+            %block_hash,
             builder_pub_key = %request.message.builder_public_key,
             "RpcSimulator::process_request",
         );
@@ -124,7 +121,7 @@ impl BlockSimulator for RpcSimulator {
             }
             Err(err) => {
                 timer.stop_and_discard();
-                error!(request_id = %request_id, err = ?err, "Error sending RPC request");
+                error!(?err, "Error sending RPC request");
                 SimulatorMetrics::sim_status(false);
                 Err(BlockSimError::RpcError(err.to_string()))
             }

crates/api/src/builder/simulator/simulator_tests.rs

@@ -16,7 +16,6 @@ use reqwest::Client;
 use reth_primitives::hex;
 use serde_json::json;
 use std::sync::Arc;
-use uuid::Uuid;
 
 // ++++ HELPERS ++++
 fn get_simulator(endpoint: &str) -> RpcSimulator {
@@ -65,9 +64,8 @@ async fn test_process_request_ok() {
     let (sim_res_sender, mut sim_res_receiver) = tokio::sync::mpsc::channel(100);
     let simulator = get_simulator(&server.url());
     let builder_info = BuilderInfo::default();
-    let result = simulator
-        .process_request(get_sim_req(), &builder_info, true, sim_res_sender, Uuid::new_v4())
-        .await;
+    let result =
+        simulator.process_request(get_sim_req(), &builder_info, true, sim_res_sender).await;
 
     mock.assert();
     assert!(result.is_ok());
@@ -98,9 +96,8 @@ async fn test_process_request_error() {
     let (sim_res_sender, _sim_res_receiver) = tokio::sync::mpsc::channel(100);
     let simulator = get_simulator(&server.url());
     let builder_info = BuilderInfo::default();
-    let result = simulator
-        .process_request(get_sim_req(), &builder_info, true, sim_res_sender, Uuid::new_v4())
-        .await;
+    let result =
+        simulator.process_request(get_sim_req(), &builder_info, true, sim_res_sender).await;
 
     mock.assert();
     assert!(result.is_err());
@@ -130,9 +127,8 @@ async fn test_process_request_validation_failed() {
     let (sim_res_sender, _sim_res_receiver) = tokio::sync::mpsc::channel(100);
     let simulator = get_simulator(&server.url());
     let builder_info = BuilderInfo::default();
-    let result = simulator
-        .process_request(get_sim_req(), &builder_info, true, sim_res_sender, Uuid::new_v4())
-        .await;
+    let result =
+        simulator.process_request(get_sim_req(), &builder_info, true, sim_res_sender).await;
 
     mock.assert();
     assert!(result.is_err());

crates/api/src/builder/simulator/traits.rs

@@ -1,7 +1,6 @@
 use async_trait::async_trait;
 use helix_common::{simulator::BlockSimError, BuilderInfo};
 use tokio::sync::mpsc::Sender;
-use uuid::Uuid;
 
 use crate::builder::{BlockSimRequest, DbInfo};
 
@@ -14,6 +13,5 @@ pub trait BlockSimulator: Send + Sync + Clone {
         builder_info: &BuilderInfo,
         is_top_bid: bool,
         sim_result_saver_sender: Sender<DbInfo>,
-        request_id: Uuid,
     ) -> Result<bool, BlockSimError>;
 }

crates/api/src/builder/tests.rs

@@ -465,10 +465,9 @@ async fn test_header_submission_decoding_json_capella() {
         load_bytes(current_dir.to_str().expect("Failed to convert path to string"));
 
     let mut header_submission_trace = HeaderSubmissionTrace::default();
-    let uuid = uuid::Uuid::new_v4();
     let request = generate_request(false, false, false, &req_payload_bytes);
     let decoded_submission =
-        decode_header_submission(request, &mut header_submission_trace, &uuid).await.unwrap();
+        decode_header_submission(request, &mut header_submission_trace).await.unwrap();
 
     assert_eq!(decoded_submission.0.slot(), 5552306);
     assert!(matches!(
@@ -505,10 +504,10 @@ async fn test_header_submission_decoding_ssz_capella() {
         load_bytes(current_dir.to_str().expect("Failed to convert path to string"));
 
     let mut header_submission_trace = HeaderSubmissionTrace::default();
-    let uuid = uuid::Uuid::new_v4();
+
     let request = generate_request(false, false, true, &req_payload_bytes);
     let decoded_submission =
-        decode_header_submission(request, &mut header_submission_trace, &uuid).await.unwrap();
+        decode_header_submission(request, &mut header_submission_trace).await.unwrap();
 
     assert!(matches!(decoded_submission.0, SignedHeaderSubmission::Capella(_)));
     assert!(decoded_submission.0.commitments().is_none());
@@ -529,10 +528,10 @@ async fn test_header_submission_decoding_ssz_deneb() {
         load_bytes(current_dir.to_str().expect("Failed to convert path to string"));
 
     let mut header_submission_trace = HeaderSubmissionTrace::default();
-    let uuid = uuid::Uuid::new_v4();
+
     let request = generate_request(false, false, true, &req_payload_bytes);
     let decoded_submission =
-        decode_header_submission(request, &mut header_submission_trace, &uuid).await.unwrap();
+        decode_header_submission(request, &mut header_submission_trace).await.unwrap();
 
     assert!(matches!(decoded_submission.0, SignedHeaderSubmission::Deneb(_)));
     assert!(decoded_submission.0.commitments().is_some());
@@ -553,9 +552,8 @@ async fn test_signed_bid_submission_decoding_capella() {
         load_bytes(current_dir.to_str().expect("Failed to convert path to string"));
 
     let mut submission_trace = SubmissionTrace::default();
-    let uuid = uuid::Uuid::new_v4();
     let request = generate_request(false, false, false, &req_payload_bytes);
-    let decoded_submission = decode_payload(request, &mut submission_trace, &uuid).await.unwrap();
+    let decoded_submission = decode_payload(request, &mut submission_trace).await.unwrap();
 
     assert_eq!(decoded_submission.0.message().slot, 5552306);
     assert!(matches!(decoded_submission.0.execution_payload(), ExecutionPayload::Capella(_)));
@@ -574,9 +572,8 @@ async fn test_signed_bid_submission_decoding_capella_gzip() {
         load_bytes(current_dir.to_str().expect("Failed to convert path to string"));
 
     let mut submission_trace = SubmissionTrace::default();
-    let uuid = uuid::Uuid::new_v4();
     let request = generate_request(false, true, false, &req_payload_bytes);
-    let decoded_submission = decode_payload(request, &mut submission_trace, &uuid).await.unwrap();
+    let decoded_submission = decode_payload(request, &mut submission_trace).await.unwrap();
 
     assert_eq!(decoded_submission.0.message().slot, 5552306);
     assert!(matches!(decoded_submission.0.execution_payload(), ExecutionPayload::Capella(_)));
@@ -595,10 +592,8 @@ async fn test_signed_bid_submission_decoding_deneb() {
         load_bytes(current_dir.to_str().expect("Failed to convert path to string"));
 
     let mut submission_trace = SubmissionTrace::default();
-    let uuid = uuid::Uuid::new_v4();
     let request = generate_request(false, false, false, &req_payload_bytes);
-    let (decoded_submission, _) =
-        decode_payload(request, &mut submission_trace, &uuid).await.unwrap();
+    let (decoded_submission, _) = decode_payload(request, &mut submission_trace).await.unwrap();
 
     assert_eq!(decoded_submission.message().slot, 5552306);
     assert!(matches!(decoded_submission.execution_payload(), ExecutionPayload::Deneb(_)));