fix(cardano-chain-follower): break down stats

Signed-off-by: bkioshn <[email protected]>

Author: bkioshn

rust/cardano-chain-follower/src/chain_sync.rs

@@ -33,7 +33,8 @@ use crate::{
     error::{Error, Result},
     mithril_snapshot_config::MithrilUpdateMessage,
     mithril_snapshot_data::latest_mithril_snapshot_id,
-    stats, ChainSyncConfig,
+    stats::{self},
+    ChainSyncConfig,
 };
 
 /// The maximum number of seconds we wait for a node to connect.
@@ -199,7 +200,11 @@ async fn process_rollback(
     // We never really know how many blocks are rolled back when advised by the peer, but we
     // can work out how many slots. This function wraps the real work, so we can properly
     // record the stats when the rollback is complete. Even if it errors.
-    stats::rollback(chain, stats::RollbackType::Peer, slot_rollback_size.into());
+    stats::rollback::rollback(
+        chain,
+        stats::rollback::RollbackType::Peer,
+        slot_rollback_size.into(),
+    );
 
     Ok(response)
 }

rust/cardano-chain-follower/src/chain_sync_live_chains.rs

@@ -15,7 +15,7 @@ use tracing::{debug, error};
 use crate::{
     error::{Error, Result},
     mithril_snapshot_data::latest_mithril_snapshot_id,
-    stats,
+    stats::{self},
 };
 
 /// Type we use to manage the Sync Task handle map.
@@ -241,7 +241,11 @@ impl ProtectedLiveChainBlockList {
 
             // Record a rollback statistic (We record the ACTUAL size our rollback effected our
             // internal live chain, not what the node thinks.)
-            stats::rollback(network, stats::RollbackType::LiveChain, rollback_size);
+            stats::rollback::rollback(
+                network,
+                stats::rollback::RollbackType::LiveChain,
+                rollback_size,
+            );
         }
 
         let head_slot = block.point().slot_or_default();

rust/cardano-chain-follower/src/follow.rs

@@ -13,7 +13,7 @@ use crate::{
     mithril_snapshot::MithrilSnapshot,
     mithril_snapshot_data::latest_mithril_snapshot_id,
     mithril_snapshot_iterator::MithrilSnapshotIterator,
-    stats::{self, rollback},
+    stats::{self},
     Statistics,
 };
 
