feat: improve log messages verbosity and style

Author: art049

src/app.rs

@@ -1,6 +1,9 @@
 use crate::{
-    api_client::CodSpeedAPIClient, auth, local_logger::CODSPEED_U8_COLOR_CODE, prelude::*, run,
-    setup,
+    api_client::CodSpeedAPIClient,
+    auth,
+    local_logger::{init_local_logger, CODSPEED_U8_COLOR_CODE},
+    prelude::*,
+    run, setup,
 };
 use clap::{
     builder::{styling, Styles},
@@ -48,6 +51,13 @@ pub async fn run() -> Result<()> {
     let cli = Cli::parse();
     let api_client = CodSpeedAPIClient::try_from(&cli)?;
 
+    match cli.command {
+        Commands::Run(_) => {} // Run is responsible for its own logger initialization
+        _ => {
+            init_local_logger()?;
+        }
+    }
+
     match cli.command {
         Commands::Run(args) => run::run(args, &api_client).await?,
         Commands::Auth(args) => auth::run(args, &api_client).await?,

src/auth.rs

@@ -1,10 +1,8 @@
 use std::time::Duration;
 
-use crate::local_logger::get_local_logger;
 use crate::{api_client::CodSpeedAPIClient, config::CodSpeedConfig, prelude::*};
 use clap::{Args, Subcommand};
 use console::style;
-use simplelog::CombinedLogger;
 use tokio::time::{sleep, Instant};
 
 #[derive(Debug, Args)]
@@ -19,15 +17,7 @@ enum AuthCommands {
     Login,
 }
 
-fn init_logger() -> Result<()> {
-    let logger = get_local_logger();
-    CombinedLogger::init(vec![logger])?;
-    Ok(())
-}
-
 pub async fn run(args: AuthArgs, api_client: &CodSpeedAPIClient) -> Result<()> {
-    init_logger()?;
-
     match args.command {
         AuthCommands::Login => login(api_client).await?,
     }

src/local_logger.rs

@@ -4,17 +4,17 @@ use std::{
     time::Duration,
 };
 
+use crate::prelude::*;
 use console::{style, Style};
 use indicatif::{ProgressBar, ProgressStyle};
 use lazy_static::lazy_static;
 use log::Log;
-use simplelog::SharedLogger;
+use simplelog::{CombinedLogger, SharedLogger};
 use std::io::Write;
 
 use crate::logger::{get_group_event, GroupEvent};
 
 pub const CODSPEED_U8_COLOR_CODE: u8 = 208; // #FF8700
-const BLACK_U8_COLOR_CODE: u8 = 16; // #000
 
 lazy_static! {
     pub static ref SPINNER: Arc<Mutex<Option<ProgressBar>>> = Arc::new(Mutex::new(None));
@@ -67,13 +67,11 @@ impl Log for LocalLogger {
             match group_event {
                 GroupEvent::Start(name) | GroupEvent::StartOpened(name) => {
                     println!(
-                        "  {}",
-                        style(format!(" {} ", name.to_uppercase()))
+                        "\n{}",
+                        style(format!("►►► {} ", name))
                             .bold()
-                            .color256(BLACK_U8_COLOR_CODE)
-                            .on_color256(CODSPEED_U8_COLOR_CODE)
+                            .color256(CODSPEED_U8_COLOR_CODE)
                     );
-                    println!();
 
                     if *IS_TTY {
                         let spinner = ProgressBar::new_spinner();
@@ -158,6 +156,12 @@ pub fn get_local_logger() -> Box<dyn SharedLogger> {
     Box::new(LocalLogger::new())
 }
 
+pub fn init_local_logger() -> Result<()> {
+    let logger = get_local_logger();
+    CombinedLogger::init(vec![logger])?;
+    Ok(())
+}
+
 pub fn clean_logger() {
     let mut spinner = SPINNER.lock().unwrap();
     if let Some(spinner) = spinner.as_mut() {

src/run/check_system.rs

@@ -130,12 +130,18 @@ pub fn check_system(system_info: &SystemInfo) -> Result<()> {
 
     match system_info.arch.as_str() {
         "x86_64" | "aarch64" => {
-            warn!("Unsupported system: {:?}", system_info);
-            warn!("Continuing with best effort support");
+            warn!(
+                "Unofficially supported system: {} {}. Continuing with best effort support.",
+                system_info.os, system_info.os_version
+            );
             return Ok(());
         }
         _ => {}
     }
 
-    bail!("Unsupported system: {:?}", system_info);
+    bail!(
+        "Unsupported system: {} {}",
+        system_info.os,
+        system_info.os_version
+    );
 }

src/run/runner/valgrind/setup.rs

@@ -73,7 +73,15 @@ fn is_valgrind_installed() -> bool {
         }
 
         let version = String::from_utf8_lossy(&version_output.stdout);
-        version.contains(VALGRIND_CODSPEED_VERSION.as_str())
+        let result = version.contains(VALGRIND_CODSPEED_VERSION.as_str());
+        if !result {
+            warn!(
+                "Valgrind is installed but the version is not the expected one. expecting {} but found installed: {}",
+                VALGRIND_CODSPEED_VERSION.as_str(),
+                version
+            );
+        }
+        result
     } else {
         false
     }

src/setup.rs

@@ -5,13 +5,15 @@ use crate::run::runner::get_all_executors;
 pub async fn setup() -> Result<()> {
     let system_info = SystemInfo::new()?;
     let executors = get_all_executors();
-    info!("Setting up the environment for all executors");
+    start_group!("Setting up the environment for all executors");
     for executor in executors {
         info!(
             "Setting up the environment for the executor: {}",
             executor.name().to_string()
         );
         executor.setup(&system_info).await?;
     }
+    info!("Environment setup completed");
+    end_group!();
     Ok(())
 }