feat(exec-harness): use the new instrument-hooks bindings rather than codspeed core

Author: GuillaumeLagrange

Cargo.lock

@@ -10,8 +10,8 @@ name = "exec-harness"
 path = "src/main.rs"
 
 [dependencies]
+instrument-hooks-bindings = { path = "../instrument-hooks-bindings" }
 anyhow = { workspace = true }
-codspeed = "4.2.0"
 log = { workspace = true }
 env_logger = { workspace = true }
 clap = { workspace = true }
@@ -23,7 +23,6 @@ tempfile = { workspace = true }
 object = { workspace = true }
 
 [build-dependencies]
-cargo_metadata = "0.19"
 cc = "1"
 
 [package.metadata.dist]

crates/exec-harness/Cargo.toml

@@ -3,16 +3,9 @@
 //! This script compiles the `libcodspeed_preload.so` shared library that is used
 //! to inject instrumentation into child processes via LD_PRELOAD.
 //!
-//! The library is built using the `core.c` and headers from the `codspeed` crate's
-//! `instrument-hooks` directory.
-//!
-//! # Environment Variables
-//!
-//! - `CODSPEED_INSTRUMENT_HOOKS_DIR`: Optional override for the instrument-hooks
-//!   source directory. If not set, the build script will locate it from the
-//!   `codspeed` crate in the cargo registry.
+//! The library is built using the `core.c` and headers from the `instrument-hooks-bindings`
+//! crate's `instrument-hooks` directory.
 
-use cargo_metadata::MetadataCommand;
 use std::env;
 use std::path::PathBuf;
 
