refactor: reorganize modules

Author: josecelano

Cargo.lock

@@ -30,6 +30,7 @@ url = "2.5.4"
 zerocopy = "0.7"
 
 [dev-dependencies]
+approx = "0.5.1"
 formatjson = "0.3.1"
 pretty_assertions = "1.4.1"
 rstest = "0.25.0"

packages/primitives/Cargo.toml

@@ -0,0 +1,37 @@
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize, Default, PartialEq)]
+pub struct Counter(u64);
+
+impl Counter {
+    #[must_use]
+    pub fn new(value: u64) -> Self {
+        Self(value)
+    }
+
+    #[must_use]
+    pub fn value(&self) -> u64 {
+        self.0
+    }
+
+    pub fn increment(&mut self, value: u64) {
+        self.0 += value;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_counter() {
+        let mut counter = Counter::new(0);
+        assert_eq!(counter.value(), 0);
+
+        counter.increment(5);
+        assert_eq!(counter.value(), 5);
+
+        counter.increment(3);
+        assert_eq!(counter.value(), 8);
+    }
+}

packages/primitives/src/metrics/counter.rs

@@ -0,0 +1,39 @@
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize, Default, PartialEq)]
+pub struct Gauge(f64);
+
+impl Gauge {
+    #[must_use]
+    pub fn new(value: f64) -> Self {
+        Self(value)
+    }
+
+    #[must_use]
+    pub fn value(&self) -> f64 {
+        self.0
+    }
+
+    pub fn set(&mut self, value: f64) {
+        self.0 = value;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use approx::assert_relative_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_gauge() {
+        let mut gauge = Gauge::new(0.0);
+        assert_relative_eq!(gauge.value(), 0.0);
+
+        gauge.set(5.5);
+        assert_relative_eq!(gauge.value(), 5.5);
+
+        gauge.set(3.3);
+        assert_relative_eq!(gauge.value(), 3.3);
+    }
+}

packages/primitives/src/metrics/gauge.rs

@@ -0,0 +1,8 @@
+use super::sample_collection::SampleCollection;
+use super::MetricName;
+
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Metric<T> {
+    pub name: MetricName,
+    pub samples: SampleCollection<T>,
+}

packages/primitives/src/metrics/metric.rs

@@ -1,11 +1,14 @@
 use std::collections::{HashMap, HashSet};
 
-use chrono::DateTime;
 use serde::ser::{SerializeSeq, Serializer};
 use serde::Serialize;
 
+use super::counter::Counter;
+use super::gauge::Gauge;
 use super::label_set::LabelSet;
+use super::metric::Metric;
 use super::MetricName;
+use crate::metrics::sample_collection::SampleCollection;
 use crate::DurationSinceUnixEpoch;
 
 #[derive(Debug, Clone, Default, PartialEq)]
@@ -217,160 +220,12 @@ impl MetricKindCollection<Gauge> {
     }
 }
 
