standardize the --text output to match that of the tui

Author: kavehtehrani

src/cli.rs

@@ -171,27 +171,68 @@ async fn run_text(args: Cli) -> Result<()> {
     let engine = TestEngine::new(cfg);
     let handle = tokio::spawn(async move { engine.run(evt_tx, ctrl_rx).await });
 
+    // Collect raw samples for metric computation (same as TUI)
+    let run_start = std::time::Instant::now();
+    let mut idle_latency_samples: Vec<f64> = Vec::new();
+    let mut loaded_dl_latency_samples: Vec<f64> = Vec::new();
+    let mut loaded_ul_latency_samples: Vec<f64> = Vec::new();
+    let mut dl_points: Vec<(f64, f64)> = Vec::new();
+    let mut ul_points: Vec<(f64, f64)> = Vec::new();
+
     while let Some(ev) = evt_rx.recv().await {
         match ev {
             TestEvent::PhaseStarted { phase } => {
                 eprintln!("== {phase:?} ==");
             }
             TestEvent::ThroughputTick {
-                phase, bps_instant, ..
+                phase,
+                bps_instant,
+                bytes_total: _,
             } => {
                 if matches!(
                     phase,
                     crate::model::Phase::Download | crate::model::Phase::Upload
                 ) {
-                    eprintln!("{phase:?}: {:.2} Mbps", (bps_instant * 8.0) / 1_000_000.0);
+                    let elapsed = run_start.elapsed().as_secs_f64();
+                    let mbps = (bps_instant * 8.0) / 1_000_000.0;
+                    eprintln!("{phase:?}: {:.2} Mbps", mbps);
+
+                    // Collect throughput points for metrics
+                    match phase {
+                        crate::model::Phase::Download => {
+                            dl_points.push((elapsed, mbps));
+                        }
+                        crate::model::Phase::Upload => {
+                            ul_points.push((elapsed, mbps));
+                        }
+                        _ => {}
+                    }
                 }
             }
             TestEvent::LatencySample {
-                phase, ok, rtt_ms, ..
+                phase,
+                ok,
+                rtt_ms,
+                during,
             } => {
-                if phase == crate::model::Phase::IdleLatency && ok {
+                if ok {
                     if let Some(ms) = rtt_ms {
-                        eprintln!("Idle latency: {:.1} ms", ms);
+                        match (phase, during) {
+                            (crate::model::Phase::IdleLatency, None) => {
+                                eprintln!("Idle latency: {:.1} ms", ms);
+                                idle_latency_samples.push(ms);
+                            }
+                            (
+                                crate::model::Phase::Download,
+                                Some(crate::model::Phase::Download),
+                            ) => {
+                                loaded_dl_latency_samples.push(ms);
+                            }
+                            (crate::model::Phase::Upload, Some(crate::model::Phase::Upload)) => {
+                                loaded_ul_latency_samples.push(ms);
+                            }
+                            _ => {}
+                        }
                     }
                 }
             }
@@ -226,29 +267,60 @@ async fn run_text(args: Cli) -> Result<()> {
     if let Some(server) = enriched.server.as_deref() {
         println!("Server: {server}");
     }
-    println!("Download: {:.2} Mbps", enriched.download.mbps);
-    println!("Upload:   {:.2} Mbps", enriched.upload.mbps);
+
+    // Compute and display throughput metrics (mean, median, p25, p75)
+    let (dl_mean, dl_median, dl_p25, dl_p75) =
+        crate::metrics::compute_throughput_metrics(&dl_points)
+            .context("insufficient download throughput data to compute metrics")?;
+    println!(
+        "Download: avg {:.2} med {:.2} p25 {:.2} p75 {:.2}",
+        dl_mean, dl_median, dl_p25, dl_p75
+    );
+
+    let (ul_mean, ul_median, ul_p25, ul_p75) =
+        crate::metrics::compute_throughput_metrics(&ul_points)
+            .context("insufficient upload throughput data to compute metrics")?;
     println!(
-        "Idle latency p50/p90/p99: {:.1}/{:.1}/{:.1} ms (loss {:.1}%, jitter {:.1} ms)",
-        enriched.idle_latency.p50_ms.unwrap_or(f64::NAN),
-        enriched.idle_latency.p90_ms.unwrap_or(f64::NAN),
-        enriched.idle_latency.p99_ms.unwrap_or(f64::NAN),
+        "Upload:   avg {:.2} med {:.2} p25 {:.2} p75 {:.2}",
+        ul_mean, ul_median, ul_p25, ul_p75
+    );
+
+    // Compute and display latency metrics (mean, median, p25, p75)
+    let (idle_mean, idle_median, idle_p25, idle_p75) =
+        crate::metrics::compute_latency_metrics(&idle_latency_samples)
+            .context("insufficient idle latency data to compute metrics")?;
+    println!(
+        "Idle latency: avg {:.1} med {:.1} p25 {:.1} p75 {:.1} ms (loss {:.1}%, jitter {:.1} ms)",
+        idle_mean,
+        idle_median,
+        idle_p25,
+        idle_p75,
         enriched.idle_latency.loss * 100.0,
         enriched.idle_latency.jitter_ms.unwrap_or(f64::NAN)
     );
+
+    let (dl_lat_mean, dl_lat_median, dl_lat_p25, dl_lat_p75) =
+        crate::metrics::compute_latency_metrics(&loaded_dl_latency_samples)
+            .context("insufficient loaded download latency data to compute metrics")?;
     println!(
-        "Loaded latency (download) p50/p90/p99: {:.1}/{:.1}/{:.1} ms (loss {:.1}%, jitter {:.1} ms)",
-        enriched.loaded_latency_download.p50_ms.unwrap_or(f64::NAN),
-        enriched.loaded_latency_download.p90_ms.unwrap_or(f64::NAN),
-        enriched.loaded_latency_download.p99_ms.unwrap_or(f64::NAN),
+        "Loaded latency (download): avg {:.1} med {:.1} p25 {:.1} p75 {:.1} ms (loss {:.1}%, jitter {:.1} ms)",
+        dl_lat_mean,
+        dl_lat_median,
+        dl_lat_p25,
+        dl_lat_p75,
         enriched.loaded_latency_download.loss * 100.0,
         enriched.loaded_latency_download.jitter_ms.unwrap_or(f64::NAN)
     );
+
+    let (ul_lat_mean, ul_lat_median, ul_lat_p25, ul_lat_p75) =
+        crate::metrics::compute_latency_metrics(&loaded_ul_latency_samples)
+            .context("insufficient loaded upload latency data to compute metrics")?;
     println!(
-        "Loaded latency (upload) p50/p90/p99: {:.1}/{:.1}/{:.1} ms (loss {:.1}%, jitter {:.1} ms)",
-        enriched.loaded_latency_upload.p50_ms.unwrap_or(f64::NAN),
-        enriched.loaded_latency_upload.p90_ms.unwrap_or(f64::NAN),
-        enriched.loaded_latency_upload.p99_ms.unwrap_or(f64::NAN),
+        "Loaded latency (upload): avg {:.1} med {:.1} p25 {:.1} p75 {:.1} ms (loss {:.1}%, jitter {:.1} ms)",
+        ul_lat_mean,
+        ul_lat_median,
+        ul_lat_p25,
+        ul_lat_p75,
         enriched.loaded_latency_upload.loss * 100.0,
         enriched.loaded_latency_upload.jitter_ms.unwrap_or(f64::NAN)
     );

src/engine/cloudflare.rs

@@ -16,19 +16,22 @@ pub struct CloudflareClient {
 impl CloudflareClient {
     pub fn new(cfg: &RunConfig) -> Result<Self> {
         let base_url = Url::parse(&cfg.base_url).context("invalid base_url")?;
-        
+
         let mut builder = reqwest::Client::builder()
             .user_agent(cfg.user_agent.clone())
             .timeout(Duration::from_secs(30))
             .tcp_keepalive(Duration::from_secs(15));
-        
+
         // Configure binding to interface or source IP if specified
         if let Some(ref iface) = cfg.interface {
             use crate::engine::network_bind;
             match network_bind::get_interface_ip(iface) {
                 Ok(ip) => {
                     builder = builder.local_address(ip);
-                    eprintln!("Binding HTTP connections to interface {} (IP: {})", iface, ip);
+                    eprintln!(
+                        "Binding HTTP connections to interface {} (IP: {})",
+                        iface, ip
+                    );
                 }
                 Err(e) => {
                     return Err(anyhow::anyhow!(
@@ -54,14 +57,15 @@ impl CloudflareClient {
                 }
             }
         }
-        
+
         // Load custom certificate if provided
         if let Some(ref cert_path) = cfg.certificate_path {
             // Check file extension
-            let ext = cert_path.extension()
+            let ext = cert_path
+                .extension()
                 .and_then(|e| e.to_str())
                 .map(|e| e.to_lowercase());
-            
+
             let valid_extensions = ["pem", "crt", "cer", "der"];
             if let Some(ref ext) = ext {
                 if !valid_extensions.contains(&ext.as_str()) {
@@ -77,25 +81,32 @@ impl CloudflareClient {
                     valid_extensions.join(", ")
                 ));
             }
-            
-            let cert_data = std::fs::read(cert_path)
-                .with_context(|| format!("failed to read certificate from {}", cert_path.display()))?;
-            
+
+            let cert_data = std::fs::read(cert_path).with_context(|| {
+                format!("failed to read certificate from {}", cert_path.display())
+            })?;
+
             // Parse based on file extension
             let cert = match ext.as_deref() {
-                Some("der") => reqwest::Certificate::from_der(&cert_data)
-                    .with_context(|| format!("failed to parse DER certificate from {}", cert_path.display()))?,
-                _ => reqwest::Certificate::from_pem(&cert_data)
-                    .with_context(|| format!("failed to parse PEM certificate from {}", cert_path.display()))?,
+                Some("der") => reqwest::Certificate::from_der(&cert_data).with_context(|| {
+                    format!(
+                        "failed to parse DER certificate from {}",
+                        cert_path.display()
+                    )
+                })?,
+                _ => reqwest::Certificate::from_pem(&cert_data).with_context(|| {
+                    format!(
+                        "failed to parse PEM certificate from {}",
+                        cert_path.display()
+                    )
+                })?,
             };
-            
+
             builder = builder.add_root_certificate(cert);
         }
-        
-        let http = builder
-            .build()
-            .context("failed to build http client")?;
-        
+
+        let http = builder.build().context("failed to build http client")?;
+
         Ok(Self {
             base_url,
             meas_id: cfg.meas_id.clone(),
@@ -390,4 +401,3 @@ pub fn map_colo_to_server(locations: &serde_json::Value, colo: &str) -> Option<S
         Some(colo.to_string())
     }
 }
-

src/engine/mod.rs

@@ -146,7 +146,9 @@ impl TestEngine {
         let mut experimental_udp = None;
         if self.cfg.experimental {
             if let Ok(info) = cloudflare::fetch_turn(&client).await {
-                experimental_udp = turn_udp::run_udp_like_loss_probe(&info, &self.cfg).await.ok();
+                experimental_udp = turn_udp::run_udp_like_loss_probe(&info, &self.cfg)
+                    .await
+                    .ok();
                 turn = Some(info);
             }
         }

src/engine/network_bind.rs

@@ -4,9 +4,9 @@ use std::net::{IpAddr, SocketAddr};
 /// Get the IP address of a network interface using the `if-addrs` crate
 pub fn get_interface_ip(interface: &str) -> Result<IpAddr> {
     use if_addrs::get_if_addrs;
-    
+
     let addrs = get_if_addrs().context("Failed to enumerate network interfaces")?;
-    
+
     // Prefer IPv4 addresses
     for addr in &addrs {
         if addr.name == interface {
@@ -15,7 +15,7 @@ pub fn get_interface_ip(interface: &str) -> Result<IpAddr> {
             }
         }
     }
-    
+
     // Fallback to IPv6 if no IPv4 found
     for addr in &addrs {
         if addr.name == interface {
@@ -24,7 +24,7 @@ pub fn get_interface_ip(interface: &str) -> Result<IpAddr> {
             }
         }
     }
-    
+
     Err(anyhow::anyhow!(
         "Interface {} not found or has no IP address assigned",
         interface
@@ -37,18 +37,15 @@ pub fn resolve_bind_address(
     source_ip: Option<&String>,
 ) -> Result<Option<SocketAddr>> {
     if let Some(ip_str) = source_ip {
-        let ip: IpAddr = ip_str
-            .parse()
-            .context("Invalid source IP address format")?;
+        let ip: IpAddr = ip_str.parse().context("Invalid source IP address format")?;
         return Ok(Some(SocketAddr::new(ip, 0)));
     }
-    
+
     if let Some(iface) = interface {
         let ip = get_interface_ip(iface)
             .with_context(|| format!("Failed to get IP for interface {}", iface))?;
         return Ok(Some(SocketAddr::new(ip, 0)));
     }
-    
+
     Ok(None)
 }
-

src/engine/turn_udp.rs

@@ -80,7 +80,10 @@ fn parse_host_port(url: &str) -> Result<(String, u16)> {
     Ok((host.to_string(), port))
 }
 
-pub async fn run_udp_like_loss_probe(turn: &TurnInfo, cfg: &RunConfig) -> Result<ExperimentalUdpSummary> {
+pub async fn run_udp_like_loss_probe(
+    turn: &TurnInfo,
+    cfg: &RunConfig,
+) -> Result<ExperimentalUdpSummary> {
     let target_url = pick_stun_target(turn).context("no stun/turn url in /__turn")?;
     let (host, port) = parse_host_port(&target_url)?;
 
@@ -89,33 +92,28 @@ pub async fn run_udp_like_loss_probe(turn: &TurnInfo, cfg: &RunConfig) -> Result
 
     // Bind UDP socket to interface or source IP if specified
     let sock = if cfg.interface.is_some() || cfg.source_ip.is_some() {
-        let bind_addr = network_bind::resolve_bind_address(
-            cfg.interface.as_ref(),
-            cfg.source_ip.as_ref(),
-        )?;
-        
+        let bind_addr =
+            network_bind::resolve_bind_address(cfg.interface.as_ref(), cfg.source_ip.as_ref())?;
+
         if let Some(addr) = bind_addr {
             // Create socket using socket2 for binding
             let domain = socket2::Domain::for_address(addr);
-            let socket = socket2::Socket::new(
-                domain,
-                socket2::Type::DGRAM,
-                Some(socket2::Protocol::UDP),
-            )?;
-            
+            let socket =
+                socket2::Socket::new(domain, socket2::Type::DGRAM, Some(socket2::Protocol::UDP))?;
+
             // Bind to the specified address
             socket.bind(&socket2::SockAddr::from(addr))?;
-            
+
             // Bind to interface if specified (Linux only)
             #[cfg(target_os = "linux")]
             if let Some(ref iface) = cfg.interface {
                 use std::ffi::CString;
                 use std::os::unix::io::AsRawFd;
-                
+
                 let ifname = CString::new(iface.as_str()).map_err(|_| {
                     std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid interface name")
                 })?;
-                
+
                 unsafe {
                     if libc::setsockopt(
                         socket.as_raw_fd(),
@@ -133,7 +131,7 @@ pub async fn run_udp_like_loss_probe(turn: &TurnInfo, cfg: &RunConfig) -> Result
                     }
                 }
             }
-            
+
             // Convert to tokio UdpSocket
             let std_socket: std::net::UdpSocket = socket.into();
             std_socket.set_nonblocking(true)?;
@@ -145,7 +143,7 @@ pub async fn run_udp_like_loss_probe(turn: &TurnInfo, cfg: &RunConfig) -> Result
         // Bind ephemeral UDP (default behavior)
         UdpSocket::bind("0.0.0.0:0").await?
     };
-    
+
     sock.connect(addr).await?;
 
     let timeout = Duration::from_millis(600);

src/main.rs

@@ -1,5 +1,6 @@
 mod cli;
 mod engine;
+mod metrics;
 mod model;
 mod network;
 mod stats;