solution: metric for a single block archive time in streaming mode

Author: splix

src/archiver/archiver.rs

@@ -100,6 +100,8 @@ impl<B: BlockchainTypes, TS: TargetStorage> ArchiveAll<Height> for Archiver<B, T
 
         let success = success_tx & success_trace;
         let duration = Utc::now().signed_duration_since(start_time);
+        let duration_secs = duration.num_milliseconds() as f64 / 1000.0;
+        crate::metrics::observe_block_archive(duration_secs);
         if success {
             tracing::info!("Blocks {} is archived in {}ms", what, duration.num_milliseconds());
         } else {
@@ -159,6 +161,10 @@ impl<B: BlockchainTypes, TS: TargetStorage> ArchiveAll<Range> for Archiver<B, TS
         }
 
         let duration = Utc::now().signed_duration_since(start_time);
+        if what.len() == 1 {
+            let duration_secs = duration.num_milliseconds() as f64 / 1000.0;
+            crate::metrics::observe_block_archive(duration_secs);
+        }
         if duration.num_seconds() > 2 {
             tracing::info!("Range {} is archived in {}sec", what, duration.num_seconds());
         } else {

src/metrics/archive.rs

@@ -2,24 +2,33 @@
 //
 // Licensed under the Apache License, Version 2.0
 
-use prometheus::{CounterVec, Opts, Registry};
+use prometheus::{CounterVec, Histogram, HistogramOpts, Opts, Registry};
 use crate::archiver::datakind::DataKind;
 use super::Direction;
 
 /// Metrics for the archive processing zone.
 ///
-/// Uses two `CounterVec` metrics with `type` and `direction` labels:
-/// - `items` — total number of items (blocks, transactions, traces) processed
-/// - `bytes` — total number of bytes transferred to/from storage
+/// - `items` — counter of items (blocks, transactions, traces) processed, by type and direction
+/// - `bytes` — counter of bytes transferred, by type and direction
+/// - `block_archive_duration` — histogram of single-block archival time (block + txes + traces)
 pub struct ArchiveMetrics {
     /// Total items processed, labeled by type and direction
     pub items: CounterVec,
     /// Total bytes transferred, labeled by type and direction
     pub bytes: CounterVec,
+    /// Time to archive a single block with all its tables
+    pub block_archive_duration: Histogram,
 }
 
 impl ArchiveMetrics {
     pub fn new(app_name: &str) -> Self {
+        // Buckets tuned for the expected 500ms–2s range, with tails for slow blocks
+        let buckets = vec![
+            0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0,
+            1.25, 1.5, 1.75, 2.0, 2.5,
+            3.0, 4.0, 5.0, 7.5, 10.0, 12.5, 15.0,
+            20.0, 25.0, 30.0,
+        ];
         Self {
             items: CounterVec::new(
                 Opts::new(
@@ -37,12 +46,21 @@ impl ArchiveMetrics {
                 &["type", "direction"],
             )
             .unwrap(),
+            block_archive_duration: Histogram::with_opts(
+                HistogramOpts::new(
+                    format!("{}_archive_blockTime_seconds", app_name),
+                    "Time to archive a single block with all its tables (block, txes, traces)",
+                )
+                .buckets(buckets),
+            )
+            .unwrap(),
         }
     }
 
     pub fn register(&self, registry: &Registry) {
         registry.register(Box::new(self.items.clone())).unwrap();
         registry.register(Box::new(self.bytes.clone())).unwrap();
+        registry.register(Box::new(self.block_archive_duration.clone())).unwrap();
     }
 
     /// Record that `n` items of the given data kind have been processed.
@@ -58,4 +76,9 @@ impl ArchiveMetrics {
             .with_label_values(&[kind.metrics_label(), direction.metrics_label()])
             .inc_by(n as f64);
     }
+
+    /// Record the time it took to archive a single block (including txes and traces).
+    pub fn observe_block_archive(&self, duration_secs: f64) {
+        self.block_archive_duration.observe(duration_secs);
+    }
 }

src/metrics/mod.rs

@@ -104,6 +104,14 @@ pub fn add_bytes(kind: &DataKind, direction: Direction, n: usize) {
     METRICS.archive.add_bytes(kind, &direction, n);
 }
 
+/// Record the time it took to archive a single block (including txes and traces).
+pub fn observe_block_archive(duration_secs: f64) {
+    if !ENABLED.load(Ordering::Relaxed) {
+        return;
+    }
+    METRICS.archive.observe_block_archive(duration_secs);
+}
+
 /// Observe the duration of a blockchain RPC request.
 pub fn observe_request(method: &str, blockchain: &str, duration_secs: f64) {
     if !ENABLED.load(Ordering::Relaxed) {