feat(system): represent the host OS as a typed Os enum with per-executor support gates

Replaces the loose `os` + `os_version` strings on `SystemInfo` with an
`Os` enum.

Adds `Executor::support_level(&Os)` so each executor declares
its own OS matrix: `run_executor` bails on `Unsupported`, skips `setup()`
on `RequiresManualSetup`, and runs it on `FullySupported`.

Author: GuillaumeLagrange

src/cli/setup.rs

@@ -1,4 +1,4 @@
-use crate::executor::{ToolInstallStatus, get_all_executors};
+use crate::executor::{ExecutorSupport, ToolInstallStatus, get_all_executors};
 use crate::prelude::*;
 use crate::system::SystemInfo;
 use clap::{Args, Subcommand};
@@ -22,10 +22,7 @@ enum SetupCommands {
 pub async fn run(args: SetupArgs, setup_cache_dir: Option<&Path>) -> Result<()> {
     match args.command {
         None => setup(setup_cache_dir).await,
-        Some(SetupCommands::Status) => {
-            status();
-            Ok(())
-        }
+        Some(SetupCommands::Status) => status(),
     }
 }
 
@@ -34,41 +31,81 @@ async fn setup(setup_cache_dir: Option<&Path>) -> Result<()> {
     let executors = get_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()
-        );
-        executor.setup(&system_info, setup_cache_dir).await?;
+        match executor.support_level(&system_info.os) {
+            ExecutorSupport::Unsupported => {
+                info!(
+                    "Skipping setup for the {} executor: not supported on {}",
+                    executor.name(),
+                    system_info.os
+                );
+            }
+            ExecutorSupport::RequiresManualInstallation => {
+                info!(
+                    "Skipping automatic setup for the {} executor on {}; install required tooling manually.",
+                    executor.name(),
+                    system_info.os
+                );
+            }
+            ExecutorSupport::FullySupported => {
+                info!(
+                    "Setting up the environment for the executor: {}",
+                    executor.name()
+                );
+                executor.setup(&system_info, setup_cache_dir).await?;
+            }
+        }
     }
     info!("Environment setup completed");
     end_group!();
     Ok(())
 }
 
