testlint_sdk/profiler/

typescript.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 TsProfileData {
    execution_count: HashMap<String, u64>,
    hot_functions: Vec<(String, u64)>,
    total_samples: u64,
}

pub struct TypeScriptProfiler {}

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

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

    fn run_node_profiler(&self, ts_file: &str) -> Result<TsProfileData, String> {
        // Check if Node.js is installed
        let node_check = Command::new("node")
            .arg("--version")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status();

        if node_check.is_err() {
            return Err("Node.js is not installed. Install from: https://nodejs.org/".to_string());
        }

        // Convert to absolute path
        let script_path = Path::new(ts_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 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!("node_cpu_profile_{}_{}.cpuprofile", pid, timestamp);
        let profile_file = temp_dir.join(&profile_filename);

        // Record existing .cpuprofile 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 == "cpuprofile")
                            .unwrap_or(false)
                    })
                    .collect()
            })
            .unwrap_or_default();

        println!("Starting Node.js process with --cpu-prof...");

        // Start Node.js with CPU profiling enabled
        let mut child = Command::new("node")
            .arg("--cpu-prof")
            .arg("--cpu-prof-dir")
            .arg(&temp_dir)
            .arg("--cpu-prof-name")
            .arg(&profile_filename)
            .arg(&script_path)
            .stdout(Stdio::inherit())
            .stderr(Stdio::piped())
            .spawn()
            .map_err(|e| format!("Failed to start Node.js process: {}", e))?;

        // Wait for the process to complete
        let status = child
            .wait()
            .map_err(|e| format!("Failed to wait for Node.js process: {}", e))?;

        if !status.success() {
            return Err("Node.js process exited with error".to_string());
        }

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

        // Find the generated CPU profile file
        // Node.js may create it with the specified name or its own naming scheme
        let actual_profile = if profile_file.exists() {
            Some(profile_file.clone())
        } else {
            // Look for NEW .cpuprofile 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 == "cpuprofile")
                        .unwrap_or(false)
                        && !existing_profiles.contains(p)
                })
            })
        };

        match actual_profile {
            Some(profile_path) => {
                let result = self.parse_cpu_profile(profile_path.to_str().unwrap());
                // Clean up
                let _ = fs::remove_file(&profile_path);
                result
            }
            None => {
                Err("CPU profile was not generated. Make sure your Node.js version supports --cpu-prof (v12+)".to_string())
            }
        }
    }

    fn run_node_profiler_pid(&self, pid: u32) -> Result<TsProfileData, String> {
        use std::thread;
        use std::time::Duration;

        println!("🔍 Attaching to Node.js process PID: {}", pid);
        println!("📊 Starting CPU profiling via V8 Inspector Protocol...");
        println!();

        // Check if process exists
        self.check_process_exists(pid)?;

        // Try to find or enable inspector
        let inspector_port = self.find_or_enable_inspector(pid)?;
        println!("✓ Found Node.js inspector on port {}", inspector_port);

        // Start profiling
        println!("⏱️  Profiling for 30 seconds...");
        self.start_profiler_via_inspector(pid)?;

        // Wait for profile duration
        thread::sleep(Duration::from_secs(30));

        // Stop profiling and collect results
        let profile_file = self.stop_profiler_and_collect(pid)?;

        // Parse the profile
        let profile_data = self.parse_cpu_profile(&profile_file)?;

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

        Ok(profile_data)
    }

    /// Check if process exists
    fn check_process_exists(&self, pid: u32) -> Result<(), String> {
        #[cfg(unix)]
        {
            use std::process::Command;

            let output = Command::new("ps")
                .args(["-p", &pid.to_string()])
                .output()
                .map_err(|e| format!("Failed to check process: {}", e))?;

            if !output.status.success() {
                return Err(format!("Process {} not found", pid));
            }

            // Check if it's a Node.js process
            let stdout = String::from_utf8_lossy(&output.stdout);
            if !stdout.contains("node") {
                println!("⚠️  Warning: Process {} may not be a Node.js process", pid);
            }

            Ok(())
        }

        #[cfg(not(unix))]
        {
            Ok(())
        }
    }

    /// Find or enable inspector for the process
    fn find_or_enable_inspector(&self, pid: u32) -> Result<u16, String> {
        // First try to find existing inspector
        if let Ok(port) = self.find_existing_inspector(pid) {
            return Ok(port);
        }

        // Try to enable inspector by sending SIGUSR1
        println!("📡 Attempting to enable inspector via SIGUSR1...");

        #[cfg(unix)]
        {
            use std::process::Command;
            use std::thread;
            use std::time::Duration;

            Command::new("kill")
                .args(["-USR1", &pid.to_string()])
                .output()
                .map_err(|e| format!("Failed to send SIGUSR1: {}", e))?;

            // Wait for inspector to start
            thread::sleep(Duration::from_secs(1));

            // Try again to find the inspector port
            self.find_existing_inspector(pid)
        }

        #[cfg(not(unix))]
        {
            Err("Inspector detection not supported on this platform.\n\
                 Start your Node.js process with --inspect flag."
                .to_string())
        }
    }

    /// Find the inspector port for a running Node.js process
    fn find_existing_inspector(&self, pid: u32) -> Result<u16, String> {
        // Check common inspector ports first (9229 is default)
        for port in [9229, 9230, 9231, 9232, 9233] {
            if self.test_inspector_port(port) {
                return Ok(port);
            }
        }

        // Try to find from process info
        #[cfg(target_os = "linux")]
        {
            let cmdline_path = format!("/proc/{}/cmdline", pid);
            if let Ok(cmdline) = fs::read_to_string(&cmdline_path) {
                if let Some(port) = self.extract_inspector_port_from_cmdline(&cmdline) {
                    if self.test_inspector_port(port) {
                        return Ok(port);
                    }
                }
            }
        }

        Err(format!(
            "Could not find Node.js inspector port for PID {}.\n\
            Process may not have inspector enabled.\n\
            Start your Node.js app with --inspect flag or send SIGUSR1 to enable.",
            pid
        ))
    }

    /// Test if an inspector port is active
    fn test_inspector_port(&self, port: u16) -> bool {
        use std::net::TcpStream;
        use std::time::Duration;

        TcpStream::connect_timeout(
            &format!("127.0.0.1:{}", port).parse().unwrap(),
            Duration::from_millis(100),
        )
        .is_ok()
    }

    /// Extract inspector port from command line
    #[allow(dead_code)]
    fn extract_inspector_port_from_cmdline(&self, cmdline: &str) -> Option<u16> {
        // Look for --inspect=<port> or --inspect-brk=<port>
        for arg in cmdline.split('\0') {
            if let Some(port_str) = arg.strip_prefix("--inspect=") {
                if let Ok(port) = port_str.parse() {
                    return Some(port);
                }
            }
            if let Some(port_str) = arg.strip_prefix("--inspect-brk=") {
                if let Ok(port) = port_str.parse() {
                    return Some(port);
                }
            }
        }
        None
    }

    /// Start profiler via Inspector Protocol
    fn start_profiler_via_inspector(&self, pid: u32) -> Result<(), String> {
        let temp_dir = std::env::temp_dir();
        let script = r#"
const inspector = require('inspector');
const session = new inspector.Session();

session.connect();

// Enable Profiler domain
session.post('Profiler.enable', (err) => {
  if (err) {
    console.error('Failed to enable profiler:', err);
    process.exit(1);
  }

  // Start profiling
  session.post('Profiler.start', (err) => {
    if (err) {
      console.error('Failed to start profiler:', err);
      process.exit(1);
    }

    console.log('[Profiler] Started CPU profiling');
    process.exit(0);
  });
});
"#;

        let script_path = temp_dir.join(format!("start_profiler_{}.js", pid));
        fs::write(&script_path, script)
            .map_err(|e| format!("Failed to write profiler script: {}", e))?;

        let output = std::process::Command::new("node")
            .arg(&script_path)
            .output()
            .map_err(|e| format!("Failed to start profiler: {}", e))?;

        let _ = fs::remove_file(&script_path);

        if !output.status.success() {
            return Err(format!(
                "Failed to start profiler: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        Ok(())
    }

    /// Stop profiler and collect results
    fn stop_profiler_and_collect(&self, pid: u32) -> Result<String, String> {
        let temp_dir = std::env::temp_dir();
        let profile_file = temp_dir.join(format!("profile_{}.cpuprofile", pid));

        let script = format!(
            r#"
const inspector = require('inspector');
const fs = require('fs');
const session = new inspector.Session();

session.connect();

// Stop profiling and get results
session.post('Profiler.stop', (err, {{ profile }}) => {{
  if (err) {{
    console.error('Failed to stop profiler:', err);
    process.exit(1);
  }}

  // Save profile to file
  fs.writeFileSync('{}', JSON.stringify(profile, null, 2));
  console.log('[Profiler] Saved profile to {}');

  // Disable profiler
  session.post('Profiler.disable');

  process.exit(0);
}});
"#,
            profile_file.display(),
            profile_file.display()
        );

        let script_path = temp_dir.join(format!("stop_profiler_{}.js", pid));
        fs::write(&script_path, script)
            .map_err(|e| format!("Failed to write stop script: {}", e))?;

        let output = std::process::Command::new("node")
            .arg(&script_path)
            .output()
            .map_err(|e| format!("Failed to stop profiler: {}", e))?;

        let _ = fs::remove_file(&script_path);

        if !output.status.success() {
            return Err(format!(
                "Failed to stop profiler: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        if !profile_file.exists() {
            return Err(format!("Profile file {} not found", profile_file.display()));
        }

        Ok(profile_file.to_string_lossy().to_string())
    }

    fn parse_cpu_profile(&self, profile_path: &str) -> Result<TsProfileData, String> {
        // Read and parse the V8 CPU profile format (JSON)
        let profile_content = fs::read_to_string(profile_path)
            .map_err(|e| format!("Failed to read CPU profile: {}", e))?;

        let profile: Value = serde_json::from_str(&profile_content)
            .map_err(|e| format!("Failed to parse CPU profile JSON: {}", e))?;

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

        // V8 CPU profile format has nodes array with function info
        if let Some(nodes) = profile.get("nodes").and_then(|n| n.as_array()) {
            // Build a map of node IDs to function names
            let mut node_map: HashMap<i64, String> = HashMap::new();

            for node in nodes {
                if let (Some(id), Some(call_frame)) = (
                    node.get("id").and_then(|i| i.as_i64()),
                    node.get("callFrame"),
                ) {
                    let func_name = call_frame
                        .get("functionName")
                        .and_then(|f| f.as_str())
                        .unwrap_or("(anonymous)");

                    let url = call_frame.get("url").and_then(|u| u.as_str()).unwrap_or("");

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

                    // Create a readable function identifier
                    let func_identifier = if !url.is_empty() && !url.is_empty() {
                        let file_name = Path::new(url)
                            .file_name()
                            .and_then(|n| n.to_str())
                            .unwrap_or("unknown");
                        if line >= 0 {
                            format!("{}:{}:{}", file_name, line + 1, func_name)
                        } else {
                            format!("{}:{}", file_name, func_name)
                        }
                    } else {
                        func_name.to_string()
                    };

                    node_map.insert(id, func_identifier);

                    // Count hit count if available
                    if let Some(hit_count) = node.get("hitCount").and_then(|h| h.as_u64()) {
                        if hit_count > 0 {
                            *execution_count.entry(node_map[&id].clone()).or_insert(0) += hit_count;
                            total_samples += hit_count;
                        }
                    }
                }
            }

            // Also parse samples array if available for more accurate counts
            if let Some(samples) = profile.get("samples").and_then(|s| s.as_array()) {
                for sample in samples {
                    if let Some(node_id) = sample.as_i64() {
                        if let Some(func_name) = node_map.get(&node_id) {
                            *execution_count.entry(func_name.clone()).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(TsProfileData {
            execution_count,
            hot_functions,
            total_samples,
        })
    }

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

        let profile_data = self.run_node_profiler(ts_file)?;

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

        for (idx, (func_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,
                func_name,
                count,
                percentage
            ));
        }

        Ok(ProfileResult {
            language: "TypeScript/Node.js".to_string(),
            details,
        })
    }

    pub fn profile_pid(&self, pid: u32) -> Result<ProfileResult, String> {
        self.run_node_profiler_pid(pid)?;

        Ok(ProfileResult {
            language: "TypeScript/Node.js".to_string(),
            details: vec!["PID attach completed".to_string()],
        })
    }

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

        let profile_data = self.run_node_profiler(ts_file)?;

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

        for (func_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(
                func_name.clone(),
                FunctionStats {
                    name: func_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: "TypeScript/Node.js".to_string(),
            source_file: ts_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 = TypeScriptProfiler::new();
        assert_eq!(std::mem::size_of_val(&profiler), 0);
    }

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