Rename metrics labels

Author: njgheorghita

portalnet/src/config.rs

@@ -1,5 +1,4 @@
 use std::net::SocketAddr;
-use std::path::PathBuf;
 
 use ethereum_types::H256;
 
@@ -22,25 +21,6 @@ pub struct PortalnetConfig {
     pub internal_ip: bool,
     pub no_stun: bool,
     pub node_addr_cache_capacity: usize,
-    pub enr_file_location: Option<PathBuf>,
-}
-
-impl PortalnetConfig {
-    pub fn new(
-        trin_config: &TrinConfig,
-        private_key: H256,
-        enr_file_location: Option<PathBuf>,
-    ) -> Self {
-        Self {
-            external_addr: trin_config.external_addr,
-            private_key,
-            listen_port: trin_config.discovery_port,
-            no_stun: trin_config.no_stun,
-            bootnodes: trin_config.bootnodes.clone(),
-            enr_file_location,
-            ..Default::default()
-        }
-    }
 }
 
 impl Default for PortalnetConfig {
@@ -54,7 +34,19 @@ impl Default for PortalnetConfig {
             internal_ip: false,
             no_stun: false,
             node_addr_cache_capacity: NODE_ADDR_CACHE_CAPACITY,
-            enr_file_location: None,
+        }
+    }
+}
+
+impl PortalnetConfig {
+    pub fn new(trin_config: &TrinConfig, private_key: H256) -> Self {
+        Self {
+            external_addr: trin_config.external_addr,
+            private_key,
+            listen_port: trin_config.discovery_port,
+            no_stun: trin_config.no_stun,
+            bootnodes: trin_config.bootnodes.clone(),
+            ..Default::default()
         }
     }
 }

portalnet/src/discovery.rs

@@ -1,5 +1,6 @@
 use std::hash::{Hash, Hasher};
 use std::net::Ipv4Addr;
+use std::path::PathBuf;
 use std::str::FromStr;
 use std::{convert::TryFrom, fmt, fs, io, net::SocketAddr, sync::Arc};
 

portalnet/src/metrics/overlay.rs

