testlint_sdk/profiler/

php.rs

#![allow(dead_code)]

use crate::profiler::ProfileResult;
use std::fs;
use std::process::Command;

pub struct PhpProfiler;

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

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

    /// Continuous profiling of PHP applications using Xdebug
    pub fn profile_continuous(&self, php_file: &str) -> Result<ProfileResult, String> {
        println!("🐘 Starting PHP runtime profiling...");
        println!("📝 Note: This uses Xdebug profiler mode");

        // Check if Xdebug is installed
        if !self.is_xdebug_installed() {
            return Err("Xdebug not found. Please install it:\n\
                 - PECL: pecl install xdebug\n\
                 - Or see: https://xdebug.org/docs/install"
                .to_string());
        }

        self.profile_with_xdebug(php_file)
    }

    /// Profile PHP script using Xdebug
    fn profile_with_xdebug(&self, php_file: &str) -> Result<ProfileResult, String> {
        println!("🚀 Profiling PHP script: {}", php_file);

        // Create output directory for cachegrind files
        let output_dir = "xdebug_profile";
        fs::create_dir_all(output_dir)
            .map_err(|e| format!("Failed to create output directory: {}", e))?;

        // Run PHP with Xdebug profiling enabled
        let mut cmd = Command::new("php");
        cmd.args([
            "-d",
            "xdebug.mode=profile",
            "-d",
            &format!("xdebug.output_dir={}", output_dir),
            "-d",
            "xdebug.profiler_output_name=cachegrind.out.%p",
            php_file,
        ]);

        println!("Running: php -d xdebug.mode=profile {}", php_file);
        println!("Profiling until script exits...");

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

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

        // Show output from the script
        let stdout = String::from_utf8_lossy(&output.stdout);
        if !stdout.is_empty() {
            println!("\n--- Script Output ---");
            println!("{}", stdout);
            println!("--- End Output ---\n");
        }

        self.parse_xdebug_output(output_dir)
    }

    /// Check if Xdebug is installed
    fn is_xdebug_installed(&self) -> bool {
        let output = Command::new("php").args(["-m"]).output();

        if let Ok(output) = output {
            let modules = String::from_utf8_lossy(&output.stdout);
            return modules.contains("Xdebug") || modules.contains("xdebug");
        }

        false
    }

    /// Parse Xdebug output and create ProfileResult
    fn parse_xdebug_output(&self, output_dir: &str) -> Result<ProfileResult, String> {
        // Find the cachegrind file
        let cachegrind_file = self.find_cachegrind_file(output_dir)?;

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

        // Try to extract some basic stats from cachegrind file
        let stats = self.analyze_cachegrind(&cachegrind_file)?;

        let mut details = vec![
            "✓ Profiling completed successfully".to_string(),
            format!("📊 Cachegrind file generated: {}", cachegrind_file),
            format!("   Size: {} bytes", file_size),
            "".to_string(),
        ];

        details.extend(stats);

        details.extend(vec![
            "".to_string(),
            "To analyze the profile:".to_string(),
            "".to_string(),
            "1. Using KCacheGrind (Linux/macOS):".to_string(),
            format!("   kcachegrind {}", cachegrind_file),
            "".to_string(),
            "2. Using QCacheGrind (macOS):".to_string(),
            "   brew install qcachegrind".to_string(),
            format!("   qcachegrind {}", cachegrind_file),
            "".to_string(),
            "3. Using WinCacheGrind (Windows):".to_string(),
            "   Download from: https://sourceforge.net/projects/wincachegrind/".to_string(),
            "".to_string(),
            "Cachegrind file contains:".to_string(),
            "  - Function call counts".to_string(),
            "  - Time spent in each function".to_string(),
            "  - Call graph relationships".to_string(),
            "  - Memory usage (if enabled)".to_string(),
        ]);

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

    /// Find the cachegrind file in output directory
    fn find_cachegrind_file(&self, output_dir: &str) -> Result<String, String> {
        let entries = fs::read_dir(output_dir)
            .map_err(|e| format!("Failed to read output directory: {}", e))?;

        for entry in entries.flatten() {
            if let Some(name) = entry.file_name().to_str() {
                if name.starts_with("cachegrind.out") {
                    return Ok(format!("{}/{}", output_dir, name));
                }
            }
        }

        Err("No cachegrind file found. Profiling may have failed.".to_string())
    }

    /// Analyze cachegrind file for basic stats
    fn analyze_cachegrind(&self, cachegrind_file: &str) -> Result<Vec<String>, String> {
        let content = fs::read_to_string(cachegrind_file)
            .map_err(|e| format!("Failed to read cachegrind file: {}", e))?;

        let mut function_count = 0;
        let mut total_calls = 0;

        for line in content.lines() {
            if line.starts_with("fn=") {
                function_count += 1;
            } else if line.starts_with("calls=") {
                if let Some(calls_str) = line.split('=').nth(1) {
                    if let Ok(calls) = calls_str
                        .split_whitespace()
                        .next()
                        .unwrap_or("0")
                        .parse::<u64>()
                    {
                        total_calls += calls;
                    }
                }
            }
        }

        Ok(vec![
            "Profile Statistics:".to_string(),
            format!("  - Functions profiled: {}", function_count),
            format!("  - Total function calls: {}", total_calls),
        ])
    }

    /// Profile by attaching to PID (not supported for PHP)
    pub fn profile_pid(&self, _pid: u32) -> Result<ProfileResult, String> {
        Err("PID profiling is not supported for PHP.\n\
             PHP profiling requires running the script with Xdebug enabled from the start."
            .to_string())
    }
}

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

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

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