prom-timer-macro 0.1.1

RAII Prometheus Timer for monitoring & tracing
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
86
87
88
89
90
91
92

//! Macros for [`prom-timer`].
//!
//! [`prom-timer`]: https://crates.io/crates/prom-timer

use proc_macro::TokenStream;
use quote::quote;
use std::collections::vec_deque::VecDeque;
use syn::parse::{Parse, ParseStream, Result};
use syn::punctuated::Punctuated;
use syn::{parse_macro_input, Expr, ItemFn, Token};

struct Args {
    metric: Expr,
    tags: Vec<Expr>,
}

impl Parse for Args {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut params: VecDeque<Expr> = Punctuated::<Expr, Token![,]>::parse_terminated(input)?
            .into_iter()
            .collect();

        let metric = params.pop_front().unwrap();

        Ok(Args {
            metric,
            tags: params.into_iter().collect(),
        })
    }
}


///
/// Decorator for synchronous and asynchronous functions to measure their execution time with
/// RAII [`prom-timer`]
///
/// As the error message says, handler function needs to be async.
///
/// ```
/// use prometheus::{self, HistogramVec, histogram_opts};
///
/// let timer = HistogramVec::new(
///             histogram_opts!("timer", "Timer")
///                 .namespace("api_v2")
///                 .const_labels(labels.clone())
///                 .buckets(
///                     [
///                         0.001, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 1.0, 2.0,
///                        3.0, 4.0, 5.0, 10.0,
///                     ]
///                     .into(),
///                 ),
///             &["tag"],
///         )
///         .unwrap();
///
/// registry.register(Box::new(timer.clone())).unwrap();
///
/// #[timer(timer, "f")]
/// async fn f() {
///     // ... Some work here.
/// }
///
/// ```
/// `f()` execution time will be stored as timer histogram entry with tag `f`
///
#[proc_macro_attribute]
pub fn timer(args: TokenStream, input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as ItemFn);

    let args = parse_macro_input!(args as Args);

    let ItemFn {
        attrs,
        vis,
        sig,
        block,
    } = input;

    let metric = args.metric;
    let tags = args.tags;
    let stmts = &block.stmts;

    let expanded = quote! {
        #(#attrs)* #vis #sig {
            let _t = prom_timer::Timer::new(#metric, &[#(#tags)*]);
            #(#stmts)*
        }
    };

    TokenStream::from(expanded)
}