testlint_sdk/runtime_coverage/

rust.rs

use crate::platform::{process_exists, signal_process, ProcessSignal};
use crate::runtime_coverage::{CoverageSummary, RuntimeCoverageResult};
use std::fs;
use std::path::Path;
use std::process::Command;
use std::thread;
use std::time::Duration;

pub struct RustRuntimeCoverage;

impl Default for RustRuntimeCoverage {
    fn default() -> Self {
        Self::new()
    }
}

impl RustRuntimeCoverage {
    pub fn new() -> Self {
        RustRuntimeCoverage
    }

    /// Attach to a running Rust process and collect coverage continuously
    /// REQUIRES: Process must be built with LLVM coverage instrumentation
    pub fn attach_and_collect(&self, pid: u32) -> Result<RuntimeCoverageResult, String> {
        println!("🦀 Attaching coverage to Rust process PID: {}", pid);
        println!("📊 Collecting coverage continuously (press Ctrl+C to stop)...");
        println!();
        println!("⚠️  IMPORTANT: This only works if the Rust binary was built with:");
        println!("   RUSTFLAGS=\"-C instrument-coverage\" cargo build");
        println!("   AND");
        println!("   Process must write profraw data on exit");
        println!();

        // Check if process exists
        self.check_process_exists(pid)?;

        // Detect binary path
        let binary_path = self.get_binary_path(pid)?;
        println!("📦 Binary: {}", binary_path);

        // Set coverage output path
        let _profraw_file = format!("rust-coverage-{}.profraw", pid);

        println!("💡 Rust coverage via LLVM profiling:");
        println!("   - Process must be built with -C instrument-coverage");
        println!("   - Coverage written to .profraw on process exit");
        println!("   - We'll trigger graceful shutdown to dump coverage");
        println!();

        // Wait for Ctrl+C
        use std::sync::atomic::{AtomicBool, Ordering};
        use std::sync::Arc;

        let running = Arc::new(AtomicBool::new(true));
        let r = running.clone();

        ctrlc::set_handler(move || {
            r.store(false, Ordering::SeqCst);
        })
        .expect("Error setting Ctrl-C handler");

        let start_time = std::time::Instant::now();

        println!("⏳ Monitoring process... Press Ctrl+C to trigger coverage dump");

        while running.load(Ordering::SeqCst) {
            thread::sleep(Duration::from_millis(100));
        }

        let duration_secs = start_time.elapsed().as_secs();

        // Signal the process to exit gracefully
        println!("\n📝 Sending SIGTERM to process to trigger coverage dump...");

        #[cfg(unix)]
        {
            signal_process(pid, ProcessSignal::Terminate)?;
        }

        #[cfg(windows)]
        {
            // On Windows, create a trigger file for graceful shutdown
            let trigger_file = std::env::temp_dir().join(format!("coverage_trigger_{}.txt", pid));
            fs::write(&trigger_file, "terminate")?;
            println!(
                "ℹ️  Created trigger file (Windows alternative to SIGTERM): {}",
                trigger_file.display()
            );
            println!("   Note: Rust process must watch for this file to trigger graceful shutdown");
        }

        // Wait for process to write profraw and exit
        println!("⏳ Waiting for process to write profraw file...");
        thread::sleep(Duration::from_secs(3));

        // Find the profraw file
        let profraw_file = self.find_profraw_file(pid)?;
        println!("✓ Found profraw file: {}", profraw_file);

        // Convert profraw to lcov using llvm-profdata and llvm-cov
        let coverage_file = self.convert_to_lcov(&profraw_file, &binary_path, pid)?;

        // Parse the lcov file
        let summary = self.parse_lcov_file(&coverage_file)?;

        Ok(RuntimeCoverageResult {
            language: "Rust".to_string(),
            pid,
            duration_secs,
            coverage_file,
            summary,
        })
    }

    /// Check if the process exists
    fn check_process_exists(&self, pid: u32) -> Result<(), String> {
        if !process_exists(pid)? {
            return Err(format!("Process {} not found", pid));
        }
        Ok(())
    }

    /// Get the binary path of the running process
    fn get_binary_path(&self, pid: u32) -> Result<String, String> {
        #[cfg(target_os = "linux")]
        {
            let exe_path = format!("/proc/{}/exe", pid);
            match fs::read_link(&exe_path) {
                Ok(path) => Ok(path.to_string_lossy().to_string()),
                Err(e) => Err(format!("Failed to read process binary: {}", e)),
            }
        }

        #[cfg(target_os = "macos")]
        {
            let output = Command::new("ps")
                .args(["-p", &pid.to_string(), "-o", "comm="])
                .output()
                .map_err(|e| format!("Failed to get process info: {}", e))?;

            Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
        }

        #[cfg(not(any(target_os = "linux", target_os = "macos")))]
        {
            Err("Binary path detection not supported on this platform".to_string())
        }
    }

