testlint_sdk/profiler/

ruby.rs

#![allow(dead_code)]

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

pub struct RubyProfiler;

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

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

    /// Continuous profiling of Ruby applications using rbspy
    pub fn profile_continuous(&self, ruby_file: &str) -> Result<ProfileResult, String> {
        println!("💎 Starting Ruby runtime profiling...");
        println!("📝 Note: This uses rbspy for CPU profiling");

        // Check if rbspy is installed
        if !self.is_rbspy_installed() {
            return Err("rbspy not found. Please install it:\n\
                 - macOS: brew install rbspy\n\
                 - Linux: cargo install rbspy\n\
                 - Or download from: https://rbspy.github.io/"
                .to_string());
        }

        self.profile_with_rbspy(ruby_file)
    }

    /// Profile Ruby script using rbspy
    fn profile_with_rbspy(&self, ruby_file: &str) -> Result<ProfileResult, String> {
        println!("🚀 Profiling Ruby script: {}", ruby_file);

        let flamegraph_file = "rbspy-flamegraph.svg";

        let mut cmd = Command::new("rbspy");
        cmd.args([
            "record",
            "--file",
            flamegraph_file,
            "--format",
            "flamegraph",
            "--",
            "ruby",
            ruby_file,
        ]);

        println!(
            "Running: rbspy record --file {} --format flamegraph -- ruby {}",
            flamegraph_file, ruby_file
        );
        println!("Profiling until script exits...");

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

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);

            // Check for permission errors
            if stderr.contains("permission") || stderr.contains("Operation not permitted") {
                return Err(
                    "Permission denied. rbspy may require elevated privileges.\n\
                     Try running with: sudo -E env PATH=$PATH <your command>"
                        .to_string(),
                );
            }

            return Err(format!("rbspy failed: {}", stderr));
        }

        self.parse_rbspy_output(flamegraph_file)
    }

    /// Check if rbspy is installed
    fn is_rbspy_installed(&self) -> bool {
        Command::new("rbspy")
            .arg("--version")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status()
            .is_ok()
    }

    /// Parse rbspy output and create ProfileResult
    fn parse_rbspy_output(&self, flamegraph_file: &str) -> Result<ProfileResult, String> {
        if !Path::new(flamegraph_file).exists() {
            return Err("Flamegraph not generated. Profiling may have failed.".to_string());
        }

        let file_size = fs::metadata(flamegraph_file).map(|m| m.len()).unwrap_or(0);

        let mut details = vec![
            "✓ Profiling completed successfully".to_string(),
            format!("📊 Flamegraph generated: {}", flamegraph_file),
            format!("   Size: {} bytes", file_size),
            "".to_string(),
            "To view the flamegraph:".to_string(),
            format!("  open {}", flamegraph_file),
            "".to_string(),
            "Flamegraph shows:".to_string(),
            "  - Ruby method call hierarchy (vertical axis)".to_string(),
            "  - Time spent in each method (horizontal width)".to_string(),
            "  - Hot methods appear wider".to_string(),
            "  - Includes C extension calls".to_string(),
        ];

        // Try to get some basic stats from stdout
        if let Ok(svg_content) = fs::read_to_string(flamegraph_file) {
            let frame_count = svg_content.matches("<g class=\"func_g\"").count();
            if frame_count > 0 {
                details.push("".to_string());
                details.push(format!("📈 Total method frames: {}", frame_count));
            }
        }

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

    /// Profile by attaching to PID
    pub fn profile_pid(&self, pid: u32) -> Result<ProfileResult, String> {
        println!("🔍 Attaching to Ruby process PID: {}", pid);

        if !self.is_rbspy_installed() {
            return Err("rbspy not found. Please install it:\n\
                 - macOS: brew install rbspy\n\
                 - Linux: cargo install rbspy\n\
                 - Or download from: https://rbspy.github.io/"
                .to_string());
        }

        let flamegraph_file = format!("rbspy-pid-{}.svg", pid);

        let mut cmd = Command::new("rbspy");
        cmd.args([
            "record",
            "--pid",
            &pid.to_string(),
            "--file",
            &flamegraph_file,
            "--format",
            "flamegraph",
        ]);

        println!(
            "Running: rbspy record --pid {} --file {} --format flamegraph",
            pid, flamegraph_file
        );
        println!("Press Ctrl+C to stop profiling...");

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

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);

            if stderr.contains("permission") || stderr.contains("Operation not permitted") {
                return Err(
                    "Permission denied. rbspy may require elevated privileges.\n\
                     Try running with: sudo -E env PATH=$PATH <your command>"
                        .to_string(),
                );
            }

            return Err(format!("rbspy failed: {}", stderr));
        }

        self.parse_rbspy_output(&flamegraph_file)
    }
}

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

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

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