merni 0.1.3

A low overhead metrics implementation.
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

/// Create a [`MetricMeta`](crate::MetricMeta).
///
/// Instead of creating and emitting metrics manually, it is recommended to emit
/// metrics using the [`counter!`](crate::counter!), [`gauge!`](crate::gauge!),
/// or [`distribution!`](crate::distribution!) macros.
#[macro_export]
macro_rules! declare_metric {
    ($ty:ident => $key:literal $(@ $unit:ident)? : $($tag_key:literal),*) => {{
        const N: usize = $crate::macros::__count_helper([$($crate::__replace_expr!($tag_key ())),*]);
        static METRIC: $crate::TaggedMetricMeta<N> = $crate::MetricMeta::new(
            $crate::MetricType::$ty,
            $crate::__metric_unit!($($unit)?),
            $key
        )
        .with_tags(&[$($tag_key,)?]);
        &METRIC
    }};
    ($ty:ident => $key:literal $(@ $unit:ident)?) => {{
        static METRIC: $crate::MetricMeta = $crate::MetricMeta::new(
            $crate::MetricType::$ty,
            $crate::__metric_unit!($($unit)?),
            $key
        );
        &METRIC
    }};
}

/// Emits a counter metric with the current [`Dispatcher`](crate::Dispatcher).
#[macro_export]
macro_rules! counter {
    ($($tt:tt)+) => {
        $crate::__emit_metric!(Counter => $($tt)+);
    }
}

/// Emits a gauge metric with the current [`Dispatcher`](crate::Dispatcher).
#[macro_export]
macro_rules! gauge {
    ($($tt:tt)+) => {
        $crate::__emit_metric!(Gauge => $($tt)+);
    }
}

/// Emits a distribution metric with the current [`Dispatcher`](crate::Dispatcher).
#[macro_export]
macro_rules! distribution {
    ($($tt:tt)+) => {
        $crate::__emit_metric!(Distribution => $($tt)+);
    }
}

#[macro_export]
#[doc(hidden)]
macro_rules! __emit_metric {
    (
        $ty:ident => $key:literal $(@ $unit:ident)? : $value:expr
        , $($tag_key:literal => $tag_value:expr),+
    ) => {{
        $crate::with_dispatcher(|dispatcher| {
            let metric = $crate::declare_metric!(
                $ty => $key $(@ $unit)? :
                $($tag_key),+
            );
            dispatcher.emit_tagged(metric, $value, [$(&($tag_value)),+]);
        });
    }};
    ($ty:ident => $key:literal $(@ $unit:ident)? : $value:expr) => {{
        $crate::with_dispatcher(|dispatcher| {
            let metric = $crate::declare_metric!($ty => $key $(@ $unit)?);
            dispatcher.emit(metric, $value);
        });
    }};
}

#[macro_export]
#[doc(hidden)]
macro_rules! __metric_unit {
    () => {
        $crate::MetricUnit::Unknown
    };
    (s) => {
        $crate::MetricUnit::Seconds
    };
    (b) => {
        $crate::MetricUnit::Bytes
    };
}

// These are taken from <https://veykril.github.io/tlborm/decl-macros/building-blocks/counting.html#array-length>

#[doc(hidden)]
pub const fn __count_helper<const N: usize>(_: [(); N]) -> usize {
    N
}

#[macro_export]
#[doc(hidden)]
macro_rules! __replace_expr {
    ($_t:tt $sub:expr) => {
        $sub
    };
}