testlint_sdk/profiler/

csharp.rs

#![allow(dead_code)]

use crate::profiler::ProfileResult;
use std::fs;
use std::path::Path;
use std::process::{Command, Stdio};

pub struct CSharpProfiler;

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

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

    /// Continuous profiling of C# applications using dotnet-trace
    pub fn profile_continuous(&self, csharp_file_or_dll: &str) -> Result<ProfileResult, String> {
        println!("🔷 Starting C# runtime profiling...");
        println!("📝 Note: This uses dotnet-trace for CPU profiling");

        // Check if dotnet-trace is installed
        if !self.is_dotnet_trace_installed() {
            println!("⚠️  dotnet-trace not found. Attempting to install...");
            self.install_dotnet_trace()?;
        }

        let path = Path::new(csharp_file_or_dll);
        let is_source = path.extension().is_some_and(|ext| ext == "cs");

        if is_source {
            // For .cs files, we need to run them with dotnet run
            self.profile_csharp_source(csharp_file_or_dll)
        } else {
            // For .dll or .exe files, profile directly
            self.profile_csharp_binary(csharp_file_or_dll)
        }
    }

    /// Profile a C# source file (compile and run with profiling)
    fn profile_csharp_source(&self, _cs_file: &str) -> Result<ProfileResult, String> {
        // Check if it's a .NET project
        if !Path::new("*.csproj").exists() && self.find_csproj().is_none() {
            return Err(
                "No .csproj file found. Please run from a .NET project directory.".to_string(),
            );
        }

        println!("🔨 Running .NET project with profiling...");

        // Start dotnet run in background and get its PID
        let mut run_cmd = Command::new("dotnet");
        run_cmd.arg("run");
        run_cmd.arg("--");

        let child = run_cmd
            .spawn()
            .map_err(|e| format!("Failed to start dotnet run: {}", e))?;

        let pid = child.id();
        println!("Started .NET application with PID: {}", pid);

        // Start profiling
        self.profile_running_process(pid)
    }

    /// Profile a C# binary (DLL or EXE)
    fn profile_csharp_binary(&self, binary_path: &str) -> Result<ProfileResult, String> {
        println!("🚀 Profiling C# binary: {}", binary_path);

        // Start the binary in background
        let mut run_cmd = Command::new("dotnet");
        run_cmd.arg(binary_path);

        let child = run_cmd
            .spawn()
            .map_err(|e| format!("Failed to start {}: {}", binary_path, e))?;

        let pid = child.id();
        println!("Started application with PID: {}", pid);

        // Start profiling
        self.profile_running_process(pid)
    }

    /// Profile a running .NET process
    fn profile_running_process(&self, pid: u32) -> Result<ProfileResult, String> {
        println!("📊 Starting dotnet-trace on PID {}...", pid);
        println!("Press Ctrl+C to stop profiling and generate trace file...");

        let trace_file = format!("trace_{}.nettrace", pid);

        let mut cmd = Command::new("dotnet-trace");
        cmd.args([
            "collect",
            "--process-id",
            &pid.to_string(),
            "--providers",
            "Microsoft-DotNETCore-SampleProfiler",
            "--output",
            &trace_file,
        ]);

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

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

        self.parse_trace_output(&trace_file)
    }

    /// Check if dotnet-trace is installed
    fn is_dotnet_trace_installed(&self) -> bool {
        Command::new("dotnet-trace")
            .arg("--version")
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status()
            .is_ok()
    }

    /// Install dotnet-trace
    fn install_dotnet_trace(&self) -> Result<(), String> {
        println!("Installing dotnet-trace...");

        let output = Command::new("dotnet")
            .args(["tool", "install", "-g", "dotnet-trace"])
            .output()
            .map_err(|e| format!("Failed to install dotnet-trace: {}", e))?;

        if !output.status.success() {
            return Err(format!(
                "Failed to install dotnet-trace: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        println!("✓ dotnet-trace installed successfully");
        Ok(())
    }

    /// Find a .csproj file in the current directory
    fn find_csproj(&self) -> Option<String> {
        if let Ok(entries) = fs::read_dir(".") {
            for entry in entries.flatten() {
                if let Some(name) = entry.file_name().to_str() {
                    if name.ends_with(".csproj") {
                        return Some(name.to_string());
                    }
                }
            }
        }
        None
    }

    /// Parse trace output and create ProfileResult
    fn parse_trace_output(&self, trace_file: &str) -> Result<ProfileResult, String> {
        if !Path::new(trace_file).exists() {
            return Err("Trace file not generated. Profiling may have failed.".to_string());
        }

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

        let details = vec![
            "✓ Profiling completed successfully".to_string(),
            format!("📊 Trace file generated: {}", trace_file),
            format!("   Size: {} bytes", file_size),
            "".to_string(),
            "To analyze the trace:".to_string(),
            "".to_string(),
            "1. Convert to speedscope format:".to_string(),
            format!("   dotnet-trace convert {} --format speedscope", trace_file),
            "".to_string(),
            "2. View with PerfView (Windows):".to_string(),
            "   Download from: https://github.com/microsoft/perfview".to_string(),
            format!("   Open {} in PerfView", trace_file),
            "".to_string(),
            "3. View with speedscope (web-based):".to_string(),
            "   Upload to: https://www.speedscope.app/".to_string(),
            "".to_string(),
            "Trace contains:".to_string(),
            "  - CPU sampling data".to_string(),
            "  - Method call stacks".to_string(),
            "  - Hot paths and bottlenecks".to_string(),
        ];

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

    /// Profile by attaching to PID
    pub fn profile_pid(&self, pid: u32) -> Result<ProfileResult, String> {
        println!("🔍 Attaching to C# process PID: {}", pid);

        if !self.is_dotnet_trace_installed() {
            println!("⚠️  dotnet-trace not found. Attempting to install...");
            self.install_dotnet_trace()?;
        }

        self.profile_running_process(pid)
    }
}

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

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

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