feat: add exec subcommand and refactor run subcommand

Refactor aims to extract common behavior between exec and run.
It mostly moves out the run::Config into the executor module, as well
as moving the run_environment module to the root of the repo.

The main aim is to offload the overloaded run module that has outgrown
its initial purpose of a clap subcommand.

Author: GuillaumeLagrange

.gitattributes

@@ -1,2 +1,2 @@
 testdata/perf_map/* filter=lfs diff=lfs merge=lfs -text
-src/run/runner/wall_time/perf/snapshots/*.snap filter=lfs diff=lfs merge=lfs -text
+*.snap filter=lfs diff=lfs merge=lfs -text

src/app.rs

@@ -4,6 +4,7 @@ use crate::{
     api_client::CodSpeedAPIClient,
     auth,
     config::CodSpeedConfig,
+    exec,
     local_logger::{CODSPEED_U8_COLOR_CODE, init_local_logger},
     prelude::*,
     run, setup,
@@ -59,8 +60,11 @@ pub struct Cli {
 
 #[derive(Subcommand, Debug)]
 enum Commands {
-    /// Run the bench command and upload the results to CodSpeed
+    /// Run a benchmark program that already contains the CodSpeed instrumentation and upload the results to CodSpeed
     Run(Box<run::RunArgs>),
+    /// Run a command after adding CodSpeed instrumentation to it and upload the results to
+    /// CodSpeed
+    Exec(Box<exec::ExecArgs>),
     /// Manage the CLI authentication state
     Auth(auth::AuthArgs),
     /// Pre-install the codspeed executors
@@ -80,7 +84,7 @@ pub async fn run() -> Result<()> {
     let setup_cache_dir = setup_cache_dir.as_deref();
 
     match cli.command {
-        Commands::Run(_) => {} // Run is responsible for its own logger initialization
+        Commands::Run(_) | Commands::Exec(_) => {} // Run and Exec are responsible for their own logger initialization
         _ => {
             init_local_logger()?;
         }
@@ -90,6 +94,9 @@ pub async fn run() -> Result<()> {
         Commands::Run(args) => {
             run::run(*args, &api_client, &codspeed_config, setup_cache_dir).await?
         }
+        Commands::Exec(args) => {
+            exec::run(*args, &api_client, &codspeed_config, setup_cache_dir).await?
+        }
         Commands::Auth(args) => auth::run(args, &api_client, cli.config_name.as_deref()).await?,
         Commands::Setup => setup::setup(setup_cache_dir).await?,
     }

src/exec/mod.rs

@@ -0,0 +1,73 @@
+use crate::api_client::CodSpeedAPIClient;
+use crate::config::CodSpeedConfig;
+use crate::prelude::*;
+use clap::Args;
+use std::path::Path;
+
+#[derive(Args, Debug)]
+pub struct ExecArgs {
+    #[command(flatten)]
+    pub shared: crate::run::ExecAndRunSharedArgs,
+
+    /// Optional benchmark name (defaults to command filename)
+    #[arg(long)]
+    pub name: Option<String>,
+
+    /// The command to execute with the exec harness
+    pub command: Vec<String>,
+}
+
+pub async fn run(
+    args: ExecArgs,
+    api_client: &CodSpeedAPIClient,
+    codspeed_config: &CodSpeedConfig,
+    setup_cache_dir: Option<&Path>,
+) -> Result<()> {
+    // Assume exec-harness is in the PATH for now
+    let wrapped_command = std::iter::once("exec-harness".to_string())
+        .chain(args.command)
+        .collect::<Vec<String>>();
+
+    let warped_command_string = wrapped_command.join(" ");
+
+    info!("Executing: {warped_command_string}");
+
+    // Convert ExecArgs to executor::Config using shared args
+    let config = crate::executor::Config {
+        upload_url: args
+            .shared
+            .upload_url
+            .as_ref()
+            .map(|url| url.parse())
+            .transpose()
+            .map_err(|e| anyhow!("Invalid upload URL: {e}"))?
+            .unwrap_or_else(|| {
+                "https://api.codspeed.io/upload"
+                    .parse()
+                    .expect("Default URL should be valid")
+            }),
+        token: args.shared.token,
+        repository_override: args
+            .shared
+            .repository
+            .map(|repo| {
+                crate::executor::config::RepositoryOverride::from_arg(repo, args.shared.provider)
+            })
+            .transpose()?,
+        working_directory: args.shared.working_directory,
+        command: warped_command_string,
+        mode: args.shared.mode,
+        instruments: crate::instruments::Instruments { mongodb: None }, // exec doesn't support MongoDB
+        enable_perf: args.shared.perf_run_args.enable_perf,
+        perf_unwinding_mode: args.shared.perf_run_args.perf_unwinding_mode,
+        profile_folder: args.shared.profile_folder,
+        skip_upload: args.shared.skip_upload,
+        skip_run: args.shared.skip_run,
+        skip_setup: args.shared.skip_setup,
+        allow_empty: args.shared.allow_empty,
+    };
+
+    // Delegate to shared execution logic
+    crate::executor::execute_benchmarks(config, api_client, codspeed_config, setup_cache_dir, false)
+        .await
+}

src/run/config.rs renamed to src/executor/config.rs

@@ -1,13 +1,11 @@
 use crate::instruments::Instruments;
 use crate::prelude::*;
+use crate::run::{RunArgs, UnwindingMode};
+use crate::run_environment::RepositoryProvider;
+use crate::runner_mode::RunnerMode;
 use std::path::PathBuf;
 use url::Url;
 
-use crate::run::RunArgs;
-use crate::run::run_environment::RepositoryProvider;
-
-use super::{RunnerMode, UnwindingMode};
-
 #[derive(Debug)]
 pub struct Config {
     pub upload_url: Url,
@@ -35,6 +33,23 @@ pub struct RepositoryOverride {
     pub repository_provider: RepositoryProvider,
 }
 
+impl RepositoryOverride {
+    /// Creates a RepositoryOverride from an "owner/repository" string
+    pub fn from_arg(
+        repository_and_owner: String,
+        provider: Option<RepositoryProvider>,
+    ) -> Result<Self> {
+        let (owner, repository) = repository_and_owner
+            .split_once('/')
+            .context("Invalid owner/repository format")?;
+        Ok(Self {
+            owner: owner.to_string(),
+            repository: repository.to_string(),
+            repository_provider: provider.unwrap_or_default(),
+        })
+    }
+}
+
 impl Config {
     pub fn set_token(&mut self, token: Option<String>) {
         self.token = token;
@@ -70,47 +85,36 @@ impl TryFrom<RunArgs> for Config {
     type Error = Error;
     fn try_from(args: RunArgs) -> Result<Self> {
         let instruments = Instruments::try_from(&args)?;
-        let raw_upload_url = args.upload_url.unwrap_or_else(|| DEFAULT_UPLOAD_URL.into());
+        let raw_upload_url = args
+            .shared
+            .upload_url
+            .unwrap_or_else(|| DEFAULT_UPLOAD_URL.into());
         let upload_url = Url::parse(&raw_upload_url)
             .map_err(|e| anyhow!("Invalid upload URL: {raw_upload_url}, {e}"))?;
 
         Ok(Self {
             upload_url,
-            token: args.token,
+            token: args.shared.token,
             repository_override: args
+                .shared
                 .repository
-                .map(|respository_and_owner| -> Result<RepositoryOverride> {
-                    let (owner, repository) =
-                        extract_owner_and_repository_from_arg(&respository_and_owner)?;
-                    Ok(RepositoryOverride {
-                        owner,
-                        repository,
-                        repository_provider: args.provider.unwrap_or_default(),
-                    })
-                })
+                .map(|repo| RepositoryOverride::from_arg(repo, args.shared.provider))
                 .transpose()?,
-            working_directory: args.working_directory,
-            mode: args.mode,
+            working_directory: args.shared.working_directory,
+            mode: args.shared.mode,
             instruments,
-            perf_unwinding_mode: args.perf_run_args.perf_unwinding_mode,
-            enable_perf: args.perf_run_args.enable_perf,
+            perf_unwinding_mode: args.shared.perf_run_args.perf_unwinding_mode,
+            enable_perf: args.shared.perf_run_args.enable_perf,
             command: args.command.join(" "),
-            profile_folder: args.profile_folder,
-            skip_upload: args.skip_upload,
-            skip_run: args.skip_run,
-            skip_setup: args.skip_setup,
-            allow_empty: args.allow_empty,
+            profile_folder: args.shared.profile_folder,
+            skip_upload: args.shared.skip_upload,
+            skip_run: args.shared.skip_run,
+            skip_setup: args.shared.skip_setup,
+            allow_empty: args.shared.allow_empty,
         })
     }
 }
 
-fn extract_owner_and_repository_from_arg(owner_and_repository: &str) -> Result<(String, String)> {
-    let (owner, repository) = owner_and_repository
-        .split_once('/')
-        .context("Invalid owner/repository format")?;
-    Ok((owner.to_string(), repository.to_string()))
-}
-
 #[cfg(test)]
 mod tests {
     use crate::instruments::MongoDBConfig;
@@ -121,24 +125,26 @@ mod tests {
     #[test]
     fn test_try_from_env_empty() {
         let config = Config::try_from(RunArgs {
-            upload_url: None,
-            token: None,
-            repository: None,
-            provider: None,
-            working_directory: None,
-            mode: RunnerMode::Simulation,
+            shared: crate::run::ExecAndRunSharedArgs {
+                upload_url: None,
+                token: None,
+                repository: None,
+                provider: None,
+                working_directory: None,
+                mode: RunnerMode::Simulation,
+                profile_folder: None,
+                skip_upload: false,
+                skip_run: false,
+                skip_setup: false,
+                allow_empty: false,
+                perf_run_args: PerfRunArgs {
+                    enable_perf: false,
+                    perf_unwinding_mode: None,
+                },
+            },
             instruments: vec![],
             mongo_uri_env_name: None,
             message_format: None,
-            profile_folder: None,
-            skip_upload: false,
-            skip_run: false,
-            skip_setup: false,
-            allow_empty: false,
-            perf_run_args: PerfRunArgs {
-                enable_perf: false,
-                perf_unwinding_mode: None,
-            },
             command: vec!["cargo".into(), "codspeed".into(), "bench".into()],
         })
         .unwrap();
@@ -157,24 +163,26 @@ mod tests {
     #[test]
     fn test_try_from_args() {
         let config = Config::try_from(RunArgs {
-            upload_url: Some("https://example.com/upload".into()),
-            token: Some("token".into()),
-            repository: Some("owner/repo".into()),
-            provider: Some(RepositoryProvider::GitLab),
-            working_directory: Some("/tmp".into()),
-            mode: RunnerMode::Simulation,
+            shared: crate::run::ExecAndRunSharedArgs {
+                upload_url: Some("https://example.com/upload".into()),
+                token: Some("token".into()),
+                repository: Some("owner/repo".into()),
+                provider: Some(RepositoryProvider::GitLab),
+                working_directory: Some("/tmp".into()),
+                mode: RunnerMode::Simulation,
+                profile_folder: Some("./codspeed.out".into()),
+                skip_upload: true,
+                skip_run: true,
+                skip_setup: true,
+                allow_empty: true,
+                perf_run_args: PerfRunArgs {
+                    enable_perf: false,
+                    perf_unwinding_mode: Some(UnwindingMode::FramePointer),
+                },
+            },
             instruments: vec!["mongodb".into()],
             mongo_uri_env_name: Some("MONGODB_URI".into()),
             message_format: Some(crate::run::MessageFormat::Json),
-            profile_folder: Some("./codspeed.out".into()),
-            skip_upload: true,
-            skip_run: true,
-            skip_setup: true,
-            allow_empty: true,
-            perf_run_args: PerfRunArgs {
-                enable_perf: false,
-                perf_unwinding_mode: Some(UnwindingMode::FramePointer),
-            },
             command: vec!["cargo".into(), "codspeed".into(), "bench".into()],
         })
         .unwrap();
@@ -210,16 +218,27 @@ mod tests {
     }
 
     #[test]
-    fn test_extract_owner_and_repository_from_arg() {
-        let owner_and_repository = "CodSpeedHQ/runner";
-        let (owner, repository) =
-            extract_owner_and_repository_from_arg(owner_and_repository).unwrap();
-        assert_eq!(owner, "CodSpeedHQ");
-        assert_eq!(repository, "runner");
+    fn test_repository_override_from_arg() {
+        let override_result =
+            RepositoryOverride::from_arg("CodSpeedHQ/runner".to_string(), None).unwrap();
+        assert_eq!(override_result.owner, "CodSpeedHQ");
+        assert_eq!(override_result.repository, "runner");
+        assert_eq!(
+            override_result.repository_provider,
+            RepositoryProvider::GitHub
+        );
 
-        let owner_and_repository = "CodSpeedHQ_runner";
+        let override_with_provider = RepositoryOverride::from_arg(
+            "CodSpeedHQ/runner".to_string(),
+            Some(RepositoryProvider::GitLab),
+        )
+        .unwrap();
+        assert_eq!(
+            override_with_provider.repository_provider,
+            RepositoryProvider::GitLab
+        );
 
-        let result = extract_owner_and_repository_from_arg(owner_and_repository);
+        let result = RepositoryOverride::from_arg("CodSpeedHQ_runner".to_string(), None);
         assert!(result.is_err());
     }
 }

src/executor/helpers/get_bench_command.rs

@@ -1,5 +1,5 @@
+use crate::executor::Config;
 use crate::prelude::*;
-use crate::run::config::Config;
 
 pub fn get_bench_command(config: &Config) -> Result<String> {
     let bench_command = &config.command.trim();