@@ -192,7 +192,11 @@ impl ChainFollower {
         if let Some(next_block) = next_block {
             // Update rollback stats for the follower if one is reported.
             if update_type == chain_update::Kind::Rollback {
-                rollback(self.network, stats::RollbackType::Follower, rollback_depth);
+                stats::rollback::rollback(
+                    self.network,
+                    stats::rollback::RollbackType::Follower,
+                    rollback_depth,
+                );
             }
             // debug!("Pre Previous update 4 : {:?}", self.previous);
             self.previous = self.current.clone();

rust/cardano-chain-follower/src/stats/follower.rs

@@ -0,0 +1,22 @@
+//! Individual Follower Statistics.
+
+use cardano_blockchain_types::Slot;
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+
+/// Individual Follower stats
+#[derive(Debug, Default, Clone, Serialize)]
+pub struct Follower {
+    /// Synthetic follower connection ID
+    pub id: u64,
+    /// Starting slot for this follower (0 = Start at Genesis Block for the chain).
+    pub start: Slot,
+    /// Current slot for this follower.
+    pub current: Slot,
+    /// Target slot for this follower (MAX U64 == Follow Tip Forever).
+    pub end: Slot,
+    /// Current Sync Time.
+    pub sync_start: DateTime<Utc>,
+    /// When this follower reached TIP or its destination slot.
+    pub sync_end: Option<DateTime<Utc>>,
+}

rust/cardano-chain-follower/src/stats/live_chain.rs

@@ -0,0 +1,62 @@
+//! Live Blockchain Statistics.
+
+use cardano_blockchain_types::Slot;
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+
+use super::{follower::Follower, rollback::Rollbacks};
+
+/// Statistics related to the live blockchain
+#[derive(Debug, Default, Clone, Serialize)]
+pub struct Live {
+    /// The Time that synchronization to this blockchain started
+    pub sync_start: DateTime<Utc>,
+    /// The Time that synchronization to this blockchain was complete up-to-tip. None =
+    /// Not yet synchronized.
+    pub sync_end: Option<DateTime<Utc>>,
+    /// When backfill started
+    pub backfill_start: Option<DateTime<Utc>>,
+    /// Backfill size to achieve synchronization. (0 before sync completed)
+    pub backfill_size: u64,
+    /// When backfill ended
+    pub backfill_end: Option<DateTime<Utc>>,
+    /// Backfill Failures
+    pub backfill_failures: u64,
+    /// The time of the last backfill failure
+    pub backfill_failure_time: Option<DateTime<Utc>>,
+    /// Current Number of Live Blocks
+    pub blocks: u64,
+    /// The current head of the live chain slot#
+    pub head_slot: Slot,
+    /// The current live tip slot# as reported by the peer.
+    pub tip: Slot,
+    /// Number of times we connected/re-connected to the Node.
+    pub reconnects: u64,
+    /// Last reconnect time,
+    pub last_connect: DateTime<Utc>,
+    /// Last reconnect time,
+    pub last_connected_peer: String,
+    /// Last disconnect time,
+    pub last_disconnect: DateTime<Utc>,
+    /// Last disconnect time,
+    pub last_disconnected_peer: String,
+    /// Is there an active connection to the node
+    pub connected: bool,
+    /// Rollback statistics.
+    pub rollbacks: Rollbacks,
+    /// New blocks read from blockchain.
+    pub new_blocks: u64,
+    /// Blocks that failed to deserialize from the blockchain.
+    pub invalid_blocks: u64,
+    /// Active Followers (range and current depth)
+    pub follower: Vec<Follower>,
+}
+
+impl Live {
+    /// Reset incremental counters in the live statistics.
+    pub(crate) fn reset(&mut self) {
+        self.new_blocks = 0;
+        self.reconnects = 0;
+        self.invalid_blocks = 0;
+    }
+}

rust/cardano-chain-follower/src/stats/mithril.rs

@@ -0,0 +1,75 @@
+//! Mithril Snapshot Statistics
+
+use cardano_blockchain_types::Slot;
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+
+/// Statistics related to Mithril Snapshots
+#[derive(Debug, Default, Clone, Serialize)]
+pub struct Mithril {
+    /// Number of Mithril Snapshots that have downloaded successfully.
+    pub updates: u64,
+    /// The Immutable TIP Slot# - Origin = No downloaded snapshot
+    pub tip: Slot,
+    /// Time we started downloading the current snapshot. 1/1/1970-00:00:00 UTC = Never
+    /// downloaded.
+    pub dl_start: DateTime<Utc>,
+    /// Time we finished downloading the current snapshot. if < `dl_start` its the
+    /// previous time we finished.
+    pub dl_end: DateTime<Utc>,
+    /// Number of times download failed (bad server connection)
+    pub dl_failures: u64,
+    /// The time the last download took, in seconds.
+    pub last_dl_duration: u64,
+    /// The size of the download archive, in bytes. (If not started and not ended, current
+    /// partial download size).
+    pub dl_size: u64,
+    /// Extraction start time. 1/1/1970-00:00:00 UTC = Never extracted.
+    pub extract_start: DateTime<Utc>,
+    /// Extraction end time. if `extract_end` < `extract_start` its the previous time we
+    /// finished extracting.
+    pub extract_end: DateTime<Utc>,
+    /// Number of times extraction failed (bad archive)
+    pub extract_failures: u64,
+    /// Size of last extracted snapshot, in bytes.
+    pub extract_size: u64,
+    /// Deduplicated Size vs previous snapshot.
+    pub deduplicated_size: u64,
+    /// Number of identical files deduplicated from previous snapshot.
+    pub deduplicated: u64,
+    /// Number of changed files from previous snapshot.
+    pub changed: u64,
+    /// Number of new files from previous snapshot.
+    pub new: u64,
+    /// Mithril Certificate Validation Start Time. 1/1/1970-00:00:00 UTC = Never
+    /// validated.
+    pub validate_start: DateTime<Utc>,
+    /// Mithril Certificate Validation End Time. if validate end < validate start its the
+    /// previous time we finished validating.
+    pub validate_end: DateTime<Utc>,
+    /// Number of times validation failed (bad snapshot)
+    pub validate_failures: u64,
+    /// Blocks that failed to deserialize from the mithril immutable chain.
+    pub invalid_blocks: u64,
+    /// Download Or Validation Failed
+    pub download_or_validation_failed: u64,
+    /// Failed to get tip from mithril snapshot.
+    pub failed_to_get_tip: u64,
+    /// Tip failed to advance
+    pub tip_did_not_advance: u64,
+    /// Failed to send new tip to updater.
+    pub tip_failed_to_send_to_updater: u64,
+    /// Failed to activate new snapshot
+    pub failed_to_activate_new_snapshot: u64,
+}
+
+impl Mithril {
+    /// Reset incremental counters in the mithril statistics.
+    pub(crate) fn reset(&mut self) {
+        self.updates = 0;
+        self.dl_failures = 0;
+        self.extract_failures = 0;
+        self.validate_failures = 0;
+        self.invalid_blocks = 0;
+    }
+}