Add MetricsReporter type for per-subnetwork metrics reporting

Author: njgheorghita

portalnet/src/metrics/overlay.rs

@@ -1,7 +1,3 @@
-use crate::metrics::labels::{
-    MessageDirectionLabel, MessageLabel, UtpDirectionLabel, UtpOutcomeLabel,
-};
-use crate::types::messages::{Request, Response};
 use prometheus_exporter::{
     self,
     prometheus::{
@@ -10,6 +6,11 @@ use prometheus_exporter::{
     },
 };
 
+use crate::metrics::labels::{
+    MessageDirectionLabel, MessageLabel, UtpDirectionLabel, UtpOutcomeLabel,
+};
+use crate::types::messages::{Request, Response};
+
 /// Contains metrics reporters for use in the overlay network
 /// (eg. `portalnet/src/overlay.rs` & `portalnet/src/overlay_service.rs`).
 /// Metric types reported here include protocol messages, utp transfers,
@@ -63,9 +64,19 @@ impl OverlayMetrics {
             validation_count,
         })
     }
+}
 
-    pub fn message_total(&self, protocol: &str, direction: &str, message_type: &str) {
-        self.message_count
+#[derive(Clone)]
+pub struct OverlayMetricsReporter {
+    pub protocol: String,
+    pub overlay_metrics: OverlayMetrics,
+}
+
+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();
     }
