Preftecher metric (#609)

Author: dvush

crates/eth-sparse-mpt/src/reth_sparse_trie/mod.rs

@@ -80,24 +80,40 @@ pub fn prefetch_tries_for_accounts<'a, Provider>(
     consistent_db_view: ConsistentDbView<Provider>,
     shared_cache: SparseTrieSharedCache,
     changed_data: impl Iterator<Item = &'a ChangedAccountData>,
-) -> Result<(), SparseTrieError>
+) -> Result<SparseTrieMetrics, SparseTrieError>
 where
     Provider: DatabaseProviderFactory<Provider: BlockReader> + Send + Sync,
     Provider: StateCommitmentProvider,
 {
+    let mut metrics = SparseTrieMetrics::default();
+
+    let start = Instant::now();
     let change_set = prepare_change_set_for_prefetch(changed_data);
+    metrics.change_set_time += start.elapsed();
 
     let fetcher = TrieFetcher::new(consistent_db_view);
 
     for _ in 0..3 {
+        let start = Instant::now();
         let gather_result = shared_cache.gather_tries_for_changes(&change_set);
+        metrics.gather_nodes_time += start.elapsed();
 
         let missing_nodes = match gather_result {
-            Ok(_) => return Ok(()),
+            Ok(_) => return Ok(metrics),
             Err(missing_nodes) => missing_nodes,
         };
+        metrics.missing_nodes += missing_nodes.len();
+
+        let start = Instant::now();
         let multiproof = fetcher.fetch_missing_nodes(missing_nodes)?;
+
+        metrics.fetch_iterations += 1;
+        metrics.fetch_nodes_time += start.elapsed();
+        metrics.fetched_nodes += multiproof.len();
+
+        let start = Instant::now();
         shared_cache.update_cache_with_fetched_nodes(multiproof)?;
+        metrics.fill_cache_time += start.elapsed();
     }
 
     Err(SparseTrieError::FailedToFetchData)

crates/rbuilder/src/building/testing/bundle_tests/mod.rs

@@ -1,19 +1,15 @@
 pub mod setup;
 
-use alloy_primitives::{Address, B256, U256};
+use alloy_primitives::{B256, U256};
 use itertools::Itertools;
 use std::collections::HashSet;
-use uuid::Uuid;
 
 use crate::{
     building::{
         testing::bundle_tests::setup::NonceValue, BuiltBlockTrace, BundleErr, OrderErr,
         TransactionErr,
     },
-    primitives::{
-        Bundle, BundleRefund, BundleReplacementData, BundleReplacementKey, Order, OrderId, Refund,
-        RefundConfig, TxRevertBehavior,
-    },
+    primitives::{Bundle, BundleRefund, Order, OrderId, Refund, RefundConfig, TxRevertBehavior},
     utils::{constants::BASE_TX_GAS, int_percentage},
 };
 

crates/rbuilder/src/roothash/mod.rs

@@ -20,6 +20,8 @@ use tracing::trace;
 
 pub use prefetcher::run_trie_prefetcher;
 
+use crate::telemetry::inc_root_hash_finalize_count;
+
 #[derive(Debug, Clone, Copy)]
 pub enum RootHashMode {
     /// Makes correct root hash calculation on the correct parent state.
@@ -156,6 +158,7 @@ where
             sparse_trie_shared_cache,
             &config.thread_pool,
         );
+        inc_root_hash_finalize_count(metrics.fetched_nodes);
         trace!(?metrics, "Sparse trie metrics");
         root?
     } else {

crates/rbuilder/src/roothash/prefetcher.rs

@@ -18,7 +18,10 @@ use tokio::sync::broadcast::{
 use tokio_util::sync::CancellationToken;
 use tracing::{error, trace, warn};
 
-use crate::{building::evm_inspector::SlotKey, live_builder::simulation::SimulatedOrderCommand};
+use crate::{
+    building::evm_inspector::SlotKey, live_builder::simulation::SimulatedOrderCommand,
+    telemetry::inc_root_hash_prefetch_count, utils::elapsed_ms,
+};
 
 const CONSUME_SIM_ORDERS_BATCH: usize = 128;
 
@@ -143,12 +146,12 @@ pub fn run_trie_prefetcher<P>(
         }
 
         let start = Instant::now();
-        match prefetch_tries_for_accounts(
+        let metrics = match prefetch_tries_for_accounts(
             consistent_db_view.clone(),
             shared_sparse_mpt_cache.clone(),
             fetch_request.values(),
         ) {
-            Ok(()) => {}
+            Ok(metrics) => metrics,
             Err(SparseTrieError::FetchNode(FetchNodeError::Provider(
                 ProviderError::ConsistentView(_),
             ))) => {
@@ -158,11 +161,14 @@ pub fn run_trie_prefetcher<P>(
                 if !err.is_db_consistency_error() {
                     error!(?err, "Error while prefetching trie nodes");
                 }
+                continue;
             }
-        }
+        };
+        inc_root_hash_prefetch_count(metrics.fetched_nodes);
+
         trace!(
-            time_ms = start.elapsed().as_millis(),
-            accounts = fetch_request.len(),
+            time_ms = elapsed_ms(start),
+            ?metrics,
             "Prefetched trie nodes"
         );
     }

crates/rbuilder/src/telemetry/metrics/mod.rs

@@ -43,6 +43,9 @@ const RELAY_ERROR_OTHER: &str = "other";
 const SIM_STATUS_OK: &str = "sim_success";
 const SIM_STATUS_FAIL: &str = "sim_fail";
 
+const ROOT_HASH_PREFETCH_STEP: &str = "prefetcher";
+const ROOT_HASH_FINALIZE_STEP: &str = "finalize";
+
 /// We record timestamps only for blocks built within interval of the block timestamp
 const BLOCK_METRICS_TIMESTAMP_LOWER_DELTA: time::Duration = time::Duration::seconds(3);
 /// We record timestamps only for blocks built within interval of the block timestamp
@@ -100,6 +103,16 @@ register_metrics! {
     .unwrap();
 
 
+    pub static ROOT_HASH_FETCHES: IntCounterVec = IntCounterVec::new(
+        Opts::new(
+            "rbuilder_sparse_mpt_root_hash_fetches",
+            "Number of nodes fetched in a finalize or prefetch step"
+        ),
+        &["step"],
+    )
+    .unwrap();
+
+
 
     pub static CURRENT_BLOCK: IntGauge =
         IntGauge::new("current_block", "Current Block").unwrap();
@@ -580,6 +593,24 @@ pub fn mark_submission_start_time(block_sealed_at: OffsetDateTime) {
         .observe(value);
 }
 
+pub fn inc_root_hash_prefetch_count(fetched_nodes: usize) {
+    if fetched_nodes == 0 {
+        return;
+    }
+    ROOT_HASH_FETCHES
+        .with_label_values(&[ROOT_HASH_PREFETCH_STEP])
+        .inc_by(fetched_nodes.try_into().unwrap_or_default());
+}
+
+pub fn inc_root_hash_finalize_count(fetched_nodes: usize) {
+    if fetched_nodes == 0 {
+        return;
+    }
+    ROOT_HASH_FETCHES
+        .with_label_values(&[ROOT_HASH_FINALIZE_STEP])
+        .inc_by(fetched_nodes.try_into().unwrap_or_default());
+}
+
 pub fn gather_prometheus_metrics(registry: &Registry) -> String {
     use prometheus::Encoder;
     let encoder = prometheus::TextEncoder::new();