Split hdiff metrics by hot/cold

michaelsproul · michaelsproul · commit c12dd1c7af91 · 2025-05-20T16:05:57.000+10:00
diff --git a/beacon_node/store/src/historic_state_cache.rs b/beacon_node/store/src/historic_state_cache.rs
@@ -34,11 +34,11 @@ impl<E: EthSpec> HistoricStateCache<E> {
 
     pub fn get_hdiff_buffer(&mut self, slot: Slot) -> Option<HDiffBuffer> {
         if let Some(buffer_ref) = self.hdiff_buffers.get(&slot) {
-            let _timer = metrics::start_timer(&metrics::BEACON_HDIFF_BUFFER_CLONE_TIMES);
+            let _timer = metrics::start_timer(&metrics::BEACON_COLD_HDIFF_BUFFER_CLONE_TIMES);
             Some(buffer_ref.clone())
         } else if let Some(state) = self.states.get(&slot) {
             let buffer = HDiffBuffer::from_state(state.clone());
-            let _timer = metrics::start_timer(&metrics::BEACON_HDIFF_BUFFER_CLONE_TIMES);
+            let _timer = metrics::start_timer(&metrics::BEACON_COLD_HDIFF_BUFFER_CLONE_TIMES);
             let cloned = buffer.clone();
             drop(_timer);
             self.hdiff_buffers.put(slot, cloned);
diff --git a/beacon_node/store/src/hot_cold_store.rs b/beacon_node/store/src/hot_cold_store.rs
@@ -1711,13 +1711,13 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
 
     fn load_hot_hdiff(&self, state_root: Hash256) -> Result<HDiff, Error> {
         let bytes = {
-            let _t = metrics::start_timer(&metrics::BEACON_HDIFF_READ_TIMES);
+            let _t = metrics::start_timer(&metrics::BEACON_HOT_HDIFF_READ_TIMES);
             self.hot_db
                 .get_bytes(DBColumn::BeaconStateHotDiff, state_root.as_slice())?
                 .ok_or(HotColdDBError::MissingHotHDiff(state_root))?
         };
         let hdiff = {
-            let _t = metrics::start_timer(&metrics::BEACON_HDIFF_DECODE_TIMES);
+            let _t = metrics::start_timer(&metrics::BEACON_HOT_HDIFF_DECODE_TIMES);
             HDiff::from_ssz_bytes(&bytes)?
         };
         Ok(hdiff)
@@ -2165,13 +2165,13 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
 
     fn load_hdiff_for_slot(&self, slot: Slot) -> Result<HDiff, Error> {
         let bytes = {
-            let _t = metrics::start_timer(&metrics::BEACON_HDIFF_READ_TIMES);
+            let _t = metrics::start_timer(&metrics::BEACON_COLD_HDIFF_READ_TIMES);
             self.cold_db
                 .get_bytes(DBColumn::BeaconStateDiff, &slot.as_u64().to_be_bytes())?
                 .ok_or(HotColdDBError::MissingHDiff(slot))?
         };
         let hdiff = {
-            let _t = metrics::start_timer(&metrics::BEACON_HDIFF_DECODE_TIMES);
+            let _t = metrics::start_timer(&metrics::BEACON_COLD_HDIFF_DECODE_TIMES);
             HDiff::from_ssz_bytes(&bytes)?
         };
         Ok(hdiff)
diff --git a/beacon_node/store/src/metrics.rs b/beacon_node/store/src/metrics.rs
@@ -142,24 +142,38 @@ pub static BEACON_STATE_HOT_GET_COUNT: LazyLock<Result<IntCounter>> = LazyLock::
         "Total number of hot beacon states requested from the store (cache or DB)",
     )
 });
-pub static BEACON_HDIFF_READ_TIMES: LazyLock<Result<Histogram>> = LazyLock::new(|| {
+pub static BEACON_HOT_HDIFF_READ_TIMES: LazyLock<Result<Histogram>> = LazyLock::new(|| {
     try_create_histogram(
-        "store_hdiff_read_seconds",
-        "Time required to read the hierarchical diff bytes from the database",
+        "store_hot_hdiff_read_seconds",
+        "Time required to read hierarchical diff bytes from the hot database",
     )
 });
-pub static BEACON_HDIFF_DECODE_TIMES: LazyLock<Result<Histogram>> = LazyLock::new(|| {
+pub static BEACON_HOT_HDIFF_DECODE_TIMES: LazyLock<Result<Histogram>> = LazyLock::new(|| {
     try_create_histogram(
-        "store_hdiff_decode_seconds",
-        "Time required to decode hierarchical diff bytes",
+        "store_hot_hdiff_decode_seconds",
+        "Time required to decode hierarchical diff bytes from the hot database",
     )
 });
-pub static BEACON_HDIFF_BUFFER_CLONE_TIMES: LazyLock<Result<Histogram>> = LazyLock::new(|| {
+pub static BEACON_COLD_HDIFF_READ_TIMES: LazyLock<Result<Histogram>> = LazyLock::new(|| {
     try_create_histogram(
-        "store_hdiff_buffer_clone_seconds",
-        "Time required to clone hierarchical diff buffer bytes",
+        "store_cold_hdiff_read_seconds",
+        "Time required to read the hierarchical diff bytes from the database",
     )
 });
+pub static BEACON_COLD_HDIFF_DECODE_TIMES: LazyLock<Result<Histogram>> = LazyLock::new(|| {
+    try_create_histogram(
+        "store_cold_hdiff_decode_seconds",
+        "Time required to decode hierarchical diff bytes",
+    )
+});
+pub static BEACON_COLD_HDIFF_BUFFER_CLONE_TIMES: LazyLock<Result<Histogram>> =
+    LazyLock::new(|| {
+        try_create_histogram(
+            "store_cold_hdiff_buffer_clone_seconds",
+            "Time required to clone hierarchical diff buffer bytes",
+        )
+    });
+// This metric is not split hot/cold because it is recorded in a place where that info is not known.
 pub static BEACON_HDIFF_BUFFER_APPLY_RESIZES: LazyLock<Result<Histogram>> = LazyLock::new(|| {
     try_create_histogram_with_buckets(
         "store_hdiff_buffer_apply_resizes",
