testlint_sdk/profiler/

rust.rs

#![allow(dead_code)]

use crate::profiler::ProfileResult;
use std::fs;
use std::path::Path;
use std::process::{Command, Stdio};

pub struct RustProfiler;

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

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

    /// Continuous profiling of Rust applications using platform-specific profilers
    /// Runs until the process exits or is interrupted
    pub fn profile_continuous(&self, rust_file_or_bin: &str) -> Result<ProfileResult, String> {
        println!("🦀 Starting Rust runtime profiling...");

        // Try platform-specific profilers first
        #[cfg(target_os = "macos")]
        {
            println!("📝 macOS detected - using sample/Instruments for profiling");
            self.profile_macos(rust_file_or_bin)
        }

        #[cfg(target_os = "windows")]
        {
            println!("📝 Windows detected - using Windows Performance Recorder");
            self.profile_windows(rust_file_or_bin)
        }

        // Linux: use cargo-flamegraph (which uses perf under the hood)
        #[cfg(target_os = "linux")]
        {
            println!("📝 Linux detected - using cargo-flamegraph (perf-based)");

            // Check if cargo-flamegraph is installed
            if !self.is_flamegraph_installed() {
                println!("⚠️  cargo-flamegraph not found. Attempting to install...");
                self.install_flamegraph()?;
            }

            let path = Path::new(rust_file_or_bin);
            let is_source = path.extension().is_some_and(|ext| ext == "rs");

            if is_source {
                self.profile_rust_source(rust_file_or_bin)
            } else {
                self.profile_rust_binary(rust_file_or_bin)
            }
        }

        #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
        {
            Err("Rust profiling is not supported on this platform".to_string())
        }
    }

    /// Profile a Rust source file (compile and run with profiling)
    fn profile_rust_source(&self, _rust_file: &str) -> Result<ProfileResult, String> {
        println!("🔨 Building Rust project with profiling...");

        // Check if it's a Cargo project
        if Path::new("Cargo.toml").exists() {
            // Run cargo flamegraph
            let mut cmd = Command::new("cargo");
            cmd.arg("flamegraph");
            cmd.arg("--bin");

            // Try to infer binary name from Cargo.toml
            let bin_name = self.get_binary_name()?;
            cmd.arg(&bin_name);

            println!("Running: cargo flamegraph --bin {}", bin_name);
            println!("Press Ctrl+C to stop profiling and generate flamegraph...");

            let output = cmd
                .output()
                .map_err(|e| format!("Failed to run cargo flamegraph: {}", e))?;

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

            self.parse_flamegraph_output()
        } else {
            Err("Not a Cargo project. Please run from a Cargo project directory.".to_string())
        }
    }

    /// Profile a Rust binary executable
    fn profile_rust_binary(&self, binary_path: &str) -> Result<ProfileResult, String> {
        println!("🚀 Profiling Rust binary: {}", binary_path);

        let mut cmd = Command::new("cargo");
        cmd.arg("flamegraph");
        cmd.arg("--");
        cmd.arg(binary_path);

        println!("Running: cargo flamegraph -- {}", binary_path);
        println!("Press Ctrl+C to stop profiling and generate flamegraph...");

        let output = cmd
            .output()
            .map_err(|e| format!("Failed to run cargo flamegraph: {}", e))?;

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

        self.parse_flamegraph_output()
    }

    /// Check if cargo-flamegraph is installed
    fn is_flamegraph_installed(&self) -> bool {
        Command::new("cargo")
            .arg("flamegraph")
            .arg("--help")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status()
            .is_ok()
    }

    /// Install cargo-flamegraph
    fn install_flamegraph(&self) -> Result<(), String> {
        println!("Installing cargo-flamegraph...");

        let output = Command::new("cargo")
            .args(["install", "flamegraph"])
            .output()
            .map_err(|e| format!("Failed to install cargo-flamegraph: {}", e))?;

        if !output.status.success() {
            return Err(format!(
                "Failed to install cargo-flamegraph: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        println!("✓ cargo-flamegraph installed successfully");
        Ok(())
    }

    /// Get binary name from Cargo.toml
    fn get_binary_name(&self) -> Result<String, String> {
        let cargo_toml = fs::read_to_string("Cargo.toml")
            .map_err(|e| format!("Failed to read Cargo.toml: {}", e))?;

        // Simple parsing - look for package.name
        for line in cargo_toml.lines() {
            if line.trim().starts_with("name") {
                if let Some(name) = line.split('=').nth(1) {
                    let name = name.trim().trim_matches('"').trim_matches('\'');
                    return Ok(name.to_string());
                }
            }
        }

        Err("Could not determine binary name from Cargo.toml".to_string())
    }

    /// Profile on macOS using sample command
    #[cfg(target_os = "macos")]
    fn profile_macos(&self, binary: &str) -> Result<ProfileResult, String> {
        println!("🍎 Profiling on macOS using 'sample' command...");

        let output_file = "rust_profile.txt";

        // First, build the binary if it's a Cargo project
        let binary_path = if Path::new("Cargo.toml").exists() {
            println!("Building Rust project...");
            let build_output = Command::new("cargo")
                .args(["build", "--release"])
                .output()
                .map_err(|e| format!("Failed to build: {}", e))?;

            if !build_output.status.success() {
                return Err(format!(
                    "Build failed: {}",
                    String::from_utf8_lossy(&build_output.stderr)
                ));
            }

            let bin_name = self.get_binary_name()?;
            format!("target/release/{}", bin_name)
        } else {
            binary.to_string()
        };

        println!("Running: sample {} 10 -file {}", binary_path, output_file);
        println!("Profiling for 10 seconds...");

        let mut cmd = Command::new("sample");
        cmd.arg(&binary_path);
        cmd.arg("10"); // Sample for 10 seconds
        cmd.arg("-file");
        cmd.arg(output_file);

        let output = cmd
            .output()
            .map_err(|e| format!("Failed to run sample command: {}", e))?;

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

        Ok(ProfileResult {
            language: "Rust".to_string(),
            details: vec![
                "✓ Profiling completed successfully".to_string(),
                format!("📊 Profile data saved to {}", output_file),
                "".to_string(),
                "macOS 'sample' command output includes:".to_string(),
                "  - Call tree showing function hierarchy".to_string(),
                "  - Sample counts per function".to_string(),
                "  - Binary image information".to_string(),
                "".to_string(),
                format!("To view the profile: open {}", output_file),
                "".to_string(),
                "For GUI profiling, use Instruments:".to_string(),
                format!("  instruments -t 'Time Profiler' {}", binary_path),
            ],
        })
    }

    #[cfg(not(target_os = "macos"))]
    #[allow(dead_code)]
    fn profile_macos(&self, _binary: &str) -> Result<ProfileResult, String> {
        Err("macOS profiling is only available on macOS".to_string())
    }

    /// Profile on Windows using Windows Performance Recorder
    #[cfg(target_os = "windows")]
    fn profile_windows(&self, binary: &str) -> Result<ProfileResult, String> {
        println!("🪟 Profiling on Windows using Windows Performance Recorder...");

        let output_file = "rust_profile.etl";

        // First, build the binary if it's a Cargo project
        let binary_path = if Path::new("Cargo.toml").exists() {
            println!("Building Rust project...");
            let build_output = Command::new("cargo")
                .args(["build", "--release"])
                .output()
                .map_err(|e| format!("Failed to build: {}", e))?;

            if !build_output.status.success() {
                return Err(format!(
                    "Build failed: {}",
                    String::from_utf8_lossy(&build_output.stderr)
                ));
            }

            let bin_name = self.get_binary_name()?;
            format!("target\\release\\{}.exe", bin_name)
        } else {
            binary.to_string()
        };

        println!("Starting Windows Performance Recorder...");
        println!("Run your application, then press Ctrl+C to stop recording.");

        // Start recording
        let mut cmd = Command::new("wpr");
        cmd.args(["-start", "CPU"]);

        let output = cmd
            .output()
            .map_err(|e| format!("Failed to start WPR: {}. Is WPR installed?", e))?;

        if !output.status.success() {
            return Err(format!(
                "WPR failed to start: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        println!("Recording started. Running {}...", binary_path);

        // Run the application
        let app_output = Command::new(&binary_path)
            .output()
            .map_err(|e| format!("Failed to run application: {}", e))?;

        if !app_output.status.success() {
            println!(
                "⚠️  Application exited with error: {}",
                String::from_utf8_lossy(&app_output.stderr)
            );
        }

        // Stop recording
        println!("Stopping Windows Performance Recorder...");
        let mut stop_cmd = Command::new("wpr");
        stop_cmd.args(["-stop", output_file]);

        let stop_output = stop_cmd
            .output()
            .map_err(|e| format!("Failed to stop WPR: {}", e))?;

        if !stop_output.status.success() {
            return Err(format!(
                "WPR failed to stop: {}",
                String::from_utf8_lossy(&stop_output.stderr)
            ));
        }

        Ok(ProfileResult {
            language: "Rust".to_string(),
            details: vec![
                "✓ Profiling completed successfully".to_string(),
                format!("📊 Profile data saved to {}", output_file),
                "".to_string(),
                "To analyze the profile with Windows Performance Analyzer (WPA):".to_string(),
                format!("  wpa {}", output_file),
                "".to_string(),
                "WPA provides:".to_string(),
                "  - Detailed CPU usage analysis".to_string(),
                "  - Call stacks and flame graphs".to_string(),
                "  - Function-level performance metrics".to_string(),
                "".to_string(),
                "Note: WPA is part of the Windows Performance Toolkit".to_string(),
                "  Download from: https://docs.microsoft.com/en-us/windows-hardware/get-started/adk-install".to_string(),
            ],
        })
    }

    #[cfg(not(target_os = "windows"))]
    #[allow(dead_code)]
    fn profile_windows(&self, _binary: &str) -> Result<ProfileResult, String> {
        Err("Windows profiling is only available on Windows".to_string())
    }

    /// Parse flamegraph output and create ProfileResult
    fn parse_flamegraph_output(&self) -> Result<ProfileResult, String> {
        let flamegraph_path = "flamegraph.svg";

        if !Path::new(flamegraph_path).exists() {
            return Err("Flamegraph not generated. Profiling may have failed.".to_string());
        }

        let mut details = vec![
            "✓ Profiling completed successfully".to_string(),
            format!("📊 Flamegraph generated: {}", flamegraph_path),
            "".to_string(),
            "To view the flamegraph:".to_string(),
            format!("  open {}", flamegraph_path),
            "".to_string(),
            "Flamegraph shows:".to_string(),
            "  - Function call hierarchy (vertical axis)".to_string(),
            "  - Time spent in each function (horizontal width)".to_string(),
            "  - Hot functions appear wider".to_string(),
        ];

        // Try to get some basic stats from the SVG
        if let Ok(svg_content) = fs::read_to_string(flamegraph_path) {
            // Count number of function frames
            let frame_count = svg_content.matches("<g class=\"func_g\"").count();
            details.push("".to_string());
            details.push(format!("📈 Total function frames: {}", frame_count));
        }

        Ok(ProfileResult {
            language: "Rust".to_string(),
            details,
        })
    }

    /// Profile by attaching to PID (using perf on Linux)
    pub fn profile_pid(&self, _pid: u32) -> Result<ProfileResult, String> {
        #[cfg(target_os = "linux")]
        {
            println!("🔍 Attaching to Rust process PID: {}", _pid);

            // Use perf record to profile the process
            let mut cmd = Command::new("perf");
            cmd.args(["record", "-F", "99", "-p", &_pid.to_string(), "-g"]);

            println!("Running: perf record -F 99 -p {} -g", _pid);
            println!("Press Ctrl+C to stop profiling...");

            let output = cmd
                .output()
                .map_err(|e| format!("Failed to run perf: {}. Is perf installed?", e))?;

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

            Ok(ProfileResult {
                language: "Rust".to_string(),
                details: vec![
                    "✓ Profiling completed successfully".to_string(),
                    "📊 Profile data saved to perf.data".to_string(),
                    "".to_string(),
                    "To view the profile:".to_string(),
                    "  perf report".to_string(),
                    "".to_string(),
                    "Or generate a flamegraph:".to_string(),
                    "  perf script | stackcollapse-perf.pl | flamegraph.pl > flamegraph.svg"
                        .to_string(),
                ],
            })
        }

        #[cfg(not(target_os = "linux"))]
        {
            Err("PID profiling for Rust is only supported on Linux (requires perf)".to_string())
        }
    }
}

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

    #[test]
    fn test_profiler_new() {
        let profiler = RustProfiler::new();
        assert_eq!(std::mem::size_of_val(&profiler), 0);
    }

    #[test]
    fn test_profiler_default() {
        let profiler = RustProfiler;
        assert_eq!(std::mem::size_of_val(&profiler), 0);
    }
}