use std::time::Duration;
#[cfg(not(feature = "tracing"))]
macro_rules! zignore {
() => {};
($msg:literal $(,)?) => {};
($name:ident = ?$val:expr $(, $($rest:tt)*)?) => {{
let _ = &$val;
$crate::obs::zignore!($($($rest)*)?);
}};
($name:ident = %$val:expr $(, $($rest:tt)*)?) => {{
let _ = &$val;
$crate::obs::zignore!($($($rest)*)?);
}};
($name:ident = $val:expr $(, $($rest:tt)*)?) => {{
let _ = &$val;
$crate::obs::zignore!($($($rest)*)?);
}};
($name:ident $(, $($rest:tt)*)?) => {{
let _ = &$name;
$crate::obs::zignore!($($($rest)*)?);
}};
}
macro_rules! zdebug {
($($t:tt)*) => {{
#[cfg(feature = "tracing")]
tracing::debug!($($t)*);
#[cfg(not(feature = "tracing"))]
$crate::obs::zignore!($($t)*);
}};
}
macro_rules! zwarn {
($($t:tt)*) => {{
#[cfg(feature = "tracing")]
tracing::warn!($($t)*);
#[cfg(not(feature = "tracing"))]
$crate::obs::zignore!($($t)*);
}};
}
#[cfg(not(feature = "tracing"))]
pub(crate) use zignore;
pub(crate) use {zdebug, zwarn};
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct TransferStats {
pub bytes_fetched: u64,
pub chunks_fetched: u32,
pub chunks_resumed: u32,
pub rejected: u32,
pub retries: u32,
pub queries: u64,
pub elapsed: Duration,
}
impl std::ops::AddAssign<&TransferStats> for TransferStats {
fn add_assign(&mut self, rhs: &TransferStats) {
self.bytes_fetched += rhs.bytes_fetched;
self.chunks_fetched += rhs.chunks_fetched;
self.chunks_resumed += rhs.chunks_resumed;
self.rejected += rhs.rejected;
self.retries += rhs.retries;
self.queries += rhs.queries;
self.elapsed += rhs.elapsed;
}
}
impl std::ops::AddAssign for TransferStats {
fn add_assign(&mut self, rhs: TransferStats) {
*self += &rhs;
}
}
impl std::ops::Add for TransferStats {
type Output = TransferStats;
fn add(mut self, rhs: TransferStats) -> TransferStats {
self += &rhs;
self
}
}
impl std::iter::Sum for TransferStats {
fn sum<I: Iterator<Item = TransferStats>>(iter: I) -> TransferStats {
iter.fold(TransferStats::default(), |acc, s| acc + s)
}
}
impl TransferStats {
pub fn throughput_bps(&self) -> u64 {
let secs = self.elapsed.as_secs_f64();
if secs <= f64::EPSILON {
return 0;
}
(self.bytes_fetched as f64 / secs) as u64
}
}
#[cfg(test)]
mod tests {
use super::*;
fn stats(bytes: u64, secs: f64) -> TransferStats {
TransferStats {
bytes_fetched: bytes,
chunks_fetched: 2,
chunks_resumed: 3,
rejected: 4,
retries: 5,
queries: 6,
elapsed: Duration::from_secs_f64(secs),
}
}
#[test]
fn throughput_is_bytes_over_seconds_and_never_divides_by_zero() {
assert_eq!(stats(1_000_000, 2.0).throughput_bps(), 500_000);
assert_eq!(stats(1_000_000, 0.0).throughput_bps(), 0);
assert_eq!(TransferStats::default().throughput_bps(), 0);
}
#[test]
fn summing_stats_sums_every_field() {
let a = stats(100, 1.0);
let b = stats(200, 2.0);
let mut acc = a.clone();
acc += &b;
assert_eq!(acc.bytes_fetched, 300);
assert_eq!(acc.chunks_fetched, 4);
assert_eq!(acc.chunks_resumed, 6);
assert_eq!(acc.rejected, 8);
assert_eq!(acc.retries, 10);
assert_eq!(acc.queries, 12);
assert_eq!(acc.elapsed, Duration::from_secs(3));
assert_eq!(a.clone() + b.clone(), acc);
let mut owned = a.clone();
owned += b.clone();
assert_eq!(owned, acc);
assert_eq!([a, b].into_iter().sum::<TransferStats>(), acc);
let z = TransferStats::default();
assert_eq!(z.clone() + z.clone(), z);
assert_eq!(
std::iter::empty::<TransferStats>().sum::<TransferStats>(),
z
);
}
}