Merge branch 'master' of https://github.com/prometheus/client_rust into fix_issue_172

Author: mxinden

CHANGELOG.md

@@ -4,6 +4,46 @@ 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.23.0] - unreleased
+
+- Update `prost` dependencies to `v0.12`.
+  See [PR 198].
+
+[PR 198]: https://github.com/prometheus/client_rust/pull/198
+
+## [0.22.3]
+
+### Added
+
+- Added `encode_registry` and `encode_eof` functions to `text` module.
+  See [PR 205].
+
+  [PR 205]: https://github.com/prometheus/client_rust/pull/205
+
+- Support all platforms with 32 bit atomics lacking 64 bit atomics.
+  See [PR 203].
+
+[PR 203]: https://github.com/prometheus/client_rust/pull/203
+
+## [0.22.2]
+
+### Added
+
+- Added `Gauge<u32, AtomicU32>` implementation.
+  See [PR 191].
+
+[PR 191]: https://github.com/prometheus/client_rust/pull/191
+
+## [0.22.1]
+
+### Added
+
+- Added `EncodeLabelValue` and `EncodeLabelKey` implementations for `Arc`,
+  `Rc`, and `Box`.
+  See [PR 188].
+
+[PR 188]: https://github.com/prometheus/client_rust/pull/188
+
 ## [0.22.0]
 
 ### Changed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "prometheus-client"
-version = "0.22.0"
+version = "0.23.0"
 authors = ["Max Inden <[email protected]>"]
 edition = "2021"
 description = "Open Metrics client library allowing users to natively instrument applications."
@@ -22,23 +22,29 @@ dtoa = "1.0"
 itoa = "1.0"
 parking_lot = "0.12"
 prometheus-client-derive-encode = { version = "0.4.1", path = "derive-encode" }
-prost = { version = "0.11.0", optional = true }
-prost-types = { version = "0.11.0", optional = true }
+prost = { version = "0.12.0", optional = true }
+prost-types = { version = "0.12.0", optional = true }
 
 [dev-dependencies]
 async-std = { version = "1", features = ["attributes"] }
 criterion = "0.5"
 http-types = "2"
-pyo3 = "0.20"
+pyo3 = "0.21"
 quickcheck = "1"
 rand = "0.8.4"
 tide = "0.16"
 actix-web = "4"
 tokio = { version = "1", features = ["rt-multi-thread", "net", "macros", "signal"] }
-hyper = { version = "0.14.16", features = ["server", "http1", "tcp"] }
+hyper = { version = "1.3.1", features = ["server", "http1"] }
+hyper-util = { version = "0.1.3", features = ["tokio"] }
+http-body-util = "0.1.1"
 
 [build-dependencies]
-prost-build = { version = "0.11.0", optional = true }
+prost-build = { version = "0.12.0", optional = true }
+
+[[bench]]
+name = "baseline"
+harness = false
 
 [[bench]]
 name = "family"
@@ -54,4 +60,9 @@ required-features = []
 name = "proto"
 path = "benches/encoding/proto.rs"
 harness = false
-required-features = ["protobuf"] 
+required-features = ["protobuf"]
+
+# Passing arguments to the docsrs builder in order to properly document cfg's.
+# More information: https://docs.rs/about/builds#cross-compiling
+[package.metadata.docs.rs]
+all-features = true

benches/baseline.rs

@@ -0,0 +1,24 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use prometheus_client::metrics::counter::Counter;
+use prometheus_client::metrics::family::Family;
+
+pub fn baseline(c: &mut Criterion) {
+    c.bench_function("counter", |b| {
+        let counter: Counter = Counter::default();
+
+        b.iter(|| {
+            counter.inc();
+        })
+    });
+
+    c.bench_function("counter via family lookup", |b| {
+        let family = Family::<(), Counter>::default();
+
+        b.iter(|| {
+            family.get_or_create(&()).inc();
+        })
+    });
+}
+
+criterion_group!(benches, baseline);
+criterion_main!(benches);

benches/family.rs

