feat: add prometheus metrics network_version and actor_version

CHANGELOG.md

@@ -30,7 +30,10 @@
 ### Added
 
 - [#6057](https://github.com/ChainSafe/forest/issues/6057) Added `--no-progress-timeout` to `forest-cli f3 ready` subcommand to exit when F3 is stuck for the given timeout.
-- [#6000](https://github.com/ChainSafe/forest/pull/6000) Add support for the `Filecoin.StateDecodeParams` API methods to enable decoding actors method params.
+
+- [#6000](https://github.com/ChainSafe/forest/pull/6000) Added support for the `Filecoin.StateDecodeParams` API methods to enable decoding actors method params.
+
+- [#6079](https://github.com/ChainSafe/forest/pull/6079) Added prometheus metrics `network_height` and `network_version`.
 
 ### Changed
 

src/daemon/mod.rs

@@ -15,8 +15,10 @@ use crate::cli_shared::{
     chain_path,
     cli::{CliOpts, Config},
 };
-use crate::daemon::context::{AppContext, DbType};
-use crate::daemon::db_util::import_chain_as_forest_car;
+use crate::daemon::{
+    context::{AppContext, DbType},
+    db_util::import_chain_as_forest_car,
+};
 use crate::db::gc::SnapshotGarbageCollector;
 use crate::db::ttl::EthMappingCollector;
 use crate::libp2p::{Libp2pService, PeerManager};
@@ -202,10 +204,33 @@ async fn maybe_start_metrics_service(
         );
         let db_directory = crate::db::db_engine::db_root(&chain_path(config))?;
         let db = ctx.db.writer().clone();
+        // Use `Weak` to not dead lock GC.
+        let chain_store = Arc::downgrade(ctx.state_manager.chain_store());
+        let get_chain_head_height = move || {
+            chain_store
+                .upgrade()
+                .map(|cs| cs.heaviest_tipset().epoch())
+                .unwrap_or_default()
+        };
+        // Use `Weak` to not dead lock GC.
+        let chain_store = Arc::downgrade(ctx.state_manager.chain_store());
+        let get_chain_head_network_version = move || {
+            if let Some(cs) = chain_store.upgrade() {
+                let epoch = cs.heaviest_tipset().epoch();
+                cs.chain_config.network_version(epoch)
+            } else {
+                NetworkVersion::V0
+            }
+        };
         services.spawn(async {
-            crate::metrics::init_prometheus(prometheus_listener, db_directory, db)
-                .await
-                .context("Failed to initiate prometheus server")
+            crate::metrics::init_prometheus(
+                prometheus_listener,
+                db_directory,
+                db,
+                get_chain_head_network_version,
+            )
+            .await
+            .context("Failed to initiate prometheus server")
         });
 
         crate::metrics::default_registry().register_collector(Box::new(
@@ -215,6 +240,7 @@ async fn maybe_start_metrics_service(
                     .chain_store()
                     .genesis_block_header()
                     .timestamp,
+                get_chain_head_height,
             ),
         ));
     }

src/metrics/mod.rs

@@ -3,7 +3,7 @@
 
 pub mod db;
 
-use crate::db::DBStatistics;
+use crate::{db::DBStatistics, shim::version::NetworkVersion};
 use axum::{Router, http::StatusCode, response::IntoResponse, routing::get};
 use parking_lot::{RwLock, RwLockWriteGuard};
 use prometheus_client::{
@@ -69,6 +69,7 @@ pub async fn init_prometheus<DB>(
     prometheus_listener: TcpListener,
     db_directory: PathBuf,
     db: Arc<DB>,
+    get_chain_head_network_version: impl Fn() -> NetworkVersion + Send + Sync + 'static,
 ) -> anyhow::Result<()>
 where
     DB: DBStatistics + Send + Sync + 'static,
@@ -86,6 +87,9 @@ where
     DEFAULT_REGISTRY
         .write()
         .register_collector(Box::new(crate::metrics::db::DBCollector::new(db_directory)));
+    DEFAULT_REGISTRY.write().register_collector(Box::new(
+        crate::networks::metrics::NetworkVersionCollector::new(get_chain_head_network_version),
+    ));
 
     // Create an configure HTTP server
     let app = Router::new()

src/networks/metrics.rs

@@ -1,47 +1,117 @@
 // Copyright 2019-2025 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use prometheus_client::{collector::Collector, encoding::EncodeMetric, metrics::gauge::Gauge};
+use educe::Educe;
+use prometheus_client::{
+    collector::Collector,
+    encoding::{DescriptorEncoder, EncodeMetric},
+    metrics::gauge::Gauge,
+};
 
 use super::calculate_expected_epoch;
+use crate::shim::{clock::ChainEpoch, version::NetworkVersion};
 
-#[derive(Debug)]
-pub struct NetworkHeightCollector {
+#[derive(Educe)]
+#[educe(Debug)]
+pub struct NetworkHeightCollector<F>
+where
+    F: Fn() -> ChainEpoch,
+{
     block_delay_secs: u32,
     genesis_timestamp: u64,
-    network_height: Gauge,
+    #[educe(Debug(ignore))]
+    get_chain_head_height: F,
 }
 
-impl NetworkHeightCollector {
-    pub fn new(block_delay_secs: u32, genesis_timestamp: u64) -> Self {
+impl<F> NetworkHeightCollector<F>
+where
+    F: Fn() -> ChainEpoch,
+{
+    pub fn new(block_delay_secs: u32, genesis_timestamp: u64, get_chain_head_height: F) -> Self {
         Self {
             block_delay_secs,
             genesis_timestamp,
-            network_height: Gauge::default(),
+            get_chain_head_height,
         }
     }
 }
 
-impl Collector for NetworkHeightCollector {
+impl<F> Collector for NetworkHeightCollector<F>
+where
+    F: Fn() -> ChainEpoch + Send + Sync + 'static,
+{
     fn encode(
         &self,
         mut encoder: prometheus_client::encoding::DescriptorEncoder,
     ) -> Result<(), std::fmt::Error> {
+        {
+            let network_height: Gauge = Default::default();
+            let epoch = (self.get_chain_head_height)();
+            network_height.set(epoch);
+            let metric_encoder = encoder.encode_descriptor(
+                "network_height",
+                "The current network height",
+                None,
+                network_height.metric_type(),
+            )?;
+            network_height.encode(metric_encoder)?;
+        }
+        {
+            let expected_network_height: Gauge = Default::default();
+            let expected_epoch = calculate_expected_epoch(
+                chrono::Utc::now().timestamp() as u64,
+                self.genesis_timestamp,
+                self.block_delay_secs,
+            );
+            expected_network_height.set(expected_epoch);
+            let metric_encoder = encoder.encode_descriptor(
+                "expected_network_height",
+                "The expected network height based on the current time and the genesis block time",
+                None,
+                expected_network_height.metric_type(),
+            )?;
+            expected_network_height.encode(metric_encoder)?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Educe)]
+#[educe(Debug)]
+pub struct NetworkVersionCollector<F>
+where
+    F: Fn() -> NetworkVersion,
+{
+    #[educe(Debug(ignore))]
+    get_chain_head_network_version: F,
+}
+
+impl<F> NetworkVersionCollector<F>
+where
+    F: Fn() -> NetworkVersion,
+{
+    pub fn new(get_chain_head_network_version: F) -> Self {
+        Self {
+            get_chain_head_network_version,
+        }
+    }
+}
+
+impl<F> Collector for NetworkVersionCollector<F>
+where
+    F: Fn() -> NetworkVersion + Send + Sync + 'static,
+{
+    fn encode(&self, mut encoder: DescriptorEncoder) -> Result<(), std::fmt::Error> {
+        let network_version = (self.get_chain_head_network_version)();
+        let nv_gauge: Gauge = Default::default();
+        nv_gauge.set(u32::from(network_version) as _);
         let metric_encoder = encoder.encode_descriptor(
-            "expected_network_height",
-            "The expected network height based on the current time and the genesis block time",
+            "network_version",
+            "Network version of the current chain head",
             None,
-            self.network_height.metric_type(),
+            nv_gauge.metric_type(),
         )?;
-
-        let expected_epoch = calculate_expected_epoch(
-            chrono::Utc::now().timestamp() as u64,
-            self.genesis_timestamp,
-            self.block_delay_secs,
-        );
-        self.network_height.set(expected_epoch);
-        self.network_height.encode(metric_encoder)?;
-
+        nv_gauge.encode(metric_encoder)?;
         Ok(())
     }
 }

src/shim/version.rs

@@ -88,6 +88,12 @@ impl From<u32> for NetworkVersion {
     }
 }
 
+impl From<NetworkVersion> for u32 {
+    fn from(value: NetworkVersion) -> Self {
+        value.0.into()
+    }
+}
+
 impl From<NetworkVersion_v2> for NetworkVersion {
     fn from(value: NetworkVersion_v2) -> Self {
         NetworkVersion((value as u32).into())