Allow setting derived label value case

When deriving label values for an enum the default case of the label matches
the identifier case.  This forced derived label values to use rust's
case rules which may not match up with metrics exported from other
programs, or metrics from other crates that export prometheus metrics.

This change adds the ability to set the case of a derived value label to
all-lowercase or all-uppercase for the entire struct in addition to for
an individual label from the prior commit.

Signed-off-by: Eric Hodel <[email protected]>

Author: drbrain

derive-encode/Cargo.toml

@@ -20,4 +20,4 @@ syn = "1"
 prometheus-client = { path = "../", features = ["protobuf"] }
 
 [lib]
-proc-macro = true
+proc-macro = true

derive-encode/src/lib.rs

@@ -9,7 +9,7 @@
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
-use syn::{DeriveInput, Ident};
+use syn::{parse::Parse, DeriveInput, Ident, LitStr, Token};
 
 /// Derive `prometheus_client::encoding::EncodeLabelSet`.
 #[proc_macro_derive(EncodeLabelSet, attributes(prometheus))]
@@ -87,18 +87,27 @@ pub fn derive_encode_label_set(input: TokenStream) -> TokenStream {
     gen.into()
 }
 
-enum ValueCase {
-    Lower,
-    Upper,
-    NoChange,
-}
-
 /// Derive `prometheus_client::encoding::EncodeLabelValue`.
 #[proc_macro_derive(EncodeLabelValue, attributes(prometheus))]
 pub fn derive_encode_label_value(input: TokenStream) -> TokenStream {
     let ast: DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
 
+    let config: LabelConfig = ast
+        .attrs
+        .iter()
+        .find_map(|attr| {
+            if attr.path.is_ident("prometheus") {
+                match attr.parse_args::<LabelConfig>() {
+                    Ok(config) => Some(config),
+                    Err(e) => panic!("invalid prometheus attribute: {e}"),
+                }
+            } else {
+                None
+            }
+        })
+        .unwrap_or_default();
+
     let body = match ast.clone().data {
         syn::Data::Struct(_) => {
             panic!("Can not derive EncodeLabelValue for struct.")
@@ -120,20 +129,10 @@ pub fn derive_encode_label_value(input: TokenStream) -> TokenStream {
                         Some(other) => {
                             panic!("Provided attribute '{other}', but only 'lower' and 'upper' are supported")
                         }
-                        None => ValueCase::NoChange,
+                        None => config.value_case.clone(),
                     };
 
-                    let value = match case {
-                        ValueCase::Lower => {
-                            Ident::new(&ident.to_string().to_lowercase(), ident.span())
-                        },
-                        ValueCase::Upper => {
-                            Ident::new(&ident.to_string().to_uppercase(), ident.span())
-                        },
-                        ValueCase::NoChange => {
-                            ident.clone()
-                        }
-                    };
+                    let value = case.apply(&ident);
 
                     quote! {
                         #name::#ident => encoder.write_str(stringify!(#value))?,
@@ -165,6 +164,77 @@ pub fn derive_encode_label_value(input: TokenStream) -> TokenStream {
     gen.into()
 }
 
+#[derive(Clone)]
+enum ValueCase {
+    Lower,
+    Upper,
+    NoChange,
+}
+
+impl ValueCase {
+    fn apply(&self, ident: &Ident) -> Ident {
+        match self {
+            ValueCase::Lower => Ident::new(&ident.to_string().to_lowercase(), ident.span()),
+            ValueCase::Upper => Ident::new(&ident.to_string().to_uppercase(), ident.span()),
+            ValueCase::NoChange => ident.clone(),
+        }
+    }
+}
+
+struct LabelConfig {
+    value_case: ValueCase,
+}
+
+impl Default for LabelConfig {
+    fn default() -> Self {
+        Self {
+            value_case: ValueCase::NoChange,
+        }
+    }
+}
+
+impl Parse for LabelConfig {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let mut config = LabelConfig::default();
+
+        while input.peek(Ident) {
+            let ident: Ident = input.parse()?;
+
+            match ident.to_string().as_str() {
+                "value_case" => {
+                    let _: Token![=] = input.parse()?;
+                    let case: LitStr = input.parse()?;
+
+                    match case.value().as_str() {
+                        "lower" => config.value_case = ValueCase::Lower,
+                        "upper" => config.value_case = ValueCase::Upper,
+                        invalid => {
+                            return Err(syn::Error::new(
+                                case.span(),
+                                format!(
+                                "value case may only be \"lower\" or \"upper\", not \"{invalid}\""
+                            ),
+                            ))
+                        }
+                    }
+                }
+                invalid => {
+                    return Err(syn::Error::new(
+                        ident.span(),
+                        format!("invalid prometheus attribute \"{invalid}\""),
+                    ))
+                }
+            }
+
+            if input.peek(Token![,]) {
+                let _: Token![,] = input.parse()?;
+            }
+        }
+
+        Ok(config)
+    }
+}
+
 // Copied from https://github.com/djc/askama (MIT and APACHE licensed) and
 // modified.
 static KEYWORD_IDENTIFIERS: [(&str, &str); 48] = [

derive-encode/tests/lib.rs

@@ -175,13 +175,14 @@ fn flatten() {
 }
 
 #[test]
-fn case() {
+fn case_per_label() {
     #[derive(EncodeLabelSet, Hash, Clone, Eq, PartialEq, Debug)]
     struct Labels {
         lower: EnumLabel,
         upper: EnumLabel,
         no_change: EnumLabel,
     }
+
     #[derive(EncodeLabelValue, Hash, Clone, Eq, PartialEq, Debug)]
     enum EnumLabel {
         #[prometheus(lower)]
@@ -214,3 +215,62 @@ fn case() {
         + "# EOF\n";
     assert_eq!(expected, buffer);
 }
+
+#[test]
+fn case_whole_enum() {
+    #[derive(EncodeLabelSet, Hash, Clone, Eq, PartialEq, Debug)]
+    struct Labels {
+        lower: EnumLowerLabel,
+        upper: EnumUpperLabel,
+        no_change: EnumNoChangeLabel,
+        override_case: EnumOverrideLabel,
+    }
+
+    #[derive(EncodeLabelValue, Hash, Clone, Eq, PartialEq, Debug)]
+    #[prometheus(value_case = "lower")]
+    enum EnumLowerLabel {
+        One,
+    }
+
+    #[derive(EncodeLabelValue, Hash, Clone, Eq, PartialEq, Debug)]
+    #[prometheus(value_case = "upper")]
+    enum EnumUpperLabel {
+        Two,
+    }
+
+    #[derive(EncodeLabelValue, Hash, Clone, Eq, PartialEq, Debug)]
+    enum EnumNoChangeLabel {
+        Three,
+    }
+
+    #[derive(EncodeLabelValue, Hash, Clone, Eq, PartialEq, Debug)]
+    #[prometheus(value_case = "upper")]
+    enum EnumOverrideLabel {
+        #[prometheus(lower)]
+        Four,
+    }
+
+    let mut registry = Registry::default();
+    let family = Family::<Labels, Counter>::default();
+    registry.register("my_counter", "This is my counter", family.clone());
+
+    // Record a single HTTP GET request.
+    family
+        .get_or_create(&Labels {
+            lower: EnumLowerLabel::One,
+            upper: EnumUpperLabel::Two,
+            no_change: EnumNoChangeLabel::Three,
+            override_case: EnumOverrideLabel::Four,
+        })
+        .inc();
+
+    // Encode all metrics in the registry in the text format.
+    let mut buffer = String::new();
+    encode(&mut buffer, &registry).unwrap();
+
+    let expected = "# HELP my_counter This is my counter.\n".to_owned()
+        + "# TYPE my_counter counter\n"
+        + "my_counter_total{lower=\"one\",upper=\"TWO\",no_change=\"Three\",override_case=\"four\"} 1\n"
+        + "# EOF\n";
+    assert_eq!(expected, buffer);
+}