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
150
151
152

use super::common::{Histogram, Metric, MetricValue, Snapshot};
use metrics_exporter_prometheus::formatting::{
    sanitize_description, sanitize_label_key, sanitize_label_value, write_help_line, write_metric_line, write_type_line,
};
use serde_json::Value;
use std::collections::HashMap;

fn create_label_string(labels: &HashMap<String, String>) -> Vec<String> {
    let mut label_string = labels
        .iter()
        .map(|(k, v)| format!("{}=\"{}\"", sanitize_label_key(k), sanitize_label_value(v)))
        .collect::<Vec<String>>();

    // This sort isn't strictly needed but adds a predictable set order of labels which makes testing easier but
    // should also be better for our users
    label_string.sort();
    label_string
}

pub(crate) fn metrics_to_json(snapshot: Snapshot) -> Value {
    let Snapshot {
        counters,
        histograms,
        gauges,
    } = snapshot;

    // For json output we convert the histogram where a value is only recorded in a single bucket
    let mut normalised_histograms = Vec::new();

    for histogram in histograms {
        if let MetricValue::Histogram(histogram_value) = histogram.value {
            let mut prev = 0;
            let buckets = histogram_value
                .buckets
                .iter()
                .cloned()
                .map(|(le, count)| {
                    let new_count = count - prev;
                    prev = count;
                    (le, new_count)
                })
                .collect();

            let new_histogram = Histogram {
                buckets,
                sum: histogram_value.sum,
                count: histogram_value.count,
            };

            normalised_histograms.push(Metric {
                key: histogram.key.clone(),
                labels: histogram.labels.clone(),
                description: histogram.description.clone(),
                value: MetricValue::Histogram(new_histogram),
            });
        }
    }

    let snapshot = Snapshot {
        counters,
        histograms: normalised_histograms,
        gauges,
    };

    serde_json::to_value(snapshot).unwrap()
}

pub(crate) fn metrics_to_prometheus(snapshot: Snapshot) -> String {
    let Snapshot {
        counters,
        histograms,
        gauges,
    } = snapshot;

    let mut output = String::new();

    for counter in counters {
        let desc = sanitize_description(counter.description.as_str());
        write_help_line(&mut output, counter.key.as_str(), desc.as_str());

        write_type_line(&mut output, counter.key.as_str(), "counter");
        let labels = create_label_string(&counter.labels);

        if let MetricValue::Counter(value) = counter.value {
            write_metric_line::<&str, u64>(&mut output, counter.key.as_str(), None, &labels, None, value);
        }
        output.push('\n');
    }

    for gauge in gauges {
        let desc = sanitize_description(gauge.description.as_str());
        write_help_line(&mut output, gauge.key.as_str(), desc.as_str());

        write_type_line(&mut output, gauge.key.as_str(), "gauge");
        let labels = create_label_string(&gauge.labels);

        if let MetricValue::Gauge(value) = gauge.value {
            write_metric_line::<&str, f64>(&mut output, gauge.key.as_str(), None, &labels, None, value);
        }
        output.push('\n');
    }

    for histogram in histograms {
        let desc = sanitize_description(histogram.description.as_str());
        write_help_line(&mut output, histogram.key.as_str(), desc.as_str());

        write_type_line(&mut output, histogram.key.as_str(), "histogram");
        let labels = create_label_string(&histogram.labels);

        if let MetricValue::Histogram(histogram_values) = histogram.value {
            for (le, count) in histogram_values.buckets {
                write_metric_line(
                    &mut output,
                    histogram.key.as_str(),
                    Some("bucket"),
                    &labels,
                    Some(("le", le)),
                    count,
                );
            }

            write_metric_line(
                &mut output,
                histogram.key.as_str(),
                Some("bucket"),
                &labels,
                Some(("le", "+Inf")),
                histogram_values.count,
            );
            write_metric_line::<&str, f64>(
                &mut output,
                histogram.key.as_str(),
                Some("sum"),
                &labels,
                None,
                histogram_values.sum,
            );
            write_metric_line::<&str, u64>(
                &mut output,
                histogram.key.as_str(),
                Some("count"),
                &labels,
                None,
                histogram_values.count,
            );
        }

        output.push('\n');
    }

    output
}