fixup: minor chnages in UX

Author: not-matthias

go-runner/src/builder/patcher.rs

@@ -45,7 +45,7 @@ pub fn patch_imports<P: AsRef<Path>>(
         bail!("Failed to install codspeed-go dependency: {}", stderr);
     }
 
-    info!("Successfully installed codspeed-go dependency");
+    debug!("Successfully installed codspeed-go dependency");
 
     Ok(())
 }

go-runner/src/builder/runner.rs

@@ -1,10 +1,7 @@
 use crate::prelude::*;
-use std::{
-    path::{Path, PathBuf},
-    process::Command,
-};
+use std::{path::Path, process::Command};
 
-pub fn build<P: AsRef<Path>>(runner_go_path: P) -> anyhow::Result<PathBuf> {
+pub fn run<P: AsRef<Path>>(runner_go_path: P, run_args: &[&str]) -> anyhow::Result<()> {
     // Extract the directory containing runner.go to use as working directory
     let runner_go_path = runner_go_path.as_ref();
     let file_dir = runner_go_path.parent().unwrap();
@@ -16,24 +13,27 @@ pub fn build<P: AsRef<Path>>(runner_go_path: P) -> anyhow::Result<PathBuf> {
         module_root
     );
 
-    // Run go build -tags=codspeed <path>
+    // Run go run -tags=codspeed <path> {args}
     let output = Command::new("go")
-        .arg("build")
+        .arg("run")
         .arg("-tags=codspeed")
         .arg(relative_path)
+        .args(run_args)
         .current_dir(module_root)
+        .stdout(std::process::Stdio::inherit())
+        .stderr(std::process::Stdio::inherit())
         .output()
         .context("Failed to execute go build command")?;
 
     if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
         let stderr = String::from_utf8_lossy(&output.stderr);
-        bail!("Go build failed: {}", stderr);
-    }
 
-    let runner_executable = module_root.join("runner");
-    if !runner_executable.exists() {
-        bail!("Runner executable not found at {:?}", runner_executable);
+        warn!("Command output: {stdout}");
+        warn!("Command error output: {stderr}");
+
+        bail!("Failed to run benchmark. Exit status: {}", output.status);
     }
 
-    Ok(runner_executable)
+    Ok(())
 }

go-runner/src/builder/template.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-    "fmt"
     "io"
     "time"
     "reflect"
@@ -77,10 +76,6 @@ func main() {
 {{/each}}
     }
 
-    for i := 0; i < len(benchmarks); i++ {
-        fmt.Printf("Benchmark %d: %s\n", i, benchmarks[i].Name)
-    }
-
     m := codspeed_testing.MainStart(simpleDeps{}, tests, benchmarks, fuzzTargets, examples)
     m.Run()
 }

go-runner/src/lib.rs

@@ -15,7 +15,9 @@ mod integration_tests;
 
 /// Builds and runs the specified Go project benchmarks, writing results to the .codspeed folder.
 pub fn run_benchmarks(project_dir: &Path, bench: &str) -> anyhow::Result<()> {
-    let binary_dir = project_dir.join(".codspeed").join("walltime");
+    let profile_dir = std::env::var("CODSPEED_PROFILE_FOLDER")
+        .context("CODSPEED_PROFILE_FOLDER env var not set")?;
+    std::fs::remove_dir_all(&profile_dir).ok();
 
     // 1. Build phase - Benchmark and package discovery
     let packages = BenchmarkPackage::from_project(project_dir)?;
@@ -30,58 +32,32 @@ pub fn run_benchmarks(project_dir: &Path, bench: &str) -> anyhow::Result<()> {
 
     let total_benchmarks: usize = packages.iter().map(|p| p.benchmarks.len()).sum();
     info!("Total benchmarks discovered: {total_benchmarks}");
+    for (name, path) in &bench_name_to_path {
+        info!("Found {name:30} in {path:?}");
+    }
 
-    debug!("Creating binary directory: {binary_dir:?}");
-    std::fs::create_dir_all(&binary_dir)?;
-
-    // 2. Generate codspeed runners and build binaries
-    let mut binaries = Vec::new();
+    // 2. Generate codspeed runners and execute them
     for package in &packages {
-        info!("Processing package: {}", package.name);
+        info!("Generating custom runner for package: {}", package.name);
         let (_target_dir, runner_path) = builder::templater::run(package)?;
 
-        info!("Building benchmarks for: {runner_path:?}");
-        let binary_path = builder::runner::build(&runner_path)?;
-
-        // Create a unique filename to avoid accidentally overwriting existing benchmarks.
-        let filename = binary_path.file_name().unwrap().to_string_lossy();
-        let unique_filename: String = format!("{}_{:08x}", filename, rand::random::<u32>());
-        let target_path = binary_dir.join(unique_filename);
-
-        debug!("Copying {binary_path:?} to {target_path:?}");
-        std::fs::copy(binary_path, &target_path)?;
-        binaries.push(target_path);
-    }
-
-    // 3. Run phase - Execute the built benchmarks
-    for bench_path in &binaries {
-        info!("Running: {bench_path:?}");
-
-        // Use a single iteration in tests to speed up execution, otherwise use 5 seconds
-        let benchtime = if cfg!(test) { "1x" } else { "5s" };
-
-        let cmd = std::process::Command::new(bench_path)
-            .arg(format!("-test.bench={bench}"))
-            .arg(format!("-test.benchtime={benchtime}"))
-            .output()
-            .context("Failed to execute benchmark command")?;
-
-        // Check if the command was successful
-        if !cmd.status.success() {
-            let stdout = String::from_utf8_lossy(&cmd.stdout);
-            let stderr = String::from_utf8_lossy(&cmd.stderr);
-
-            warn!("Command output: {stdout}");
-            warn!("Command error output: {stderr}");
-
-            bail!(
-                "Failed to run benchmark: {bench_path:?}. Exit status: {}",
-                cmd.status
-            );
-        }
+        let args = [
+            "-test.bench",
+            bench,
+            // Use a single iteration in tests to speed up execution, otherwise use 5 seconds
+            "-test.benchtime",
+            if cfg!(test) || std::env::var("CODSPEED_ENV").is_err() {
+                "1x"
+            } else {
+                "5s"
+            },
+        ];
+
+        info!("Running benchmarks for package: {}", package.name);
+        builder::runner::run(&runner_path, &args)?;
     }
 
-    // 4. Collect the results
+    // 3. Collect the results
     collect_walltime_results(bench_name_to_path)?;
 
     Ok(())

go-runner/src/main.rs

@@ -5,6 +5,7 @@ fn main() -> anyhow::Result<()> {
     env_logger::builder()
         .parse_env("CODSPEED_LOG")
         .filter_module("handlebars", log::LevelFilter::Off)
+        .format_timestamp(None)
         .init();
 
     let cli = Cli::parse();