feat(o11y): implementing metrics and Grafana panels for chain abstraction (#926)

geekbrother · web-flow · commit 84c25352bd49 · 2025-01-31T21:37:51.000+01:00
diff --git a/src/handlers/chain_agnostic/route.rs b/src/handlers/chain_agnostic/route.rs
@@ -10,6 +10,7 @@ use {
             ChainAbstractionInitialTxInfo, MessageSource,
         },
         error::RpcError,
+        metrics::{ChainAbstractionNoBridgingNeededType, ChainAbstractionTransactionType},
         state::AppState,
         storage::irn::OperationType,
         utils::{
@@ -119,6 +120,9 @@ async fn handler_internal(
             "The transaction is a native token transfer with value: {:?}",
             transfer_value
         );
+        state
+            .metrics
+            .add_ca_no_bridging_needed(ChainAbstractionNoBridgingNeededType::NativeTokenTransfer);
         return Ok(no_bridging_needed_response.into_response());
     }
     let transaction_data = initial_transaction.input.clone();
@@ -141,6 +145,9 @@ async fn handler_internal(
                 .is_none()
                 {
                     error!("The destination address is not a supported bridging asset contract");
+                    state.metrics.add_ca_no_bridging_needed(
+                        ChainAbstractionNoBridgingNeededType::AssetNotSupported,
+                    );
                     return Ok(no_bridging_needed_response.into_response());
                 };
 
@@ -164,6 +171,11 @@ async fn handler_internal(
                             state.metrics.clone(),
                         )
                         .await?;
+                        state.metrics.add_ca_gas_estimation(
+                            simulated_gas_used,
+                            initial_transaction.chain_id.clone(),
+                            ChainAbstractionTransactionType::Transfer,
+                        );
                         // Save the initial tx gas estimation to the cache
                         {
                             let state = state.clone();
@@ -222,6 +234,9 @@ async fn handler_internal(
                 }
                 if asset_transfer_value.is_zero() {
                     error!("The transaction does not change any supported bridging assets");
+                    state.metrics.add_ca_no_bridging_needed(
+                        ChainAbstractionNoBridgingNeededType::AssetNotSupported,
+                    );
                     return Ok(no_bridging_needed_response.into_response());
                 }
 
@@ -244,6 +259,9 @@ async fn handler_internal(
             Some((symbol, decimals)) => (symbol, decimals),
             None => {
                 error!("The destination address is not a supported bridging asset contract");
+                state.metrics.add_ca_no_bridging_needed(
+                    ChainAbstractionNoBridgingNeededType::AssetNotSupported,
+                );
                 return Ok(no_bridging_needed_response.into_response());
             }
         };
@@ -260,6 +278,9 @@ async fn handler_internal(
     .await?;
     let erc20_balance = U256::from_be_bytes(erc20_balance.into());
     if erc20_balance >= asset_transfer_value {
+        state
+            .metrics
+            .add_ca_no_bridging_needed(ChainAbstractionNoBridgingNeededType::SufficientFunds);
         return Ok(no_bridging_needed_response.into_response());
     }
     let erc20_topup_value = asset_transfer_value - erc20_balance;
@@ -276,6 +297,7 @@ async fn handler_internal(
     )
     .await?
     else {
+        state.metrics.add_ca_insufficient_funds();
         return Ok(Json(PrepareResponse::Error(PrepareResponseError {
             error: BridgingError::InsufficientFunds,
         }))
@@ -302,6 +324,14 @@ async fn handler_internal(
         )
         .await?;
     let Some(best_route) = quotes.first() else {
+        state
+            .metrics
+            .add_ca_no_routes_found(construct_metrics_bridging_route(
+                bridge_chain_id.clone(),
+                bridge_contract.to_string(),
+                request_payload.transaction.chain_id.clone(),
+                asset_transfer_contract.to_string(),
+            ));
         return Ok(Json(PrepareResponse::Error(PrepareResponseError {
             error: BridgingError::NoRoutesAvailable,
         }))
@@ -325,6 +355,7 @@ async fn handler_internal(
             "The current bridging asset balance on {} is {} less than the required topup amount:{}. The bridging fee is:{}",
             from_address, current_bridging_asset_balance, required_topup_amount, bridging_fee
         );
+        state.metrics.add_ca_insufficient_funds();
         return Ok(Json(PrepareResponse::Error(PrepareResponseError {
             error: BridgingError::InsufficientFunds,
         }))
@@ -346,6 +377,14 @@ async fn handler_internal(
         )
         .await?;
     let Some(best_route) = quotes.first() else {
+        state
+            .metrics
+            .add_ca_no_routes_found(construct_metrics_bridging_route(
+                bridge_chain_id.clone(),
+                bridge_contract.to_string(),
+                request_payload.transaction.chain_id.clone(),
+                asset_transfer_contract.to_string(),
+            ));
         return Ok(Json(PrepareResponse::Error(PrepareResponseError {
             error: BridgingError::NoRoutesAvailable,
         }))
@@ -448,7 +487,7 @@ async fn handler_internal(
         .await?;
     for (index, simulation_result) in simulation_results.simulation_results.iter().enumerate() {
         // Making sure the simulation input matches the transaction input
-        let curr_route = routes.get(index).ok_or_else(|| {
+        let curr_route = routes.get_mut(index).ok_or_else(|| {
             RpcError::SimulationFailed("The route index is out of bounds".to_string())
         })?;
         if simulation_result.transaction.input != curr_route.input {
@@ -458,9 +497,25 @@ async fn handler_internal(
             ));
         }
 
-        routes[index].gas_limit = U64::from(
+        curr_route.gas_limit = U64::from(
             (simulation_result.transaction.gas * (100 + ESTIMATED_GAS_SLIPPAGE as u64)) / 100,
         );
+
+        // Get the transaction type for metrics based on the assumption that the first transaction is an approval
+        // and the rest are bridging transactions
+        let tx_type = if simulation_results.simulation_results.len() == 1 {
+            // If there is only one transaction, it's a bridging transaction
+            ChainAbstractionTransactionType::Bridge
+        } else if index == 0 {
+            ChainAbstractionTransactionType::Approve
+        } else {
+            ChainAbstractionTransactionType::Bridge
+        };
+        state.metrics.add_ca_gas_estimation(
+            simulation_result.transaction.gas,
+            curr_route.chain_id.clone(),
+            tx_type,
+        );
     }
 
     // Save the bridging transaction to the IRN
@@ -578,3 +633,15 @@ async fn handler_internal(
         .into_response(),
     );
 }
+
+fn construct_metrics_bridging_route(
+    from_chain_id: String,
+    from_contract: String,
+    to_chain_id: String,
+    to_contract: String,
+) -> String {
+    format!(
+        "{}:{}->{}:{}",
+        from_chain_id, from_contract, to_chain_id, to_contract
+    )
+}
diff --git a/src/metrics.rs b/src/metrics.rs
@@ -20,6 +20,20 @@ use {
     },
 };
 
+#[derive(strum_macros::Display)]
+pub enum ChainAbstractionTransactionType {
+    Transfer,
+    Approve,
+    Bridge,
+}
+
+#[derive(strum_macros::Display)]
+pub enum ChainAbstractionNoBridgingNeededType {
+    NativeTokenTransfer,
+    AssetNotSupported,
+    SufficientFunds,
+}
+
 #[derive(Debug)]
 pub struct Metrics {
     pub rpc_call_counter: Counter<u64>,
@@ -70,6 +84,12 @@ pub struct Metrics {
 
     // IRN client
     pub irn_latency_tracker: Histogram<f64>,
+
+    // Chain Abstracton
+    pub ca_gas_estimation_tracker: Histogram<f64>,
+    pub ca_no_routes_found_counter: Counter<u64>,
+    pub ca_insufficient_funds_counter: Counter<u64>,
+    pub ca_no_bridging_needed_counter: Counter<u64>,
 }
 
 impl Metrics {
@@ -266,6 +286,26 @@ impl Metrics {
             .with_description("The number of chain RPC calls that had no available providers")
             .init();
 
+        let ca_gas_estimation_tracker = meter
+            .f64_histogram("gas_estimation")
+            .with_description("The gas estimation for transactions")
+            .init();
+
+        let ca_no_routes_found_counter = meter
+            .u64_counter("ca_no_routes_found")
+            .with_description("The number of times no routes were found for a CA")
+            .init();
+
+        let ca_insufficient_funds_counter = meter
+            .u64_counter("ca_insufficient_funds")
+            .with_description("The number of times insufficient funds were responded for a CA")
+            .init();
+
+        let ca_no_bridging_needed_counter = meter
+            .u64_counter("ca_no_bridging_needed")
+            .with_description("The number of times no bridging was needed for a CA")
+            .init();
+
         Metrics {
             rpc_call_counter,
             rpc_call_retries,
@@ -305,6 +345,10 @@ impl Metrics {
             rate_limiting_latency_tracker,
             rate_limited_entries_counter,
             rate_limited_responses_counter,
+            ca_gas_estimation_tracker,
+            ca_no_routes_found_counter,
+            ca_insufficient_funds_counter,
+            ca_no_bridging_needed_counter,
         }
     }
 }
@@ -642,6 +686,43 @@ impl Metrics {
         );
     }
 
+    pub fn add_ca_gas_estimation(
+        &self,
+        gas: u64,
+        chain_id: String,
+        tx_type: ChainAbstractionTransactionType,
+    ) {
+        self.ca_gas_estimation_tracker.record(
+            &otel::Context::new(),
+            gas as f64,
+            &[
+                otel::KeyValue::new("chain_id", chain_id),
+                otel::KeyValue::new("tx_type", tx_type.to_string()),
+            ],
+        );
+    }
+
+    pub fn add_ca_no_routes_found(&self, route: String) {
+        self.ca_no_routes_found_counter.add(
+            &otel::Context::new(),
+            1,
+            &[otel::KeyValue::new("route", route)],
+        );
+    }
+
+    pub fn add_ca_insufficient_funds(&self) {
+        self.ca_insufficient_funds_counter
+            .add(&otel::Context::new(), 1, &[]);
+    }
+
+    pub fn add_ca_no_bridging_needed(&self, ca_type: ChainAbstractionNoBridgingNeededType) {
+        self.ca_no_bridging_needed_counter.add(
+            &otel::Context::new(),
+            1,
+            &[otel::KeyValue::new("type", ca_type.to_string())],
+        );
+    }
+
     /// Gathering system CPU(s) and Memory usage metrics
     pub async fn gather_system_metrics(&self) {
         let mut system = System::new_with_specifics(
diff --git a/terraform/monitoring/dashboard.jsonnet b/terraform/monitoring/dashboard.jsonnet
@@ -192,6 +192,12 @@ dashboard.new(
   row.new('Account names (ENS gateway) Metrics'),
     panels.names.registered(ds, vars)                { gridPos: pos_short._3 },
 
+  row.new('Chain Abstraction'),
+    panels.chain_abstraction.gas_estimation(ds, vars)     { gridPos: pos_short._4 },
+    panels.chain_abstraction.insufficient_funds(ds, vars) { gridPos: pos_short._4 },
+    panels.chain_abstraction.no_bridging(ds, vars)        { gridPos: pos_short._4 },
+    panels.chain_abstraction.no_routes(ds, vars)          { gridPos: pos_short._4 },
+
   row.new('Redis'),
     panels.redis.cpu(ds, vars)                    { gridPos: pos._2 },
     panels.redis.memory(ds, vars)                 { gridPos: pos._2 },
diff --git a/terraform/monitoring/panels/chain_abstraction/gas_estimation.libsonnet b/terraform/monitoring/panels/chain_abstraction/gas_estimation.libsonnet
@@ -0,0 +1,19 @@
+local grafana   = import '../../grafonnet-lib/grafana.libsonnet';
+local defaults  = import '../../grafonnet-lib/defaults.libsonnet';
+
+local panels    = grafana.panels;
+local targets   = grafana.targets;
+
+{
+  new(ds, vars)::
+    panels.timeseries(
+      title       = 'Gas estimations',
+      datasource  = ds.prometheus,
+    )
+    .configure(defaults.configuration.timeseries)
+    .addTarget(targets.prometheus(
+      datasource    = ds.prometheus,
+      expr          = 'sum by(chain_id) (rate(gas_estimation_sum[$__rate_interval])) / sum by(chain_id) (rate(gas_estimation_count[$__rate_interval]))',
+      legendFormat  = 'Gas estimation',
+    ))
+}
diff --git a/terraform/monitoring/panels/chain_abstraction/insufficient_funds.libsonnet b/terraform/monitoring/panels/chain_abstraction/insufficient_funds.libsonnet
@@ -0,0 +1,19 @@
+local grafana   = import '../../grafonnet-lib/grafana.libsonnet';
+local defaults  = import '../../grafonnet-lib/defaults.libsonnet';
+
+local panels    = grafana.panels;
+local targets   = grafana.targets;
+
+{
+  new(ds, vars)::
+    panels.timeseries(
+      title       = 'Insufficient funds responses',
+      datasource  = ds.prometheus,
+    )
+    .configure(defaults.configuration.timeseries)
+    .addTarget(targets.prometheus(
+      datasource    = ds.prometheus,
+      expr          = 'sum(increase(ca_insufficient_funds_total{}[$__rate_interval]))',
+      legendFormat  = 'Insufficient funds responses counter',
+    ))
+}
diff --git a/terraform/monitoring/panels/chain_abstraction/no_bridging.libsonnet b/terraform/monitoring/panels/chain_abstraction/no_bridging.libsonnet
@@ -0,0 +1,19 @@
+local grafana   = import '../../grafonnet-lib/grafana.libsonnet';
+local defaults  = import '../../grafonnet-lib/defaults.libsonnet';
+
+local panels    = grafana.panels;
+local targets   = grafana.targets;
+
+{
+  new(ds, vars)::
+    panels.timeseries(
+      title       = 'No bridging needed responses',
+      datasource  = ds.prometheus,
+    )
+    .configure(defaults.configuration.timeseries)
+    .addTarget(targets.prometheus(
+      datasource    = ds.prometheus,
+      expr          = 'sum by(type) (increase(ca_no_bridging_needed_total{}[$__rate_interval]))',
+      legendFormat  = 'No bridging needed responses counter',
+    ))
+}
diff --git a/terraform/monitoring/panels/chain_abstraction/no_routes.libsonnet b/terraform/monitoring/panels/chain_abstraction/no_routes.libsonnet
@@ -0,0 +1,19 @@
+local grafana   = import '../../grafonnet-lib/grafana.libsonnet';
+local defaults  = import '../../grafonnet-lib/defaults.libsonnet';
+
+local panels    = grafana.panels;
+local targets   = grafana.targets;
+
+{
+  new(ds, vars)::
+    panels.timeseries(
+      title       = 'No bridging routes found',
+      datasource  = ds.prometheus,
+    )
+    .configure(defaults.configuration.timeseries)
+    .addTarget(targets.prometheus(
+      datasource    = ds.prometheus,
+      expr          = 'sum by(route) (increase(ca_no_routes_found_total{}[$__rate_interval]))',
+      legendFormat  = 'No routes responses counter',
+    ))
+}
diff --git a/terraform/monitoring/panels/panels.libsonnet b/terraform/monitoring/panels/panels.libsonnet
@@ -90,4 +90,11 @@ local redis  = panels.aws.redis;
     endpoints_latency: (import 'non_rpc/endpoints_latency.libsonnet').new,
     cache_latency: (import 'non_rpc/cache_latency.libsonnet').new,
   },
+
+  chain_abstraction: {
+    gas_estimation: (import 'chain_abstraction/gas_estimation.libsonnet').new,
+    insufficient_funds: (import 'chain_abstraction/insufficient_funds.libsonnet').new,
+    no_bridging: (import 'chain_abstraction/no_bridging.libsonnet').new,
+    no_routes: (import 'chain_abstraction/no_routes.libsonnet').new,
+  },
 }
