metrics_facade/
macros.rs

1/// Records a counter.
2///
3/// Functionally equivalent to calling [`Recorder::record_counter`].
4///
5/// ### Examples
6///
7/// ```rust
8/// # #[macro_use]
9/// # extern crate metrics_facade;
10/// fn do_thing() {
11///     let count: u64 = 42;
12///     counter!("do_thing", count);
13/// }
14/// # fn main() {}
15/// ```
16#[macro_export]
17macro_rules! counter {
18    ($name:tt, $value:expr) => {{
19        $crate::__private_api_record_count($name, $value);
20    }};
21}
22
23/// Records a gauge.
24///
25/// Functionally equivalent to calling [`Recorder::record_gauge`].
26///
27/// ### Examples
28///
29/// ```rust
30/// # #[macro_use]
31/// # extern crate metrics_facade;
32/// fn update_current_value() {
33///     let value: i64 = -131;
34///     gauge!("current_value", value);
35/// }
36/// # fn main() {}
37/// ```
38#[macro_export]
39macro_rules! gauge {
40    ($name:tt, $value:expr) => {{
41        $crate::__private_api_record_gauge($name, $value);
42    }};
43}
44
45/// Records a timing.
46///
47/// Functionally equivalent to calling [`Recorder::record_histogram`].
48///
49/// ### Examples
50///
51/// ```rust
52/// # #[macro_use]
53/// # extern crate metrics_facade;
54/// # use std::time::Instant;
55/// # fn process() {}
56/// fn handle_request() {
57///     let start = Instant::now();
58///     process();
59///     let end = Instant::now();
60///
61///     // We can pass instances of `Instant` directly:
62///     timing!("performance.request_processed", start, end);
63///
64///     // Or we can pass just the delta:
65///     let delta = end - start;
66///     timing!("performance.request_processed", delta);
67///
68///     // And we can even pass unsigned values, both for the start/end notation:
69///     let start: u64 = 100;
70///     let end: u64 = 200;
71///     timing!("performance.request_processed", start, end);
72///
73///     // And the delta notation:
74///     let delta: u64 = end - start;
75///     timing!("performance.request_processed", delta);
76/// }
77/// # fn main() {}
78/// ```
79#[macro_export]
80macro_rules! timing {
81    ($name:tt, $value:expr) => {{
82        $crate::__private_api_record_histogram($name, $value);
83    }};
84    ($name:tt, $start:expr, $end:expr) => {{
85        let delta = $end - $start;
86        $crate::__private_api_record_histogram($name, delta);
87    }};
88}
89
90/// Records a value.
91///
92/// Functionally equivalent to calling [`Recorder::record_histogram`].
93///
94/// ### Examples
95///
96/// ```rust
97/// # #[macro_use]
98/// # extern crate metrics_facade;
99/// # use std::time::Instant;
100/// # fn process() -> u64 { 42 }
101/// fn handle_request() {
102///     let rows_read = process();
103///     value!("client.process_num_rows", rows_read);
104/// }
105/// # fn main() {}
106/// ```
107#[macro_export]
108macro_rules! value {
109    ($name:tt, $value:expr) => {{
110        $crate::__private_api_record_histogram($name, $value);
111    }};
112}