@@ -3,6 +3,32 @@ use prometheus_client::metrics::counter::Counter;
 use prometheus_client::metrics::family::Family;
 
 pub fn family(c: &mut Criterion) {
+    c.bench_function(
+        "counter family with [(&'static str, &'static str)] label set",
+        |b| {
+            let family = Family::<[(&'static str, &'static str); 2], Counter>::default();
+
+            b.iter(|| {
+                family
+                    .get_or_create(&[("method", "GET"), ("status", "200")])
+                    .inc();
+            })
+        },
+    );
+
+    c.bench_function(
+        "counter family with Vec<(&'static str, &'static str)> label set",
+        |b| {
+            let family = Family::<Vec<(&'static str, &'static str)>, Counter>::default();
+
+            b.iter(|| {
+                family
+                    .get_or_create(&vec![("method", "GET"), ("status", "200")])
+                    .inc();
+            })
+        },
+    );
+
     c.bench_function("counter family with Vec<(String, String)> label set", |b| {
         let family = Family::<Vec<(String, String)>, Counter>::default();
 

examples/actix-web.rs

@@ -1,5 +1,6 @@
 use std::sync::Mutex;
 
+use actix_web::middleware::Compress;
 use actix_web::{web, App, HttpResponse, HttpServer, Responder, Result};
 use prometheus_client::encoding::text::encode;
 use prometheus_client::encoding::{EncodeLabelSet, EncodeLabelValue};
@@ -61,6 +62,7 @@ async fn main() -> std::io::Result<()> {
 
     HttpServer::new(move || {
         App::new()
+            .wrap(Compress::default())
             .app_data(metrics.clone())
             .app_data(state.clone())
             .service(web::resource("/metrics").route(web::get().to(metrics_handler)))

examples/hyper.rs

@@ -1,7 +1,11 @@
+use http_body_util::{combinators, BodyExt, Full};
 use hyper::{
-    service::{make_service_fn, service_fn},
-    Body, Request, Response, Server,
+    body::{Bytes, Incoming},
+    server::conn::http1,
+    service::service_fn,
+    Request, Response,
 };
+use hyper_util::rt::TokioIo;
 use prometheus_client::{encoding::text::encode, metrics::counter::Counter, registry::Registry};
 use std::{
     future::Future,
@@ -10,7 +14,11 @@ use std::{
     pin::Pin,
     sync::Arc,
 };
-use tokio::signal::unix::{signal, SignalKind};
+use tokio::{
+    net::TcpListener,
+    pin,
+    signal::unix::{signal, SignalKind},
+};
 
 #[tokio::main]
 async fn main() {
@@ -31,39 +39,48 @@ async fn main() {
 
 /// Start a HTTP server to report metrics.
 pub async fn start_metrics_server(metrics_addr: SocketAddr, registry: Registry) {
-    let mut shutdown_stream = signal(SignalKind::terminate()).unwrap();
-
     eprintln!("Starting metrics server on {metrics_addr}");
 
     let registry = Arc::new(registry);
-    Server::bind(&metrics_addr)
-        .serve(make_service_fn(move |_conn| {
-            let registry = registry.clone();
-            async move {
-                let handler = make_handler(registry);
-                Ok::<_, io::Error>(service_fn(handler))
+
+    let tcp_listener = TcpListener::bind(metrics_addr).await.unwrap();
+    let server = http1::Builder::new();
+    while let Ok((stream, _)) = tcp_listener.accept().await {
+        let mut shutdown_stream = signal(SignalKind::terminate()).unwrap();
+        let io = TokioIo::new(stream);
+        let server_clone = server.clone();
+        let registry_clone = registry.clone();
+        tokio::task::spawn(async move {
+            let conn = server_clone.serve_connection(io, service_fn(make_handler(registry_clone)));
+            pin!(conn);
+            tokio::select! {
+                _ = conn.as_mut() => {}
+                _ = shutdown_stream.recv() => {
+                    conn.as_mut().graceful_shutdown();
+                }
             }
-        }))
-        .with_graceful_shutdown(async move {
-            shutdown_stream.recv().await;
-        })
-        .await
-        .unwrap();
+        });
+    }
 }
 
+/// Boxed HTTP body for responses
+type BoxBody = combinators::BoxBody<Bytes, hyper::Error>;
+
 /// This function returns a HTTP handler (i.e. another function)
 pub fn make_handler(
     registry: Arc<Registry>,
-) -> impl Fn(Request<Body>) -> Pin<Box<dyn Future<Output = io::Result<Response<Body>>> + Send>> {
+) -> impl Fn(Request<Incoming>) -> Pin<Box<dyn Future<Output = io::Result<Response<BoxBody>>> + Send>>
+{
     // This closure accepts a request and responds with the OpenMetrics encoding of our metrics.
-    move |_req: Request<Body>| {
+    move |_req: Request<Incoming>| {
         let reg = registry.clone();
+
         Box::pin(async move {
             let mut buf = String::new();
             encode(&mut buf, &reg.clone())
                 .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))
                 .map(|_| {
-                    let body = Body::from(buf);
+                    let body = full(Bytes::from(buf));
                     Response::builder()
                         .header(
                             hyper::header::CONTENT_TYPE,
@@ -75,3 +92,8 @@ pub fn make_handler(
         })
     }
 }
+
+/// helper function to build a full boxed body
+pub fn full(body: Bytes) -> BoxBody {
+    Full::new(body).map_err(|never| match never {}).boxed()
+}

src/encoding.rs

@@ -9,8 +9,11 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fmt::Write;
 use std::ops::Deref;
+use std::rc::Rc;
+use std::sync::Arc;
 
 #[cfg(feature = "protobuf")]
+#[cfg_attr(docsrs, doc(cfg(feature = "protobuf")))]
 pub mod protobuf;
 pub mod text;
 
@@ -389,6 +392,33 @@ impl<'a> EncodeLabelKey for Cow<'a, str> {
     }
 }
 
+impl<T> EncodeLabelKey for Box<T>
+where
+    for<'a> &'a T: EncodeLabelKey,
+{
+    fn encode(&self, encoder: &mut LabelKeyEncoder) -> Result<(), std::fmt::Error> {
+        EncodeLabelKey::encode(&self.as_ref(), encoder)
+    }
+}
+
+impl<T> EncodeLabelKey for Arc<T>
+where
+    for<'a> &'a T: EncodeLabelKey,
+{
+    fn encode(&self, encoder: &mut LabelKeyEncoder) -> Result<(), std::fmt::Error> {
+        EncodeLabelKey::encode(&self.as_ref(), encoder)
+    }
+}
+
+impl<T> EncodeLabelKey for Rc<T>
+where
+    for<'a> &'a T: EncodeLabelKey,
+{
+    fn encode(&self, encoder: &mut LabelKeyEncoder) -> Result<(), std::fmt::Error> {
+        EncodeLabelKey::encode(&self.as_ref(), encoder)
+    }
+}
+
 /// An encodable label value.
 pub trait EncodeLabelValue {
     /// Encode oneself into the given encoder.
@@ -450,6 +480,33 @@ impl<'a> EncodeLabelValue for Cow<'a, str> {
     }
 }
 
+impl<T> EncodeLabelValue for Box<T>
+where
+    for<'a> &'a T: EncodeLabelValue,
+{
+    fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
+        EncodeLabelValue::encode(&self.as_ref(), encoder)
+    }
+}
+
+impl<T> EncodeLabelValue for Arc<T>
+where
+    for<'a> &'a T: EncodeLabelValue,
+{
+    fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
+        EncodeLabelValue::encode(&self.as_ref(), encoder)
+    }
+}
+
+impl<T> EncodeLabelValue for Rc<T>
+where
+    for<'a> &'a T: EncodeLabelValue,
+{
+    fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
+        EncodeLabelValue::encode(&self.as_ref(), encoder)
+    }
+}
+
 impl EncodeLabelValue for f64 {
     fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
         encoder.write_str(dtoa::Buffer::new().format(*self))
@@ -488,6 +545,12 @@ pub trait EncodeGaugeValue {
     fn encode(&self, encoder: &mut GaugeValueEncoder) -> Result<(), std::fmt::Error>;
 }
 
+impl EncodeGaugeValue for u32 {
+    fn encode(&self, encoder: &mut GaugeValueEncoder) -> Result<(), std::fmt::Error> {
+        encoder.encode_u32(*self)
+    }
+}
+
 impl EncodeGaugeValue for i64 {
     fn encode(&self, encoder: &mut GaugeValueEncoder) -> Result<(), std::fmt::Error> {
         encoder.encode_i64(*self)
@@ -524,13 +587,17 @@ enum GaugeValueEncoderInner<'a> {
 }
 
 impl<'a> GaugeValueEncoder<'a> {
-    fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {
-        for_both_mut!(self, GaugeValueEncoderInner, e, e.encode_f64(v))
+    fn encode_u32(&mut self, v: u32) -> Result<(), std::fmt::Error> {
+        for_both_mut!(self, GaugeValueEncoderInner, e, e.encode_u32(v))
     }
 
     fn encode_i64(&mut self, v: i64) -> Result<(), std::fmt::Error> {
         for_both_mut!(self, GaugeValueEncoderInner, e, e.encode_i64(v))
     }
+
+    fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {
+        for_both_mut!(self, GaugeValueEncoderInner, e, e.encode_f64(v))
+    }
 }
 
 impl<'a> From<text::GaugeValueEncoder<'a>> for GaugeValueEncoder<'a> {

src/encoding/protobuf.rs

@@ -323,6 +323,10 @@ pub(crate) struct GaugeValueEncoder<'a> {
 }
 
 impl<'a> GaugeValueEncoder<'a> {
+    pub fn encode_u32(&mut self, v: u32) -> Result<(), std::fmt::Error> {
+        self.encode_i64(v as i64)
+    }
+
     pub fn encode_i64(&mut self, v: i64) -> Result<(), std::fmt::Error> {
         *self.value = openmetrics_data_model::gauge_value::Value::IntValue(v);
         Ok(())