prometrics 0.1.13

Client library for exposing prometheus metrics
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
132
133
134
135
136
137
138
139

// so the API is "complete" even if not all functions are used
#![allow(dead_code)]

use std::sync::atomic::{self, Ordering::Relaxed};

#[derive(Debug)]
pub struct AtomicU64(atomic::AtomicU64);

impl AtomicU64 {
    pub fn new(v: u64) -> Self {
        AtomicU64(v.into())
    }

    pub fn get(&self) -> u64 {
        self.0.load(Relaxed)
    }

    pub fn inc(&self) {
        self.add(1);
    }

    pub fn add(&self, v: u64) {
        self.0.fetch_add(v, Relaxed);
    }

    pub fn update<F>(&self, f: F)
    where
        F: Fn(u64) -> u64,
    {
        let mut old = self.0.load(Relaxed);
        loop {
            let new = f(old);
            match self.0.compare_exchange_weak(old, new, Relaxed, Relaxed) {
                Ok(_) => break,
                Err(v) => old = v, // try again
            }
        }
    }

    pub fn set(&self, v: u64) {
        self.0.store(v, Relaxed);
    }
}

#[derive(Debug)]
pub struct AtomicI64(atomic::AtomicI64);

impl AtomicI64 {
    pub fn new(v: i64) -> Self {
        AtomicI64(v.into())
    }

    pub fn get(&self) -> i64 {
        self.0.load(Relaxed)
    }

    pub fn inc(&self) {
        self.add(1);
    }

    pub fn add(&self, v: i64) {
        self.0.fetch_add(v, Relaxed);
    }

    pub fn update<F>(&self, f: F)
    where
        F: Fn(i64) -> i64,
    {
        let mut old = self.0.load(Relaxed);
        loop {
            let new = f(old);
            match self.0.compare_exchange_weak(old, new, Relaxed, Relaxed) {
                Ok(_) => break,
                Err(v) => old = v, // try again
            }
        }
    }

    pub fn set(&self, v: i64) {
        self.0.store(v, Relaxed);
    }
}

/// Add (and inc) is not a dedicated atomic instruction, use busy-loop
#[derive(Debug)]
pub struct AtomicF64(atomic::AtomicU64);

impl AtomicF64 {
    pub fn new(v: f64) -> Self {
        AtomicF64(v.to_bits().into())
    }

    pub fn get(&self) -> f64 {
        f64::from_bits(self.0.load(Relaxed))
    }

    pub fn inc(&self) {
        self.add(1.0);
    }

    pub fn add(&self, v: f64) {
        self.update(|old| old + v);
    }

    pub fn update<F>(&self, f: F)
    where
        F: Fn(f64) -> f64,
    {
        let mut old = self.0.load(Relaxed);
        loop {
            let new = f(f64::from_bits(old)).to_bits();
            match self.0.compare_exchange_weak(old, new, Relaxed, Relaxed) {
                Ok(_) => break,
                Err(v) => old = v, // try again
            }
        }
    }

    pub fn set(&self, v: f64) {
        self.0.store(v.to_bits(), Relaxed);
    }
}

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

    #[test]
    fn atomic_f64_works() {
        let value = AtomicF64::new(0.0);
        assert_eq!(value.get(), 0.0);

        value.set(123456789.0);
        assert_eq!(value.get(), 123456789.0);

        value.update(|v| v + 1.0);
        assert_eq!(value.get(), 123456790.0);
    }
}