feat(circleci): render log groups with indentation and timings

CircleCI collapses output per step and has no in-output section markers, so
groups were printed as a single bold line, with nothing marking where they
end. Reuse the local logger's formatting instead: a styled header surrounded
by blank lines, indented and icon-prefixed records, and a closing checkmark
reporting the group name and how long it took.

Widen format_group_header, format_elapsed and format_log to pub(crate) so the
CircleCI logger can share them. Local output is unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: fargito

src/local_logger/mod.rs

@@ -168,7 +168,7 @@ impl Log for LocalLogger {
 }
 
 /// Format a group header with styled prefix
-fn format_group_header(name: &str) -> String {
+pub(crate) fn format_group_header(name: &str) -> String {
     let prefix = style(Icon::GroupArrow.to_string())
         .color256(CODSPEED_U8_COLOR_CODE)
         .bold();
@@ -191,7 +191,7 @@ pub(crate) fn format_checkmark(label: &str, dim: bool) -> String {
 }
 
 /// Format elapsed duration in a compact human-readable way
-fn format_elapsed(duration: Duration) -> String {
+pub(crate) fn format_elapsed(duration: Duration) -> String {
     let secs = duration.as_secs();
     let millis = duration.as_millis();
 
@@ -234,7 +234,7 @@ fn print_record(record: &log::Record) {
 }
 
 /// Format a log entry with the appropriate style for its level.
-fn format_log(level: log::Level, message: &str, target: &str) -> String {
+pub(crate) fn format_log(level: log::Level, message: &str, target: &str) -> String {
     match level {
         log::Level::Error => {
             let prefix = style(Icon::Error.to_string()).red().bold();

src/run_environment/circleci/logger.rs

@@ -1,19 +1,28 @@
 use console::style;
 use log::*;
 use simplelog::SharedLogger;
-use std::{env, io::Write};
+use std::{env, io::Write, sync::Mutex, time::Instant};
 
 use crate::{
+    local_logger::{format_checkmark, format_elapsed, format_group_header, format_log},
     logger::{GroupEvent, get_announcement_event, get_group_event, get_json_event},
     run_environment::logger::should_provider_logger_handle_record,
 };
 
+/// The group currently open, used to report its name and duration when it ends.
+struct OpenGroup {
+    name: String,
+    started_at: Instant,
+}
+
 /// A logger that prints logs in the format expected by CircleCI
 ///
-/// CircleCI has no collapsible section markers, so groups are printed as plain
-/// headers.
+/// CircleCI collapses output per step and has no in-output section markers, so
+/// groups cannot be folded. They are rendered with the local logger's formatting
+/// instead.
 pub struct CircleCILogger {
     log_level: LevelFilter,
+    open_group: Mutex<Option<OpenGroup>>,
 }
 
 impl CircleCILogger {
@@ -26,7 +35,10 @@ impl CircleCILogger {
             .ok()
             .and_then(|log_level| log_level.parse::<log::LevelFilter>().ok())
             .unwrap_or(log::LevelFilter::Info);
-        Self { log_level }
+        Self {
+            log_level,
+            open_group: Mutex::new(None),
+        }
     }
 }
 
@@ -45,10 +57,29 @@ impl Log for CircleCILogger {
 
         if let Some(group_event) = get_group_event(record) {
             match group_event {
-                GroupEvent::Start(name) | GroupEvent::StartOpened(name) => {
-                    println!("{}", style(name).cyan().bold());
+                GroupEvent::Start(ref name) | GroupEvent::StartOpened(ref name) => {
+                    println!();
+                    println!("{}", format_group_header(name));
+                    println!();
+
+                    // Opened groups are not closed with a checkmark.
+                    if matches!(group_event, GroupEvent::Start(_)) {
+                        *self.open_group.lock().unwrap() = Some(OpenGroup {
+                            name: name.clone(),
+                            started_at: Instant::now(),
+                        });
+                    }
+                }
+                GroupEvent::End => {
+                    let open_group = self.open_group.lock().unwrap().take();
+                    if let Some(OpenGroup { name, started_at }) = open_group {
+                        println!(
+                            "{} {}",
+                            format_checkmark(&name, true),
+                            style(format_elapsed(started_at.elapsed())).dim(),
+                        );
+                    }
                 }
-                GroupEvent::End => {}
             }
             return;
         }
@@ -66,23 +97,10 @@ impl Log for CircleCILogger {
             return;
         }
 
-        match level {
-            Level::Error => {
-                println!("{}", style(message).red());
-            }
-            Level::Warn => {
-                println!("{}", style(message).yellow());
-            }
-            Level::Info => {
-                println!("{message}");
-            }
-            Level::Debug => {
-                println!("{}", style(message).cyan());
-            }
-            Level::Trace => {
-                println!("{}", style(message).magenta());
-            }
-        }
+        println!(
+            "{}",
+            format_log(level, &message.to_string(), record.target())
+        );
     }
 
     fn flush(&self) {