refact: add lock to metrics to avoid names duplication in different types

Author: josecelano

packages/http-tracker-core/src/statistics/metrics.rs

@@ -25,8 +25,10 @@ pub struct Metrics {
 
 impl Metrics {
     pub fn increase_counter(&mut self, metric_name: &MetricName, labels: &LabelSet, now: DurationSinceUnixEpoch) {
-        tracing::info!("Increasing counter for metric: {metric_name} with labels: {labels:?}");
-
         self.metric_collection.increase_counter(metric_name, labels, now);
     }
+
+    pub fn set_gauge(&mut self, metric_name: &MetricName, labels: &LabelSet, value: f64, now: DurationSinceUnixEpoch) {
+        self.metric_collection.set_gauge(metric_name, labels, value, now);
+    }
 }

packages/metrics/src/metric_collection.rs

@@ -1,4 +1,5 @@
 use std::collections::{HashMap, HashSet};
+use std::sync::RwLock;
 
 use serde::ser::{SerializeSeq, Serializer};
 use serde::{Deserialize, Deserializer, Serialize};
@@ -11,6 +12,57 @@ use super::metric::{Metric, MetricName};
 use super::prometheus::PrometheusSerializable;
 use crate::sample_collection::SampleCollection;
 
+#[derive(Debug, Default)]
+pub struct Metrics {
+    inner: RwLock<MetricCollection>,
+}
+
+impl Metrics {
+    #[must_use]
+    pub fn new(counters: MetricKindCollection<Counter>, gauges: MetricKindCollection<Gauge>) -> Self {
+        Self {
+            inner: RwLock::new(MetricCollection::new(counters, gauges)),
+        }
+    }
+
+    // Counter-specific methods
+
+    /// # Panics
+    ///
+    /// Panics if it can't get read access to the inner collection.
+    #[must_use]
+    pub fn get_counter_value(&self, name: &MetricName, labels: &LabelSet) -> Counter {
+        self.inner.read().unwrap().counters.get_value(name, labels)
+    }
+
+    /// # Panics
+    ///
+    /// Panics if it can't get write access to the inner collection.
+    pub fn increase_counter(&mut self, name: &MetricName, labels: &LabelSet, time: DurationSinceUnixEpoch) {
+        self.inner.write().unwrap().increase_counter(name, labels, time);
+    }
+
+    // Gauge-specific methods
+
+    /// # Panics
+    ///
+    /// Panics if it can't get read access to the inner collection.
+    #[must_use]
+    pub fn get_gauge_value(&self, name: &MetricName, labels: &LabelSet) -> Gauge {
+        self.inner.read().unwrap().gauges.get_value(name, labels)
+    }
+
+    /// # Panics
+    ///
+    /// Panics if it can't get write access to the inner collection.
+    pub fn set_gauge(&mut self, name: &MetricName, labels: &LabelSet, value: f64, time: DurationSinceUnixEpoch) {
+        self.inner.write().unwrap().set_gauge(name, labels, value, time);
+    }
+}
+
+/// Use this type only when behind a lock that guarantees thread-safety.
+/// Otherwise, there could be race conditions that lead to duplicate metric
+/// names in different metric types.
 #[derive(Debug, Clone, Default, PartialEq)]
 pub struct MetricCollection {
     counters: MetricKindCollection<Counter>,