fix: valgrind crash for unresolved libpython

Author: not-matthias

src/run/runner/valgrind/measure.rs

@@ -12,7 +12,7 @@ use std::fs::canonicalize;
 use std::io::Write;
 use std::os::unix::fs::PermissionsExt;
 use std::os::unix::process::ExitStatusExt;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::{env::consts::ARCH, process::Command};
 use tempfile::TempPath;
 
@@ -73,11 +73,98 @@ fn create_run_script() -> anyhow::Result<TempPath> {
     Ok(script_file.into_temp_path())
 }
 
+/// By default, uv only symlinks the python3 executable which will cause the library lookups of
+/// valgrind or ldd to fail:
+/// ```no_run
+/// > ldd .venv/bin/python3
+/// /home/project/.venv/bin/../lib/libpython3.13.so.1.0 => not found
+/// ```
+///
+/// To fix this, we have to also add the symlink to the `libpython` shared object.
+fn symlink_libcpython(cwd: Option<&String>) -> anyhow::Result<()> {
+    let run_cmd = |cmd: &str, args: &[&str]| -> anyhow::Result<String> {
+        let mut cmd = Command::new(cmd);
+
+        if let Some(cwd) = cwd {
+            cmd.current_dir(cwd);
+        }
+
+        let output = cmd.args(args).output()?;
+        if !output.status.success() {
+            let stderr = String::from_utf8(output.stderr)?;
+            bail!("Failed to execute command: {}", stderr);
+        }
+
+        let output = String::from_utf8(output.stdout)?;
+        Ok(output.trim().to_string())
+    };
+
+    // 1. find the python installation and version
+    let venv_python =
+        run_cmd("uv", &["python", "find"]).context("Failed to find uv python executable")?;
+    let system_python = std::fs::canonicalize(&venv_python)?;
+    debug!(
+        "Python executables: {} (venv), {} (system)",
+        venv_python,
+        system_python.display()
+    );
+
+    // 2. Resolve the symlink, then find the python dir
+    let python_dir = |py_exe: &Path| {
+        py_exe
+            .parent()
+            .and_then(|p| p.parent())
+            .context("Failed to find python dir")
+            .map(|p| p.to_path_buf())
+    };
+
+    let system_python_dir = python_dir(&system_python)?;
+    let venv_python_dir = python_dir(&PathBuf::from(venv_python))?;
+    debug!(
+        "Python dirs: {} (venv), {} (system)",
+        venv_python_dir.display(),
+        system_python_dir.display(),
+    );
+
+    // 3. Find the libpython in the system dir
+    let mut libpython_name = None;
+    for entry in std::fs::read_dir(system_python_dir.join("lib"))?.filter_map(Result::ok) {
+        let filename = entry.file_name().to_string_lossy().to_string();
+        if filename.starts_with("libpython") && filename.ends_with(".so.1.0") {
+            libpython_name = Some(filename);
+            break;
+        }
+    }
+    let libpython_name = libpython_name.context("Failed to find libpython shared object")?;
+
+    // Ensure the lib directory exists
+    let venv_lib = venv_python_dir.join("lib");
+    std::fs::create_dir_all(&venv_lib)?;
+
+    // 4. Create a symlink in .venv/lib/
+    let libpython_path = |python_dir: &Path| python_dir.join("lib").join(&*libpython_name);
+    let original_path = libpython_path(&system_python_dir);
+    let link_path = libpython_path(&venv_python_dir);
+    match std::os::unix::fs::symlink(original_path, link_path) {
+        Err(error) if error.kind() != std::io::ErrorKind::AlreadyExists => {
+            bail!("Failed to create symlink: {}", error)
+        }
+        _ => {}
+    }
+
+    Ok(())
+}
+
 pub async fn measure(
     config: &Config,
     profile_folder: &Path,
     mongo_tracer: &Option<MongoTracer>,
 ) -> Result<()> {
+    // Ensure that valgrind can find the libpython library when using uv:
+    if config.command.contains("uv run") {
+        symlink_libcpython(config.working_directory.as_ref())?;
+    }
+
     // Create the command
     let mut cmd = Command::new("setarch");
     cmd.arg(ARCH).arg("-R");