Show progress while mach rpm runs

Cargo.toml

@@ -32,6 +32,7 @@ http-body-util = "0.1.2"
 humansize = "2.1.3"
 hyper = { version = "1.0", features = ["client", "http1", "http2"] }
 hyper-util = { version = "0.1", features = ["tokio"] }
+indicatif = "0.18"
 pin-project-lite = "0.2"
 rand = "0.8"
 rustls = { version = "0.23.10", default-features = false, features = ["std", "ring"] }

src/main.rs

@@ -12,6 +12,8 @@ mod saturate;
 mod up_down;
 mod util;
 
+use std::io::IsTerminal;
+
 use cf_mach::{nq_core, nq_latency, nq_load_generator, nq_packetloss, nq_rpm, nq_tokio_network};
 
 use clap::error::ErrorKind;
@@ -39,6 +41,10 @@ async fn main() -> anyhow::Result<()> {
         return Ok(());
     }
 
+    let show_progress = std::io::stderr().is_terminal()
+        && std::env::var_os("RUST_LOG").is_none()
+        && args.verbosity.log_level_filter() <= LevelFilter::Error;
+
     setup_logging(args.verbosity)?;
 
     // default to RPM
@@ -47,7 +53,7 @@ async fn main() -> anyhow::Result<()> {
         .unwrap_or_else(|| Command::Rpm(RpmArgs::default()));
 
     match command {
-        Command::Rpm(config) => rpm::run(config).await?,
+        Command::Rpm(config) => rpm::run(config, show_progress).await?,
         Command::Download(config) => up_down::download(config).await?,
         Command::Upload(config) => up_down::upload(config).await?,
         Command::Rtt { url, runs } => latency::run(url, runs).await?,

src/rpm.rs

@@ -11,6 +11,7 @@ use crate::nq_rpm::{Responsiveness, ResponsivenessConfig, ResponsivenessResult};
 use crate::nq_tokio_network::TokioNetwork;
 use anyhow::{Context, bail};
 use http_body_util::BodyExt;
+use indicatif::{ProgressBar, ProgressFinish, ProgressStyle};
 use serde::Deserialize;
 use tokio::time::timeout;
 use tokio_util::sync::CancellationToken;
@@ -48,8 +49,34 @@ fn warn_on_degraded_result(leg: &str, failed_connections: usize, upload_bytes_pe
     }
 }
 
+fn start_phase(show: bool, msg: &'static str) -> ProgressBar {
+    if !show {
+        return ProgressBar::hidden();
+    }
+
+    let pb = ProgressBar::new_spinner()
+        .with_style(
+            ProgressStyle::with_template("{spinner:.cyan} {msg} {elapsed:.dim}")
+                .expect("valid spinner template"),
+        )
+        .with_message(msg)
+        .with_finish(ProgressFinish::AndClear);
+    pb.enable_steady_tick(Duration::from_millis(100));
+    pb
+}
+
+/// Replace a phase's spinner with a permanent `✓` line.
+fn finish_phase(pb: ProgressBar, msg: String) {
+    pb.set_style(
+        ProgressStyle::with_template("{prefix:.green} {msg} {elapsed:.dim}")
+            .expect("valid finished template"),
+    );
+    pb.set_prefix("✓");
+    pb.finish_with_message(msg);
+}
+
 /// Run a responsiveness test.
-pub async fn run(cli_config: RpmArgs) -> anyhow::Result<()> {
+pub async fn run(cli_config: RpmArgs, show_progress: bool) -> anyhow::Result<()> {
     info!("running responsiveness test");
 
     let scoped_headers = crate::access::cf_access_scoped_headers()?;
@@ -65,7 +92,9 @@ pub async fn run(cli_config: RpmArgs) -> anyhow::Result<()> {
     let rpm_urls = match cli_config.config.clone() {
         Some(endpoint) => {
             info!("fetching configuration from {endpoint}");
+            let pb = start_phase(show_progress, "Fetching configuration");
             let urls = get_rpm_config(endpoint, scoped_headers.clone()).await?;
+            finish_phase(pb, "Fetched configuration".to_string());
             info!("retrieved configuration urls: {urls:?}");
 
             urls
@@ -84,23 +113,23 @@ pub async fn run(cli_config: RpmArgs) -> anyhow::Result<()> {
 
     // first get unloaded RTT measurements
     info!("determining unloaded latency");
+    let pb = start_phase(show_progress, "Measuring unloaded latency");
     let rtt_result = crate::latency::run_test(&LatencyConfig {
         url: rpm_urls.small_download_url.parse()?,
         runs: 20,
         scoped_headers: scoped_headers.clone(),
     })
     .await?;
-    info!(
-        "unloaded latency: {} ms. jitter: {} ms",
-        rtt_result
-            .median()
-            .map(pretty_secs_to_ms)
-            .unwrap_or_default(),
-        rtt_result
-            .jitter()
-            .map(pretty_secs_to_ms)
-            .unwrap_or_default(),
-    );
+    let median_ms = rtt_result
+        .median()
+        .map(pretty_secs_to_ms)
+        .unwrap_or_default();
+    let jitter_ms = rtt_result
+        .jitter()
+        .map(pretty_secs_to_ms)
+        .unwrap_or_default();
+    finish_phase(pb, format!("Unloaded latency: {median_ms} ms"));
+    info!("unloaded latency: {median_ms} ms. jitter: {jitter_ms} ms");
 
     let config = ResponsivenessConfig {
         large_download_url: rpm_urls.large_download_url.parse()?,
@@ -129,11 +158,15 @@ pub async fn run(cli_config: RpmArgs) -> anyhow::Result<()> {
     }
 
     info!("running download test");
+    let pb = start_phase(show_progress, "Running download test");
     let download_result = run_test(&config, true).await?;
+    finish_phase(pb, "Download test".to_string());
     debug!("download result={download_result:?}");
 
     info!("running upload test");
+    let pb = start_phase(show_progress, "Running upload test");
     let upload_result = run_test(&config, false).await?;
+    finish_phase(pb, "Upload test".to_string());
     debug!("upload result={upload_result:?}");
 
     warn_on_degraded_result(