diff --git a/Cargo.toml b/Cargo.toml index f6d8264..42c7c51 100644 --- a/Cargo.toml +++ b/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] diff --git a/src/main.rs b/src/main.rs index 3e18e85..e319569 100644 --- a/src/main.rs +++ b/src/main.rs @@ -275,8 +275,7 @@ async fn tcp_acceptor(globals: Arc, 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, 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 _); })); } } diff --git a/src/metrics.rs b/src/metrics.rs index 5df82e7..e470e1d 100644 --- a/src/metrics.rs +++ b/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(); diff --git a/src/varz.rs b/src/varz.rs index 2aa90c6..9dc017a 100644 --- a/src/varz.rs +++ b/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",}