Add more metrics

CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+- [2310](https://github.com/FuelLabs/fuel-core/pull/2310): New metrics: "The total gas used in a block" (`executor_gas_per_block`), "The size of a block in bytes" (`executor_size_per_block_bytes`), "The total fee (gwei) paid by transactions in a block" (`executor_fee_per_block_gwei`), "The total number of transactions in a block" (`executor_transactions_per_block`), P2P metrics for swarm and protocol.
+
 ## [Version 0.38.0]
 
 ### Added

crates/metrics/Cargo.toml

@@ -18,4 +18,6 @@ regex = "1"
 tracing = { workspace = true }
 
 [dev-dependencies]
-tokio = { workspace = true, features = ["macros"] }
+strum = { workspace = true }
+strum_macros = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }

crates/metrics/src/buckets.rs

@@ -0,0 +1,141 @@
+use std::{
+    collections::HashMap,
+    sync::OnceLock,
+};
+#[cfg(test)]
+use strum_macros::EnumIter;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(test, derive(EnumIter))]
+pub(crate) enum Buckets {
+    Timing,
+    GasUsed,
+    TransactionsCount,
+    Fee,
+    SizeUsed,
+}
+static BUCKETS: OnceLock<HashMap<Buckets, Vec<f64>>> = OnceLock::new();
+pub(crate) fn buckets(b: Buckets) -> impl Iterator<Item = f64> {
+    BUCKETS.get_or_init(initialize_buckets)[&b].iter().copied()
+}
+
+#[rustfmt::skip]
+fn initialize_buckets() -> HashMap<Buckets, Vec<f64>> {
+    [
+        (
+            Buckets::Timing,
+            vec![
+                0.005,
+                0.010,
+                0.025,
+                0.050,
+                0.100,
+                0.250,
+                0.500,
+                1.000,
+                2.500,
+                5.000,
+               10.000,
+            ],
+        ),
+        (
+            // Gas limit is 30_000_000.
+            Buckets::GasUsed,
+            vec![
+                    10_000.0,
+                    25_000.0,
+                    50_000.0,
+                   100_000.0,
+                   250_000.0,
+                   500_000.0,
+                 1_000_000.0,
+                 3_000_000.0,
+                 7_500_000.0,
+                15_000_000.0,
+                25_000_000.0,
+            ],
+        ),
+        (
+            // Transaction count is fixed at 65_535.
+            Buckets::TransactionsCount,
+            vec![
+                     5.0,
+                    10.0,
+                    25.0,
+                    50.0,
+                   100.0,
+                 1_000.0,
+                 5_000.0,
+                10_000.0,
+                20_000.0,
+                40_000.0,
+                60_000.0,
+            ],
+        ),
+        (
+            // 50 ETH is expected to be the realistic maximum fee for the time being.
+            Buckets::Fee,
+            vec![
+                    50_000_000.0,
+                   400_000_000.0,
+                 1_350_000_000.0,
+                 3_200_000_000.0,
+                 6_250_000_000.0,
+                10_800_000_000.0,
+                17_150_000_000.0,
+                25_600_000_000.0,
+                36_450_000_000.0,
+                50_000_000_000.0,
+            ]
+        ),
+        (
+            // Consider blocks up to 256kb in size, one bucket per 16kb.
+            Buckets::SizeUsed,
+            vec![
+                 16.0 * 1024.0,
+                 32.0 * 1024.0,
+                 48.0 * 1024.0,
+                 64.0 * 1024.0,
+                 80.0 * 1024.0,
+                 96.0 * 1024.0,
+                112.0 * 1024.0,
+                128.0 * 1024.0,
+                144.0 * 1024.0,
+                160.0 * 1024.0,
+                176.0 * 1024.0,
+                192.0 * 1024.0,
+                208.0 * 1024.0,
+                224.0 * 1024.0,
+                240.0 * 1024.0,
+                256.0 * 1024.0,
+            ]
+        ),
+    ]
+    .into_iter()
+    .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use strum::IntoEnumIterator;
+
+    use crate::buckets::Buckets;
+
+    use super::initialize_buckets;
+
+    #[test]
+    fn buckets_are_defined_for_every_variant() {
+        let actual_buckets = initialize_buckets();
+        let actual_buckets = actual_buckets.keys().collect::<Vec<_>>();
+
+        let required_buckets: Vec<_> = Buckets::iter().collect();
+
+        assert_eq!(required_buckets.len(), actual_buckets.len());
+
+        let all_buckets_defined = required_buckets
+            .iter()
+            .all(|required_bucket| actual_buckets.contains(&required_bucket));
+
+        assert!(all_buckets_defined)
+    }
+}

crates/metrics/src/executor.rs

