File: proto.rs

package info (click to toggle)
rust-prometheus-client 0.22.2-3
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 608 kB
  • sloc: makefile: 2
file content (91 lines) | stat: -rw-r--r-- 2,910 bytes parent folder | download
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
// Benchmark inspired by
// https://github.com/tikv/rust-prometheus/blob/ab1ca7285d3463504381a5025ae1951e020d6796/benches/text_encoder.rs:write

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use prometheus_client::encoding::protobuf;
use prometheus_client::metrics::counter::Counter;
use prometheus_client::metrics::family::Family;
use prometheus_client::metrics::histogram::{exponential_buckets, Histogram};
use prometheus_client::registry::Registry;
use prometheus_client_derive_encode::{EncodeLabelSet, EncodeLabelValue};

#[cfg(not(target_has_atomic = "64"))]
pub fn proto(c: &mut Criterion) {
    println!("bench disabled on architectures without 64-bit atomics")
}

#[cfg(target_has_atomic = "64")]
pub fn proto(c: &mut Criterion) {
    c.bench_function("encode", |b| {
        #[derive(Clone, Hash, PartialEq, Eq, EncodeLabelSet, Debug)]
        struct CounterLabels {
            path: String,
            method: Method,
            some_number: u64,
        }

        #[derive(Clone, Hash, PartialEq, Eq, EncodeLabelValue, Debug)]
        enum Method {
            Get,
            #[allow(dead_code)]
            Put,
        }

        #[derive(Clone, Hash, PartialEq, Eq, EncodeLabelSet, Debug)]
        struct HistogramLabels {
            region: Region,
        }

        #[derive(Clone, Hash, PartialEq, Eq, EncodeLabelValue, Debug)]
        enum Region {
            Africa,
            #[allow(dead_code)]
            Asia,
        }

        let mut registry = Registry::default();

        for i in 0..100 {
            let counter_family = Family::<CounterLabels, Counter>::default();
            let histogram_family =
                Family::<HistogramLabels, Histogram>::new_with_constructor(|| {
                    Histogram::new(exponential_buckets(1.0, 2.0, 10))
                });

            registry.register(
                format!("my_counter{}", i),
                "My counter",
                counter_family.clone(),
            );
            registry.register(
                format!("my_histogram{}", i),
                "My histogram",
                histogram_family.clone(),
            );

            for j in 0_u32..100 {
                counter_family
                    .get_or_create(&CounterLabels {
                        path: format!("/path/{}", i),
                        method: Method::Get,
                        some_number: j.into(),
                    })
                    .inc();

                histogram_family
                    .get_or_create(&HistogramLabels {
                        region: Region::Africa,
                    })
                    .observe(j.into());
            }
        }

        b.iter(|| {
            let metric_set = protobuf::encode(&registry).unwrap();
            black_box(metric_set);
        })
    });
}

criterion_group!(benches, proto);
criterion_main!(benches);