@@ -25,7 +18,6 @@ struct PreloadConstants {
     /// Integration name reported to CodSpeed.
     integration_name: &'static str,
     /// Integration version reported to CodSpeed.
-    /// This should match the version of the `codspeed` crate dependency.
     integration_version: &'static str,
     /// Filename for the preload shared library.
     preload_lib_filename: &'static str,
@@ -58,11 +50,11 @@ fn main() {
     let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
 
     // Try to get the instrument-hooks directory from the environment variable first,
-    // otherwise locate it from the codspeed crate
-    let instrument_hooks_dir = match env::var("CODSPEED_INSTRUMENT_HOOKS_DIR") {
-        Ok(dir) => PathBuf::from(dir),
-        Err(_) => find_codspeed_instrument_hooks_dir(),
-    };
+    // otherwise use the one from the instrument-hooks-bindings crate
+    let instrument_hooks_dir = manifest_dir
+        .parent()
+        .unwrap()
+        .join("instrument-hooks-bindings/instrument-hooks");
 
     // Build the preload shared library
     let paths = PreloadBuildPaths {
@@ -130,40 +122,12 @@ fn build_shared_library(paths: &PreloadBuildPaths, constants: &PreloadConstants)
     }
 }
 
-/// Find the instrument-hooks directory from the codspeed crate using cargo_metadata
-fn find_codspeed_instrument_hooks_dir() -> PathBuf {
-    let metadata = MetadataCommand::new()
-        .exec()
-        .expect("Failed to run cargo metadata");
-
-    // Find the codspeed package in the resolved dependencies
-    let codspeed_pkg = metadata
-        .packages
-        .iter()
-        .find(|p| p.name == "codspeed")
-        .expect("codspeed crate not found in dependencies");
-
-    let codspeed_dir = codspeed_pkg
-        .manifest_path
-        .parent()
-        .expect("Failed to get codspeed crate directory");
-
-    let instrument_hooks_dir = codspeed_dir.join("instrument-hooks");
-
-    if !instrument_hooks_dir.exists() {
-        panic!("instrument-hooks directory not found at {instrument_hooks_dir}");
-    }
-
-    instrument_hooks_dir.into_std_path_buf()
-}
-
 impl Default for PreloadConstants {
-    // TODO(COD-1736): Stop impersonating codspeed-rust 🥸
     fn default() -> Self {
         Self {
             uri_env: "CODSPEED_BENCH_URI",
-            integration_name: "codspeed-rust",
-            integration_version: "4.2.0",
+            integration_name: "exec-harness",
+            integration_version: env!("CARGO_PKG_VERSION"),
             preload_lib_filename: "libcodspeed_preload.so",
         }
     }
@@ -185,13 +149,13 @@ impl PreloadBuildPaths {
     fn check_sources_exist(&self) {
         if !self.core_c.exists() {
             panic!(
-                "core.c not found at {}. Make sure the codspeed crate is available.",
+                "core.c not found at {}. Make sure the instrument-hooks-bindings crate is available.",
                 self.core_c.display()
             );
         }
         if !self.includes_dir.exists() {
             panic!(
-                "includes directory not found at {}. Make sure the codspeed crate is available.",
+                "includes directory not found at {}. Make sure the instrument-hooks-bindings crate is available.",
                 self.includes_dir.display()
             );
         }

crates/exec-harness/build.rs

@@ -1,16 +1,18 @@
+use crate::constants::INTEGRATION_NAME;
+use crate::constants::INTEGRATION_VERSION;
 use crate::prelude::*;
 
 use crate::BenchmarkCommand;
 use crate::constants;
 use crate::uri;
-use codspeed::instrument_hooks::InstrumentHooks;
+use instrument_hooks_bindings::InstrumentHooks;
 use std::process::Command;
 
 mod ld_preload_check;
 mod preload_lib_file;
 
 pub fn perform(commands: Vec<BenchmarkCommand>) -> Result<()> {
-    let hooks = InstrumentHooks::instance();
+    let hooks = InstrumentHooks::instance(INTEGRATION_NAME, INTEGRATION_VERSION);
 
     for benchmark_cmd in commands {
         let name_and_uri = uri::generate_name_and_uri(&benchmark_cmd.name, &benchmark_cmd.command);

crates/exec-harness/src/analysis/mod.rs

@@ -1,7 +1,8 @@
 use super::ExecutionOptions;
 use super::config::RoundOrTime;
+use crate::constants::{INTEGRATION_NAME, INTEGRATION_VERSION};
 use crate::prelude::*;
-use codspeed::instrument_hooks::InstrumentHooks;
+use instrument_hooks_bindings::InstrumentHooks;
 use std::process::Command;
 use std::time::Duration;
 
@@ -11,7 +12,7 @@ pub fn run_rounds(
     config: &ExecutionOptions,
 ) -> Result<Vec<u128>> {
     let warmup_time_ns = config.warmup_time_ns;
-    let hooks = InstrumentHooks::instance();
+    let hooks = InstrumentHooks::instance(INTEGRATION_NAME, INTEGRATION_VERSION);
 
     let do_one_round = || -> Result<(u64, u64)> {
         let mut child = Command::new(&command[0])

crates/exec-harness/src/walltime/benchmark_loop.rs

@@ -3,10 +3,13 @@ mod config;
 
 pub use config::ExecutionOptions;
 pub use config::WalltimeExecutionArgs;
+use runner_shared::walltime_results::Creator;
 use runner_shared::walltime_results::WalltimeBenchmark;
 pub use runner_shared::walltime_results::WalltimeResults;
 
 use crate::BenchmarkCommand;
+use crate::constants::INTEGRATION_NAME;
+use crate::constants::INTEGRATION_VERSION;
 use crate::prelude::*;
 use crate::uri::NameAndUri;
 use crate::uri::generate_name_and_uri;
@@ -42,8 +45,15 @@ pub fn perform(commands: Vec<BenchmarkCommand>) -> Result<()> {
         walltime_benchmarks.push(walltime_benchmark);
     }
 
-    let walltime_results = WalltimeResults::from_benchmarks(walltime_benchmarks)
-        .expect("Failed to create walltime results");
+    let walltime_results = WalltimeResults::new(
+        Creator {
+            name: INTEGRATION_NAME.to_string(),
+            version: INTEGRATION_VERSION.to_string(),
+            pid: std::process::id(),
+        },
+        walltime_benchmarks,
+    )
+    .expect("Failed to create walltime results");
 
     walltime_results
         .save_to_file(

crates/exec-harness/src/walltime/mod.rs

@@ -27,13 +27,13 @@ mod linux_impl {
 
         /// Returns a singleton instance of `InstrumentHooks`.
         #[inline(always)]
-        pub fn instance() -> &'static Self {
+        pub fn instance(integration: &str, version: &str) -> &'static Self {
             static INSTANCE: OnceLock<InstrumentHooks> = OnceLock::new();
             INSTANCE.get_or_init(|| {
                 let instance =
                     InstrumentHooks::new().expect("Failed to initialize InstrumentHooks");
                 instance
-                    .set_integration("codspeed-rust", env!("CARGO_PKG_VERSION"))
+                    .set_integration(integration, version)
                     .expect("Failed to set integration");
                 instance
             })
@@ -210,7 +210,7 @@ mod tests {
 
     #[test]
     fn test_instrument_hooks() {
-        let hooks = InstrumentHooks::instance();
+        let hooks = InstrumentHooks::instance("test_integration", "1.0.0");
         assert!(!hooks.is_instrumented() || hooks.start_benchmark().is_ok());
         assert!(hooks.set_executed_benchmark("test_uri").is_ok());
         assert!(hooks.set_integration("test_integration", "1.0.0").is_ok());

crates/instrument-hooks-bindings/src/lib.rs

@@ -4,17 +4,12 @@ mod stats;
 pub use interfaces::*;
 
 impl WalltimeResults {
-    pub fn from_benchmarks(benchmarks: Vec<WalltimeBenchmark>) -> anyhow::Result<Self> {
+    pub fn new(creator: Creator, benchmarks: Vec<WalltimeBenchmark>) -> anyhow::Result<Self> {
         Ok(WalltimeResults {
             instrument: Instrument {
                 type_: "walltime".to_string(),
             },
-            creator: Creator {
-                // TODO(COD-1736): Stop impersonating codspeed-rust 🥸
-                name: "codspeed-rust".to_string(),
-                version: env!("CARGO_PKG_VERSION").to_string(),
-                pid: std::process::id(),
-            },
+            creator,
             benchmarks,
         })
     }