testlint_sdk/profiler/

python.rs

#![allow(dead_code)]

use super::{
    CommonProfileData, FunctionStats, HotFunction, ProfileResult, RuntimeMetrics, StaticMetrics,
};
use chrono::Utc;
use py_spy::{Config, PythonSpy};
use std::collections::HashMap;
use std::path::Path;
use std::process::{Command, Stdio};
use std::thread;
use std::time::Duration;

pub struct PythonProfiler {
    // No static analysis fields needed - only runtime profiling
}

#[derive(Debug, Clone)]
pub struct FunctionLocation {
    pub function_name: String,
    pub filename: String,
    pub line_number: u32,
    pub execution_count: u64,
}

#[derive(Debug)]
pub struct PyCoverageData {
    pub execution_count: HashMap<(String, String, u32), u64>,
    pub hot_functions: Vec<((String, String, u32), u64)>,
    pub total_samples: u64,
    pub function_locations: HashMap<(String, String, u32), FunctionLocation>, // Maps function_key -> location details
    pub lines_executed: HashMap<String, HashMap<u32, u64>>, // filename -> line_number -> count
}

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

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

    fn run_pyspy_continuous(&self, python_script: &str) -> Result<PyCoverageData, String> {
        // Convert to absolute path
        let script_path = Path::new(python_script)
            .canonicalize()
            .map_err(|e| format!("Failed to resolve script path: {}", e))?;

        // Start the Python process
        let mut child = Command::new("python3")
            .arg(&script_path)
            .stdout(Stdio::inherit())
            .stderr(Stdio::inherit())
            .spawn()
            .map_err(|e| format!("Failed to start Python process: {}", e))?;

        let pid = child.id() as py_spy::Pid;

        // Give the process a moment to start and initialize Python runtime
        thread::sleep(Duration::from_millis(500));

        // Create py-spy config
        let config = Config::default();

        // Attach to the running Python process
        let mut spy = PythonSpy::new(pid, &config)
            .map_err(|e| {
                let _ = child.kill(); // Clean up the process
                format!(
                    "Failed to attach py-spy to process {}: {}\n\
                    Note: On macOS/Linux, you may need to run with sudo or adjust security settings.\n\
                    Try: sudo cargo run -- python {}",
                    pid, e, python_script
                )
            })?;

        // Collect samples continuously until process ends or Ctrl+C
        let sample_interval = Duration::from_millis(10); // Sample every 10ms
        let mut execution_count: HashMap<(String, String, u32), u64> = HashMap::new();
        let mut total_samples = 0u64;
        let mut function_locations: HashMap<(String, String, u32), FunctionLocation> =
            HashMap::new();
        let mut lines_executed: HashMap<String, HashMap<u32, u64>> = HashMap::new();

        let mut consecutive_errors = 0;
        let max_consecutive_errors = 10;

        loop {
            // Check if process is still alive
            match child.try_wait() {
                Ok(Some(_status)) => {
                    println!("\nProcess exited. Generating profile...");
                    break;
                }
                Ok(None) => {
                    // Process still running, continue sampling
                }
                Err(_) => {
                    break;
                }
            }

            match spy.get_stack_traces() {
                Ok(traces) => {
                    consecutive_errors = 0; // Reset error counter on success
                    for trace in traces {
                        for frame in &trace.frames {
                            let filename = frame
                                .short_filename
                                .as_ref()
                                .unwrap_or(&frame.filename)
                                .clone();
                            let line_number = frame.line as u32;
                            let func_name = frame.name.clone();
                            let func_key = (func_name.clone(), filename.clone(), line_number);

                            // Track function execution count
                            *execution_count.entry(func_key.clone()).or_insert(0) += 1;
                            total_samples += 1;

                            // Store function location details
                            function_locations
                                .entry(func_key)
                                .or_insert_with(|| FunctionLocation {
                                    function_name: func_name,
                                    filename: filename.clone(),
                                    line_number,
                                    execution_count: 0,
                                })
                                .execution_count += 1;

                            // Track line-level execution
                            lines_executed
                                .entry(filename)
                                .or_default()
                                .entry(line_number)
                                .and_modify(|count| *count += 1)
                                .or_insert(1);
                        }
                    }
                }
                Err(e) => {
                    consecutive_errors += 1;
                    // Only warn on critical errors or after many consecutive failures
                    let error_msg = e.to_string();
                    if !error_msg.contains("timed out")
                        && !error_msg.contains("Operation timed out")
                    {
                        eprintln!("Warning: Failed to get stack trace: {}", e);
                    } else if consecutive_errors >= max_consecutive_errors {
                        eprintln!(
                            "Warning: Multiple consecutive timeouts - process may have exited"
                        );
                        break;
                    }
                    // Timeouts are normal when the process is busy, don't spam warnings
                }
            }

            thread::sleep(sample_interval);
        }

        // Wait for the Python process to finish
        let _ = child.wait();

        // Sort and get hot functions
        let mut hot_functions: Vec<((String, String, u32), u64)> = execution_count
            .iter()
            .map(|(k, v)| (k.clone(), *v))
            .collect();
        hot_functions.sort_by(|a, b| b.1.cmp(&a.1));
        hot_functions.truncate(10);

        Ok(PyCoverageData {
            execution_count,
            hot_functions,
            total_samples,
            function_locations,
            lines_executed,
        })
    }
}

