testlint_sdk/profiler/

go.rs

#![allow(dead_code)]

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

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

#[derive(Debug)]
pub struct GoPprofData {
    pub execution_count: HashMap<String, u64>,
    pub hot_functions: Vec<(String, u64)>,
    pub total_samples: u64,
}

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

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

// Removed LanguageProfiler trait - only runtime profiling methods below

impl GoProfiler {
    fn instrument_with_pprof_continuous(
        &self,
        original_code: &str,
        profile_file: &Path,
    ) -> Result<String, String> {
        // Parse the original code to add pprof instrumentation
        let lines: Vec<&str> = original_code.lines().collect();
        let mut instrumented = String::new();

        // Find package declaration
        let mut found_package = false;
        let mut found_imports = false;
        let mut in_import_block = false;
        let mut import_end_index = 0;

        for (i, line) in lines.iter().enumerate() {
            let trimmed = line.trim();

            if trimmed.starts_with("package ") {
                found_package = true;
                instrumented.push_str(line);
                instrumented.push('\n');
                continue;
            }

            if found_package && !found_imports {
                if trimmed.starts_with("import (") {
                    in_import_block = true;
                } else if in_import_block && trimmed == ")" {
                    in_import_block = false;
                    found_imports = true;
                    import_end_index = i;
                } else if trimmed.starts_with("import \"") {
                    found_imports = true;
                    import_end_index = i;
                }
            }
        }

        // Add imports if needed
        if !found_imports {
            instrumented.push_str(
                "\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"runtime/pprof\"\n\t\"time\"\n)\n\n",
            );
        } else {
            // Check if we need to add pprof imports
            let has_os = original_code.contains("\"os\"");
            let has_pprof = original_code.contains("\"runtime/pprof\"");
            let has_fmt = original_code.contains("\"fmt\"");
            let has_time = original_code.contains("\"time\"");

            if !has_os || !has_pprof || !has_fmt || !has_time {
                // Need to modify imports
                for (i, line) in lines.iter().enumerate() {
                    if i <= import_end_index {
                        instrumented.push_str(line);
                        instrumented.push('\n');

                        if line.trim().starts_with("import (") {
                            if !has_os {
                                instrumented.push_str("\t\"os\"\n");
                            }
                            if !has_pprof {
                                instrumented.push_str("\t\"runtime/pprof\"\n");
                            }
                            if !has_fmt {
                                instrumented.push_str("\t\"fmt\"\n");
                            }
                            if !has_time {
                                instrumented.push_str("\t\"time\"\n");
                            }
                        }
                    }
                }
            } else {
                for (i, line) in lines.iter().enumerate() {
                    if i <= import_end_index {
                        instrumented.push_str(line);
                        instrumented.push('\n');
                    }
                }
            }
        }

        // Find and wrap main function
        let mut in_main = false;
        let mut brace_count = 0;
        let mut main_start_index = 0;

        for (i, line) in lines.iter().enumerate() {
            if i <= import_end_index {
                continue; // Already processed
            }

            let trimmed = line.trim();

            if !in_main && trimmed.starts_with("func main()") {
                in_main = true;
                main_start_index = i;

                // Add profiling setup before main
                instrumented.push_str("\nfunc main() {\n");
                instrumented.push_str("\t// CPU Profiling setup\n");
                instrumented.push_str(&format!(
                    "\tf, err := os.Create(\"{}\")\n",
                    profile_file.display()
                ));
                instrumented.push_str("\tif err != nil {\n");
                instrumented.push_str(
                    "\t\tfmt.Fprintf(os.Stderr, \"could not create CPU profile: %v\\n\", err)\n",
                );
                instrumented.push_str("\t\tos.Exit(1)\n");
                instrumented.push_str("\t}\n");
                instrumented.push_str("\tdefer f.Close()\n\n");
                instrumented.push_str("\tif err := pprof.StartCPUProfile(f); err != nil {\n");
                instrumented.push_str(
                    "\t\tfmt.Fprintf(os.Stderr, \"could not start CPU profile: %v\\n\", err)\n",
                );
                instrumented.push_str("\t\tos.Exit(1)\n");
                instrumented.push_str("\t}\n");
                instrumented.push_str("\tdefer pprof.StopCPUProfile()\n\n");
                instrumented.push_str("\t// Original main function code\n");

                brace_count = 1; // Opening brace of main
                continue;
            }

            if in_main {
                // Count braces to find end of main
                for c in line.chars() {
                    if c == '{' {
                        brace_count += 1;
                    }
                    if c == '}' {
                        brace_count -= 1;
                    }
                }

                // Add the line (excluding the first func main() { )
                if i > main_start_index {
                    instrumented.push_str(line);
                    instrumented.push('\n');
                }

                if brace_count == 0 {
                    // End of main function
                    break;
                }
            } else {
                // Copy everything before main as-is
                instrumented.push_str(line);
                instrumented.push('\n');
            }
        }

        Ok(instrumented)
    }