    /// Find the profraw file written by the Rust process
    fn find_profraw_file(&self, pid: u32) -> Result<String, String> {
        // Common locations for profraw files
        let possible_files = vec![
            format!("rust-coverage-{}.profraw", pid),
            format!("default-{}.profraw", pid),
            "default.profraw".to_string(),
            format!("{}.profraw", pid),
        ];

        for file in &possible_files {
            if Path::new(file).exists() {
                return Ok(file.clone());
            }
        }

        // Search for recent .profraw files
        if let Ok(entries) = fs::read_dir(".") {
            for entry in entries.flatten() {
                if let Ok(file_name) = entry.file_name().into_string() {
                    if file_name.ends_with(".profraw") {
                        if let Ok(metadata) = entry.metadata() {
                            if let Ok(modified) = metadata.modified() {
                                if let Ok(elapsed) = modified.elapsed() {
                                    if elapsed.as_secs() < 10 {
                                        return Ok(file_name);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        Err(format!(
            "Coverage profraw file not found.\n\
            \n\
            The Rust process may not have been built with coverage instrumentation.\n\
            \n\
            To enable coverage in your Rust application:\n\
            1. Build with: RUSTFLAGS=\"-C instrument-coverage\" cargo build\n\
            2. Set LLVM_PROFILE_FILE env var when running:\n\
               LLVM_PROFILE_FILE=\"rust-coverage-%p.profraw\" ./myapp\n\
            \n\
            Or use cargo-llvm-cov: cargo llvm-cov run\n\
            \n\
            Checked files: {:?}",
            possible_files
        ))
    }

    /// Convert profraw to lcov format using llvm tools
    fn convert_to_lcov(
        &self,
        profraw_file: &str,
        binary_path: &str,
        pid: u32,
    ) -> Result<String, String> {
        println!("📄 Converting profraw to lcov format...");

        // First, create profdata file
        let profdata_file = format!("rust-coverage-{}.profdata", pid);

        let output = Command::new("llvm-profdata")
            .args(["merge", "-sparse", profraw_file, "-o", &profdata_file])
            .output()
            .map_err(|e| {
                format!(
                    "Failed to run llvm-profdata (is it installed?): {}\n\
                Install with: rustup component add llvm-tools-preview",
                    e
                )
            })?;

        if !output.status.success() {
            return Err(format!(
                "llvm-profdata failed: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        println!("✓ Created profdata file");

        // Convert to lcov
        let lcov_file = format!("rust-coverage-{}.lcov", pid);

        let output = Command::new("llvm-cov")
            .args([
                "export",
                binary_path,
                "-instr-profile",
                &profdata_file,
                "-format=lcov",
            ])
            .output()
            .map_err(|e| format!("Failed to run llvm-cov: {}", e))?;

        if !output.status.success() {
            return Err(format!(
                "llvm-cov export failed: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        // Write lcov output
        fs::write(&lcov_file, &output.stdout)
            .map_err(|e| format!("Failed to write lcov file: {}", e))?;

        println!("✓ Converted to lcov format");

        // Clean up intermediate files
        let _ = fs::remove_file(profraw_file);
        let _ = fs::remove_file(&profdata_file);

        Ok(lcov_file)
    }

    /// Parse lcov format coverage file
    fn parse_lcov_file(&self, lcov_file: &str) -> Result<CoverageSummary, String> {
        println!("📊 Parsing coverage report...");

        let content = fs::read_to_string(lcov_file)
            .map_err(|e| format!("Failed to read lcov file: {}", e))?;

        let mut total_lines = 0;
        let mut covered_lines = 0;

        // LCOV format:
        // DA:line,count
        for line in content.lines() {
            if line.starts_with("DA:") {
                let parts: Vec<&str> = line.strip_prefix("DA:").unwrap().split(',').collect();
                if parts.len() >= 2 {
                    if let Ok(count) = parts[1].parse::<usize>() {
                        total_lines += 1;
                        if count > 0 {
                            covered_lines += 1;
                        }
                    }
                }
            }
        }

        if total_lines == 0 {
            return Err("No coverage data found in lcov file".to_string());
        }

        let coverage_percentage = (covered_lines as f64 / total_lines as f64) * 100.0;

        Ok(CoverageSummary {
            total_lines,
            covered_lines,
            coverage_percentage,
            total_branches: None,
            covered_branches: None,
            branch_percentage: None,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_runtime_coverage_new() {
        let coverage = RustRuntimeCoverage::new();
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }

    #[test]
    fn test_runtime_coverage_default() {
        let coverage = RustRuntimeCoverage;
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }
}