metrique-macro 0.1.1

Library for working with unit of work metrics - #[metrics] macro
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::{
    MetricsField, MetricsFieldKind, MetricsVariant, NameStyle, RootAttributes, metric_name,
};

use proc_macro2::{Span, TokenStream as Ts2};
use quote::{quote, quote_spanned};
use syn::Ident;

pub(crate) fn generate_value_impl_for_enum(
    root_attrs: &RootAttributes,
    value_name: &Ident,
    parsed_variants: &[MetricsVariant],
) -> Ts2 {
    let variants_and_strings = parsed_variants.iter().map(|variant| {
        let variant_ident = &variant.ident;
        let metric_name = metric_name(root_attrs, root_attrs.rename_all, variant);
        quote_spanned!(variant.ident.span()=> #value_name::#variant_ident => #metric_name)
    });
    quote!(
        impl ::metrique::__writer::Value for #value_name {
            fn write(&self, writer: impl ::metrique::__writer::ValueWriter) {
                writer.string(#[allow(deprecated)] match self {
                    #(#variants_and_strings),*
                });
            }
        }
    )
}

pub fn validate_value_impl_for_struct(
    root_attrs: &RootAttributes,
    value_name: &Ident,
    parsed_fields: &[MetricsField],
) -> Result<(), syn::Error> {
    let non_ignore_fields: Vec<&MetricsField> = parsed_fields
        .iter()
        .filter(|f| !matches!(f.attrs.kind, MetricsFieldKind::Ignore(_)))
        .collect::<Vec<_>>();
    if non_ignore_fields.len() > 1 {
        return Err(syn::Error::new(
            non_ignore_fields[1].span,
            "multiple non-ignored fields for #[metrics(value)]",
        ));
    }
    if root_attrs.emf_dimensions.is_some() {
        return Err(syn::Error::new(
            value_name.span(),
            "emf_dimensions is not supported for #[metrics(value)]",
        ));
    }
    if root_attrs.prefix.is_some() {
        return Err(syn::Error::new(
            value_name.span(),
            "prefix is not supported for #[metrics(value)]",
        ));
    }
    if !matches!(root_attrs.rename_all, NameStyle::Preserve) {
        return Err(syn::Error::new(
            value_name.span(),
            "NameStyle is not supported for #[metrics(value)]",
        ));
    }

    Ok(())
}

pub(crate) fn format_value(format: &Option<syn::Path>, span: Span, field: Ts2) -> Ts2 {
    if let Some(format) = format {
        quote_spanned! { span=> &::metrique::format::FormattedValue::<_, #format>::new(#field)}
    } else {
        field
    }
}

pub(crate) fn generate_value_impl_for_struct(
    _root_attrs: &RootAttributes,
    value_name: &Ident,
    parsed_fields: &[MetricsField],
) -> Result<Ts2, syn::Error> {
    // support struct with only ignored fields as no value for orthogonality
    let non_ignore_fields = parsed_fields
        .iter()
        .filter(|f| !matches!(f.attrs.kind, MetricsFieldKind::Ignore(_)));
    let body: Vec<Ts2> = non_ignore_fields.map(|field| {
        match &field.attrs.kind {
            MetricsFieldKind::Field { unit: _, name: None, format } => {
                let ident = &field.ident;
                let value = format_value(format, field.span, quote! { &self.#ident });
                Ok(quote_spanned!{field.span=> ::metrique::__writer::Value::write(#value, writer) })
            }
            _ => {
                Err(syn::Error::new(field.span, "only plain fields are supported in #[metrics(value)]"))
            }
        }
    }).collect::<Result<Vec<_>, _>>()?;

    Ok(quote! {
        impl ::metrique::__writer::Value for #value_name {
            fn write(&self, writer: impl ::metrique::__writer::ValueWriter) {
                #[allow(deprecated)] {
                    #(#body);*
                }
            }
        }
    })
}