@@ -0,0 +1,64 @@
+use crate::{
+    buckets::{
+        buckets,
+        Buckets,
+    },
+    global_registry,
+};
+use prometheus_client::metrics::histogram::Histogram;
+use std::sync::OnceLock;
+
+pub struct ExecutorMetrics {
+    pub gas_per_block: Histogram,
+    pub fee_per_block: Histogram,
+    pub transactions_per_block: Histogram,
+    pub size_per_block_bytes: Histogram,
+}
+
+impl Default for ExecutorMetrics {
+    fn default() -> Self {
+        let gas_per_block = Histogram::new(buckets(Buckets::GasUsed));
+        let fee_per_block = Histogram::new(buckets(Buckets::Fee));
+        let transactions_per_block = Histogram::new(buckets(Buckets::TransactionsCount));
+        let size_per_block_bytes = Histogram::new(buckets(Buckets::SizeUsed));
+
+        let mut registry = global_registry().registry.lock();
+        registry.register(
+            "executor_gas_per_block",
+            "The total gas used in a block",
+            gas_per_block.clone(),
+        );
+
+        registry.register(
+            "executor_fee_per_block_gwei",
+            "The total fee (gwei) paid by transactions in a block",
+            fee_per_block.clone(),
+        );
+
+        registry.register(
+            "executor_transactions_per_block",
+            "The total number of transactions in a block",
+            transactions_per_block.clone(),
+        );
+
+        registry.register(
+            "executor_size_per_block_bytes",
+            "The size of a block in bytes",
+            transactions_per_block.clone(),
+        );
+
+        Self {
+            gas_per_block,
+            fee_per_block,
+            transactions_per_block,
+            size_per_block_bytes,
+        }
+    }
+}
+
+// Setup a global static for accessing importer metrics
+static EXECUTOR_METRICS: OnceLock<ExecutorMetrics> = OnceLock::new();
+
+pub fn executor_metrics() -> &'static ExecutorMetrics {
+    EXECUTOR_METRICS.get_or_init(ExecutorMetrics::default)
+}

crates/metrics/src/future_tracker.rs

@@ -133,7 +133,9 @@ impl<T: Future> Future for FutureTracker<T> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::time::Duration;
+
+    use crate::future_tracker::FutureTracker;
 
     #[tokio::test]
     async fn empty_future() {

crates/metrics/src/graphql_metrics.rs

@@ -1,6 +1,9 @@
 use crate::{
+    buckets::{
+        buckets,
+        Buckets,
+    },
     global_registry,
-    timing_buckets,
 };
 use prometheus_client::{
     encoding::EncodeLabelSet,
@@ -28,7 +31,7 @@ impl GraphqlMetrics {
     fn new() -> Self {
         let tx_count_gauge = Gauge::default();
         let requests = Family::<Label, Histogram>::new_with_constructor(|| {
-            Histogram::new(timing_buckets().iter().cloned())
+            Histogram::new(buckets(Buckets::Timing))
         });
         let mut registry = global_registry().registry.lock();
         registry.register("graphql_request_duration_seconds", "", requests.clone());

crates/metrics/src/importer.rs

@@ -1,6 +1,9 @@
 use crate::{
+    buckets::{
+        buckets,
+        Buckets,
+    },
     global_registry,
-    timing_buckets,
 };
 use prometheus_client::metrics::{
     gauge::Gauge,
@@ -21,8 +24,7 @@ impl Default for ImporterMetrics {
     fn default() -> Self {
         let block_height_gauge = Gauge::default();
         let latest_block_import_ms = Gauge::default();
-        let execute_and_commit_duration =
-            Histogram::new(timing_buckets().iter().cloned());
+        let execute_and_commit_duration = Histogram::new(buckets(Buckets::Timing));
 
         let mut registry = global_registry().registry.lock();
         registry.register(

crates/metrics/src/lib.rs

@@ -19,24 +19,16 @@ pub struct GlobalRegistry {
     pub registry: parking_lot::Mutex<Registry>,
 }
 
+mod buckets;
 pub mod core_metrics;
+pub mod executor;
 pub mod future_tracker;
 pub mod graphql_metrics;
 pub mod importer;
 pub mod p2p_metrics;
 pub mod services;
 pub mod txpool_metrics;
 
-// recommended bucket defaults for logging response times
-static BUCKETS: OnceLock<Vec<f64>> = OnceLock::new();
-pub fn timing_buckets() -> &'static Vec<f64> {
-    BUCKETS.get_or_init(|| {
-        vec![
-            0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0,
-        ]
-    })
-}
-
 static GLOBAL_REGISTER: OnceLock<GlobalRegistry> = OnceLock::new();
 
 pub fn global_registry() -> &'static GlobalRegistry {

crates/services/executor/Cargo.toml

@@ -11,6 +11,7 @@ description = "Fuel Block Executor"
 
 [dependencies]
 anyhow = { workspace = true }
+fuel-core-metrics = { workspace = true }
 fuel-core-storage = { workspace = true, default-features = false, features = [
   "alloc",
 ] }

crates/services/executor/src/executor.rs

@@ -6,6 +6,7 @@ use crate::{
     },
     refs::ContractRef,
 };
+use fuel_core_metrics::executor::executor_metrics;
 use fuel_core_storage::{
     column::Column,
     kv_store::KeyValueInspect,
@@ -441,6 +442,19 @@ where
         )?;
         debug_assert!(data.found_mint, "Mint transaction is not found");
 
+        executor_metrics()
+            .gas_per_block
+            .observe(data.used_gas as f64);
+        executor_metrics()
+            .size_per_block_bytes
+            .observe(data.used_size as f64);
+        executor_metrics()
+            .fee_per_block
+            .observe(data.coinbase as f64);
+        executor_metrics()
+            .transactions_per_block
+            .observe(data.tx_count as f64);
+
         data.changes = block_storage_tx.into_changes();
         Ok((partial_block, data))
     }

crates/services/p2p/Cargo.toml

@@ -36,6 +36,7 @@ libp2p = { version = "0.53.2", default-features = false, features = [
   "tokio",
   "yamux",
   "websocket",
+  "metrics",
 ] }
 libp2p-mplex = "0.41.0"
 postcard = { workspace = true, features = ["use-std"] }