feat: add a spinner while waiting for results

Author: GuillaumeLagrange

src/local_logger/mod.rs

@@ -19,7 +19,10 @@ use crate::logger::{GroupEvent, JsonEvent, get_group_event, get_json_event};
 pub const CODSPEED_U8_COLOR_CODE: u8 = 208; // #FF8700
 
 /// Spinner tick characters - smooth animation for a polished feel
-const SPINNER_TICKS: &[&str] = &["  ", ". ", "..", " ."];
+pub(crate) const SPINNER_TICKS: &[&str] = &["  ", ". ", "..", " ."];
+
+/// Interval between spinner animation ticks (milliseconds)
+pub(crate) const TICK_INTERVAL_MS: u64 = 300;
 
 lazy_static! {
     pub static ref SPINNER: Arc<Mutex<Option<ProgressBar>>> = Arc::new(Mutex::new(None));
@@ -88,32 +91,7 @@ impl Log for LocalLogger {
                             *current = Some(name.clone());
                         }
 
-                        if *IS_TTY {
-                            let spinner = ProgressBar::new_spinner();
-                            let tick_strings: Vec<String> = SPINNER_TICKS
-                                .iter()
-                                .map(|s| {
-                                    format!("{}", style(s).color256(CODSPEED_U8_COLOR_CODE).dim())
-                                })
-                                .collect();
-                            let tick_strs: Vec<&str> =
-                                tick_strings.iter().map(|s| s.as_str()).collect();
-
-                            spinner.set_style(
-                                ProgressStyle::with_template(
-                                    &format!(
-                                        "  {{spinner}} {{wide_msg:.{CODSPEED_U8_COLOR_CODE}}} {{elapsed:.dim}}"
-                                    ),
-                                )
-                                .unwrap()
-                                .tick_strings(&tick_strs),
-                            );
-                            spinner.set_message(format!("{name}..."));
-                            spinner.enable_steady_tick(Duration::from_millis(300));
-                            SPINNER.lock().unwrap().replace(spinner);
-                        } else {
-                            eprintln!("{name}...");
-                        }
+                        install_spinner(&name);
                     }
                 }
                 GroupEvent::End => {
@@ -262,6 +240,54 @@ pub fn init_local_logger() -> Result<()> {
     Ok(())
 }
 
+/// Create a styled spinner progress bar with CodSpeed branding.
+fn create_spinner(message: &str) -> ProgressBar {
+    let spinner = ProgressBar::new_spinner();
+    let tick_strings: Vec<String> = SPINNER_TICKS
+        .iter()
+        .map(|s| format!("{}", style(s).color256(CODSPEED_U8_COLOR_CODE).dim()))
+        .collect();
+    let tick_strs: Vec<&str> = tick_strings.iter().map(|s| s.as_str()).collect();
+
+    spinner.set_style(
+        ProgressStyle::with_template(&format!(
+            "  {{spinner}} {{wide_msg:.{CODSPEED_U8_COLOR_CODE}}} {{elapsed:.dim}}"
+        ))
+        .unwrap()
+        .tick_strings(&tick_strs),
+    );
+    spinner.set_message({ message }.to_string());
+    spinner.enable_steady_tick(Duration::from_millis(TICK_INTERVAL_MS));
+    spinner
+}
+
+/// Install a spinner into the global slot so log records suspend it.
+fn install_spinner(message: &str) {
+    if *IS_TTY {
+        let spinner = create_spinner(message);
+        SPINNER.lock().unwrap().replace(spinner);
+    } else {
+        eprintln!("{message}...");
+    }
+}
+
+/// Start a standalone spinner with a message (no group header or checkmark).
+///
+/// The spinner animates on TTY outputs. On non-TTY, prints the message once.
+/// Call [`stop_spinner`] to clear it when done.
+pub fn start_spinner(message: &str) {
+    install_spinner(message);
+}
+
+/// Stop and clear the current standalone spinner.
+pub fn stop_spinner() {
+    if let Ok(mut spinner) = SPINNER.lock() {
+        if let Some(pb) = spinner.take() {
+            pb.finish_and_clear();
+        }
+    }
+}
+
 pub fn clean_logger() {
     let mut spinner = SPINNER.lock().unwrap();
     if let Some(spinner) = spinner.as_mut() {

src/local_logger/rolling_buffer/mod.rs

@@ -3,13 +3,13 @@ use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::{Duration, Instant};
 
-use super::{CODSPEED_U8_COLOR_CODE, IS_TTY, SPINNER, format_checkmark};
+use super::{
+    CODSPEED_U8_COLOR_CODE, IS_TTY, SPINNER, SPINNER_TICKS, TICK_INTERVAL_MS, format_checkmark,
+};
 use console::{Term, style};
 use lazy_static::lazy_static;
 
 const INDENT: &str = "    ";
-const SPINNER_TICKS: &[&str] = &["  ", ". ", "..", " ."];
-const TICK_INTERVAL_MS: u128 = 300;
 
 lazy_static! {
     /// Global shared rolling buffer, set by `activate_rolling_buffer` and
@@ -19,6 +19,11 @@ lazy_static! {
 }
 
 /// Stop signal for the tick thread.
+///
+/// The rolling buffer manages its own background tick thread rather than using
+/// `ProgressBar` because it renders a multi-line frame (title + bordered log box)
+/// via direct terminal cursor manipulation. `ProgressBar` only manages a single
+/// line and would conflict with the rolling buffer's cursor movements.
 static TICK_STOP: AtomicBool = AtomicBool::new(false);
 
 pub struct RollingBuffer {
@@ -100,7 +105,7 @@ impl RollingBuffer {
 
     fn spinner_tick(&self) -> &'static str {
         let elapsed_ms = self.start.elapsed().as_millis();
-        let idx = (elapsed_ms / TICK_INTERVAL_MS) as usize % SPINNER_TICKS.len();
+        let idx = (elapsed_ms / TICK_INTERVAL_MS as u128) as usize % SPINNER_TICKS.len();
         SPINNER_TICKS[idx]
     }
 
@@ -297,7 +302,7 @@ pub fn activate_rolling_buffer(title: &str) {
     TICK_STOP.store(false, Ordering::Relaxed);
     std::thread::spawn(|| {
         while !TICK_STOP.load(Ordering::Relaxed) {
-            std::thread::sleep(Duration::from_millis(TICK_INTERVAL_MS as u64));
+            std::thread::sleep(Duration::from_millis(TICK_INTERVAL_MS));
             if TICK_STOP.load(Ordering::Relaxed) {
                 break;
             }

src/upload/poll_results.rs

@@ -2,6 +2,7 @@ use console::style;
 
 use crate::api_client::CodSpeedAPIClient;
 use crate::cli::run::helpers::benchmark_display::{build_benchmark_table, build_detailed_summary};
+use crate::local_logger::{start_spinner, stop_spinner};
 use crate::prelude::*;
 
 use super::{UploadResult, poll_run_report};
@@ -42,7 +43,10 @@ pub async fn poll_results(
     upload_result: &UploadResult,
     options: &PollResultsOptions,
 ) -> Result<()> {
-    let response = poll_run_report(api_client, upload_result).await?;
+    start_spinner("Waiting for results");
+    let response = poll_run_report(api_client, upload_result).await;
+    stop_spinner();
+    let response = response?;
 
     if options.show_impact {
         let report = response.run.head_reports.into_iter().next();