torrust-metrics 0.1.0

Prometheus metrics integration library providing type-safe metric collection and aggregation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! This module defines the `Unit` enum, which represents various units of
//! measurement.
//!
//! The `Unit` enum is used to specify the unit of measurement for metrics.
//!
//! They were copied from the `metrics` crate, to allow future compatibility.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Unit {
    Count,
    Percent,
    Seconds,
    Milliseconds,
    Microseconds,
    Nanoseconds,
    Tebibytes,
    Gibibytes,
    Mebibytes,
    Kibibytes,
    Bytes,
    TerabitsPerSecond,
    GigabitsPerSecond,
    MegabitsPerSecond,
    KilobitsPerSecond,
    BitsPerSecond,
    CountPerSecond,
}

#[cfg(test)]
mod tests {
    use super::Unit;

    #[test]
    fn it_should_serialize_count_to_snake_case() {
        let json = serde_json::to_string(&Unit::Count).unwrap();
        assert_eq!(json, r#""count""#);
    }

    #[test]
    fn it_should_deserialize_count_from_snake_case() {
        let unit: Unit = serde_json::from_str(r#""count""#).unwrap();
        assert_eq!(unit, Unit::Count);
    }

    #[test]
    fn it_should_round_trip_all_variants() {
        let variants = [
            Unit::Count,
            Unit::Percent,
            Unit::Seconds,
            Unit::Milliseconds,
            Unit::Microseconds,
            Unit::Nanoseconds,
            Unit::Tebibytes,
            Unit::Gibibytes,
            Unit::Mebibytes,
            Unit::Kibibytes,
            Unit::Bytes,
            Unit::TerabitsPerSecond,
            Unit::GigabitsPerSecond,
            Unit::MegabitsPerSecond,
            Unit::KilobitsPerSecond,
            Unit::BitsPerSecond,
            Unit::CountPerSecond,
        ];

        for variant in variants {
            let json = serde_json::to_string(&variant).unwrap();
            let deserialized: Unit = serde_json::from_str(&json).unwrap();
            assert_eq!(deserialized, variant);
        }
    }

    #[test]
    fn it_should_implement_clone_copy_eq_hash_debug() {
        let u = Unit::Count;
        let c = u;
        assert_eq!(u, c);
        let s = format!("{u:?}");
        assert!(!s.is_empty());
        let mut set = std::collections::HashSet::new();
        set.insert(u);
        assert!(set.contains(&Unit::Count));
    }
}