Prometheus: use int counters and gauges

Cargo.toml

@@ -24,7 +24,7 @@ env_logger = { version = "0.7.1", default-features = false, features = ["humanti
 futures = { version = "0.3", features = ["async-await"] }
 ipext = "0.1.0"
 jemallocator = "0.3.2"
-libsodium-sys-stable="1.18.2"
+libsodium-sys-stable="1.19"
 log = { version = "0.4.8", features = ["std", "release_max_level_debug"] }
 net2 = "0.2.33"
 parking_lot = "0.10"
@@ -41,7 +41,7 @@ toml = "0.5.5"
 [dependencies.hyper]
 optional = true
 git = "https://github.com/hyperium/hyper"
-rev = "0b03b730531654b1b5f632099386ab27c94eb9f4"
+rev = "5a59875742500672f253719c1e1a16b4eddfacc7"
 default_features = false
 
 [dependencies.prometheus]

src/main.rs

@@ -275,8 +275,7 @@ async fn tcp_acceptor(globals: Arc<Globals>, mut tcp_listener: TcpListener) -> R
         let varz = globals.varz.clone();
         #[cfg(feature = "metrics")]
         {
-            varz.inflight_tcp_queries
-                .set(_count.saturating_add(1) as f64);
+            varz.inflight_tcp_queries.set(_count.saturating_add(1) as _);
             varz.client_queries_tcp.inc();
         }
         client_connection.set_nodelay(true)?;
@@ -304,8 +303,7 @@ async fn tcp_acceptor(globals: Arc<Globals>, mut tcp_listener: TcpListener) -> R
         runtime_handle.spawn(fut_all.map(move |_| {
             let _count = concurrent_connections.fetch_sub(1, Ordering::Relaxed);
             #[cfg(feature = "metrics")]
-            varz.inflight_tcp_queries
-                .set(_count.saturating_sub(1) as f64);
+            varz.inflight_tcp_queries.set(_count.saturating_sub(1) as _);
         }));
     }
     Ok(())
@@ -347,8 +345,7 @@ async fn udp_acceptor(
         let varz = globals.varz.clone();
         #[cfg(feature = "metrics")]
         {
-            varz.inflight_udp_queries
-                .set(_count.saturating_add(1) as f64);
+            varz.inflight_udp_queries.set(_count.saturating_add(1) as _);
             varz.client_queries_udp.inc();
         }
         let globals = globals.clone();
@@ -359,8 +356,7 @@ async fn udp_acceptor(
         runtime_handle.spawn(fut_all.map(move |_| {
             let _count = concurrent_connections.fetch_sub(1, Ordering::Relaxed);
             #[cfg(feature = "metrics")]
-            varz.inflight_udp_queries
-                .set(_count.saturating_sub(1) as f64);
+            varz.inflight_udp_queries.set(_count.saturating_sub(1) as _);
         }));
     }
 }

src/metrics.rs

@@ -33,7 +33,7 @@ async fn handle_client_connection(
     }
     let StartInstant(start_instant) = varz.start_instant;
     let uptime = start_instant.elapsed().as_secs();
-    varz.uptime.set(uptime as f64);
+    varz.uptime.set(uptime as _);
     let client_queries = varz.client_queries_udp.get() + varz.client_queries_tcp.get();
     varz.client_queries.set(client_queries);
     let metric_families = prometheus::gather();

src/varz.rs

@@ -1,27 +1,27 @@
 use coarsetime::Instant;
-use prometheus::{Counter, Gauge, Histogram};
+use prometheus::{Histogram, IntCounter, IntGauge};
 use std::sync::Arc;
 
 pub struct StartInstant(pub Instant);
 
 pub struct Inner {
     pub start_instant: StartInstant,
-    pub uptime: Gauge,
-    pub anonymized_queries: Counter,
-    pub anonymized_responses: Counter,
-    pub client_queries: Gauge,
-    pub client_queries_udp: Counter,
-    pub client_queries_tcp: Counter,
-    pub client_queries_cached: Counter,
-    pub client_queries_expired: Counter,
-    pub client_queries_offline: Counter,
-    pub client_queries_errors: Counter,
-    pub client_queries_blocked: Counter,
-    pub inflight_udp_queries: Gauge,
-    pub inflight_tcp_queries: Gauge,
-    pub upstream_errors: Counter,
-    pub upstream_sent: Counter,
-    pub upstream_received: Counter,
+    pub uptime: IntGauge,
+    pub anonymized_queries: IntCounter,
+    pub anonymized_responses: IntCounter,
+    pub client_queries: IntGauge,
+    pub client_queries_udp: IntCounter,
+    pub client_queries_tcp: IntCounter,
+    pub client_queries_cached: IntCounter,
+    pub client_queries_expired: IntCounter,
+    pub client_queries_offline: IntCounter,
+    pub client_queries_errors: IntCounter,
+    pub client_queries_blocked: IntCounter,
+    pub inflight_udp_queries: IntGauge,
+    pub inflight_tcp_queries: IntGauge,
+    pub upstream_errors: IntCounter,
+    pub upstream_sent: IntCounter,
+    pub upstream_received: IntCounter,
     pub upstream_response_sizes: Histogram,
 }
 
@@ -35,58 +35,58 @@ impl Inner {
     pub fn new() -> Inner {
         Inner {
             start_instant: StartInstant::default(),
-            uptime: register_gauge!(opts!(
+            uptime: register_int_gauge!(opts!(
                 "encrypted_dns_uptime",
                 "Uptime",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            anonymized_queries: register_counter!(opts!(
+            anonymized_queries: register_int_counter!(opts!(
                 "encrypted_dns_anonymized_queries",
                 "Number of anomymized queries received",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            anonymized_responses: register_counter!(opts!(
+            anonymized_responses: register_int_counter!(opts!(
                 "encrypted_dns_anonymized_responses",
                 "Number of anomymized responses received",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            client_queries: register_gauge!(opts!(
+            client_queries: register_int_gauge!(opts!(
                 "encrypted_dns_client_queries",
                 "Number of client queries received",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            client_queries_udp: register_counter!(opts!(
+            client_queries_udp: register_int_counter!(opts!(
                 "encrypted_dns_client_queries_udp",
                 "Number of client queries received \
                  using UDP",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            client_queries_tcp: register_counter!(opts!(
+            client_queries_tcp: register_int_counter!(opts!(
                 "encrypted_dns_client_queries_tcp",
                 "Number of client queries received \
                  using TCP",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            client_queries_cached: register_counter!(opts!(
+            client_queries_cached: register_int_counter!(opts!(
                 "encrypted_dns_client_queries_cached",
                 "Number of client queries sent from \
                  the cache",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            client_queries_expired: register_counter!(opts!(
+            client_queries_expired: register_int_counter!(opts!(
                 "encrypted_dns_client_queries_expired",
                 "Number of expired client queries",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            client_queries_offline: register_counter!(opts!(
+            client_queries_offline: register_int_counter!(opts!(
                 "encrypted_dns_client_queries_offline",
                 "Number of client queries answered \
                  while upstream resolvers are \
@@ -94,43 +94,43 @@ impl Inner {
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            client_queries_errors: register_counter!(opts!(
+            client_queries_errors: register_int_counter!(opts!(
                 "encrypted_dns_client_queries_errors",
                 "Number of bogus client queries",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            client_queries_blocked: register_counter!(opts!(
+            client_queries_blocked: register_int_counter!(opts!(
                 "encrypted_dns_client_queries_blocked",
                 "Number of blocked client queries",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            inflight_udp_queries: register_gauge!(opts!(
+            inflight_udp_queries: register_int_gauge!(opts!(
                 "encrypted_dns_inflight_udp_queries",
                 "Number of UDP queries currently waiting for a response",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            inflight_tcp_queries: register_gauge!(opts!(
+            inflight_tcp_queries: register_int_gauge!(opts!(
                 "encrypted_dns_inflight_tcp_queries",
                 "Number of TCP queries currently waiting for a response",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            upstream_errors: register_counter!(opts!(
+            upstream_errors: register_int_counter!(opts!(
                 "encrypted_dns_upstream_errors",
                 "Number of bogus upstream servers responses",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            upstream_sent: register_counter!(opts!(
+            upstream_sent: register_int_counter!(opts!(
                 "encrypted_dns_upstream_sent",
                 "Number of upstream servers queries sent",
                 labels! {"handler" => "all",}
             ))
             .unwrap(),
-            upstream_received: register_counter!(opts!(
+            upstream_received: register_int_counter!(opts!(
                 "encrypted_dns_upstream_received",
                 "Number of upstream servers responses received",
                 labels! {"handler" => "all",}