-#[derive(Debug, Clone, Default, PartialEq)]
-pub struct Metric<T> {
-    pub name: MetricName,
-    pub samples: SampleCollection<T>,
-}
-
-impl<T: Serialize> Serialize for SampleCollection<T> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let samples: Vec<&Sample<T>> = self.samples.values().collect();
-        samples.serialize(serializer)
-    }
-}
-
-#[derive(Debug, Clone, Default, PartialEq)]
-pub struct SampleCollection<T> {
-    samples: HashMap<LabelSet, Sample<T>>,
-}
-
-impl<T> SampleCollection<T> {
-    /// # Panics
-    ///
-    /// Panics if there are duplicate `LabelSets` in the provided samples.
-    #[must_use]
-    pub fn new(samples: Vec<Sample<T>>) -> Self {
-        let mut map = HashMap::with_capacity(samples.len());
-        for sample in samples {
-            assert!(
-                map.insert(sample.labels().clone(), sample).is_none(),
-                "Duplicate LabelSet found in SampleCollection"
-            );
-        }
-        Self { samples: map }
-    }
-
-    #[must_use]
-    pub fn get(&self, label: &LabelSet) -> Option<&Sample<T>> {
-        self.samples.get(label)
-    }
-
-    #[must_use]
-    pub fn get_mut(&mut self, label: &LabelSet) -> Option<&mut Sample<T>> {
-        self.samples.get_mut(label)
-    }
-}
-
-#[derive(Debug, Clone, Serialize, PartialEq)]
-pub struct Sample<T> {
-    value: T,
-
-    #[serde(serialize_with = "serialize_duration")]
-    update_at: DurationSinceUnixEpoch,
-
-    labels: LabelSet,
-}
-
-impl<T> Sample<T> {
-    #[must_use]
-    pub fn new(value: T, update_at: DurationSinceUnixEpoch, labels: LabelSet) -> Self {
-        Self {
-            value,
-            update_at,
-            labels,
-        }
-    }
-
-    #[must_use]
-    pub fn labels(&self) -> &LabelSet {
-        &self.labels
-    }
-
-    #[must_use]
-    pub fn value(&self) -> &T {
-        &self.value
-    }
-
-    pub fn value_mut(&mut self) -> &mut T {
-        &mut self.value
-    }
-
-    #[must_use]
-    pub fn update_at(&self) -> DurationSinceUnixEpoch {
-        self.update_at
-    }
-
-    pub fn set_update_at(&mut self, time: DurationSinceUnixEpoch) {
-        self.update_at = time;
-    }
-}
-
-/// Serializes the `update_at` field as a string in ISO 8601 format (RFC 3339).
-///
-/// # Errors
-///
-/// Returns an error if:
-/// - The conversion from `u64` to `i64` fails.
-/// - The timestamp is invalid.
-fn serialize_duration<S>(duration: &DurationSinceUnixEpoch, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let secs = i64::try_from(duration.as_secs()).map_err(|_| serde::ser::Error::custom("Timestamp too large"))?;
-    let nanos = duration.subsec_nanos();
-
-    let datetime = DateTime::from_timestamp(secs, nanos).ok_or_else(|| serde::ser::Error::custom("Invalid timestamp"))?;
-
-    serializer.serialize_str(&datetime.to_rfc3339()) // Serializes as ISO 8601 (RFC 3339)
-}
-
-#[derive(Debug, Clone, Serialize, Default, PartialEq)]
-pub struct Counter(u64);
-
-impl Counter {
-    #[must_use]
-    pub fn new(value: u64) -> Self {
-        Self(value)
-    }
-
-    #[must_use]
-    pub fn value(&self) -> u64 {
-        self.0
-    }
-
-    pub fn increment(&mut self, value: u64) {
-        self.0 += value;
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Default, PartialEq)]
-pub struct Gauge(f64);
-
-impl Gauge {
-    #[must_use]
-    pub fn new(value: f64) -> Self {
-        Self(value)
-    }
-
-    #[must_use]
-    pub fn value(&self) -> f64 {
-        self.0
-    }
-
-    pub fn set(&mut self, value: f64) {
-        self.0 = value;
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use pretty_assertions::assert_eq;
 
     use super::*;
+    use crate::metrics::sample::Sample;
     use crate::metrics::{LabelName, LabelValue};
 
     #[test]
@@ -381,11 +236,7 @@ mod tests {
         let mut metric_collection = MetricCollection {
             counters: MetricKindCollection::new(vec![Metric {
                 name: MetricName::new("test_counter"),
-                samples: SampleCollection::new(vec![Sample {
-                    value: Counter::new(0),
-                    update_at: time,
-                    labels: label_set.clone(),
-                }]),
+                samples: SampleCollection::new(vec![Sample::new(Counter::new(0), time, label_set.clone())]),
             }]),
             gauges: MetricKindCollection::new(vec![]),
         };
@@ -401,7 +252,7 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "Metric names must be unique across counters and gauges")]
-    fn test_duplicate_names_across_types() {
+    fn it_should_not_allow_duplicate_names_across_types() {
         let counter = MetricKindCollection::new(vec![Metric {
             name: MetricName::new("test_metric"),
             samples: SampleCollection::new(vec![]),
@@ -428,11 +279,7 @@ mod tests {
         let metric_collection = MetricCollection::new(
             MetricKindCollection::new(vec![Metric {
                 name: MetricName::new("announce_requests_received_total"),
-                samples: SampleCollection::new(vec![Sample {
-                    value: Counter::new(1), // Initialize with 1 to match the test expectation
-                    update_at: time,
-                    labels: label_set.clone(),
-                }]),
+                samples: SampleCollection::new(vec![Sample::new(Counter::new(1), time, label_set.clone())]),
             }]),
             MetricKindCollection::new(vec![]),
         );
@@ -487,11 +334,7 @@ mod tests {
         let metric_collection = MetricCollection::new(
             MetricKindCollection::new(vec![Metric {
                 name: MetricName::new("announce_requests_received_total"),
-                samples: SampleCollection::new(vec![Sample {
-                    value: Counter::new(1),
-                    update_at: time,
-                    labels: label_set.clone(),
-                }]),
+                samples: SampleCollection::new(vec![Sample::new(Counter::new(1), time, label_set.clone())]),
             }]),
             MetricKindCollection::new(vec![]),
         );
@@ -502,17 +345,4 @@ mod tests {
 
         assert_eq!(prometheus_output, expected);
     }
-
-    #[test]
-    fn test_counter() {
-        let counter = Counter::new(42);
-        assert_eq!(counter.value(), 42);
-    }
-
-    #[test]
-    #[allow(clippy::float_cmp)]
-    fn test_gauge() {
-        let gauge = Gauge::new(3.35);
-        assert_eq!(gauge.value(), 3.35);
-    }
 }

packages/primitives/src/metrics/metric_collection.rs

@@ -1,5 +1,10 @@
+pub mod counter;
+pub mod gauge;
 pub mod label_set;
+pub mod metric;
 pub mod metric_collection;
+pub mod sample;
+pub mod sample_collection;
 
 use derive_more::Display;
 use serde::{Deserialize, Serialize};