refactor: use guard pattern

Author: MegaRedHand

crates/blockchain/state_transition/src/lib.rs

@@ -29,7 +29,7 @@ pub enum Error {
 ///
 /// Similar to the spec's `State.state_transition`: https://github.com/leanEthereum/leanSpec/blob/bf0f606a75095cf1853529bc770516b1464d9716/src/lean_spec/subspecs/containers/state/state.py#L569
 pub fn state_transition(state: &mut State, block: &Block) -> Result<(), Error> {
-    let start = std::time::Instant::now();
+    let _timing = metrics::time_state_transition();
 
     process_slots(state, block.slot)?;
     process_block(state, block)?;
@@ -53,13 +53,12 @@ pub fn state_transition(state: &mut State, block: &Block) -> Result<(), Error> {
             computed: computed_state_root,
         });
     }
-    metrics::observe_state_transition_time(start.elapsed().as_secs_f64());
     Ok(())
 }
 
 /// Advance the state through empty slots up to, but not including, target_slot.
 pub fn process_slots(state: &mut State, target_slot: u64) -> Result<(), Error> {
-    let start = std::time::Instant::now();
+    let _timing = metrics::time_slots_processing();
 
     if state.slot >= target_slot {
         return Err(Error::StateSlotIsNewer {
@@ -74,18 +73,16 @@ pub fn process_slots(state: &mut State, target_slot: u64) -> Result<(), Error> {
     let slots_processed = target_slot - state.slot;
     state.slot = target_slot;
     metrics::inc_slots_processed(slots_processed);
-    metrics::observe_slots_processing_time(start.elapsed().as_secs_f64());
     Ok(())
 }
 
 /// Apply full block processing including header and body.
 pub fn process_block(state: &mut State, block: &Block) -> Result<(), Error> {
-    let start = std::time::Instant::now();
+    let _timing = metrics::time_block_processing();
 
     process_block_header(state, block)?;
     process_attestations(state, &block.body.attestations)?;
 
-    metrics::observe_block_processing_time(start.elapsed().as_secs_f64());
     Ok(())
 }
 
@@ -194,7 +191,7 @@ fn process_attestations(
     state: &mut State,
     attestations: &AggregatedAttestations,
 ) -> Result<(), Error> {
-    let start = std::time::Instant::now();
+    let _timing = metrics::time_attestations_processing();
     let validator_count = state.validators.len();
     let mut attestations_processed: u64 = 0;
     let mut justifications: HashMap<H256, Vec<bool>> = state
@@ -349,7 +346,6 @@ fn process_attestations(
         .expect("justifications_roots limit exceeded");
     state.justifications_validators = justifications_validators;
     metrics::inc_attestations_processed(attestations_processed);
-    metrics::observe_attestations_processing_time(start.elapsed().as_secs_f64());
     Ok(())
 }
 

crates/blockchain/state_transition/src/metrics.rs

@@ -1,8 +1,11 @@
 //! Prometheus metrics for state transition.
 
 use std::sync::LazyLock;
+use std::time::Instant;
 
-use prometheus::{IntCounter, IntCounterVec, register_int_counter, register_int_counter_vec};
+use prometheus::{
+    Histogram, IntCounter, IntCounterVec, register_int_counter, register_int_counter_vec,
+};
 
 static LEAN_STATE_TRANSITION_SLOTS_PROCESSED_TOTAL: LazyLock<IntCounter> = LazyLock::new(|| {
     register_int_counter!(
@@ -45,7 +48,7 @@ pub fn inc_finalizations(result: &str) {
     LEAN_FINALIZATIONS_TOTAL.with_label_values(&[result]).inc();
 }
 
-static LEAN_STATE_TRANSITION_TIME_SECONDS: LazyLock<prometheus::Histogram> = LazyLock::new(|| {
+static LEAN_STATE_TRANSITION_TIME_SECONDS: LazyLock<Histogram> = LazyLock::new(|| {
     prometheus::register_histogram!(
         "lean_state_transition_time_seconds",
         "Duration of the entire state transition",
@@ -54,7 +57,7 @@ static LEAN_STATE_TRANSITION_TIME_SECONDS: LazyLock<prometheus::Histogram> = Laz
     .unwrap()
 });
 
-static LEAN_STATE_TRANSITION_SLOTS_PROCESSING_TIME_SECONDS: LazyLock<prometheus::Histogram> =
+static LEAN_STATE_TRANSITION_SLOTS_PROCESSING_TIME_SECONDS: LazyLock<Histogram> =
     LazyLock::new(|| {
         prometheus::register_histogram!(
             "lean_state_transition_slots_processing_time_seconds",
@@ -64,7 +67,7 @@ static LEAN_STATE_TRANSITION_SLOTS_PROCESSING_TIME_SECONDS: LazyLock<prometheus:
         .unwrap()
     });
 
-static LEAN_STATE_TRANSITION_BLOCK_PROCESSING_TIME_SECONDS: LazyLock<prometheus::Histogram> =
+static LEAN_STATE_TRANSITION_BLOCK_PROCESSING_TIME_SECONDS: LazyLock<Histogram> =
     LazyLock::new(|| {
         prometheus::register_histogram!(
             "lean_state_transition_block_processing_time_seconds",
@@ -74,7 +77,7 @@ static LEAN_STATE_TRANSITION_BLOCK_PROCESSING_TIME_SECONDS: LazyLock<prometheus:
         .unwrap()
     });
 
-static LEAN_STATE_TRANSITION_ATTESTATIONS_PROCESSING_TIME_SECONDS: LazyLock<prometheus::Histogram> =
+static LEAN_STATE_TRANSITION_ATTESTATIONS_PROCESSING_TIME_SECONDS: LazyLock<Histogram> =
     LazyLock::new(|| {
         prometheus::register_histogram!(
             "lean_state_transition_attestations_processing_time_seconds",
@@ -84,22 +87,43 @@ static LEAN_STATE_TRANSITION_ATTESTATIONS_PROCESSING_TIME_SECONDS: LazyLock<prom
         .unwrap()
     });
 
-/// Record state transition time in seconds.
-pub fn observe_state_transition_time(duration_secs: f64) {
-    LEAN_STATE_TRANSITION_TIME_SECONDS.observe(duration_secs);
+/// A guard that records elapsed time to a histogram when dropped.
+pub struct TimingGuard {
+    histogram: &'static Histogram,
+    start: Instant,
 }
 
-/// Record slots processing time in seconds.
-pub fn observe_slots_processing_time(duration_secs: f64) {
-    LEAN_STATE_TRANSITION_SLOTS_PROCESSING_TIME_SECONDS.observe(duration_secs);
+impl TimingGuard {
+    fn new(histogram: &'static Histogram) -> Self {
+        Self {
+            histogram,
+            start: Instant::now(),
+        }
+    }
 }
 
-/// Record block processing time in seconds.
-pub fn observe_block_processing_time(duration_secs: f64) {
-    LEAN_STATE_TRANSITION_BLOCK_PROCESSING_TIME_SECONDS.observe(duration_secs);
+impl Drop for TimingGuard {
+    fn drop(&mut self) {
+        self.histogram.observe(self.start.elapsed().as_secs_f64());
+    }
 }
 
-/// Record attestations processing time in seconds.
-pub fn observe_attestations_processing_time(duration_secs: f64) {
-    LEAN_STATE_TRANSITION_ATTESTATIONS_PROCESSING_TIME_SECONDS.observe(duration_secs);
+/// Start timing state transition. Records duration when the guard is dropped.
+pub fn time_state_transition() -> TimingGuard {
+    TimingGuard::new(&LEAN_STATE_TRANSITION_TIME_SECONDS)
+}
+
+/// Start timing slots processing. Records duration when the guard is dropped.
+pub fn time_slots_processing() -> TimingGuard {
+    TimingGuard::new(&LEAN_STATE_TRANSITION_SLOTS_PROCESSING_TIME_SECONDS)
+}
+
+/// Start timing block processing. Records duration when the guard is dropped.
+pub fn time_block_processing() -> TimingGuard {
+    TimingGuard::new(&LEAN_STATE_TRANSITION_BLOCK_PROCESSING_TIME_SECONDS)
+}
+
+/// Start timing attestations processing. Records duration when the guard is dropped.
+pub fn time_attestations_processing() -> TimingGuard {
+    TimingGuard::new(&LEAN_STATE_TRANSITION_ATTESTATIONS_PROCESSING_TIME_SECONDS)
 }