Protobuf support

.github/workflows/rust.yml

@@ -39,7 +39,7 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --benches
+          args: --benches --all-features
 
   test:
     name: Test Suite
@@ -73,7 +73,7 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --all
+          args: --all --all-features
 
   fmt:
     name: Rustfmt
@@ -135,7 +135,7 @@ jobs:
           RUSTDOCFLAGS: "--deny broken_intra_doc_links"
         with:
           command: doc
-          args: --verbose --workspace --no-deps --document-private-items
+          args: --verbose --workspace --no-deps --document-private-items --all-features
 
   cross-compile:
     name: Cross compile
@@ -159,4 +159,4 @@ jobs:
         with:
           use-cross: true
           command: build
-          args: --release --target=${{ matrix.target }}
+          args: --release --target=${{ matrix.target }} --all-features

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.18.1] - unreleased
+
+### Added
+- Added support for the OpenMetrics protobuf format. See [PR 47]
+
+[PR 47]: https://github.com/prometheus/client_rust/pull/47
+
 ## [0.18.0]
 
 ### Changed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "prometheus-client"
-version = "0.18.0"
+version = "0.18.1"
 authors = ["Max Inden <mail@max-inden.de>"]
 edition = "2021"
 description = "Open Metrics client library allowing users to natively instrument applications."
@@ -10,14 +10,21 @@ repository = "https://github.com/prometheus/client_rust"
 homepage = "https://github.com/prometheus/client_rust"
 documentation = "https://docs.rs/prometheus-client"
 
+[features]
+protobuf = ["dep:prost", "dep:prost-types", "dep:prost-build", "dep:prometheus-client-derive-proto-encode", "dep:void"]
+
 [workspace]
-members = ["derive-text-encode"]
+members = ["derive-text-encode", "derive-proto-encode"]
 
 [dependencies]
 dtoa = "1.0"
 itoa = "1.0"
 parking_lot = "0.12"
+prometheus-client-derive-proto-encode = { version = "0.1.0", path = "derive-proto-encode", optional = true }
 prometheus-client-derive-text-encode = { version = "0.3.0", path = "derive-text-encode" }
+prost = { version = "0.9.0", optional = true }
+prost-types = { version = "0.9.0", optional = true }
+void = { version = "1.0", optional = true }
 
 [dev-dependencies]
 async-std = { version = "1", features = ["attributes"] }
@@ -29,6 +36,9 @@ rand = "0.8.4"
 tide = "0.16"
 actix-web = "4"
 
+[build-dependencies]
+prost-build = { version = "0.9.0", optional = true }
+
 [[bench]]
 name = "family"
 harness = false
@@ -37,3 +47,8 @@ harness = false
 name = "text"
 path = "benches/encoding/text.rs"
 harness = false
+
+[[bench]]
+name = "proto"
+path = "benches/encoding/proto.rs"
+harness = false

benches/encoding/proto.rs

@@ -0,0 +1,85 @@
+// Benchmark inspired by https://github.com/tikv/rust-prometheus/blob/ab1ca7285d3463504381a5025ae1951e020d6796/benches/text_encoder.rs
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use prometheus_client::encoding::proto::{encode, Encode, EncodeMetric};
+use prometheus_client::metrics::counter::Counter;
+use prometheus_client::metrics::family::Family;
+use prometheus_client::metrics::histogram::{exponential_buckets, Histogram};
+use prometheus_client::registry::Registry;
+use std::fmt::{Display, Formatter};
+
+pub fn proto(c: &mut Criterion) {
+    c.bench_function("encode", |b| {
+        #[derive(Clone, Hash, PartialEq, Eq, Encode)]
+        struct Labels {
+            path: String,
+            method: Method,
+            some_number: u64,
+        }
+
+        #[derive(Clone, Hash, PartialEq, Eq)]
+        enum Method {
+            Get,
+            #[allow(dead_code)]
+            Put,
+        }
+
+        impl Display for Method {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                match self {
+                    Method::Get => write!(f, "Get"),
+                    Method::Put => write!(f, "Put"),
+                }
+            }
+        }
+
+        #[derive(Clone, Hash, PartialEq, Eq, Encode)]
+        enum Region {
+            Africa,
+            #[allow(dead_code)]
+            Asia,
+        }
+
+        let mut registry = Registry::<Box<dyn EncodeMetric>>::default();
+
+        for i in 0..100 {
+            let counter_family = Family::<Labels, Counter>::default();
+            let histogram_family = Family::<Region, Histogram>::new_with_constructor(|| {
+                Histogram::new(exponential_buckets(1.0, 2.0, 10))
+            });
+
+            registry.register(
+                format!("my_counter{}", i),
+                "My counter",
+                Box::new(counter_family.clone()),
+            );
+            registry.register(
+                format!("my_histogram{}", i),
+                "My histogram",
+                Box::new(histogram_family.clone()),
+            );
+
+            for j in 0_u32..100 {
+                counter_family
+                    .get_or_create(&Labels {
+                        path: format!("/path/{}", i),
+                        method: Method::Get,
+                        some_number: j.into(),
+                    })
+                    .inc();
+
+                histogram_family
+                    .get_or_create(&Region::Africa)
+                    .observe(j.into());
+            }
+        }
+
+        b.iter(|| {
+            let metric_set = encode(&registry);
+            black_box(metric_set);
+        })
+    });
+}
+
+criterion_group!(benches, proto);
+criterion_main!(benches);

build.rs