-pub fn status() {
+pub fn status() -> Result<()> {
+    let system_info = SystemInfo::new()?;
     info!("{}", style("Tools").bold());
     for executor in get_all_executors() {
-        let tool_status = executor.tool_status();
-        match &tool_status.status {
-            ToolInstallStatus::Installed { version } => {
-                info!("  {} {} ({})", check_mark(), tool_status.tool_name, version);
-            }
-            ToolInstallStatus::IncorrectVersion { version, message } => {
-                info!(
-                    "  {} {} ({}, {})",
-                    warn_mark(),
-                    tool_status.tool_name,
-                    version,
-                    message
-                );
-            }
-            ToolInstallStatus::NotInstalled => {
+        // Don't probe for tooling that can't be used on this OS anyway.
+        if executor.support_level(&system_info.os) == ExecutorSupport::Unsupported {
+            continue;
+        }
+        match executor.tool_status() {
+            Some(tool_status) => match &tool_status.status {
+                ToolInstallStatus::Installed { version } => {
+                    info!(
+                        "  {} {} executor: {} ({})",
+                        check_mark(),
+                        executor.name(),
+                        tool_status.tool_name,
+                        version
+                    );
+                }
+                ToolInstallStatus::IncorrectVersion { version, message } => {
+                    info!(
+                        "  {} {} executor: {} ({}, {})",
+                        warn_mark(),
+                        executor.name(),
+                        tool_status.tool_name,
+                        version,
+                        message
+                    );
+                }
+                ToolInstallStatus::NotInstalled => {
+                    info!(
+                        "  {} {} executor: {} (not installed)",
+                        cross_mark(),
+                        executor.name(),
+                        tool_status.tool_name
+                    );
+                }
+            },
+            None => {
                 info!(
-                    "  {} {} (not installed)",
-                    cross_mark(),
-                    tool_status.tool_name
+                    "  {} {} executor: No tool to install",
+                    check_mark(),
+                    executor.name()
                 );
             }
         }
     }
+    Ok(())
 }

src/cli/status.rs

@@ -22,17 +22,14 @@ pub async fn run(api_client: &CodSpeedAPIClient) -> Result<()> {
     info!("");
 
     // Setup/tools status
-    super::setup::status();
+    super::setup::status()?;
     info!("");
 
     // System info
     info!("{}", style("System").bold());
     info!("  codspeed {VERSION}");
     let system_info = SystemInfo::new()?;
-    info!(
-        "  {} {} ({})",
-        system_info.os, system_info.os_version, system_info.arch
-    );
+    info!("  {} ({})", system_info.os, system_info.arch);
     info!(
         "  {} ({}C / {}GB)",
         system_info.cpu_brand, system_info.cpu_cores, system_info.total_memory_gb

src/executor/helpers/apt.rs

@@ -1,13 +1,13 @@
 use super::run_with_sudo::run_with_sudo;
 use crate::prelude::*;
-use crate::system::SystemInfo;
+use crate::system::{Os, SystemInfo};
 use std::path::Path;
 use std::process::Command;
 
 const METADATA_FILENAME: &str = "./tmp/codspeed-cache-metadata.txt";
 
 fn is_system_compatible(system_info: &SystemInfo) -> bool {
-    system_info.os == "ubuntu" || system_info.os == "debian"
+    matches!(system_info.os, Os::SupportedLinux { .. })
 }
 
 /// Installs packages with caching support.

src/executor/memory/executor.rs

@@ -1,4 +1,5 @@
 use crate::executor::ExecutorName;
+use crate::executor::ExecutorSupport;
 use crate::executor::ToolStatus;
 use crate::executor::helpers::command::CommandBuilder;
 use crate::executor::helpers::env::get_base_injected_env;
@@ -11,7 +12,7 @@ use crate::executor::{ExecutionContext, Executor};
 use crate::instruments::mongo_tracer::MongoTracer;
 use crate::prelude::*;
 use crate::runner_mode::RunnerMode;
-use crate::system::SystemInfo;
+use crate::system::{Os, SystemInfo};
 use async_trait::async_trait;
 use ipc_channel::ipc;
 use memtrack::MemtrackIpcClient;
@@ -72,8 +73,15 @@ impl Executor for MemoryExecutor {
         ExecutorName::Memory
     }
 
-    fn tool_status(&self) -> ToolStatus {
-        get_memtrack_status()
+    fn tool_status(&self) -> Option<ToolStatus> {
+        Some(get_memtrack_status())
+    }
+
+    fn support_level(&self, os: &Os) -> ExecutorSupport {
+        match os {
+            Os::SupportedLinux { .. } | Os::Other { .. } => ExecutorSupport::FullySupported,
+            Os::MacOs { .. } => ExecutorSupport::Unsupported,
+        }
     }
 
     async fn setup(

src/executor/mod.rs

@@ -15,7 +15,7 @@ mod wall_time;
 use crate::instruments::mongo_tracer::{MongoTracer, install_mongodb_tracer};
 use crate::prelude::*;
 use crate::runner_mode::RunnerMode;
-use crate::system::SystemInfo;
+use crate::system::{Os, SystemInfo};
 use async_trait::async_trait;
 pub use config::{BenchmarkTarget, ExecutorConfig, OrchestratorConfig};
 pub use execution_context::ExecutionContext;
@@ -73,12 +73,28 @@ pub enum ToolInstallStatus {
     NotInstalled,
 }
 
+/// How well a given executor runs on a given [`Os`].
+#[derive(Debug, Eq, PartialEq, Clone, Copy)]
+pub enum ExecutorSupport {
+    /// The executor cannot run on this OS at all — `run_executor` hard-bails.
+    Unsupported,
+    /// The executor runs on this OS, but the user is responsible for installing the required tooling themselves.
+    RequiresManualInstallation,
+    /// The executor runs on this OS and `setup()` knows how to auto-install tooling.
+    FullySupported,
+}
+
 #[async_trait(?Send)]
 pub trait Executor {
     fn name(&self) -> ExecutorName;
 
     /// Report the installation status of the tool(s) this executor depends on.
-    fn tool_status(&self) -> ToolStatus;
+    fn tool_status(&self) -> Option<ToolStatus>;
+
+    /// Declare how well this executor runs on the host OS. Drives whether `setup()` is invoked
+    /// (only when [`ExecutorSupport::FullySupported`]) and whether we bail out of running the
+    /// executor at all (on [`ExecutorSupport::Unsupported`]).
+    fn support_level(&self, os: &Os) -> ExecutorSupport;
 
     async fn setup(
         &self,
@@ -107,11 +123,24 @@ pub async fn run_executor(
     execution_context: &ExecutionContext,
     setup_cache_dir: Option<&Path>,
 ) -> Result<()> {
-    if !execution_context.config.skip_setup {
-        executor
-            .setup(&orchestrator.system_info, setup_cache_dir)
-            .await?;
+    match executor.support_level(&orchestrator.system_info.os) {
+        ExecutorSupport::Unsupported => {
+            bail!(
+                "The {} executor is not supported on {}",
+                executor.name(),
+                orchestrator.system_info.os
+            );
+        }
+        ExecutorSupport::RequiresManualInstallation | ExecutorSupport::FullySupported => {
+            if !execution_context.config.skip_setup {
+                executor
+                    .setup(&orchestrator.system_info, setup_cache_dir)
+                    .await?;
+            }
+        }
+    }
 
+    if !execution_context.config.skip_setup {
         // TODO: refactor and move directly in the Instruments struct as a `setup` method
         if execution_context.config.instruments.is_mongodb_enabled() {
             install_mongodb_tracer().await?;

src/executor/valgrind/executor.rs

@@ -3,10 +3,10 @@ use std::path::Path;
 
 use crate::executor::Executor;
 use crate::executor::ToolStatus;
-use crate::executor::{ExecutionContext, ExecutorName};
+use crate::executor::{ExecutionContext, ExecutorName, ExecutorSupport};
 use crate::instruments::mongo_tracer::MongoTracer;
 use crate::prelude::*;
-use crate::system::SystemInfo;
+use crate::system::{Os, SystemInfo};
 
 use super::setup::{get_valgrind_status, install_valgrind};
 use super::{helpers::perf_maps::harvest_perf_maps, helpers::venv_compat, measure};
@@ -19,8 +19,16 @@ impl Executor for ValgrindExecutor {
         ExecutorName::Valgrind
     }
 
-    fn tool_status(&self) -> ToolStatus {
-        get_valgrind_status()
+    fn tool_status(&self) -> Option<ToolStatus> {
+        Some(get_valgrind_status())
+    }
+
+    fn support_level(&self, os: &Os) -> ExecutorSupport {
+        match os {
+            Os::SupportedLinux { .. } => ExecutorSupport::FullySupported,
+            Os::Other { .. } => ExecutorSupport::RequiresManualInstallation,
+            Os::MacOs { .. } => ExecutorSupport::Unsupported,
+        }
     }
 
     async fn setup(&self, system_info: &SystemInfo, setup_cache_dir: Option<&Path>) -> Result<()> {

src/executor/valgrind/setup.rs

@@ -2,7 +2,7 @@ use crate::cli::run::helpers::download_file;
 use crate::executor::helpers::apt;
 use crate::executor::{ToolInstallStatus, ToolStatus};
 use crate::prelude::*;
-use crate::system::SystemInfo;
+use crate::system::{Os, SupportedLinuxDistro, SystemInfo};
 use crate::{
     VALGRIND_CODSPEED_DEB_VERSION, VALGRIND_CODSPEED_VERSION, VALGRIND_CODSPEED_VERSION_STRING,
 };
@@ -11,22 +11,25 @@ use std::{env, path::Path, process::Command};
 use url::Url;
 
 fn get_codspeed_valgrind_filename(system_info: &SystemInfo) -> Result<String> {
-    let (version, architecture) = match (
-        system_info.os.as_str(),
-        system_info.os_version.as_str(),
-        system_info.arch.as_str(),
-    ) {
-        ("ubuntu", "22.04", "x86_64") | ("debian", "12", "x86_64") => ("22.04", "amd64"),
-        ("ubuntu", "24.04", "x86_64") => ("24.04", "amd64"),
-        ("ubuntu", "22.04", "aarch64") | ("debian", "12", "aarch64") => ("22.04", "arm64"),
-        ("ubuntu", "24.04", "aarch64") => ("24.04", "arm64"),
-        _ => bail!("Unsupported system"),
+    let Os::SupportedLinux { distro, version } = &system_info.os else {
+        bail!("Unsupported system");
     };
 
+    let (deb_ubuntu_version, architecture) =
+        match (distro, version.as_str(), system_info.arch.as_str()) {
+            (SupportedLinuxDistro::Ubuntu, "22.04", "x86_64")
+            | (SupportedLinuxDistro::Debian, "12", "x86_64") => ("22.04", "amd64"),
+            (SupportedLinuxDistro::Ubuntu, "24.04", "x86_64") => ("24.04", "amd64"),
+            (SupportedLinuxDistro::Ubuntu, "22.04", "aarch64")
+            | (SupportedLinuxDistro::Debian, "12", "aarch64") => ("22.04", "arm64"),
+            (SupportedLinuxDistro::Ubuntu, "24.04", "aarch64") => ("24.04", "arm64"),
+            _ => bail!("Unsupported system"),
+        };
+
     Ok(format!(
         "valgrind_{}_ubuntu-{}_{}.deb",
         VALGRIND_CODSPEED_DEB_VERSION.as_str(),
-        version,
+        deb_ubuntu_version,
         architecture
     ))
 }
@@ -175,8 +178,7 @@ mod tests {
     #[test]
     fn test_system_info_to_codspeed_valgrind_version_ubuntu() {
         let system_info = SystemInfo {
-            os: "ubuntu".to_string(),
-            os_version: "22.04".to_string(),
+            os: Os::from_id("ubuntu", "22.04"),
             arch: "x86_64".to_string(),
             ..SystemInfo::test()
         };
@@ -189,8 +191,7 @@ mod tests {
     #[test]
     fn test_system_info_to_codspeed_valgrind_version_ubuntu_24() {
         let system_info = SystemInfo {
-            os: "ubuntu".to_string(),
-            os_version: "24.04".to_string(),
+            os: Os::from_id("ubuntu", "24.04"),
             arch: "x86_64".to_string(),
             ..SystemInfo::test()
         };
@@ -203,8 +204,7 @@ mod tests {
     #[test]
     fn test_system_info_to_codspeed_valgrind_version_debian() {
         let system_info = SystemInfo {
-            os: "debian".to_string(),
-            os_version: "12".to_string(),
+            os: Os::from_id("debian", "12"),
             arch: "x86_64".to_string(),
             ..SystemInfo::test()
         };
@@ -217,8 +217,7 @@ mod tests {
     #[test]
     fn test_system_info_to_codspeed_valgrind_version_ubuntu_arm() {
         let system_info = SystemInfo {
-            os: "ubuntu".to_string(),
-            os_version: "22.04".to_string(),
+            os: Os::from_id("ubuntu", "22.04"),
             arch: "aarch64".to_string(),
             ..SystemInfo::test()
         };