// Removed LanguageProfiler trait - only runtime profiling methods below

impl PythonProfiler {
    // Continuous profiling - runs until interrupted with Ctrl+C
    pub fn profile_continuous(&self, python_script: &str) -> Result<ProfileResult, String> {
        println!("Starting Python continuous runtime profiling with py-spy...");
        println!("Script: {}", python_script);
        println!("Press Ctrl+C to stop and see results...\n");

        // Run py-spy runtime profiling continuously (no duration limit)
        let coverage_data = self.run_pyspy_continuous(python_script)?;

        let mut details = Vec::new();
        details.push("=== Runtime Profile (py-spy) ===".to_string());
        details.push(format!(
            "Total samples collected: {}",
            coverage_data.total_samples
        ));
        details.push(format!(
            "Unique functions executed: {}",
            coverage_data.execution_count.len()
        ));
        details.push(format!(
            "Files covered: {}",
            coverage_data.lines_executed.len()
        ));
        details.push("\nTop 10 Hot Functions:".to_string());

        for (idx, (func_key, count)) in coverage_data.hot_functions.iter().enumerate() {
            let percentage = if coverage_data.total_samples > 0 {
                (*count as f64 / coverage_data.total_samples as f64) * 100.0
            } else {
                0.0
            };

            // Get location details
            if let Some(loc) = coverage_data.function_locations.get(func_key) {
                details.push(format!(
                    "  {}. {}() at {}:{} - {} samples ({:.2}%)",
                    idx + 1,
                    loc.function_name,
                    loc.filename,
                    loc.line_number,
                    count,
                    percentage
                ));
            } else {
                let (name, file, line) = func_key;
                details.push(format!(
                    "  {}. {}:{}:{} - {} samples ({:.2}%)",
                    idx + 1,
                    name,
                    file,
                    line,
                    count,
                    percentage
                ));
            }
        }

        // Add file-level coverage summary
        details.push("\n=== File Coverage Summary ===".to_string());
        let mut file_stats: Vec<(String, usize)> = coverage_data
            .lines_executed
            .iter()
            .map(|(filename, lines)| (filename.clone(), lines.len()))
            .collect();
        file_stats.sort_by(|a, b| b.1.cmp(&a.1));

        for (filename, line_count) in file_stats.iter().take(10) {
            details.push(format!("  {} - {} lines executed", filename, line_count));
        }

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

    // Attach to an existing Python process by PID
    pub fn profile_pid(&self, pid: u32) -> Result<ProfileResult, String> {
        println!("Attaching to Python process PID: {}", pid);
        println!("Profiling until interrupted (Ctrl+C)...\n");

        // Convert to py_spy::Pid type
        let spy_pid = pid as py_spy::Pid;

        // Create py-spy config
        let config = Config::default();

        // Attach to the running Python process
        let mut spy = PythonSpy::new(spy_pid, &config).map_err(|e| {
            format!(
                "Failed to attach py-spy to process {}: {}\n\
                    Note: On macOS/Linux, you may need to run with sudo.\n\
                    Make sure the process ID is valid and the process is running Python.\n\
                    Try: sudo cargo run -- python --pid {}",
                pid, e, pid
            )
        })?;

        println!("✅ Successfully attached to process {}", pid);
        println!("Collecting samples... Press Ctrl+C to stop and see results.\n");

        // Collect samples continuously until Ctrl+C
        let sample_interval = Duration::from_millis(10); // Sample every 10ms
        let mut execution_count: HashMap<(String, String, u32), u64> = HashMap::new();
        let mut total_samples = 0u64;
        let mut function_locations: HashMap<(String, String, u32), FunctionLocation> =
            HashMap::new();
        let mut lines_executed: HashMap<String, HashMap<u32, u64>> = HashMap::new();

        let mut consecutive_errors = 0;
        let max_consecutive_errors = 10;
        let mut samples_without_line_info = 0u64;
        let line_info_check_threshold = 100; // Check after 100 samples

        loop {
            match spy.get_stack_traces() {
                Ok(traces) => {
                    consecutive_errors = 0; // Reset error counter on success
                    for trace in traces {
                        for frame in &trace.frames {
                            let filename = frame
                                .short_filename
                                .as_ref()
                                .unwrap_or(&frame.filename)
                                .clone();
                            let line_number = frame.line as u32;
                            let func_name = frame.name.clone();

                            // Detect missing line number information
                            if line_number == 0 {
                                samples_without_line_info += 1;

                                // After threshold, check if most samples lack line info
                                if total_samples >= line_info_check_threshold {
                                    let missing_percentage = (samples_without_line_info as f64
                                        / total_samples as f64)
                                        * 100.0;
                                    if missing_percentage > 50.0 {
                                        return Err(format!(
                                            "Unable to collect line number information from process {}.\n\
                                            {:.1}% of samples have missing line numbers (line 0).\n\n\
                                            Possible causes:\n\
                                            - Code obfuscation or minification\n\
                                            - Stripped or optimized bytecode (.pyc without line info)\n\
                                            - Non-standard Python runtime (PyPy, Jython, etc.)\n\
                                            - C extensions or compiled modules\n\
                                            - Python built with -O or -OO flags (removes debug info)\n\
                                            - Frozen executables (PyInstaller, cx_Freeze, etc.)\n\n\
                                            Recommendation: Run with standard Python interpreter and unoptimized code.",
                                            pid, missing_percentage
                                        ));
                                    }
                                }
                            }

                            let func_key = (func_name.clone(), filename.clone(), line_number);

                            // Track function execution count
                            *execution_count.entry(func_key.clone()).or_insert(0) += 1;
                            total_samples += 1;

                            // Store function location details
                            function_locations
                                .entry(func_key)
                                .or_insert_with(|| FunctionLocation {
                                    function_name: func_name,
                                    filename: filename.clone(),
                                    line_number,
                                    execution_count: 0,
                                })
                                .execution_count += 1;

                            // Track line-level execution
                            lines_executed
                                .entry(filename)
                                .or_default()
                                .entry(line_number)
                                .and_modify(|count| *count += 1)
                                .or_insert(1);
                        }
                    }
                }
                Err(e) => {
                    consecutive_errors += 1;
                    let error_msg = e.to_string();

                    // Check if process has exited
                    if error_msg.contains("No such process") || error_msg.contains("process") {
                        println!("\n⚠️  Target process has exited. Generating profile...");
                        break;
                    }

                    // Only warn on critical errors or after many consecutive failures
                    if !error_msg.contains("timed out")
                        && !error_msg.contains("Operation timed out")
                    {
                        eprintln!("Warning: Failed to get stack trace: {}", e);
                    } else if consecutive_errors >= max_consecutive_errors {
                        eprintln!(
                            "Warning: Multiple consecutive timeouts - process may have exited"
                        );
                        break;
                    }
                    // Timeouts are normal when the process is busy, don't spam warnings
                }
            }

            thread::sleep(sample_interval);
        }

        // Sort and get hot functions
        let mut hot_functions: Vec<((String, String, u32), u64)> = execution_count
            .iter()
            .map(|(k, v)| (k.clone(), *v))
            .collect();
        hot_functions.sort_by(|a, b| b.1.cmp(&a.1));
        hot_functions.truncate(10);

        // Build result with detailed location information
        let mut details = Vec::new();
        details.push("=== Runtime Profile (py-spy) ===".to_string());
        details.push(format!("Attached to PID: {}", pid));
        details.push(format!("Total samples collected: {}", total_samples));
        details.push(format!(
            "Unique functions executed: {}",
            execution_count.len()
        ));
        details.push(format!("Files covered: {}", lines_executed.len()));
        details.push("\nTop 10 Hot Functions:".to_string());

        for (idx, (func_key, count)) in hot_functions.iter().enumerate() {
            let percentage = if total_samples > 0 {
                (*count as f64 / total_samples as f64) * 100.0
            } else {
                0.0
            };

            // Get location details
            if let Some(loc) = function_locations.get(func_key) {
                details.push(format!(
                    "  {}. {}() at {}:{} - {} samples ({:.2}%)",
                    idx + 1,
                    loc.function_name,
                    loc.filename,
                    loc.line_number,
                    count,
                    percentage
                ));
            } else {
                let (name, file, line) = func_key;
                details.push(format!(
                    "  {}. {}:{}:{} - {} samples ({:.2}%)",
                    idx + 1,
                    name,
                    file,
                    line,
                    count,
                    percentage
                ));
            }
        }

        // Add file-level coverage summary
        details.push("\n=== File Coverage Summary ===".to_string());
        let mut file_stats: Vec<(String, usize)> = lines_executed
            .iter()
            .map(|(filename, lines)| (filename.clone(), lines.len()))
            .collect();
        file_stats.sort_by(|a, b| b.1.cmp(&a.1));

        for (filename, line_count) in file_stats.iter().take(10) {
            details.push(format!("  {} - {} lines executed", filename, line_count));
        }

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

    pub fn profile_to_common_format(
        &self,
        python_script: &str,
    ) -> Result<CommonProfileData, String> {
        println!("Starting Python runtime profiling for JSON export...");

        // Run runtime profiling continuously
        let coverage_data = self.run_pyspy_continuous(python_script)?;

        // Build function stats from runtime data
        let mut function_stats = HashMap::new();

        for ((func_name, filename, line), count) in &coverage_data.execution_count {
            let percentage = if coverage_data.total_samples > 0 {
                (*count as f64 / coverage_data.total_samples as f64) * 100.0
            } else {
                0.0
            };

            let display_name = format!("{}:{}:{}", func_name, filename, line);

            function_stats.insert(
                display_name.clone(),
                FunctionStats {
                    name: display_name,
                    execution_count: *count,
                    percentage,
                    line_number: Some(*line as usize),
                    file_path: Some(filename.clone()),
                },
            );
        }

        let hot_functions: Vec<HotFunction> = coverage_data
            .hot_functions
            .iter()
            .enumerate()
            .map(|(idx, ((name, file, line), samples))| {
                let percentage = if coverage_data.total_samples > 0 {
                    (*samples as f64 / coverage_data.total_samples as f64) * 100.0
                } else {
                    0.0
                };
                HotFunction {
                    rank: idx + 1,
                    name: format!("{}:{}:{}", name, file, line),
                    samples: *samples,
                    percentage,
                }
            })
            .collect();

        let runtime_metrics = RuntimeMetrics {
            total_samples: coverage_data.total_samples,
            execution_duration_secs: 0, // Continuous profiling - duration not limited
            functions_executed: coverage_data.execution_count.len(),
            function_stats,
            hot_functions,
        };

        // Minimal static metrics (not the focus)
        let static_metrics = StaticMetrics {
            file_size_bytes: 0,
            line_count: 0,
            function_count: 0,
            class_count: 0,
            import_count: 0,
            complexity_score: 0,
        };

        Ok(CommonProfileData {
            language: "Python".to_string(),
            source_file: python_script.to_string(),
            timestamp: Utc::now().to_rfc3339(),
            static_analysis: static_metrics,
            runtime_analysis: Some(runtime_metrics),
        })
    }
}

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

    #[test]
    fn test_python_profiler_new() {
        let profiler = PythonProfiler::new();
        // Just verify we can create the profiler
        assert_eq!(std::mem::size_of_val(&profiler), 0); // Zero-sized struct
    }

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

    #[test]
    fn test_py_coverage_data_structure() {
        // Test that we can create and use PyCoverageData
        let mut execution_count = HashMap::new();
        execution_count.insert(("test_function".to_string(), "test.py".to_string(), 10), 10);

        let data = PyCoverageData {
            execution_count,
            hot_functions: vec![(("test_function".to_string(), "test.py".to_string(), 10), 10)],
            total_samples: 10,
            function_locations: HashMap::new(),
            lines_executed: HashMap::new(),
        };

        assert_eq!(data.total_samples, 10);
        assert_eq!(data.hot_functions.len(), 1);
    }

    #[test]
    fn test_function_location_creation() {
        let location = FunctionLocation {
            function_name: "test_func".to_string(),
            filename: "test.py".to_string(),
            line_number: 10,
            execution_count: 5,
        };

        assert_eq!(location.function_name, "test_func");
        assert_eq!(location.filename, "test.py");
        assert_eq!(location.line_number, 10);
        assert_eq!(location.execution_count, 5);
    }
}