metrical 0.1.1

Graphite/Statsd metrics client
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use crate::metric::{MetricData, MetricGenerator, MetricType};
use std::time::{SystemTime, UNIX_EPOCH};
use crate::shared::collector;

pub struct CounterBuilder {
    name: String,
    namespace: Option<String>
}

impl CounterBuilder {
    pub fn new(name: String) -> CounterBuilder {
        CounterBuilder{ name, namespace: Option::None }
    }

    pub fn namespace(&mut self, namespace: Option<String>) -> &Self {
        self.namespace = namespace;
        self
    }

    pub fn build(&self) -> Counter {
        Counter {
            count: 0,
            name: self.name.clone(),
            namespace: self.namespace.clone()
        }
    }
}

/// A metric used to measure incrementing values.
///
/// Counters can be created via the `metrical::counter` function,
/// or the `metrical::namespace::counter` method.
///
/// # Examples
/// - The number of login attempts you've handled
/// - The number of cache lookups you've successfully made
#[derive(Debug)]
pub struct Counter {
    count: u32,
    name: String,
    namespace: Option<String>
}

impl Counter {
    /// Increment the value of a counter by the given amount
    pub fn increment(&mut self, amount: u32) -> &Self {
        self.count += amount;
        self
    }
}

impl Drop for Counter {
    fn drop(&mut self) {
        collector().send(self.metric());
    }
}

impl MetricGenerator for Counter {
    fn metric(&self) -> MetricData {
        let namespace = self.namespace.clone().take();
        let name = self.name.clone();

        let occurred = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map_or(0, |d| d.as_secs());

        MetricData{
            namespace,
            name,
            occurred,
            metric: MetricType::Counter(self.count)
        }
    }
}


#[cfg(test)]
mod test {
    mod counter {
        use crate::metric::{MetricGenerator, MetricData, MetricType};
        use crate::metric::counter::CounterBuilder;

        #[test]
        pub fn test_increment() {
            let mut counter = CounterBuilder::new("HelloCounter".to_owned())
                .namespace(Option::None)
                .build();

            counter.increment(1);
            counter.increment(1);

            let result = counter.metric();

            assert_eq!(
                result,
                MetricData {
                    namespace: Option::None,
                    occurred: result.occurred,
                    name: "HelloCounter".to_owned(),
                    metric: MetricType::Counter(2)
                }
            );

            std::mem::forget(counter);
        }

        #[test]
        pub fn it_should_work_after_many_additions() {
            let mut counter = CounterBuilder::new("HelloCounter".to_owned())
                .namespace(Option::None)
                .build();

            for i in 1..100 {
                counter.increment(i);
            }

            let result = counter.metric();
            assert_eq!(
                result,
                MetricData{
                    namespace: Option::None,
                    occurred: result.occurred,
                    name: "HelloCounter".to_owned(),
                    metric: MetricType::Counter(4950)
                }
            );

            std::mem::forget(counter);
        }
    }
}