feat: improve sequencer metrics

.github/workflows/lint.yaml

@@ -27,7 +27,7 @@ jobs:
         with:
           cache-on-failure: true
       - name: Run clippy
-        run: cargo clippy --workspace --lib --examples --tests --benches --all-features --locked
+        run: cargo clean && cargo clippy --workspace --lib --examples --tests --benches --all-features --locked
         env:
           RUSTFLAGS: -D warnings
 

crates/chain-orchestrator/src/lib.rs

@@ -292,13 +292,17 @@ impl<
                 }
             }
             SequencerEvent::PayloadReady(payload_id) => {
-                if let Some(block) = self
+                let block = self
                     .sequencer
                     .as_mut()
                     .expect("sequencer must be present")
                     .finalize_payload_building(payload_id, &mut self.engine)
-                    .await?
-                {
+                    .await?;
+
+                self.metric_handler.finish_all_block_building_recording();
+                self.metric_handler.finish_block_building_interval_recording();
+
+                if let Some(block) = block {
                     let block_info: L2BlockInfoWithL1Messages = (&block).into();
                     self.database
                         .update_l1_messages_from_l2_blocks(vec![block_info.clone()])
@@ -307,7 +311,7 @@ impl<
                         .as_mut()
                         .expect("signer must be present")
                         .sign_block(block.clone())?;
-                    self.metric_handler.finish_block_building_recording();
+                    self.metric_handler.finish_no_empty_block_building_recording();
                     return Ok(Some(ChainOrchestratorEvent::BlockSequenced(block)));
                 }
             }

crates/chain-orchestrator/src/metrics.rs

@@ -20,19 +20,52 @@ impl MetricsHandler {
 
     /// Starts tracking a new block building task.
     pub(crate) fn start_block_building_recording(&mut self) {
-        if self.block_building_meter.start.is_some() {
+        if self.block_building_meter.block_building_start.is_some() {
             tracing::warn!(target: "scroll::chain_orchestrator", "block building recording is already ongoing, overwriting");
         }
-        self.block_building_meter.start = Some(Instant::now());
+        self.block_building_meter.block_building_start = Some(Instant::now());
     }
 
     /// The duration of the current block building task if any.
-    pub(crate) fn finish_block_building_recording(&mut self) {
-        let duration = self.block_building_meter.start.take().map(|start| start.elapsed());
+    pub(crate) fn finish_no_empty_block_building_recording(&mut self) {
+        let duration = self
+            .block_building_meter
+            .block_building_start
+            .take()
+            .map(|block_building_start| block_building_start.elapsed());
         if let Some(duration) = duration {
             self.block_building_meter.metric.block_building_duration.record(duration.as_secs_f64());
         }
     }
+
+    pub(crate) fn finish_all_block_building_recording(&mut self) {
+        let duration = self
+            .block_building_meter
+            .block_building_start
+            .take()
+            .map(|block_building_start| block_building_start.elapsed());
+        if let Some(duration) = duration {
+            self.block_building_meter
+                .metric
+                .all_block_building_duration
+                .record(duration.as_secs_f64());
+        }
+    }
+
+    pub(crate) fn finish_block_building_interval_recording(&mut self) {
+        let interval = self
+            .block_building_meter
+            .last_block_building_time
+            .take()
+            .map(|last_block_building_time| last_block_building_time.elapsed());
+        if let Some(interval) = interval {
+            self.block_building_meter
+                .metric
+                .consecutive_block_interval
+                .record(interval.as_secs_f64());
+        }
+        self.block_building_meter.last_block_building_time = Some(Instant::now());
+    }
 }
 
 impl Default for MetricsHandler {
@@ -104,13 +137,18 @@ pub(crate) struct ChainOrchestratorMetrics {
 #[derive(Debug, Default)]
 pub(crate) struct BlockBuildingMeter {
     metric: BlockBuildingMetric,
-    start: Option<Instant>,
+    block_building_start: Option<Instant>,
+    last_block_building_time: Option<Instant>,
 }
 
 /// Block building related metric.
 #[derive(Metrics, Clone)]
 #[metrics(scope = "chain_orchestrator")]
 pub(crate) struct BlockBuildingMetric {
-    /// The duration of the block building task.
+    /// The duration of the block building task without empty block
     block_building_duration: Histogram,
+    /// The duration of the block building task for all blocks include empty block
+    all_block_building_duration: Histogram,
+    /// The duration of the block interval include empty block
+    consecutive_block_interval: Histogram,
 }