testlint_sdk/profiler/

java.rs

#![allow(dead_code)]

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

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

pub struct JavaProfiler {}

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

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

    fn run_java_profiler(&self, java_file: &str) -> Result<JavaProfileData, String> {
        // Check if Java is installed
        let java_check = Command::new("java")
            .arg("-version")
            .stderr(Stdio::piped())
            .output();

        if java_check.is_err() {
            return Err("Java is not installed. Install from: https://adoptium.net/ or https://www.oracle.com/java/".to_string());
        }

        // Parse Java file path
        let script_path = Path::new(java_file)
            .canonicalize()
            .map_err(|e| format!("Failed to resolve script path: {}", e))?;

        // Check if it's a .java source file or .jar file
        let is_jar = script_path
            .extension()
            .and_then(|ext| ext.to_str())
            .map(|ext| ext == "jar")
            .unwrap_or(false);

        let is_class = script_path
            .extension()
            .and_then(|ext| ext.to_str())
            .map(|ext| ext == "class")
            .unwrap_or(false);

        // For .java files, we need to compile first
        let class_file = if !is_jar && !is_class {
            println!("Compiling Java source file...");
            let compile_output = Command::new("javac")
                .arg(&script_path)
                .output()
                .map_err(|e| format!("Failed to compile Java file: {}", e))?;

            if !compile_output.status.success() {
                let stderr = String::from_utf8_lossy(&compile_output.stderr);
                return Err(format!("Java compilation failed:\n{}", stderr));
            }

            // Derive class file path
            script_path.with_extension("class")
        } else {
            script_path.clone()
        };

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

        // Use unique filename 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_filename = format!("java_profile_{}_{}.jfr", pid, timestamp);
        let profile_file = temp_dir.join(&profile_filename);

        // Record existing .jfr files before starting
        let existing_profiles: HashSet<PathBuf> = fs::read_dir(&temp_dir)
            .ok()
            .map(|entries| {
                entries
                    .filter_map(|e| e.ok())
                    .map(|e| e.path())
                    .filter(|p| {
                        p.extension()
                            .and_then(|ext| ext.to_str())
                            .map(|ext| ext == "jfr")
                            .unwrap_or(false)
                    })
                    .collect()
            })
            .unwrap_or_default();

        println!("Starting Java process with JFR (Java Flight Recorder)...");

        // Determine the main class name
        let main_class = if is_jar {
            // For JAR files, use -jar
            script_path.to_str().unwrap().to_string()
        } else if is_class {
            // For .class files, extract class name
            script_path
                .file_stem()
                .and_then(|s| s.to_str())
                .unwrap_or("Main")
                .to_string()
        } else {
            // For .java files, extract class name
            script_path
                .file_stem()
                .and_then(|s| s.to_str())
                .unwrap_or("Main")
                .to_string()
        };

        // Build Java command with JFR options
        let mut java_cmd = Command::new("java");

        // Add JFR options (works with Java 8+ but improved in Java 11+)
        // Java 8 requires UnlockCommercialFeatures, Java 11+ does not
        java_cmd
            .arg("-XX:+UnlockCommercialFeatures") // Required for Java 8, ignored in Java 11+
            .arg("-XX:+FlightRecorder") // Enable Flight Recorder
            .arg("-XX:+UnlockDiagnosticVMOptions")
            .arg("-XX:+DebugNonSafepoints")
            .arg(format!(
                "-XX:StartFlightRecording=filename={},dumponexit=true,settings=profile",
                profile_file.display()
            ));

        if is_jar {
            java_cmd.arg("-jar").arg(&main_class);
        } else {
            // Set classpath to the directory containing the class file
            if let Some(parent) = class_file.parent() {
                java_cmd.arg("-cp").arg(parent);
            }
            java_cmd.arg(&main_class);
        }

        // Run the Java program
        let output = java_cmd
            .stdout(Stdio::inherit())
            .stderr(Stdio::piped())
            .output()
            .map_err(|e| format!("Failed to start Java process: {}", e))?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Err(format!("Java process failed:\n{}", stderr));
        }

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

        // Find the generated JFR file
        let actual_profile = if profile_file.exists() {
            Some(profile_file.clone())
        } else {
            // Look for NEW .jfr files (not in the existing set)
            fs::read_dir(&temp_dir).ok().and_then(|entries| {
                entries.filter_map(|e| e.ok()).map(|e| e.path()).find(|p| {
                    p.extension()
                        .and_then(|ext| ext.to_str())
                        .map(|ext| ext == "jfr")
                        .unwrap_or(false)
                        && !existing_profiles.contains(p)
                })
            })
        };

        match actual_profile {
            Some(profile_path) => {
                let result = self.parse_jfr_profile(profile_path.to_str().unwrap());
                // Clean up
                let _ = fs::remove_file(&profile_path);
                result
            }
            None => {
                Err("JFR profile was not generated. Make sure your Java version supports JFR (Java 8+ with commercial features, or Java 11+ free)".to_string())
            }
        }
    }

    fn parse_jfr_profile(&self, profile_path: &str) -> Result<JavaProfileData, String> {
        println!("Parsing JFR profile...");

        // JFR files are binary format, we need to convert them to JSON using jfr tool
        // jfr command is available in JDK 9+ (or with Mission Control in JDK 8)

        let json_output = Command::new("jfr")
            .arg("print")
            .arg("--json")
            .arg(profile_path)
            .output();

        match json_output {
            Ok(output) if output.status.success() => {
                let json_str = String::from_utf8_lossy(&output.stdout);
                self.parse_jfr_json(&json_str)
            }
            Ok(_) => {
                // jfr command failed, try alternative: jcmd or jmc
                println!("⚠️  'jfr' command not available or failed");
                println!("   JFR profile created but parsing requires JDK 9+ jfr tool");
                println!("   Returning basic profile data");

                // Return minimal data
                Ok(JavaProfileData {
                    execution_count: HashMap::new(),
                    hot_functions: Vec::new(),
                    total_samples: 0,
                })
            }
            Err(_) => {
                println!("⚠️  Could not parse JFR file (jfr command not found)");
                println!("   Install JDK 9+ for full profiling support");
                println!("   Or use: jcmd <pid> JFR.dump filename=profile.jfr");

                Ok(JavaProfileData {
                    execution_count: HashMap::new(),
                    hot_functions: Vec::new(),
                    total_samples: 0,
                })
            }
        }
    }

    fn parse_jfr_json(&self, json_str: &str) -> Result<JavaProfileData, String> {
        // Parse JFR JSON format
        // JFR events include: jdk.ExecutionSample, jdk.MethodSample, etc.

        let json_value: Value = serde_json::from_str(json_str)
            .map_err(|e| format!("Failed to parse JFR JSON: {}", e))?;

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

        // JFR JSON has "recording" -> "events" structure
        if let Some(recording) = json_value.get("recording") {
            if let Some(events) = recording.get("events").and_then(|e| e.as_array()) {
                for event in events {
                    // Look for ExecutionSample or MethodSample events
                    if let Some(event_type) = event.get("type").and_then(|t| t.as_str()) {
                        if event_type.contains("ExecutionSample")
                            || event_type.contains("MethodSample")
                        {
                            // Extract stack trace
                            if let Some(stack_trace) = event.get("stackTrace") {
                                if let Some(frames) =
                                    stack_trace.get("frames").and_then(|f| f.as_array())
                                {
                                    for frame in frames {
                                        if let Some(method) = frame.get("method") {
                                            let class_name = method
                                                .get("type")
                                                .and_then(|t| t.get("name"))
                                                .and_then(|n| n.as_str())
                                                .unwrap_or("Unknown");

                                            let method_name = method
                                                .get("name")
                                                .and_then(|n| n.as_str())
                                                .unwrap_or("unknown");

                                            let line_number = frame
                                                .get("lineNumber")
                                                .and_then(|l| l.as_i64())
                                                .unwrap_or(-1);

                                            let func_identifier = if line_number > 0 {
                                                format!(
                                                    "{}.{}:{}",
                                                    class_name, method_name, line_number
                                                )
                                            } else {
                                                format!("{}.{}", class_name, method_name)
                                            };

                                            *execution_count.entry(func_identifier).or_insert(0) +=
                                                1;
                                            total_samples += 1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        // 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(JavaProfileData {
            execution_count,
            hot_functions,
            total_samples,
        })
    }

    pub fn profile_continuous(&self, java_file: &str) -> Result<ProfileResult, String> {
        println!("Starting Java continuous runtime profiling...");
        println!("File: {}", java_file);
        println!("Running until process completes...\n");

        let profile_data = self.run_java_profiler(java_file)?;

        let mut details = Vec::new();
        details.push("=== Runtime Profile (Java Flight Recorder) ===".to_string());
        details.push(format!(
            "Total samples collected: {}",
            profile_data.total_samples
        ));
        details.push(format!(
            "Unique methods executed: {}",
            profile_data.execution_count.len()
        ));
        details.push("\nTop 10 Hot Methods:".to_string());

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

        if profile_data.total_samples == 0 {
            details.push("\n⚠️  No profiling data collected.".to_string());
            details.push("   This may be because:".to_string());
            details.push(
                "   - JFR is not available (requires Java 8+ commercial or Java 11+ free)"
                    .to_string(),
            );
            details.push("   - The program ran too quickly".to_string());
            details.push("   - The 'jfr' command is not installed (requires JDK 9+)".to_string());
            details.push(
                "\n   Java Flight Recorder was introduced in Java 8 but required".to_string(),
            );
            details.push("   commercial features until Java 11, where it became free.".to_string());
        }

        Ok(ProfileResult {
            language: "Java/JVM".to_string(),
            details,
        })
    }

    pub fn profile_pid(&self, pid: u32) -> Result<ProfileResult, String> {
        println!("🔍 Attaching to Java process PID: {}", pid);
        println!("📊 Collecting 30-second JFR profile...\n");

        // Check if jcmd is available
        self.ensure_jcmd_available()?;

        // Check if the process is a Java process
        self.check_java_process(pid)?;

        let recording_name = format!("profile_{}", pid);
        let jfr_file = format!("/tmp/java-profile-{}.jfr", pid);

        // Start JFR recording
        println!("🎬 Starting JFR recording...");
        let start_output = Command::new("jcmd")
            .args([
                &pid.to_string(),
                "JFR.start",
                &format!("name={}", recording_name),
                "settings=profile",
                "duration=30s",
            ])
            .output()
            .map_err(|e| format!("Failed to start JFR: {}", e))?;

        let start_msg = String::from_utf8_lossy(&start_output.stdout);
        if start_msg.contains("Started recording") {
            println!("✓ JFR recording started");
        } else {
            return Err(format!(
                "Failed to start JFR recording:\n{}",
                String::from_utf8_lossy(&start_output.stderr)
            ));
        }

        // Wait for recording to complete
        println!("⏳ Recording for 30 seconds...");
        thread::sleep(Duration::from_secs(31));

        // Dump the recording
        println!("📝 Dumping JFR data...");
        let dump_output = Command::new("jcmd")
            .args([
                &pid.to_string(),
                "JFR.dump",
                &format!("name={}", recording_name),
                &format!("filename={}", jfr_file),
            ])
            .output()
            .map_err(|e| format!("Failed to dump JFR: {}", e))?;

        if !dump_output.status.success() {
            return Err(format!(
                "Failed to dump JFR data:\n{}",
                String::from_utf8_lossy(&dump_output.stderr)
            ));
        }

        println!("✓ JFR data dumped to {}", jfr_file);

        // Stop the recording
        let _ = Command::new("jcmd")
            .args([
                &pid.to_string(),
                "JFR.stop",
                &format!("name={}", recording_name),
            ])
            .output();

        // Parse the JFR file
        if !Path::new(&jfr_file).exists() {
            return Err(format!("JFR file {} not found", jfr_file));
        }

        let profile_data = self.parse_jfr_profile(&jfr_file)?;

        // Clean up
        let _ = fs::remove_file(&jfr_file);

        // Build result
        let mut details = Vec::new();
        details.push(format!(
            "=== Java Flight Recorder Profile (PID: {}) ===",
            pid
        ));
        details.push(format!("Total samples: {}", profile_data.total_samples));
        details.push(format!(
            "Unique methods: {}",
            profile_data.execution_count.len()
        ));
        details.push("\nTop 10 Hot Methods:".to_string());

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

            if idx >= 9 {
                break;
            }
        }

        Ok(ProfileResult {
            language: "Java/JVM".to_string(),
            details,
        })
    }

    /// Check if jcmd is available
    fn ensure_jcmd_available(&self) -> Result<(), String> {
        let output = Command::new("jcmd")
            .arg("-h")
            .output()
            .map_err(|_| "jcmd not found. Please install JDK (Java Development Kit).")?;

        if output.status.success() {
            Ok(())
        } else {
            Err("jcmd is not available. Please install JDK.".to_string())
        }
    }

    /// Check if the process is a Java process
    fn check_java_process(&self, pid: u32) -> Result<(), String> {
        let output = Command::new("jps")
            .arg("-l")
            .output()
            .map_err(|_| "jps not found. Please install JDK.")?;

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

        if jps_output.contains(&pid.to_string()) {
            Ok(())
        } else {
            Err(format!(
                "Process {} is not a Java process or not visible to jps",
                pid
            ))
        }
    }

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

        let profile_data = self.run_java_profiler(java_file)?;

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

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

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

        let hot_functions: Vec<HotFunction> = profile_data
            .hot_functions
            .iter()
            .enumerate()
            .map(|(idx, (name, samples))| {
                let percentage = if profile_data.total_samples > 0 {
                    (*samples as f64 / profile_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: profile_data.total_samples,
            execution_duration_secs: 0,
            functions_executed: profile_data.execution_count.len(),
            function_stats,
            hot_functions,
        };

        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: "Java/JVM".to_string(),
            source_file: java_file.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_profiler_new() {
        let profiler = JavaProfiler::new();
        assert_eq!(std::mem::size_of_val(&profiler), 0);
    }

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