promformat 0.4.1

Simple formatter for 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
140
141
142
143
144
145
146
147
148
149

use std::fmt::Write;

#[derive(Default)]
pub struct Metrics {
    buffer: String,
}

impl Metrics {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn gauge<'a>(&'a mut self, name: &str, help: &str) -> MetricGroup<'a> {
        self.metric_group("gauge", name, help)
    }

    pub fn counter<'a>(&'a mut self, name: &str, help: &str) -> MetricGroup<'a> {
        self.metric_group("counter", name, help)
    }

    fn metric_group<'a>(
        &'a mut self,
        type_: &'static str,
        name: &str,
        help: &str,
    ) -> MetricGroup<'a> {
        MetricGroup::new(self, type_, name, help)
    }

    pub fn render(&self) -> &str {
        &self.buffer
    }

    pub fn into_rendered(self) -> String {
        self.buffer
    }
}

pub struct MetricGroup<'a> {
    metrics: &'a mut Metrics,
    name: String,
}

impl<'a> MetricGroup<'a> {
    fn new(metrics: &'a mut Metrics, metric_type: &str, name: &str, help: &str) -> Self {
        writeln!(&mut metrics.buffer, "# HELP {name} {help}").unwrap();
        writeln!(&mut metrics.buffer, "# TYPE {name} {metric_type}").unwrap();
        Self {
            name: name.to_owned(),
            metrics,
        }
    }

    pub fn label(&mut self, label: impl AsRef<str>, value: impl AsRef<str>) -> SingleMetric {
        SingleMetric {
            name: &self.name,
            metrics: self.metrics,
            labels: String::default(),
        }
        .label(label, value)
    }

    pub fn set(self, value: impl std::fmt::Display) {
        SingleMetric {
            name: &self.name,
            metrics: self.metrics,
            labels: String::from("{"),
        }
        .set(value)
    }
}

pub struct SingleMetric<'a, 'b> {
    labels: String,
    name: &'a String,
    metrics: &'b mut Metrics,
}

impl<'a, 'b> SingleMetric<'a, 'b> {
    pub fn label(mut self, label: impl AsRef<str>, value: impl AsRef<str>) -> Self {
        let label = label.as_ref();
        let value = value.as_ref();
        if self.labels.is_empty() {
            self.labels.push('{')
        } else {
            self.labels.push(',')
        }

        // TODO: escaping
        write!(&mut self.labels, "{label}=\"{value}\"").unwrap();

        self
    }

    pub fn set(mut self, value: impl std::fmt::Display) {
        self.labels.push('}');
        writeln!(self.metrics.buffer, "{}{} {value}", self.name, self.labels).unwrap();
    }
}

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

    #[test]
    fn test_gauge() {
        let mut metrics = Metrics::default();

        let mut gauge = metrics.gauge("testme", "help here");
        gauge.label("x", "y").set(2);
        gauge.label("a", "b").label("c", "d").set(20);

        assert_eq!(
            metrics.render(),
            r#"# HELP testme help here
# TYPE testme gauge
testme{x="y"} 2
testme{a="b",c="d"} 20
"#
        );
    }

    #[test]
    fn test_gauge_no_labels() {
        let mut metrics = Metrics::default();

        metrics.gauge("testme", "help here").set(20);

        assert_eq!(
            metrics.render(),
            r#"# HELP testme help here
# TYPE testme gauge
testme{} 20
"#
        );
    }
}

#[cfg(doctest)]
mod test_readme {
    macro_rules! external_doc_test {
        ($x:expr) => {
            #[doc = $x]
            extern "C" {}
        };
    }

    external_doc_test!(include_str!("../README.md"));
}