measure duration with one instant, use static strings

crates/blockchain-tree/src/metrics.rs

@@ -31,31 +31,30 @@ pub struct BlockBufferMetrics {
 
 #[derive(Debug)]
 pub(crate) struct MakeCanonicalDurationsRecorder {
+    start: Instant,
     pub(crate) actions: Vec<(MakeCanonicalAction, Duration)>,
-    latest: Instant,
+    latest: Option<Duration>,
 }
 
 impl Default for MakeCanonicalDurationsRecorder {
     fn default() -> Self {
-        Self { actions: Vec::new(), latest: Instant::now() }
+        Self { start: Instant::now(), actions: Vec::new(), latest: None }
     }
 }
 
 impl MakeCanonicalDurationsRecorder {
-    /// Saves the provided duration for future logging and instantly reports as a metric with
-    /// `action` label.
-    pub(crate) fn record_duration(&mut self, action: MakeCanonicalAction, duration: Duration) {
+    /// Records the duration since last record, saves it for future logging and instantly reports as
+    /// a metric with `action` label.
+    pub(crate) fn record_relative(&mut self, action: MakeCanonicalAction) {
+        let elapsed = self.start.elapsed();
+        let duration = elapsed - self.latest.unwrap_or_default();
+
         self.actions.push((action, duration));
-        MakeCanonicalMetrics::new_with_labels(&[("action", format!("{action:?}"))])
+        MakeCanonicalMetrics::new_with_labels(&[("action", action.as_str())])
             .duration
             .record(duration);
-        self.latest = Instant::now();
-    }
 
-    /// Records the duration since last record, saves it for future logging and instantly reports as
-    /// a metric with `action` label.
-    pub(crate) fn record_relative(&mut self, action: MakeCanonicalAction) {
-        self.record_duration(action, self.latest.elapsed());
+        self.latest = Some(elapsed);
     }
 }
 
@@ -72,6 +71,26 @@ pub(crate) enum MakeCanonicalAction {
     InsertOldCanonicalChain,
 }
 
+impl MakeCanonicalAction {
+    fn as_str(&self) -> &'static str {
+        match self {
+            MakeCanonicalAction::CloneOldBlocks => "clone old blocks",
+            MakeCanonicalAction::FindCanonicalHeader => "find canonical header",
+            MakeCanonicalAction::SplitChain => "split chain",
+            MakeCanonicalAction::SplitChainForks => "split chain forks",
+            MakeCanonicalAction::MergeAllChains => "merge all chains",
+            MakeCanonicalAction::UpdateCanonicalIndex => "update canonical index",
+            MakeCanonicalAction::CommitCanonicalChainToDatabase => {
+                "commit canonical chain to database"
+            }
+            MakeCanonicalAction::RevertCanonicalChainFromDatabase => {
+                "revert canonical chain from database"
+            }
+            MakeCanonicalAction::InsertOldCanonicalChain => "insert old canonical chain",
+        }
+    }
+}
+
 #[derive(Metrics)]
 #[metrics(scope = "blockchain_tree.make_canonical")]
 /// Canonicalization metrics

crates/storage/provider/src/providers/database/metrics.rs

@@ -4,13 +4,14 @@ use std::time::{Duration, Instant};
 
 #[derive(Debug)]
 pub(crate) struct DurationsRecorder {
+    start: Instant,
     pub(crate) actions: Vec<(Action, Duration)>,
-    latest: Instant,
+    latest: Option<Duration>,
 }
 
 impl Default for DurationsRecorder {
     fn default() -> Self {
-        Self { actions: Vec::new(), latest: Instant::now() }
+        Self { start: Instant::now(), actions: Vec::new(), latest: None }
     }
 }
 
@@ -20,13 +21,19 @@ impl DurationsRecorder {
     pub(crate) fn record_duration(&mut self, action: Action, duration: Duration) {
         self.actions.push((action, duration));
         Metrics::new_with_labels(&[("action", format!("{action:?}"))]).duration.record(duration);
-        self.latest = Instant::now();
+        self.latest = Some(self.start.elapsed());
     }
 
     /// Records the duration since last record, saves it for future logging and instantly reports as
     /// a metric with `action` label.
     pub(crate) fn record_relative(&mut self, action: Action) {
-        self.record_duration(action, self.latest.elapsed());
+        let elapsed = self.start.elapsed();
+        let duration = elapsed - self.latest.unwrap_or_default();
+
+        self.actions.push((action, duration));
+        Metrics::new_with_labels(&[("action", action.as_str())]).duration.record(duration);
+
+        self.latest = Some(elapsed);
     }
 }
 
@@ -57,6 +64,35 @@ pub(crate) enum Action {
     GetParentTD,
 }
 
+impl Action {
+    fn as_str(&self) -> &'static str {
+        match self {
+            Action::InsertStorageHashing => "insert storage hashing",
+            Action::InsertAccountHashing => "insert account hashing",
+            Action::InsertMerkleTree => "insert merkle tree",
+            Action::InsertBlock => "insert block",
+            Action::InsertState => "insert state",
+            Action::InsertHashes => "insert hashes",
+            Action::InsertHistoryIndices => "insert history indices",
+            Action::UpdatePipelineStages => "update pipeline stages",
+            Action::InsertCanonicalHeaders => "insert canonical headers",
+            Action::InsertHeaders => "insert headers",
+            Action::InsertHeaderNumbers => "insert header numbers",
+            Action::InsertHeaderTD => "insert header TD",
+            Action::InsertBlockOmmers => "insert block ommers",
+            Action::InsertTxSenders => "insert tx senders",
+            Action::InsertTransactions => "insert transactions",
+            Action::InsertTxHashNumbers => "insert tx hash numbers",
+            Action::InsertBlockWithdrawals => "insert block withdrawals",
+            Action::InsertBlockBodyIndices => "insert block body indices",
+            Action::InsertTransactionBlock => "insert transaction block",
+            Action::RecoverSigners => "recover signers",
+            Action::GetNextTxNum => "get next tx num",
+            Action::GetParentTD => "get parent TD",
+        }
+    }
+}
+
 #[derive(Metrics)]
 #[metrics(scope = "storage.providers.database")]
 /// Database provider metrics