@@ -0,0 +1,11 @@
+use std::io::Result;
+
+fn main() -> Result<()> {
+    #[cfg(feature = "protobuf")]
+    prost_build::compile_protos(
+        &["src/encoding/proto/openmetrics_data_model.proto"],
+        &["src/encoding/proto/"],
+    )?;
+
+    Ok(())
+}

derive-proto-encode/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "prometheus-client-derive-proto-encode"
+version = "0.1.0"
+authors = ["Akihito Nakano <sora.akatsuki@gmail.com>"]
+edition = "2021"
+description = "Auxiliary crate to derive protobuf EncodeLabel trait from prometheus-client."
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/prometheus/client_rust"
+homepage = "https://github.com/prometheus/client_rust"
+documentation = "https://docs.rs/prometheus-client-derive-proto-encode"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+proc-macro2 = "1"
+quote = "1"
+syn = "1"
+
+[dev-dependencies]
+prometheus-client = { path = "../", features = ["protobuf"] }
+
+[lib]
+proc-macro = true

derive-proto-encode/src/lib.rs

@@ -0,0 +1,127 @@
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::DeriveInput;
+
+#[proc_macro_derive(Encode)]
+pub fn derive_encode(input: TokenStream) -> TokenStream {
+    let ast: DeriveInput = syn::parse(input).unwrap();
+    let name = &ast.ident;
+
+    match ast.data {
+        syn::Data::Struct(s) => match s.fields {
+            syn::Fields::Named(syn::FieldsNamed { named, .. }) => {
+                let push_labels: TokenStream2 = named
+                    .into_iter()
+                    .map(|f| {
+                        let ident = f.ident.unwrap();
+                        let ident_string = KEYWORD_IDENTIFIERS
+                            .iter()
+                            .find(|pair| ident == pair.1)
+                            .map(|pair| pair.0.to_string())
+                            .unwrap_or_else(|| ident.to_string());
+
+                        quote! {
+                            let mut label = prometheus_client::encoding::proto::Label::default();
+                            label.name = #ident_string.to_string();
+                            label.value = format!("{}", self.#ident);
+                            labels.push(label);
+                        }
+                    })
+                    .collect();
+
+                quote! {
+                    impl prometheus_client::encoding::proto::EncodeLabels for #name {
+                        fn encode(&self, labels: &mut Vec<prometheus_client::encoding::proto::Label>) {
+                            #push_labels
+                        }
+                    }
+                }
+            }
+            syn::Fields::Unnamed(_) => {
+                panic!("Can not derive Encode for struct with unnamed fields.")
+            }
+            syn::Fields::Unit => panic!("Can not derive Encode for struct with unit field."),
+        },
+        syn::Data::Enum(syn::DataEnum { variants, .. }) => {
+            let match_arms: TokenStream2 = variants
+                .into_iter()
+                .map(|v| {
+                    let ident = v.ident;
+                    quote! {
+                        #name::#ident => {
+                            let mut label = prometheus_client::encoding::proto::Label::default();
+                            label.name = stringify!(#name).to_string();
+                            label.value = stringify!(#ident).to_string();
+                            labels.push(label);
+                        }
+                    }
+                })
+                .collect();
+
+            quote! {
+                impl prometheus_client::encoding::proto::EncodeLabels for #name {
+                    fn encode(&self, labels: &mut Vec<prometheus_client::encoding::proto::Label>) {
+                        match self {
+                            #match_arms
+                        };
+                    }
+                }
+            }
+        }
+        syn::Data::Union(_) => panic!("Can not derive Encode for union."),
+    }.into()
+}
+
+// Copied from https://github.com/djc/askama (MIT and APACHE licensed) and
+// modified.
+static KEYWORD_IDENTIFIERS: [(&str, &str); 48] = [
+    ("as", "r#as"),
+    ("break", "r#break"),
+    ("const", "r#const"),
+    ("continue", "r#continue"),
+    ("crate", "r#crate"),
+    ("else", "r#else"),
+    ("enum", "r#enum"),
+    ("extern", "r#extern"),
+    ("false", "r#false"),
+    ("fn", "r#fn"),
+    ("for", "r#for"),
+    ("if", "r#if"),
+    ("impl", "r#impl"),
+    ("in", "r#in"),
+    ("let", "r#let"),
+    ("loop", "r#loop"),
+    ("match", "r#match"),
+    ("mod", "r#mod"),
+    ("move", "r#move"),
+    ("mut", "r#mut"),
+    ("pub", "r#pub"),
+    ("ref", "r#ref"),
+    ("return", "r#return"),
+    ("static", "r#static"),
+    ("struct", "r#struct"),
+    ("trait", "r#trait"),
+    ("true", "r#true"),
+    ("type", "r#type"),
+    ("unsafe", "r#unsafe"),
+    ("use", "r#use"),
+    ("where", "r#where"),
+    ("while", "r#while"),
+    ("async", "r#async"),
+    ("await", "r#await"),
+    ("dyn", "r#dyn"),
+    ("abstract", "r#abstract"),
+    ("become", "r#become"),
+    ("box", "r#box"),
+    ("do", "r#do"),
+    ("final", "r#final"),
+    ("macro", "r#macro"),
+    ("override", "r#override"),
+    ("priv", "r#priv"),
+    ("typeof", "r#typeof"),
+    ("unsized", "r#unsized"),
+    ("virtual", "r#virtual"),
+    ("yield", "r#yield"),
+    ("try", "r#try"),
+];