feat: clean up group headers and emoji usage, make the executor title not dim after run

GuillaumeLagrange · GuillaumeLagrange · commit bd0755a6de75 · 2026-03-13T17:01:03.000+01:00
diff --git a/src/cli/run/helpers/benchmark_display.rs b/src/cli/run/helpers/benchmark_display.rs
@@ -159,7 +159,11 @@ fn build_simulation_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {
             }
         })
         .collect();
-    build_table_with_style(&rows, "CPU Simulation", "\u{2699}")
+    build_table_with_style(
+        &rows,
+        ExecutorName::Valgrind.label(),
+        ExecutorName::Valgrind.icon(),
+    )
 }
 
 fn build_walltime_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {
@@ -197,7 +201,11 @@ fn build_walltime_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {
             }
         })
         .collect();
-    build_table_with_style(&rows, "Walltime", "\u{23F1}")
+    build_table_with_style(
+        &rows,
+        ExecutorName::WallTime.label(),
+        ExecutorName::WallTime.icon(),
+    )
 }
 
 fn build_memory_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {
@@ -231,7 +239,11 @@ fn build_memory_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {
             }
         })
         .collect();
-    build_table_with_style(&rows, "Memory", "\u{2630}")
+    build_table_with_style(
+        &rows,
+        ExecutorName::Memory.label(),
+        ExecutorName::Memory.icon(),
+    )
 }
 
 pub fn build_benchmark_table(results: &[FetchLocalRunBenchmarkResult]) -> String {
diff --git a/src/cli/run/helpers/snapshots/codspeed_runner__cli__run__helpers__benchmark_display__tests__benchmark_table_formatting.snap b/src/cli/run/helpers/snapshots/codspeed_runner__cli__run__helpers__benchmark_display__tests__benchmark_table_formatting.snap
@@ -3,23 +3,23 @@ source: src/cli/run/helpers/benchmark_display.rs
 expression: table
 ---
 ╭─────────────────────────────────────────────────────────────────╮
-│                        ⚙ CPU Simulation                         │
+│                         CPU Simulation                         │
 ├─────────────────┬─────────┬────────┬───────┬────────┬───────────┤
 │ Benchmark       │    Time │ Instr. │ Cache │ Memory │ Sys. Time │
 ├─────────────────┼─────────┼────────┼───────┼────────┼───────────┤
 │ bench_parse     │ 1.23 ms │  85.0% │ 10.0% │   4.0% │  12.34 µs │
 │ bench_serialize │ 2.57 ms │  70.0% │ 20.0% │   8.0% │  51.34 µs │
 ╰─────────────────┴─────────┴────────┴───────┴────────┴───────────╯
 ╭─────────────────────────────────────────────────────────────────────╮
-│                             ⏱ Walltime                              │
+│                              Walltime                              │
 ├────────────────────┬─────────────┬────────────┬────────┬────────────┤
 │ Benchmark          │ Time (best) │ Iterations │ StdDev │ Total time │
 ├────────────────────┼─────────────┼────────────┼────────┼────────────┤
 │ bench_http_request │   150.00 ms │        100 │  5.00% │  150.00 ms │
 │ bench_db_query     │    25.00 ms │        500 │  2.00% │   25.00 ms │
 ╰────────────────────┴─────────────┴────────────┴────────┴────────────╯
 ╭─────────────────────────────────────────────────────────────────╮
-│                            ☰ Memory                            │
+│                             Memory                             │
 ├───────────────────┬─────────────┬─────────────────┬─────────────┤
 │ Benchmark         │ Peak memory │ Total allocated │ Allocations │
 ├───────────────────┼─────────────┼─────────────────┼─────────────┤
diff --git a/src/cli/setup.rs b/src/cli/setup.rs
@@ -10,7 +10,7 @@ pub async fn setup(setup_cache_dir: Option<&Path>) -> Result<()> {
     for executor in executors {
         info!(
             "Setting up the environment for the executor: {}",
-            executor.name().to_string()
+            executor.name()
         );
         executor.setup(&system_info, setup_cache_dir).await?;
     }
diff --git a/src/executor/interfaces.rs b/src/executor/interfaces.rs
@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use std::fmt;
 
 #[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq, Hash)]
 #[serde(rename_all = "lowercase")]
@@ -8,13 +9,32 @@ pub enum ExecutorName {
     Memory,
 }
 
-#[allow(clippy::to_string_trait_impl)]
-impl ToString for ExecutorName {
-    fn to_string(&self) -> String {
+impl fmt::Display for ExecutorName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ExecutorName::Valgrind => "valgrind".to_string(),
-            ExecutorName::WallTime => "walltime".to_string(),
-            ExecutorName::Memory => "memory".to_string(),
+            ExecutorName::Valgrind => write!(f, "valgrind"),
+            ExecutorName::WallTime => write!(f, "walltime"),
+            ExecutorName::Memory => write!(f, "memory"),
+        }
+    }
+}
+
+impl ExecutorName {
+    /// Human-readable label for this executor.
+    pub fn label(&self) -> &'static str {
+        match self {
+            ExecutorName::Valgrind => "CPU Simulation",
+            ExecutorName::WallTime => "Walltime",
+            ExecutorName::Memory => "Memory",
+        }
+    }
+
+    /// Nerd Font icon for this executor.
+    pub fn icon(&self) -> &'static str {
+        match self {
+            ExecutorName::Valgrind => "\u{f4bc}",
+            ExecutorName::WallTime => "\u{f520}",
+            ExecutorName::Memory => "\u{efc5}",
         }
     }
 }