@@ -17,39 +17,39 @@ use crate::types::messages::{Request, Response};
 /// and content validation.
 #[derive(Clone)]
 pub struct OverlayMetrics {
-    pub message_count: IntCounterVec,
-    pub utp_outcome_count: IntCounterVec,
+    pub message_total: IntCounterVec,
+    pub utp_outcome_total: IntCounterVec,
     pub utp_active_gauge: IntGaugeVec,
-    pub validation_count: IntCounterVec,
+    pub validation_total: IntCounterVec,
 }
 
 impl OverlayMetrics {
     pub fn new(registry: &Registry) -> anyhow::Result<Self> {
-        let message_count = register_int_counter_vec_with_registry!(
+        let message_total = register_int_counter_vec_with_registry!(
             opts!(
-                "trin_message_count",
+                "trin_message_total",
                 "count all network messages sent and received"
             ),
             &["protocol", "direction", "type"],
             registry
         )?;
-        let utp_outcome_count = register_int_counter_vec_with_registry!(
+        let utp_outcome_total = register_int_counter_vec_with_registry!(
             opts!(
-                "trin_utp_outcome",
+                "trin_utp_outcome_total",
                 "track success rate for all utp transfers outbound and inbound"
             ),
             &["protocol", "direction", "outcome"],
             registry
         )?;
         let utp_active_gauge = register_int_gauge_vec_with_registry!(
             opts!(
-                "trin_utp_active",
+                "trin_utp_active_streams",
                 "count all active utp transfers outbound and inbound"
             ),
             &["protocol", "direction"],
             registry
         )?;
-        let validation_count = register_int_counter_vec_with_registry!(
+        let validation_total = register_int_counter_vec_with_registry!(
             opts!(
                 "trin_validation_total",
                 "count all content validations successful and failed"
@@ -58,10 +58,10 @@ impl OverlayMetrics {
             registry
         )?;
         Ok(Self {
-            message_count,
-            utp_outcome_count,
+            message_total,
+            utp_outcome_total,
             utp_active_gauge,
-            validation_count,
+            validation_total,
         })
     }
 }
@@ -73,53 +73,43 @@ pub struct OverlayMetricsReporter {
 }
 
 impl OverlayMetricsReporter {
-    pub fn message_total(&self, direction: &str, message_type: &str) {
-        let protocol: &str = &self.protocol.to_string();
-        self.overlay_metrics
-            .message_count
-            .with_label_values(&[protocol, direction, message_type])
-            .inc();
-    }
-
     //
     // Message Count
     //
 
     /// Returns the value of the given metric with the specified labels.
-    pub fn message_count_by_labels(
+    fn message_total_by_labels(
         &self,
         direction: MessageDirectionLabel,
         message_name: MessageLabel,
     ) -> u64 {
-        let protocol: &str = &self.protocol.to_string();
-        let labels: [&str; 3] = [protocol, direction.into(), message_name.into()];
+        let labels: [&str; 3] = [&self.protocol, direction.into(), message_name.into()];
         self.overlay_metrics
-            .message_count
+            .message_total
             .with_label_values(&labels)
             .get()
     }
 
     pub fn report_outbound_request(&self, request: &Request) {
-        self.increment_message_count(MessageDirectionLabel::Sent, request.into());
+        self.increment_message_total(MessageDirectionLabel::Sent, request.into());
     }
 
     pub fn report_inbound_request(&self, request: &Request) {
-        self.increment_message_count(MessageDirectionLabel::Received, request.into());
+        self.increment_message_total(MessageDirectionLabel::Received, request.into());
     }
 
     pub fn report_outbound_response(&self, response: &Response) {
-        self.increment_message_count(MessageDirectionLabel::Sent, response.into());
+        self.increment_message_total(MessageDirectionLabel::Sent, response.into());
     }
 
     pub fn report_inbound_response(&self, response: &Response) {
-        self.increment_message_count(MessageDirectionLabel::Received, response.into());
+        self.increment_message_total(MessageDirectionLabel::Received, response.into());
     }
 
-    fn increment_message_count(&self, direction: MessageDirectionLabel, message: MessageLabel) {
-        let protocol: &str = &self.protocol.to_string();
-        let labels: [&str; 3] = [protocol, direction.into(), message.into()];
+    fn increment_message_total(&self, direction: MessageDirectionLabel, message: MessageLabel) {
+        let labels: [&str; 3] = [&self.protocol, direction.into(), message.into()];
         self.overlay_metrics
-            .message_count
+            .message_total
             .with_label_values(&labels)
             .inc();
     }
@@ -128,46 +118,41 @@ impl OverlayMetricsReporter {
     // uTP metrics
     //
 
-    fn utp_active_count(&self, direction: UtpDirectionLabel) -> u64 {
-        let protocol: &str = &self.protocol.to_string();
-        let labels: [&str; 2] = [protocol, direction.into()];
+    fn utp_active_streams(&self, direction: UtpDirectionLabel) -> u64 {
+        let labels: [&str; 2] = [&self.protocol, direction.into()];
         self.overlay_metrics
             .utp_active_gauge
             .with_label_values(&labels)
             .get() as u64
     }
 
-    fn utp_outcome_count(&self, direction: UtpDirectionLabel, outcome: UtpOutcomeLabel) -> u64 {
-        let protocol: &str = &self.protocol.to_string();
-        let labels: [&str; 3] = [protocol, direction.into(), outcome.into()];
+    fn utp_outcome_total(&self, direction: UtpDirectionLabel, outcome: UtpOutcomeLabel) -> u64 {
+        let labels: [&str; 3] = [&self.protocol, direction.into(), outcome.into()];
         self.overlay_metrics
-            .utp_outcome_count
+            .utp_outcome_total
             .with_label_values(&labels)
             .get()
     }
 
     pub fn report_utp_outcome(&self, direction: UtpDirectionLabel, outcome: UtpOutcomeLabel) {
-        let protocol: &str = &self.protocol.to_string();
-        let labels: [&str; 3] = [protocol, direction.into(), outcome.into()];
+        let labels: [&str; 3] = [&self.protocol, direction.into(), outcome.into()];
         self.overlay_metrics
-            .utp_outcome_count
+            .utp_outcome_total
             .with_label_values(&labels)
             .inc();
         self.report_utp_active_dec(direction);
     }
 
     pub fn report_utp_active_inc(&self, direction: UtpDirectionLabel) {
-        let protocol: &str = &self.protocol.to_string();
-        let labels: [&str; 2] = [protocol, direction.into()];
+        let labels: [&str; 2] = [&self.protocol, direction.into()];
         self.overlay_metrics
             .utp_active_gauge
             .with_label_values(&labels)
             .inc();
     }
 
     pub fn report_utp_active_dec(&self, direction: UtpDirectionLabel) {
-        let protocol: &str = &self.protocol.to_string();
-        let labels: [&str; 2] = [protocol, direction.into()];
+        let labels: [&str; 2] = [&self.protocol, direction.into()];
         self.overlay_metrics
             .utp_active_gauge
             .with_label_values(&labels)
@@ -178,49 +163,47 @@ impl OverlayMetricsReporter {
     // Validations
     //
     /// Returns the value of the given metric with the specified labels.
-    pub fn validation_count_by_outcome(&self, outcome: bool) -> u64 {
-        let protocol: &str = &self.protocol.to_string();
+    fn validation_total_by_outcome(&self, outcome: bool) -> u64 {
         let outcome = outcome.to_string();
-        let labels: [&str; 2] = [protocol, outcome.as_str()];
+        let labels: [&str; 2] = [&self.protocol, outcome.as_str()];
         self.overlay_metrics
-            .validation_count
+            .validation_total
             .with_label_values(&labels)
             .get()
     }
 
     pub fn report_validation(&self, success: bool) {
-        let protocol: &str = &self.protocol.to_string();
         let success = success.to_string();
-        let labels: [&str; 2] = [protocol, success.as_str()];
+        let labels: [&str; 2] = [&self.protocol, success.as_str()];
         self.overlay_metrics
-            .validation_count
+            .validation_total
             .with_label_values(&labels)
             .inc();
     }
 
     pub fn get_utp_summary(&self) -> String {
         let inbound_success =
-            self.utp_outcome_count(UtpDirectionLabel::Inbound, UtpOutcomeLabel::Success);
-        let inbound_failed_connection = self.utp_outcome_count(
+            self.utp_outcome_total(UtpDirectionLabel::Inbound, UtpOutcomeLabel::Success);
+        let inbound_failed_connection = self.utp_outcome_total(
             UtpDirectionLabel::Inbound,
             UtpOutcomeLabel::FailedConnection,
         );
         let inbound_failed_data_tx =
-            self.utp_outcome_count(UtpDirectionLabel::Inbound, UtpOutcomeLabel::FailedDataTx);
+            self.utp_outcome_total(UtpDirectionLabel::Inbound, UtpOutcomeLabel::FailedDataTx);
         let inbound_failed_shutdown =
-            self.utp_outcome_count(UtpDirectionLabel::Inbound, UtpOutcomeLabel::FailedShutdown);
+            self.utp_outcome_total(UtpDirectionLabel::Inbound, UtpOutcomeLabel::FailedShutdown);
         let outbound_success =
-            self.utp_outcome_count(UtpDirectionLabel::Outbound, UtpOutcomeLabel::Success);
-        let outbound_failed_connection = self.utp_outcome_count(
+            self.utp_outcome_total(UtpDirectionLabel::Outbound, UtpOutcomeLabel::Success);
+        let outbound_failed_connection = self.utp_outcome_total(
             UtpDirectionLabel::Outbound,
             UtpOutcomeLabel::FailedConnection,
         );
         let outbound_failed_data_tx =
-            self.utp_outcome_count(UtpDirectionLabel::Outbound, UtpOutcomeLabel::FailedDataTx);
+            self.utp_outcome_total(UtpDirectionLabel::Outbound, UtpOutcomeLabel::FailedDataTx);
         let outbound_failed_shutdown =
-            self.utp_outcome_count(UtpDirectionLabel::Outbound, UtpOutcomeLabel::FailedShutdown);
-        let active_inbound = self.utp_active_count(UtpDirectionLabel::Inbound);
-        let active_outbound = self.utp_active_count(UtpDirectionLabel::Outbound);
+            self.utp_outcome_total(UtpDirectionLabel::Outbound, UtpOutcomeLabel::FailedShutdown);
+        let active_inbound = self.utp_active_streams(UtpDirectionLabel::Inbound);
+        let active_outbound = self.utp_active_streams(UtpDirectionLabel::Outbound);
         format!(
             "(in/out): active={} ({}/{}), success={} ({}/{}), failed={} ({}/{}) \
             failed_connection={} ({}/{}), failed_data_tx={} ({}/{}), failed_shutdown={} ({}/{})",
@@ -253,14 +236,14 @@ impl OverlayMetricsReporter {
     pub fn get_message_summary(&self) -> String {
         // for every offer you made, how many accepts did you receive
         // for every offer you received, how many accepts did you make
-        let successful_validations = self.validation_count_by_outcome(true);
-        let failed_validations = self.validation_count_by_outcome(false);
+        let successful_validations = self.validation_total_by_outcome(true);
+        let failed_validations = self.validation_total_by_outcome(false);
         format!(
             "offers={}/{}, accepts={}/{}, validations={}/{}",
-            self.message_count_by_labels(MessageDirectionLabel::Received, MessageLabel::Accept),
-            self.message_count_by_labels(MessageDirectionLabel::Sent, MessageLabel::Offer),
-            self.message_count_by_labels(MessageDirectionLabel::Sent, MessageLabel::Accept),
-            self.message_count_by_labels(MessageDirectionLabel::Received, MessageLabel::Offer),
+            self.message_total_by_labels(MessageDirectionLabel::Received, MessageLabel::Accept),
+            self.message_total_by_labels(MessageDirectionLabel::Sent, MessageLabel::Offer),
+            self.message_total_by_labels(MessageDirectionLabel::Sent, MessageLabel::Accept),
+            self.message_total_by_labels(MessageDirectionLabel::Received, MessageLabel::Offer),
             successful_validations,
             successful_validations + failed_validations,
         )

portalnet/src/overlay.rs

@@ -141,6 +141,7 @@ where
             config.table_filter,
             config.bucket_filter,
         )));
+        // Initialize metrics, keep a reference in order to build metrics summaries for logging
         let metrics = OverlayMetricsReporter {
             overlay_metrics: PORTALNET_METRICS.overlay(),
             protocol: protocol.to_string(),

portalnet/src/overlay_service.rs

@@ -2697,10 +2697,9 @@ mod tests {
     use crate::{
         config::PortalnetConfig,
         discovery::{Discovery, NodeAddress},
-        metrics::{portalnet::PORTALNET_METRICS, registry::METRICS_REGISTRY},
+        metrics::portalnet::PORTALNET_METRICS,
         overlay::OverlayConfig,
         storage::{DistanceFunction, MemoryContentStore},
-        types::messages::PortalnetConfig,
         utils::db::setup_temp_dir,
     };
     use ethportal_api::types::content_key::overlay::IdentityContentKey;

portalnet/src/types/messages.rs

@@ -2,7 +2,6 @@ use std::{
     convert::{TryFrom, TryInto},
     fmt,
     ops::Deref,
-    path::PathBuf,
     str::FromStr,
 };
 

src/lib.rs

@@ -45,19 +45,18 @@ pub async fn run_trin(
     let (node_data_dir, private_key) =
         configure_node_data_dir(trin_data_dir, trin_config.private_key)?;
 
-    // Initialize prometheus metrics
-    if let Some(addr) = trin_config.enable_metrics_with_url {
-        prometheus_exporter::start(addr)?;
-    }
-
-    let portalnet_config =
-        PortalnetConfig::new(&trin_config, private_key, Some(node_data_dir.clone()));
+    let portalnet_config = PortalnetConfig::new(&trin_config, private_key);
 
     // Initialize base discovery protocol
     let mut discovery = Discovery::new(portalnet_config.clone(), node_data_dir.clone())?;
     let talk_req_rx = discovery.start().await?;
     let discovery = Arc::new(discovery);
 
+    // Initialize prometheus metrics
+    if let Some(addr) = trin_config.enable_metrics_with_url {
+        prometheus_exporter::start(addr)?;
+    }
+
     // Initialize and spawn uTP socket
     let (utp_talk_reqs_tx, utp_talk_reqs_rx) = mpsc::unbounded_channel();
     let discv5_utp_socket = Discv5UdpSocket::new(Arc::clone(&discovery), utp_talk_reqs_rx);

utp-testing/src/lib.rs

@@ -12,6 +12,7 @@ use jsonrpsee::proc_macros::rpc;
 use jsonrpsee::server::{Server, ServerHandle};
 use portalnet::config::PortalnetConfig;
 use portalnet::discovery::{Discovery, UtpEnr};
+use portalnet::types::messages::ProtocolId;
 use portalnet::utils::db::setup_temp_dir;
 use std::net::SocketAddr;
 use std::str::FromStr;