chain/ethereum, core: Better fix for deployment_eth_rpc_* metrics

Author: Jannis

chain/ethereum/src/adapter.rs

@@ -769,42 +769,44 @@ impl ProviderEthRpcMetrics {
 
 #[derive(Clone)]
 pub struct SubgraphEthRpcMetrics {
-    request_duration: Box<GaugeVec>,
-    errors: Box<CounterVec>,
+    request_duration: GaugeVec,
+    errors: CounterVec,
+    deployment: String,
 }
 
 impl SubgraphEthRpcMetrics {
     pub fn new(registry: Arc<dyn MetricsRegistry>, subgraph_hash: &str) -> Self {
         let request_duration = registry
-            .new_deployment_gauge_vec(
+            .global_gauge_vec(
                 "deployment_eth_rpc_request_duration",
                 "Measures eth rpc request duration for a subgraph deployment",
-                &subgraph_hash,
-                vec![String::from("method"), String::from("provider")],
+                vec!["deployment", "method", "provider"].as_slice(),
             )
             .unwrap();
         let errors = registry
-            .new_deployment_counter_vec(
+            .global_counter_vec(
                 "deployment_eth_rpc_errors",
                 "Counts eth rpc request errors for a subgraph deployment",
-                &subgraph_hash,
-                vec![String::from("method"), String::from("provider")],
+                vec!["deployment", "method", "provider"].as_slice(),
             )
             .unwrap();
         Self {
             request_duration,
             errors,
+            deployment: subgraph_hash.into(),
         }
     }
 
     pub fn observe_request(&self, duration: f64, method: &str, provider: &str) {
         self.request_duration
-            .with_label_values(&[method, provider])
+            .with_label_values(&[&self.deployment, method, provider])
             .set(duration);
     }
 
     pub fn add_error(&self, method: &str, provider: &str) {
-        self.errors.with_label_values(&[method, provider]).inc();
+        self.errors
+            .with_label_values(&[&self.deployment, method, provider])
+            .inc();
     }
 }
 

chain/ethereum/src/chain.rs

@@ -23,9 +23,9 @@ use graph::{
     },
 };
 use prost::Message;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
 use std::iter::FromIterator;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 use crate::data_source::DataSourceTemplate;
 use crate::data_source::UnresolvedDataSourceTemplate;
@@ -58,7 +58,6 @@ pub struct Chain {
     chain_head_update_listener: Arc<dyn ChainHeadUpdateListener>,
     reorg_threshold: BlockNumber,
     pub is_ingestible: bool,
-    deployment_rpc_metrics: Arc<Mutex<HashMap<String, Arc<SubgraphEthRpcMetrics>>>>,
 }
 
 impl std::fmt::Debug for Chain {
@@ -94,7 +93,6 @@ impl Chain {
             chain_head_update_listener,
             reorg_threshold,
             is_ingestible,
-            deployment_rpc_metrics: Default::default(),
         }
     }
 
@@ -159,15 +157,7 @@ impl Blockchain for Chain {
             self.eth_adapters.cheapest_with(capabilities)?.clone()
         };
 
-        let ethrpc_metrics = self
-            .deployment_rpc_metrics
-            .lock()
-            .unwrap()
-            .entry(String::from(loc.hash.as_str()))
-            .or_insert_with(|| {
-                Arc::new(SubgraphEthRpcMetrics::new(self.registry.clone(), &loc.hash))
-            })
-            .cheap_clone();
+        let ethrpc_metrics = Arc::new(SubgraphEthRpcMetrics::new(self.registry.clone(), &loc.hash));
 
         let adapter = TriggersAdapter {
             logger,

core/src/metrics/registry.rs

@@ -17,6 +17,7 @@ pub struct MetricsRegistry {
     global_counters: Arc<RwLock<HashMap<u64, Counter>>>,
     global_counter_vecs: Arc<RwLock<HashMap<u64, CounterVec>>>,
     global_gauges: Arc<RwLock<HashMap<u64, Gauge>>>,
+    global_gauge_vecs: Arc<RwLock<HashMap<u64, GaugeVec>>>,
 }
 
 impl MetricsRegistry {
@@ -35,6 +36,7 @@ impl MetricsRegistry {
             global_counters: Arc::new(RwLock::new(HashMap::new())),
             global_counter_vecs: Arc::new(RwLock::new(HashMap::new())),
             global_gauges: Arc::new(RwLock::new(HashMap::new())),
+            global_gauge_vecs: Arc::new(RwLock::new(HashMap::new())),
         }
     }
 
@@ -193,6 +195,28 @@ impl MetricsRegistryTrait for MetricsRegistry {
         }
     }
 
+    fn global_gauge_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: &[&str],
+    ) -> Result<GaugeVec, PrometheusError> {
+        let opts = Opts::new(name, help);
+        let gauges = GaugeVec::new(opts, variable_labels)?;
+        let id = gauges.desc().first().unwrap().id;
+        let maybe_gauge = self.global_gauge_vecs.read().unwrap().get(&id).cloned();
+        if let Some(gauges) = maybe_gauge {
+            Ok(gauges)
+        } else {
+            self.register(name, Box::new(gauges.clone()));
+            self.global_gauge_vecs
+                .write()
+                .unwrap()
+                .insert(id, gauges.clone());
+            Ok(gauges)
+        }
+    }
+
     fn unregister(&self, metric: Box<dyn Collector>) {
         match self.registry.unregister(metric) {
             Ok(_) => {

graph/src/components/metrics/mod.rs

@@ -70,6 +70,13 @@ pub trait MetricsRegistry: Send + Sync + 'static {
         const_labels: HashMap<String, String>,
     ) -> Result<Gauge, PrometheusError>;
 
+    fn global_gauge_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: &[&str],
+    ) -> Result<GaugeVec, PrometheusError>;
+
     fn new_gauge(
         &self,
         name: &str,

mock/src/metrics_registry.rs

@@ -1,6 +1,6 @@
 use graph::components::metrics::{Collector, Counter, Gauge, Opts, PrometheusError};
 use graph::prelude::MetricsRegistry as MetricsRegistryTrait;
-use graph::prometheus::CounterVec;
+use graph::prometheus::{CounterVec, GaugeVec};
 
 use std::collections::HashMap;
 
@@ -55,4 +55,15 @@ impl MetricsRegistryTrait for MockMetricsRegistry {
         let counters = CounterVec::new(opts, variable_labels)?;
         Ok(counters)
     }
+
+    fn global_gauge_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: &[&str],
+    ) -> Result<GaugeVec, PrometheusError> {
+        let opts = Opts::new(name, help);
+        let gauges = GaugeVec::new(opts, variable_labels)?;
+        Ok(gauges)
+    }
 }