diff --git a/src/utils/metrics.rs b/src/utils/metrics.rs index 080664c..15db04d 100644 --- a/src/utils/metrics.rs +++ b/src/utils/metrics.rs @@ -1,8 +1,9 @@ use pingora_http::Method; use pingora_http::StatusCode; use pingora_http::Version; -use prometheus::{register_histogram, register_int_counter, register_int_counter_vec, Histogram, IntCounter, IntCounterVec}; +use prometheus::{register_histogram, register_int_counter, register_int_counter_vec, register_int_gauge, Histogram, IntCounter, IntCounterVec, IntGauge}; use std::sync::Arc; +use std::sync::LazyLock; use std::time::Duration; pub struct MetricTypes { @@ -13,22 +14,13 @@ pub struct MetricTypes { pub version: Version, } -use std::sync::LazyLock; +pub static ACTIVE_SESSIONS: LazyLock = LazyLock::new(|| register_int_gauge!("aralez_active_sessions", "Current number of active sessions").unwrap()); pub static REQUEST_COUNT: LazyLock = LazyLock::new(|| register_int_counter!("aralez_requests_total", "Total number of requests handled by Aralez").unwrap()); pub static RESPONSE_CODES: LazyLock = LazyLock::new(|| register_int_counter_vec!("aralez_responses_total", "Responses grouped by status code", &["status"]).unwrap()); -pub static REQUEST_LATENCY: LazyLock = LazyLock::new(|| { - register_histogram!( - "aralez_request_latency_seconds", - "Request latency in seconds", - vec![0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0] - ) - .unwrap() -}); - pub static RESPONSE_LATENCY: LazyLock = LazyLock::new(|| { register_histogram!( "aralez_response_latency_seconds", @@ -49,9 +41,6 @@ pub static REQUESTS_BY_VERSION: LazyLock = pub fn calc_metrics(metric_types: &MetricTypes) { REQUEST_COUNT.inc(); - let timer = REQUEST_LATENCY.start_timer(); - timer.observe_duration(); - let version_str = match metric_types.version { Version::HTTP_11 => "HTTP/1.1", Version::HTTP_2 => "HTTP/2.0", @@ -59,9 +48,9 @@ pub fn calc_metrics(metric_types: &MetricTypes) { Version::HTTP_10 => "HTTP/1.0", _ => "Unknown", }; - REQUESTS_BY_VERSION.with_label_values(&[&version_str]).inc(); + REQUESTS_BY_VERSION.with_label_values(&[version_str]).inc(); RESPONSE_CODES.with_label_values(&[metric_types.code.unwrap_or(StatusCode::GONE).as_str()]).inc(); - REQUESTS_BY_METHOD.with_label_values(&[&metric_types.method]).inc(); + REQUESTS_BY_METHOD.with_label_values(&[metric_types.method.as_str()]).inc(); REQUESTS_BY_UPSTREAM.with_label_values(&[metric_types.upstream.as_ref()]).inc(); RESPONSE_LATENCY.observe(metric_types.latency.as_secs_f64()); } diff --git a/src/web/gethosts.rs b/src/web/gethosts.rs index bfc0016..b34ec0a 100644 --- a/src/web/gethosts.rs +++ b/src/web/gethosts.rs @@ -19,9 +19,6 @@ pub trait GetHost { } #[async_trait] impl GetHost for LB { - // fn get_upstreams(&self) -> Arc { - // self.ump_full.clone() - // } fn get_host(&self, peer: &str, path: &str, backend_id: Option<&str>) -> Option> { if let Some(b) = backend_id { if let Some(bb) = self.ump_byid.get(b) { diff --git a/src/web/proxyhttp.rs b/src/web/proxyhttp.rs index fdc64a4..3fd63f3 100644 --- a/src/web/proxyhttp.rs +++ b/src/web/proxyhttp.rs @@ -12,10 +12,8 @@ use pingora::prelude::*; use pingora::ErrorSource::Upstream; use pingora_core::listeners::ALPN; use pingora_core::prelude::HttpPeer; -// use pingora_core::protocols::TcpKeepalive; use pingora_limits::rate::Rate; use pingora_proxy::{ProxyHttp, Session}; -// use prometheus::{register_int_counter, IntCounter}; use sha2::{Digest, Sha256}; use std::cell::RefCell; use std::fmt::Write; @@ -23,11 +21,10 @@ use std::sync::{Arc, LazyLock}; use std::time::Duration; use tokio::time::Instant; -// static RATE_LIMITER: Lazy = Lazy::new(|| Rate::new(Duration::from_secs(1))); -// static REVERSE_STORE: Lazy> = Lazy::new(|| DashMap::new()); static REVERSE_STORE: LazyLock> = LazyLock::new(DashMap::new); thread_local! {static IP_BUFFER: RefCell = RefCell::new(String::with_capacity(50));} pub static RATE_LIMITER: LazyLock = LazyLock::new(|| Rate::new(Duration::from_secs(1))); +pub static LOCALHOST: LazyLock> = LazyLock::new(|| Arc::from("localhost")); #[derive(Clone)] pub struct LB { @@ -43,7 +40,6 @@ pub struct LB { pub struct Context { backend_id: Option, sticky_sessions: bool, - // redirect_to: Option, start_time: Instant, hostname: Option>, upstream_peer: Option>, @@ -58,7 +54,6 @@ impl ProxyHttp for LB { Context { backend_id: None, sticky_sessions: false, - // redirect_to: None, start_time: Instant::now(), hostname: None, upstream_peer: None, @@ -67,6 +62,7 @@ impl ProxyHttp for LB { } } async fn request_filter(&self, session: &mut Session, _ctx: &mut Self::CTX) -> Result { + ACTIVE_SESSIONS.inc(); let hostname = return_header_host_from_upstream(session, &self.ump_upst); _ctx.hostname = hostname; let mut backend_id = None; @@ -165,21 +161,6 @@ impl ProxyHttp for LB { peer.options.verify_cert = false; peer.options.verify_hostname = false; } - /* - Experimental optionsv - The following TCP optimizations were tested but caused performance degrade under heavy load: - peer.options.tcp_keepalive = Some(TcpKeepalive { - idle: Duration::from_secs(60), - interval: Duration::from_secs(10), - count: 5, - user_timeout: Duration::from_secs(30), - }); - - peer.options.idle_timeout = Some(Duration::from_secs(300)); - peer.options.tcp_recv_buf = Some(128 * 1024); - End of experimental options - */ - if ctx.extraparams.sticky_sessions { let mut s = String::with_capacity(64); write!( @@ -229,10 +210,6 @@ impl ProxyHttp for LB { } async fn upstream_request_filter(&self, session: &mut Session, upstream_request: &mut RequestHeader, ctx: &mut Self::CTX) -> Result<()> { - // if let Some(hostname) = ctx.hostname.as_deref() { - // upstream_request.insert_header("Host", hostname)?; - // } - if let Some(client_ip) = session.client_addr() { IP_BUFFER.with(|buffer| { let mut buf = buffer.borrow_mut(); @@ -288,9 +265,6 @@ impl ProxyHttp for LB { _upstream_response.append_header(k.clone(), v.as_ref())?; } } - - // session.set_keepalive(Some(300)); - // println!("session.get_keepalive: {:?}", session.get_keepalive()); Ok(()) } @@ -302,10 +276,10 @@ impl ProxyHttp for LB { code: session.response_written().map(|resp| resp.status), latency: ctx.start_time.elapsed(), version: session.req_header().version, - // upstream: ctx.hostname.clone().unwrap_or(Arc::from("localhost")), - upstream: ctx.hostname.take().unwrap_or_else(|| Arc::from("localhost")), + upstream: ctx.hostname.take().unwrap_or_else(|| LOCALHOST.clone()), }; calc_metrics(m); + ACTIVE_SESSIONS.dec(); } }