    fn parse_pprof_data(&self, profile_path: &str) -> Result<GoPprofData, String> {
        // Use go tool pprof to analyze the profile
        let output = Command::new("go")
            .arg("tool")
            .arg("pprof")
            .arg("-top")
            .arg("-flat")
            .arg(profile_path)
            .output()
            .map_err(|e| format!("Failed to run pprof: {}", e))?;

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

        let pprof_output = String::from_utf8_lossy(&output.stdout);

        let mut execution_count: HashMap<String, u64> = HashMap::new();
        let mut total_samples = 0u64;

        // Parse pprof output format:
        // Showing nodes accounting for 123ms, 95.35% of 129ms total
        //       flat  flat%   sum%        cum   cum%
        //      50ms 38.76% 38.76%       50ms 38.76%  main.fibonacci

        for line in pprof_output.lines() {
            let parts: Vec<&str> = line.split_whitespace().collect();

            // Look for lines with function names (they have 6+ parts)
            if parts.len() >= 6 {
                // Try to parse the flat time (first column)
                if let Some(flat_str) = parts.first() {
                    if flat_str.ends_with("ms") || flat_str.ends_with('s') {
                        // Extract function name (last part)
                        if let Some(func_name) = parts.last() {
                            // Parse the sample count from flat time
                            let count = self.parse_time_to_samples(flat_str);
                            if count > 0 {
                                execution_count.insert(func_name.to_string(), count);
                                total_samples += count;
                            }
                        }
                    }
                }
            }
        }

        // Sort and get hot functions
        let mut hot_functions: Vec<(String, 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(GoPprofData {
            execution_count,
            hot_functions,
            total_samples,
        })
    }

    fn parse_time_to_samples(&self, time_str: &str) -> u64 {
        // Convert time strings like "50ms" or "1.5s" to sample counts
        // Approximate: 1ms ≈ 1 sample
        if time_str.ends_with("ms") {
            time_str
                .trim_end_matches("ms")
                .parse::<f64>()
                .unwrap_or(0.0) as u64
        } else if time_str.ends_with('s') {
            let secs = time_str.trim_end_matches('s').parse::<f64>().unwrap_or(0.0);
            (secs * 1000.0) as u64
        } else {
            0
        }
    }

    pub fn profile_continuous(&self, go_file: &str) -> Result<ProfileResult, String> {
        println!("Starting Go continuous runtime profiling with pprof...");
        println!("File: {}", go_file);
        println!("Press Ctrl+C to stop and see results...\n");

        // Run pprof runtime profiling continuously
        let pprof_data = self.run_go_pprof_continuous(go_file)?;

        let mut details = Vec::new();
        details.push("=== Runtime Profile (pprof) ===".to_string());
        details.push(format!(
            "Total samples collected: {}",
            pprof_data.total_samples
        ));
        details.push(format!(
            "Unique functions executed: {}",
            pprof_data.execution_count.len()
        ));
        details.push("\nTop 10 Hot Functions:".to_string());

        for (idx, (func_name, count)) in pprof_data.hot_functions.iter().enumerate() {
            let percentage = if pprof_data.total_samples > 0 {
                (*count as f64 / pprof_data.total_samples as f64) * 100.0
            } else {
                0.0
            };
            details.push(format!(
                "  {}. {} - {} samples ({:.2}%)",
                idx + 1,
                func_name,
                count,
                percentage
            ));
        }

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

    fn run_go_pprof_continuous(&self, go_file: &str) -> Result<GoPprofData, String> {
        // Check if Go is installed
        let go_check = Command::new("go")
            .arg("version")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status();

        if go_check.is_err() {
            return Err("Go is not installed. Install from: https://go.dev/dl/".to_string());
        }

        // Convert to absolute path
        let script_path = Path::new(go_file)
            .canonicalize()
            .map_err(|e| format!("Failed to resolve script path: {}", e))?;

        // Create a temporary directory for profiling
        let temp_dir = std::env::temp_dir();

        // Use unique filenames to avoid conflicts when multiple profiling sessions run in parallel
        let pid = std::process::id();
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_millis();
        let profile_file = temp_dir.join(format!("go_cpu_profile_{}_{}.prof", pid, timestamp));

        println!("Instrumenting Go program for continuous profiling...");

        // Read the original Go file
        let original_content = fs::read_to_string(&script_path)
            .map_err(|e| format!("Failed to read Go file: {}", e))?;

        // Create an instrumented version with pprof (no duration limit)
        let instrumented =
            self.instrument_with_pprof_continuous(&original_content, &profile_file)?;
        let instrumented_path =
            temp_dir.join(format!("instrumented_main_{}_{}.go", pid, timestamp));
        fs::write(&instrumented_path, instrumented)
            .map_err(|e| format!("Failed to write instrumented file: {}", e))?;

        // Build the instrumented program
        let build_output = temp_dir.join(format!("go_profiler_binary_{}_{}", pid, timestamp));

        println!("Building instrumented Go program...");
        let build_result = Command::new("go")
            .arg("build")
            .arg("-o")
            .arg(&build_output)
            .arg(&instrumented_path)
            .stderr(Stdio::piped())
            .status();

        if let Err(e) = build_result {
            return Err(format!("Failed to build instrumented Go program: {}", e));
        }

        if !build_output.exists() {
            return Err("Go build succeeded but binary not found".to_string());
        }

        println!("Running Go program with continuous CPU profiling...");

        // Run the instrumented program (it will run until completion or Ctrl+C)
        let run_output = Command::new(&build_output)
            .stdout(Stdio::inherit())
            .stderr(Stdio::inherit())
            .status();

        match run_output {
            Ok(status) => {
                if !status.success() && status.code() != Some(0) {
                    // Process was interrupted or failed
                    println!("\nProcess stopped. Generating profile...");
                }
            }
            Err(e) => {
                return Err(format!("Failed to run Go program: {}", e));
            }
        }

        // Give it a moment to finish writing the profile
        thread::sleep(Duration::from_millis(500));

        // Parse the pprof output
        if profile_file.exists() {
            let result = self.parse_pprof_data(profile_file.to_str().unwrap());
            // Clean up
            let _ = fs::remove_file(profile_file);
            let _ = fs::remove_file(instrumented_path);
            let _ = fs::remove_file(build_output);
            result
        } else {
            Err("Profile data was not generated".to_string())
        }
    }

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

        // Run continuous profiling
        let pprof_data = self.run_go_pprof_continuous(go_file)?;

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

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

            function_stats.insert(
                func_name.clone(),
                FunctionStats {
                    name: func_name.clone(),
                    execution_count: *count,
                    percentage,
                    line_number: None,
                    file_path: None,
                },
            );
        }

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

        let runtime_metrics = RuntimeMetrics {
            total_samples: pprof_data.total_samples,
            execution_duration_secs: 0, // Continuous profiling - duration not limited
            functions_executed: pprof_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: "Go".to_string(),
            source_file: go_file.to_string(),
            timestamp: Utc::now().to_rfc3339(),
            static_analysis: static_metrics,
            runtime_analysis: Some(runtime_metrics),
        })
    }

    /// Profile by attaching to PID (not supported - Go processes need pprof HTTP endpoint)
    pub fn profile_pid(&self, pid: u32) -> Result<ProfileResult, String> {
        println!("🔍 Attempting to attach to Go process PID: {}", pid);

        // Go doesn't support direct PID attachment like Python
        // But we can try to connect to pprof HTTP endpoint if available

        // First, try common pprof ports
        for port in [6060, 6061, 6062, 6063, 6064] {
            if let Ok(profile_data) = self.fetch_pprof_from_http(pid, port) {
                println!(
                    "✓ Successfully connected to pprof endpoint on port {}",
                    port
                );
                return Ok(profile_data);
            }
        }

        Err(format!(
            "Could not attach to Go process PID {}.\n\
            \n\
            Go profiling requires the process to expose an HTTP pprof endpoint.\n\
            \n\
            To enable profiling in your Go application:\n\
            \n\
            1. Import net/http/pprof in your code:\n\
               import _ \"net/http/pprof\"\n\
            \n\
            2. Start an HTTP server:\n\
               go func() {{\n\
                   log.Println(http.ListenAndServe(\"localhost:6060\", nil))\n\
               }}()\n\
            \n\
            3. Then profile using:\n\
               go tool pprof http://localhost:6060/debug/pprof/profile\n\
            \n\
            Or use the profiler binary on a .go file to instrument and profile from the start.",
            pid
        ))
    }

    /// Try to fetch pprof data from HTTP endpoint
    fn fetch_pprof_from_http(&self, pid: u32, port: u16) -> Result<ProfileResult, String> {
        use std::net::TcpStream;

        // Test if port is open
        if TcpStream::connect(format!("127.0.0.1:{}", port)).is_err() {
            return Err(format!("Port {} not open", port));
        }

        println!(
            "📊 Fetching profile from http://localhost:{}/debug/pprof/profile",
            port
        );

        // Use curl or wget to fetch 30-second CPU profile
        let profile_file = format!("/tmp/go-profile-{}.pprof", pid);

        let output = Command::new("curl")
            .args([
                "-s",
                "-o",
                &profile_file,
                &format!("http://localhost:{}/debug/pprof/profile?seconds=30", port),
            ])
            .output()
            .map_err(|e| format!("Failed to fetch profile: {}", e))?;

        if !output.status.success() {
            return Err("Failed to download pprof data".to_string());
        }

        // Wait for profile collection (30 seconds)
        println!("⏳ Collecting 30-second CPU profile...");
        thread::sleep(Duration::from_secs(31));

        // Parse the pprof file
        if Path::new(&profile_file).exists() {
            let pprof_data = self.parse_pprof_data(&profile_file)?;
            let _ = fs::remove_file(&profile_file);

            // Convert to ProfileResult
            let mut details = Vec::new();
            details.push(format!("=== Go Profile via HTTP pprof (PID: {}) ===", pid));
            details.push(format!("Total samples: {}", pprof_data.total_samples));
            details.push(format!(
                "Unique functions: {}",
                pprof_data.execution_count.len()
            ));
            details.push("\nTop 10 Hot Functions:".to_string());

            for (idx, (func_name, count)) in pprof_data.hot_functions.iter().enumerate() {
                let percentage = if pprof_data.total_samples > 0 {
                    (*count as f64 / pprof_data.total_samples as f64) * 100.0
                } else {
                    0.0
                };
                details.push(format!(
                    "  {}. {} - {} samples ({:.2}%)",
                    idx + 1,
                    func_name,
                    count,
                    percentage
                ));

                if idx >= 9 {
                    break;
                }
            }

            Ok(ProfileResult {
                language: "Go".to_string(),
                details,
            })
        } else {
            Err("Profile file not created".to_string())
        }
    }
}

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

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

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