diff --git a/src/executor/orchestrator.rs b/src/executor/orchestrator.rs
@@ -128,10 +128,17 @@ impl Orchestrator {
         let run_parts: Vec<ExecutorTarget> = command_labels
             .iter()
             .flat_map(|(cmd, label)| {
-                modes.iter().map(move |mode| ExecutorTarget {
-                    command: cmd.clone(),
-                    mode,
-                    label: format!("[{mode}] {label}"),
+                modes.iter().map(move |mode| {
+                    let executor_name = get_executor_from_mode(mode).name();
+                    ExecutorTarget {
+                        command: cmd.clone(),
+                        mode,
+                        label: format!(
+                            "{} {} - {label}",
+                            executor_name.icon(),
+                            executor_name.label()
+                        ),
+                    }
                 })
             })
             .collect();
@@ -145,11 +152,11 @@ impl Orchestrator {
 
         for (run_part_index, part) in run_parts.into_iter().enumerate() {
             let config = self.config.executor_config_for_command(part.command);
+            let executor = get_executor_from_mode(part.mode);
             let profile_folder =
-                self.resolve_profile_folder(part.mode, run_part_index, total_parts)?;
+                self.resolve_profile_folder(&executor.name(), run_part_index, total_parts)?;
 
             let ctx = ExecutionContext::new(config, profile_folder);
-            let executor = get_executor_from_mode(part.mode);
 
             activate_rolling_buffer(&part.label);
 
@@ -172,18 +179,18 @@ impl Orchestrator {
     /// Resolve the profile folder for a given run part.
     ///
     /// - Single run part + user-specified folder: use as-is
-    /// - Multiple run parts + user-specified folder: `<folder>/<mode>-<index>`
+    /// - Multiple run parts + user-specified folder: `<folder>/<executor>-<index>`
     /// - No user-specified folder: create a random temp folder
     fn resolve_profile_folder(
         &self,
-        mode: &RunnerMode,
+        executor_name: &ExecutorName,
         run_part_index: usize,
         total_parts: usize,
     ) -> Result<PathBuf> {
         match (&self.config.profile_folder, total_parts) {
             (Some(folder), 1) => Ok(folder.clone()),
             (Some(folder), _) => {
-                let subfolder = folder.join(format!("{mode}-{run_part_index}"));
+                let subfolder = folder.join(format!("{executor_name}-{run_part_index}"));
                 std::fs::create_dir_all(&subfolder).with_context(|| {
                     format!(
                         "Failed to create profile subfolder: {}",
diff --git a/src/local_logger/mod.rs b/src/local_logger/mod.rs
@@ -72,38 +72,48 @@ impl Log for LocalLogger {
 
         if let Some(group_event) = get_group_event(record) {
             match group_event {
-                GroupEvent::Start(name) | GroupEvent::StartOpened(name) => {
-                    let header = format_group_header(&name);
-                    eprintln!("\n{header}");
+                GroupEvent::Start(ref name) | GroupEvent::StartOpened(ref name) => {
+                    let opened = matches!(group_event, GroupEvent::StartOpened(_));
+                    let name = name.clone();
 
-                    // Store current group name for completion message
-                    if let Ok(mut current) = CURRENT_GROUP_NAME.lock() {
-                        *current = Some(name.clone());
-                    }
+                    let header = format_group_header(&name);
+                    eprintln!();
+                    eprintln!("{header}");
+                    eprintln!();
+
+                    // Opened groups don't get a spinner or closing checkmark
+                    if !opened {
+                        // Store current group name for completion message
+                        if let Ok(mut current) = CURRENT_GROUP_NAME.lock() {
+                            *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}...");
+                        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}...");
+                        }
                     }
                 }
                 GroupEvent::End => {
@@ -119,7 +129,7 @@ impl Log for LocalLogger {
                                     let elapsed_str = format_elapsed(elapsed);
                                     eprintln!(
                                         "{} {}",
-                                        format_checkmark(&name),
+                                        format_checkmark(&name, true),
                                         style(elapsed_str).dim(),
                                     );
                                 }
@@ -147,18 +157,19 @@ impl Log for LocalLogger {
 
 /// Format a group header with styled prefix
 fn format_group_header(name: &str) -> String {
-    let prefix = style("\u{25B6}").color256(CODSPEED_U8_COLOR_CODE).bold();
+    let prefix = style("\u{f0da}").color256(CODSPEED_U8_COLOR_CODE).bold();
     let title = style(name).bold();
     format!("{prefix} {title}")
 }
 
-/// Format a completion checkmark with a dimmed label.
-pub(crate) fn format_checkmark(label: &str) -> String {
-    format!(
-        "  {} {}",
-        style("\u{2714} ").green().bold(),
-        style(label).dim(),
-    )
+/// Format a completion checkmark with a label.
+pub(crate) fn format_checkmark(label: &str, dim: bool) -> String {
+    let label = if dim {
+        style(label).dim().to_string()
+    } else {
+        label.to_string()
+    };
+    format!("  {}  {}", style("\u{f00c}").green().bold(), label)
 }
 
 /// Format elapsed duration in a compact human-readable way
@@ -196,13 +207,13 @@ fn indent_lines(s: &str, indent: &str) -> String {
 fn print_record(record: &log::Record) {
     match record.level() {
         log::Level::Error => {
-            let prefix = style("\u{2717}").red().bold();
+            let prefix = style("\u{f00d}").red().bold();
             let msg = indent_lines(&format!("{}", record.args()), "    ");
             let msg = Style::new().red().apply_to(msg);
             eprintln!("  {prefix} {msg}");
         }
         log::Level::Warn => {
-            let prefix = style("\u{25B2}").yellow();
+            let prefix = style("\u{f071}").yellow();
             let msg = indent_lines(&format!("{}", record.args()), "    ");
             let msg = Style::new().yellow().apply_to(msg);
             eprintln!("  {prefix} {msg}");
diff --git a/src/local_logger/rolling_buffer/mod.rs b/src/local_logger/rolling_buffer/mod.rs
@@ -189,7 +189,7 @@ impl RollingBuffer {
     /// Render the finished frame (checkmark title instead of spinner).
     fn render_finished_frame(&self) -> Vec<String> {
         let mut frame = Vec::new();
-        frame.push(format_checkmark(&self.title));
+        frame.push(format_checkmark(&self.title, false));
         frame.push(self.render_top_delimiter());
         for line in &self.lines {
             frame.push(self.render_content_line(line));
diff --git a/src/upload/poll_results.rs b/src/upload/poll_results.rs
@@ -50,12 +50,12 @@ pub async fn poll_results(
                 let rounded_impact = (impact * 100.0).round();
                 let (arrow, impact_text) = if impact > 0.0 {
                     (
-                        style("\u{25B2}").green(),
+                        style("\u{f062}").green(),
                         style(format!("+{rounded_impact}%")).green().bold(),
                     )
                 } else if impact < 0.0 {
                     (
-                        style("\u{25BC}").red(),
+                        style("\u{f063}").red(),
                         style(format!("{rounded_impact}%")).red().bold(),
                     )
                 } else {
@@ -90,14 +90,14 @@ pub async fn poll_results(
         );
     } else {
         end_group!();
-        start_group!("Benchmark results");
+        start_opened_group!("Benchmark results");
 
         if options.detailed_single && response.run.results.len() == 1 {
             let summary = build_detailed_summary(&response.run.results[0]);
-            info!("\n{summary}");
+            info!("{summary}\n");
         } else {
             let table = build_benchmark_table(&response.run.results);
-            info!("\n{table}");
+            info!("{table}\n");
         }
 
         if options.output_json {
@@ -114,7 +114,6 @@ pub async fn poll_results(
             style("View full report:").dim(),
             style(response.run.url).blue().bold().underlined()
         );
-        end_group!();
     }
 
     Ok(())

Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,11 @@ fn build_simulation_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {`
`159`	`159`	`}`
`160`	`160`	`})`
`161`	`161`	`.collect();`
`162`		`- build_table_with_style(&rows, "CPU Simulation", "\u{2699}")`
	`162`	`+ build_table_with_style(`
	`163`	`+ &rows,`
	`164`	`+ ExecutorName::Valgrind.label(),`
	`165`	`+ ExecutorName::Valgrind.icon(),`
	`166`	`+ )`
`163`	`167`	`}`
`164`	`168`
`165`	`169`	`fn build_walltime_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {`
`@@ -197,7 +201,11 @@ fn build_walltime_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {`
`197`	`201`	`}`
`198`	`202`	`})`
`199`	`203`	`.collect();`
`200`		`- build_table_with_style(&rows, "Walltime", "\u{23F1}")`
	`204`	`+ build_table_with_style(`
	`205`	`+ &rows,`
	`206`	`+ ExecutorName::WallTime.label(),`
	`207`	`+ ExecutorName::WallTime.icon(),`
	`208`	`+ )`
`201`	`209`	`}`
`202`	`210`
`203`	`211`	`fn build_memory_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {`
`@@ -231,7 +239,11 @@ fn build_memory_table(results: &[&FetchLocalRunBenchmarkResult]) -> String {`
`231`	`239`	`}`
`232`	`240`	`})`
`233`	`241`	`.collect();`
`234`		`- build_table_with_style(&rows, "Memory", "\u{2630}")`
	`242`	`+ build_table_with_style(`
	`243`	`+ &rows,`
	`244`	`+ ExecutorName::Memory.label(),`
	`245`	`+ ExecutorName::Memory.icon(),`
	`246`	`+ )`
`235`	`247`	`}`
`236`	`248`
`237`	`249`	`pub fn build_benchmark_table(results: &[FetchLocalRunBenchmarkResult]) -> String {`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ pub async fn setup(setup_cache_dir: Option<&Path>) -> Result<()> {`
`10`	`10`	`for executor in executors {`
`11`	`11`	`info!(`
`12`	`12`	`"Setting up the environment for the executor: {}",`
`13`		`- executor.name().to_string()`
	`13`	`+ executor.name()`
`14`	`14`	`);`
`15`	`15`	`executor.setup(&system_info, setup_cache_dir).await?;`
`16`	`16`	`}`