use std::sync::atomic::{AtomicUsize, Ordering};
#[cfg(feature = "http3")]
use std::net::{IpAddr, SocketAddr};
#[cfg(feature = "http3")]
use std::sync::Mutex;
#[cfg(feature = "http3")]
use std::time::Duration;
#[cfg(feature = "http3")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum H3RouteKind {
Explicit,
AltSvc,
}
#[cfg(feature = "http3")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum H3CloseKind {
VersionMismatch,
TransportError,
ConnectionClosed,
ApplicationClosed,
Reset,
TimedOut,
LocallyClosed,
CidsExhausted,
}
#[cfg(feature = "http3")]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct H3ConnectionDiagnostic {
pub stable_id: usize,
pub remote_address: SocketAddr,
pub local_ip: Option<IpAddr>,
pub route: H3RouteKind,
pub alt_svc_generation: Option<u64>,
pub rtt: Duration,
pub sent_packets: u64,
pub received_datagrams: u64,
pub lost_packets: u64,
pub sent_bytes: u64,
pub received_bytes: u64,
pub lost_bytes: u64,
pub close: Option<H3CloseSummary>,
pub open_streams: Option<usize>,
}
#[cfg(feature = "http3")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct H3CloseSummary {
pub kind: H3CloseKind,
pub code: Option<u64>,
pub graceful: bool,
}
#[derive(Debug, Default)]
pub struct TransportMetrics {
pub physical_admission_waits: AtomicUsize,
pub physical_admission_timeouts: AtomicUsize,
pub physical_connections_live: AtomicUsize,
pub physical_connections_high_water: AtomicUsize,
pub transport_read_inactivity_timeouts: AtomicUsize,
pub transport_write_inactivity_timeouts: AtomicUsize,
pub direct_connector_attempts: AtomicUsize,
pub direct_connector_successes: AtomicUsize,
pub direct_connector_failures: AtomicUsize,
pub direct_dns_attempts: AtomicUsize,
pub direct_dns_failures: AtomicUsize,
pub direct_tls_attempts: AtomicUsize,
pub direct_tls_failures: AtomicUsize,
pub uds_connector_attempts: AtomicUsize,
pub uds_connector_failures: AtomicUsize,
pub proxy_connector_attempts: AtomicUsize,
pub proxy_connector_failures: AtomicUsize,
pub proxy_tls_attempts: AtomicUsize,
pub proxy_tls_failures: AtomicUsize,
pub h3_connections_created: AtomicUsize,
pub h3_cache_evictions: AtomicUsize,
pub upgraded_connections_created: AtomicUsize,
pub altsvc_learned: AtomicUsize,
pub altsvc_expired: AtomicUsize,
pub altsvc_cleared: AtomicUsize,
pub altsvc_rejected: AtomicUsize,
pub h3_route_attempted: AtomicUsize,
pub h3_route_suppressed: AtomicUsize,
pub h3_fallback_selected: AtomicUsize,
pub h3_drain_observed: AtomicUsize,
pub h3_closed: AtomicUsize,
pub h3_reconnected: AtomicUsize,
#[cfg(feature = "http3")]
h3_diagnostics: Mutex<std::collections::VecDeque<H3ConnectionDiagnostic>>,
}
impl TransportMetrics {
#[must_use]
pub fn new() -> Self {
Self::default()
}
fn inc(counter: &AtomicUsize) {
counter.fetch_add(1, Ordering::Relaxed);
}
pub(crate) fn record_physical_admission_wait(&self) {
Self::inc(&self.physical_admission_waits);
}
pub(crate) fn record_physical_admission_timeout(&self) {
Self::inc(&self.physical_admission_timeouts);
}
pub(crate) fn record_physical_connection_admitted(&self) {
let live = self
.physical_connections_live
.fetch_add(1, Ordering::Relaxed)
.saturating_add(1);
let mut high_water = self.physical_connections_high_water.load(Ordering::Relaxed);
while live > high_water {
match self.physical_connections_high_water.compare_exchange_weak(
high_water,
live,
Ordering::Relaxed,
Ordering::Relaxed,
) {
Ok(_) => break,
Err(observed) => high_water = observed,
}
}
}
pub(crate) fn record_physical_connection_released(&self) {
self.physical_connections_live
.fetch_sub(1, Ordering::Relaxed);
}
pub(crate) fn record_transport_io_timeout(&self, direction: crate::TransportIoDirection) {
match direction {
crate::TransportIoDirection::Read => {
Self::inc(&self.transport_read_inactivity_timeouts);
}
crate::TransportIoDirection::Write => {
Self::inc(&self.transport_write_inactivity_timeouts);
}
}
}
pub fn record_direct_attempt(&self) {
Self::inc(&self.direct_connector_attempts);
}
pub fn record_direct_success(&self) {
Self::inc(&self.direct_connector_successes);
}
pub fn record_direct_failure(&self) {
Self::inc(&self.direct_connector_failures);
}
pub fn record_direct_dns_attempt(&self) {
Self::inc(&self.direct_dns_attempts);
}
pub fn record_direct_dns_failure(&self) {
Self::inc(&self.direct_dns_failures);
}
pub fn record_direct_tls_attempt(&self) {
Self::inc(&self.direct_tls_attempts);
}
pub fn record_direct_tls_failure(&self) {
Self::inc(&self.direct_tls_failures);
}
pub fn record_uds_attempt(&self) {
Self::inc(&self.uds_connector_attempts);
}
pub fn record_uds_failure(&self) {
Self::inc(&self.uds_connector_failures);
}
pub fn record_proxy_attempt(&self) {
Self::inc(&self.proxy_connector_attempts);
}
pub fn record_proxy_failure(&self) {
Self::inc(&self.proxy_connector_failures);
}
pub fn record_proxy_tls_attempt(&self) {
Self::inc(&self.proxy_tls_attempts);
}
pub fn record_proxy_tls_failure(&self) {
Self::inc(&self.proxy_tls_failures);
}
pub fn record_h3_created(&self) {
Self::inc(&self.h3_connections_created);
}
pub fn record_h3_eviction(&self) {
Self::inc(&self.h3_cache_evictions);
}
pub fn record_upgraded(&self) {
Self::inc(&self.upgraded_connections_created);
}
pub fn record_altsvc_learned(&self) {
Self::inc(&self.altsvc_learned);
}
pub fn record_altsvc_expired(&self) {
Self::inc(&self.altsvc_expired);
}
pub fn record_altsvc_cleared(&self) {
Self::inc(&self.altsvc_cleared);
}
pub fn record_altsvc_rejected(&self) {
Self::inc(&self.altsvc_rejected);
}
pub fn record_h3_attempted(&self) {
Self::inc(&self.h3_route_attempted);
}
pub fn record_h3_suppressed(&self) {
Self::inc(&self.h3_route_suppressed);
}
pub fn record_h3_fallback(&self) {
Self::inc(&self.h3_fallback_selected);
}
pub fn record_h3_drain(&self) {
Self::inc(&self.h3_drain_observed);
}
pub fn record_h3_closed(&self) {
Self::inc(&self.h3_closed);
}
pub fn record_h3_reconnected(&self) {
Self::inc(&self.h3_reconnected);
}
#[cfg(feature = "http3")]
pub(crate) fn record_h3_diagnostic(&self, diagnostic: H3ConnectionDiagnostic) {
let Ok(mut diagnostics) = self.h3_diagnostics.lock() else {
return;
};
if let Some(existing) = diagnostics
.iter_mut()
.find(|existing| existing.stable_id == diagnostic.stable_id)
{
*existing = diagnostic;
return;
}
if diagnostics.len() >= 64 {
diagnostics.pop_front();
}
diagnostics.push_back(diagnostic);
}
#[cfg(feature = "http3")]
#[must_use]
pub fn h3_diagnostics(&self) -> Vec<H3ConnectionDiagnostic> {
self.h3_diagnostics
.lock()
.map(|diagnostics| diagnostics.iter().cloned().collect())
.unwrap_or_default()
}
#[must_use]
#[allow(
clippy::too_many_arguments,
reason = "snapshot groups all counters for deterministic test assertions"
)]
pub fn snapshot(&self) -> TransportSnapshot {
TransportSnapshot {
physical_admission_waits: self.physical_admission_waits.load(Ordering::Relaxed),
physical_admission_timeouts: self.physical_admission_timeouts.load(Ordering::Relaxed),
physical_connections_live: self.physical_connections_live.load(Ordering::Relaxed),
physical_connections_high_water: self
.physical_connections_high_water
.load(Ordering::Relaxed),
transport_read_inactivity_timeouts: self
.transport_read_inactivity_timeouts
.load(Ordering::Relaxed),
transport_write_inactivity_timeouts: self
.transport_write_inactivity_timeouts
.load(Ordering::Relaxed),
direct_connector_attempts: self.direct_connector_attempts.load(Ordering::Relaxed),
direct_connector_successes: self.direct_connector_successes.load(Ordering::Relaxed),
direct_connector_failures: self.direct_connector_failures.load(Ordering::Relaxed),
direct_dns_attempts: self.direct_dns_attempts.load(Ordering::Relaxed),
direct_dns_failures: self.direct_dns_failures.load(Ordering::Relaxed),
direct_tls_attempts: self.direct_tls_attempts.load(Ordering::Relaxed),
direct_tls_failures: self.direct_tls_failures.load(Ordering::Relaxed),
uds_connector_attempts: self.uds_connector_attempts.load(Ordering::Relaxed),
uds_connector_failures: self.uds_connector_failures.load(Ordering::Relaxed),
proxy_connector_attempts: self.proxy_connector_attempts.load(Ordering::Relaxed),
proxy_connector_failures: self.proxy_connector_failures.load(Ordering::Relaxed),
proxy_tls_attempts: self.proxy_tls_attempts.load(Ordering::Relaxed),
proxy_tls_failures: self.proxy_tls_failures.load(Ordering::Relaxed),
h3_connections_created: self.h3_connections_created.load(Ordering::Relaxed),
h3_cache_evictions: self.h3_cache_evictions.load(Ordering::Relaxed),
upgraded_connections_created: self.upgraded_connections_created.load(Ordering::Relaxed),
altsvc_learned: self.altsvc_learned.load(Ordering::Relaxed),
altsvc_expired: self.altsvc_expired.load(Ordering::Relaxed),
altsvc_cleared: self.altsvc_cleared.load(Ordering::Relaxed),
altsvc_rejected: self.altsvc_rejected.load(Ordering::Relaxed),
h3_route_attempted: self.h3_route_attempted.load(Ordering::Relaxed),
h3_route_suppressed: self.h3_route_suppressed.load(Ordering::Relaxed),
h3_fallback_selected: self.h3_fallback_selected.load(Ordering::Relaxed),
h3_drain_observed: self.h3_drain_observed.load(Ordering::Relaxed),
h3_closed: self.h3_closed.load(Ordering::Relaxed),
h3_reconnected: self.h3_reconnected.load(Ordering::Relaxed),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TransportSnapshot {
pub physical_admission_waits: usize,
pub physical_admission_timeouts: usize,
pub physical_connections_live: usize,
pub physical_connections_high_water: usize,
pub transport_read_inactivity_timeouts: usize,
pub transport_write_inactivity_timeouts: usize,
pub direct_connector_attempts: usize,
pub direct_connector_successes: usize,
pub direct_connector_failures: usize,
pub direct_dns_attempts: usize,
pub direct_dns_failures: usize,
pub direct_tls_attempts: usize,
pub direct_tls_failures: usize,
pub uds_connector_attempts: usize,
pub uds_connector_failures: usize,
pub proxy_connector_attempts: usize,
pub proxy_connector_failures: usize,
pub proxy_tls_attempts: usize,
pub proxy_tls_failures: usize,
pub h3_connections_created: usize,
pub h3_cache_evictions: usize,
pub upgraded_connections_created: usize,
pub altsvc_learned: usize,
pub altsvc_expired: usize,
pub altsvc_cleared: usize,
pub altsvc_rejected: usize,
pub h3_route_attempted: usize,
pub h3_route_suppressed: usize,
pub h3_fallback_selected: usize,
pub h3_drain_observed: usize,
pub h3_closed: usize,
pub h3_reconnected: usize,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn counters_start_zeroed() {
let m = TransportMetrics::new();
let s = m.snapshot();
assert_eq!(s.direct_connector_attempts, 0);
assert_eq!(s.upgraded_connections_created, 0);
assert_eq!(s.altsvc_learned, 0);
assert_eq!(s.h3_route_attempted, 0);
}
#[test]
fn increments_are_exact() {
let m = TransportMetrics::new();
m.record_direct_attempt();
m.record_direct_attempt();
m.record_direct_success();
m.record_upgraded();
m.record_altsvc_learned();
m.record_h3_attempted();
m.record_h3_fallback();
let s = m.snapshot();
assert_eq!(s.direct_connector_attempts, 2);
assert_eq!(s.direct_connector_successes, 1);
assert_eq!(s.upgraded_connections_created, 1);
assert_eq!(s.altsvc_learned, 1);
assert_eq!(s.h3_route_attempted, 1);
assert_eq!(s.h3_fallback_selected, 1);
}
#[cfg(feature = "http3")]
#[test]
fn h3_diagnostics_replace_by_connection_and_stay_bounded() {
let m = TransportMetrics::new();
let address = "127.0.0.1:443".parse().expect("address");
for stable_id in 0..65 {
m.record_h3_diagnostic(H3ConnectionDiagnostic {
stable_id,
remote_address: address,
local_ip: None,
route: H3RouteKind::Explicit,
alt_svc_generation: None,
rtt: Duration::from_millis(1),
sent_packets: 1,
received_datagrams: 1,
lost_packets: 0,
sent_bytes: 1,
received_bytes: 1,
lost_bytes: 0,
close: None,
open_streams: None,
});
}
let diagnostics = m.h3_diagnostics();
assert_eq!(diagnostics.len(), 64);
assert_eq!(diagnostics[0].stable_id, 1);
m.record_h3_diagnostic(H3ConnectionDiagnostic {
stable_id: 64,
remote_address: address,
local_ip: None,
route: H3RouteKind::AltSvc,
alt_svc_generation: Some(7),
rtt: Duration::from_millis(2),
sent_packets: 2,
received_datagrams: 2,
lost_packets: 1,
sent_bytes: 2,
received_bytes: 2,
lost_bytes: 1,
close: Some(H3CloseSummary {
kind: H3CloseKind::ApplicationClosed,
code: Some(0x100),
graceful: true,
}),
open_streams: None,
});
let updated = m.h3_diagnostics();
assert_eq!(updated.len(), 64);
assert_eq!(
updated.last().expect("last diagnostic").alt_svc_generation,
Some(7)
);
assert_eq!(updated.last().expect("last diagnostic").lost_packets, 1);
}
}