rs-prom2json 0.1.0

Converts the prometheus text to json.
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

use serde::Serialize;

#[derive(Serialize)]
pub struct PrometheusJson<'a> {
    pub docs: &'a std::collections::HashMap<String, String>,
    pub samples: Vec<SampleJson<'a>>,
}

#[derive(Serialize)]
pub struct SampleJson<'a> {
    pub metric: &'a str,
    pub value: MyValue,
    pub labels: &'a std::collections::HashMap<String, String>,
    pub timestamp: i64,
}

impl<'a> From<&'a prometheus_parse::Sample> for SampleJson<'a> {
    fn from(sample: &'a prometheus_parse::Sample) -> Self {
        Self {
            metric: &sample.metric,
            value: MyValue::from(&sample.value),
            labels: &sample.labels,
            timestamp: sample.timestamp.timestamp_micros(),
        }
    }
}

#[derive(Serialize)]
pub struct MyHistogramCount {
    pub less_than: f64,
    pub count: f64,
}

impl From<&prometheus_parse::HistogramCount> for MyHistogramCount {
    fn from(hc: &prometheus_parse::HistogramCount) -> Self {
        Self {
            less_than: hc.less_than,
            count: hc.count,
        }
    }
}

#[derive(Serialize)]
pub struct MySummaryCount {
    pub quantile: f64,
    pub count: f64,
}

impl From<&prometheus_parse::SummaryCount> for MySummaryCount {
    fn from(sc: &prometheus_parse::SummaryCount) -> Self {
        Self {
            quantile: sc.quantile,
            count: sc.count,
        }
    }
}

#[derive(Serialize)]
#[serde(untagged)] // This allows deserialization to try variants in order
pub enum MyValue {
    Counter(f64),
    Gauge(f64),
    Histogram(Vec<MyHistogramCount>),
    Summary(Vec<MySummaryCount>),
    Untyped(f64),
}

impl From<&prometheus_parse::Value> for MyValue {
    fn from(value: &prometheus_parse::Value) -> Self {
        match value {
            prometheus_parse::Value::Counter(f) => MyValue::Counter(*f),
            prometheus_parse::Value::Gauge(f) => MyValue::Gauge(*f),
            prometheus_parse::Value::Histogram(hcs) => {
                let my_hcs: Vec<MyHistogramCount> =
                    hcs.iter().map(MyHistogramCount::from).collect();
                MyValue::Histogram(my_hcs)
            }
            prometheus_parse::Value::Summary(scs) => {
                let my_scs: Vec<MySummaryCount> = scs.iter().map(MySummaryCount::from).collect();
                MyValue::Summary(my_scs)
            }
            prometheus_parse::Value::Untyped(f) => MyValue::Untyped(*f),
        }
    }
}