@@ -77,139 +88,139 @@ impl OverlayMetrics {
     /// Returns the value of the given metric with the specified labels.
     pub fn message_count_by_labels(
         &self,
-        protocol: &str,
         direction: MessageDirectionLabel,
         message_name: MessageLabel,
     ) -> u64 {
+        let protocol: &str = &self.protocol.to_string();
         let labels: [&str; 3] = [protocol, direction.into(), message_name.into()];
-        self.message_count.with_label_values(&labels).get()
+        self.overlay_metrics
+            .message_count
+            .with_label_values(&labels)
+            .get()
     }
 
-    pub fn report_outbound_request(&self, protocol: &str, request: &Request) {
-        self.increment_message_count(protocol, MessageDirectionLabel::Sent, request.into());
+    pub fn report_outbound_request(&self, request: &Request) {
+        self.increment_message_count(MessageDirectionLabel::Sent, request.into());
     }
 
-    pub fn report_inbound_request(&self, protocol: &str, request: &Request) {
-        self.increment_message_count(protocol, MessageDirectionLabel::Received, request.into());
+    pub fn report_inbound_request(&self, request: &Request) {
+        self.increment_message_count(MessageDirectionLabel::Received, request.into());
     }
 
-    pub fn report_outbound_response(&self, protocol: &str, response: &Response) {
-        self.increment_message_count(protocol, MessageDirectionLabel::Sent, response.into());
+    pub fn report_outbound_response(&self, response: &Response) {
+        self.increment_message_count(MessageDirectionLabel::Sent, response.into());
     }
 
-    pub fn report_inbound_response(&self, protocol: &str, response: &Response) {
-        self.increment_message_count(protocol, MessageDirectionLabel::Received, response.into());
+    pub fn report_inbound_response(&self, response: &Response) {
+        self.increment_message_count(MessageDirectionLabel::Received, response.into());
     }
 
-    fn increment_message_count(
-        &self,
-        protocol: &str,
-        direction: MessageDirectionLabel,
-        message: MessageLabel,
-    ) {
+    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()];
-        self.message_count.with_label_values(&labels).inc();
+        self.overlay_metrics
+            .message_count
+            .with_label_values(&labels)
+            .inc();
     }
 
     //
     // uTP metrics
     //
 
-    fn utp_active_count(&self, protocol: &str, direction: UtpDirectionLabel) -> u64 {
+    fn utp_active_count(&self, direction: UtpDirectionLabel) -> u64 {
+        let protocol: &str = &self.protocol.to_string();
         let labels: [&str; 2] = [protocol, direction.into()];
-        self.utp_active_gauge.with_label_values(&labels).get() as u64
+        self.overlay_metrics
+            .utp_active_gauge
+            .with_label_values(&labels)
+            .get() as u64
     }
 
-    fn utp_outcome_count(
-        &self,
-        protocol: &str,
-        direction: UtpDirectionLabel,
-        outcome: UtpOutcomeLabel,
-    ) -> 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()];
-        self.utp_outcome_count.with_label_values(&labels).get()
+        self.overlay_metrics
+            .utp_outcome_count
+            .with_label_values(&labels)
+            .get()
     }
 
-    pub fn report_utp_outcome(
-        &self,
-        protocol: &str,
-        direction: UtpDirectionLabel,
-        outcome: UtpOutcomeLabel,
-    ) {
+    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()];
-        self.utp_outcome_count.with_label_values(&labels).inc();
-        self.report_utp_active_dec(protocol, direction);
+        self.overlay_metrics
+            .utp_outcome_count
+            .with_label_values(&labels)
+            .inc();
+        self.report_utp_active_dec(direction);
     }
 
-    pub fn report_utp_active_inc(&self, protocol: &str, direction: UtpDirectionLabel) {
+    pub fn report_utp_active_inc(&self, direction: UtpDirectionLabel) {
+        let protocol: &str = &self.protocol.to_string();
         let labels: [&str; 2] = [protocol, direction.into()];
-        self.utp_active_gauge.with_label_values(&labels).inc();
+        self.overlay_metrics
+            .utp_active_gauge
+            .with_label_values(&labels)
+            .inc();
     }
 
-    pub fn report_utp_active_dec(&self, protocol: &str, direction: UtpDirectionLabel) {
+    pub fn report_utp_active_dec(&self, direction: UtpDirectionLabel) {
+        let protocol: &str = &self.protocol.to_string();
         let labels: [&str; 2] = [protocol, direction.into()];
-        self.utp_active_gauge.with_label_values(&labels).dec();
+        self.overlay_metrics
+            .utp_active_gauge
+            .with_label_values(&labels)
+            .dec();
     }
 
     //
     // Validations
     //
     /// Returns the value of the given metric with the specified labels.
-    pub fn validation_count_by_outcome(&self, protocol: &str, outcome: bool) -> u64 {
+    pub fn validation_count_by_outcome(&self, outcome: bool) -> u64 {
+        let protocol: &str = &self.protocol.to_string();
         let outcome = outcome.to_string();
         let labels: [&str; 2] = [protocol, outcome.as_str()];
-        self.validation_count.with_label_values(&labels).get()
+        self.overlay_metrics
+            .validation_count
+            .with_label_values(&labels)
+            .get()
     }
 
-    pub fn report_validation(&self, protocol: &str, success: bool) {
+    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()];
-        self.validation_count.with_label_values(&labels).inc();
+        self.overlay_metrics
+            .validation_count
+            .with_label_values(&labels)
+            .inc();
     }
 
-    pub fn get_utp_summary(&self, protocol: &str) -> String {
-        let inbound_success = self.utp_outcome_count(
-            protocol,
-            UtpDirectionLabel::Inbound,
-            UtpOutcomeLabel::Success,
-        );
+    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(
-            protocol,
             UtpDirectionLabel::Inbound,
             UtpOutcomeLabel::FailedConnection,
         );
-        let inbound_failed_data_tx = self.utp_outcome_count(
-            protocol,
-            UtpDirectionLabel::Inbound,
-            UtpOutcomeLabel::FailedDataTx,
-        );
-        let inbound_failed_shutdown = self.utp_outcome_count(
-            protocol,
-            UtpDirectionLabel::Inbound,
-            UtpOutcomeLabel::FailedShutdown,
-        );
-        let outbound_success = self.utp_outcome_count(
-            protocol,
-            UtpDirectionLabel::Outbound,
-            UtpOutcomeLabel::Success,
-        );
+        let inbound_failed_data_tx =
+            self.utp_outcome_count(UtpDirectionLabel::Inbound, UtpOutcomeLabel::FailedDataTx);
+        let inbound_failed_shutdown =
+            self.utp_outcome_count(UtpDirectionLabel::Inbound, UtpOutcomeLabel::FailedShutdown);
+        let outbound_success =
+            self.utp_outcome_count(UtpDirectionLabel::Outbound, UtpOutcomeLabel::Success);
         let outbound_failed_connection = self.utp_outcome_count(
-            protocol,
             UtpDirectionLabel::Outbound,
             UtpOutcomeLabel::FailedConnection,
         );
-        let outbound_failed_data_tx = self.utp_outcome_count(
-            protocol,
-            UtpDirectionLabel::Outbound,
-            UtpOutcomeLabel::FailedDataTx,
-        );
-        let outbound_failed_shutdown = self.utp_outcome_count(
-            protocol,
-            UtpDirectionLabel::Outbound,
-            UtpOutcomeLabel::FailedShutdown,
-        );
-        let active_inbound = self.utp_active_count(protocol, UtpDirectionLabel::Inbound);
-        let active_outbound = self.utp_active_count(protocol, UtpDirectionLabel::Outbound);
+        let outbound_failed_data_tx =
+            self.utp_outcome_count(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);
         format!(
             "(in/out): active={} ({}/{}), success={} ({}/{}), failed={} ({}/{}) \
             failed_connection={} ({}/{}), failed_data_tx={} ({}/{}), failed_shutdown={} ({}/{})",
@@ -239,33 +250,17 @@ impl OverlayMetrics {
         )
     }
 
-    pub fn get_message_summary(&self, protocol: &str) -> String {
+    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(protocol, true);
-        let failed_validations = self.validation_count_by_outcome(protocol, false);
+        let successful_validations = self.validation_count_by_outcome(true);
+        let failed_validations = self.validation_count_by_outcome(false);
         format!(
             "offers={}/{}, accepts={}/{}, validations={}/{}",
-            self.message_count_by_labels(
-                protocol,
-                MessageDirectionLabel::Received,
-                MessageLabel::Accept
-            ),
-            self.message_count_by_labels(
-                protocol,
-                MessageDirectionLabel::Sent,
-                MessageLabel::Offer
-            ),
-            self.message_count_by_labels(
-                protocol,
-                MessageDirectionLabel::Sent,
-                MessageLabel::Accept
-            ),
-            self.message_count_by_labels(
-                protocol,
-                MessageDirectionLabel::Received,
-                MessageLabel::Offer
-            ),
+            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),
             successful_validations,
             successful_validations + failed_validations,
         )