feat: add FeProfilerTool for flame graph generation (#11)

* feat: add FeProfilerTool for flame graph generation

Author: QuakeWang

src/lib.rs

@@ -271,11 +271,13 @@ fn execute_tool_enhanced(config: &Config, tool: &dyn Tool, _service_name: &str)
     match tool.execute(config, pid) {
         Ok(result) => {
             print_success(&result.message);
-            if result.output_path.to_str() != Some("console_output") {
-                print_info(&format!(
-                    "Output saved to: {}",
-                    result.output_path.display()
-                ));
+            if let Some(path) = result.output_path.to_str() {
+                if !path.is_empty() && path != "console_output" {
+                    print_info(&format!(
+                        "Output saved to: {}",
+                        result.output_path.display()
+                    ));
+                }
             }
             Ok(())
         }

src/tools/fe/mod.rs

@@ -1,5 +1,7 @@
 mod jmap;
 mod jstack;
+mod profiler;
 
 pub use jmap::{JmapDumpTool, JmapHistoTool};
 pub use jstack::JstackTool;
+pub use profiler::FeProfilerTool;

src/tools/fe/profiler.rs

@@ -0,0 +1,102 @@
+use crate::config::Config;
+use crate::error::{CliError, Result};
+use crate::executor;
+use crate::tools::{ExecutionResult, Tool};
+use crate::ui;
+use dialoguer::Input;
+use std::env;
+use std::process::Command;
+
+pub struct FeProfilerTool;
+
+impl FeProfilerTool {
+    /// Prompt user for profile duration and return the duration value
+    /// This method can be called before tool execution to get user input
+    pub fn prompt_duration() -> Result<u32> {
+        let input: String = Input::with_theme(&dialoguer::theme::ColorfulTheme::default())
+            .with_prompt("Enter collection duration in seconds")
+            .with_initial_text("10")
+            .interact_text()
+            .map_err(|e| CliError::InvalidInput(format!("Duration input failed: {e}")))?;
+
+        let duration_str = if input.trim().is_empty() {
+            "10"
+        } else {
+            input.trim()
+        };
+
+        match duration_str.parse::<u32>() {
+            Ok(val) if val > 0 && val <= 300 => Ok(val),
+            Ok(_) => {
+                ui::print_warning("Duration must be between 1 and 300 seconds!");
+                ui::print_info("Hint: Enter a number between 1-300, e.g., 25");
+                Err(CliError::GracefulExit)
+            }
+            Err(_) => {
+                ui::print_warning("Please enter a valid number!");
+                ui::print_info("Hint: Enter a number between 1-300, e.g., 25");
+                Err(CliError::GracefulExit)
+            }
+        }
+    }
+
+    /// Execute the profiler with a specific duration
+    pub fn execute_with_duration(&self, config: &Config, duration: u32) -> Result<ExecutionResult> {
+        let doris_config = crate::config_loader::load_config()?;
+
+        let fe_install_dir = doris_config
+            .fe_install_dir
+            .as_ref()
+            .or(Some(&doris_config.install_dir))
+            .ok_or_else(|| CliError::ConfigError("FE install directory not found".to_string()))?;
+
+        let profile_script = fe_install_dir.join("bin").join("profile_fe.sh");
+
+        if !profile_script.exists() {
+            return Err(CliError::ConfigError(format!(
+                "profile_fe.sh not found at {}. Please ensure Doris version is 2.1.4+",
+                profile_script.display()
+            )));
+        }
+
+        let mut command = Command::new("bash");
+        command.arg(&profile_script);
+        command.env("PROFILE_SECONDS", duration.to_string());
+
+        executor::execute_command_with_timeout(&mut command, self.name(), config)?;
+
+        let message = format!("Flame graph generated successfully (duration: {duration}s).");
+
+        Ok(ExecutionResult {
+            output_path: std::path::PathBuf::new(),
+            message,
+        })
+    }
+}
+
+impl Tool for FeProfilerTool {
+    fn name(&self) -> &str {
+        "fe-profiler"
+    }
+
+    fn description(&self) -> &str {
+        "Generate flame graph for FE performance analysis using async-profiler"
+    }
+
+    fn execute(&self, config: &Config, _pid: u32) -> Result<ExecutionResult> {
+        let profile_seconds = if env::var("PROFILE_SECONDS").is_ok() {
+            env::var("PROFILE_SECONDS")
+                .unwrap()
+                .parse::<u32>()
+                .unwrap_or(10)
+        } else {
+            Self::prompt_duration()?
+        };
+
+        self.execute_with_duration(config, profile_seconds)
+    }
+
+    fn requires_pid(&self) -> bool {
+        false // FE profiler doesn't need PID as it uses profile_fe.sh script
+    }
+}

src/tools/mod.rs

@@ -50,7 +50,7 @@ impl ToolRegistry {
             BeVarsTool, MemzGlobalTool, MemzTool, PipelineTasksTool, PstackTool,
         };
         use crate::tools::be::{JmapDumpTool as BeJmapDumpTool, JmapHistoTool as BeJmapHistoTool};
-        use crate::tools::fe::{JmapDumpTool, JmapHistoTool, JstackTool};
+        use crate::tools::fe::{FeProfilerTool, JmapDumpTool, JmapHistoTool, JstackTool};
 
         let mut registry = Self {
             fe_tools: Vec::new(),
@@ -61,6 +61,7 @@ impl ToolRegistry {
         registry.fe_tools.push(Box::new(JmapDumpTool));
         registry.fe_tools.push(Box::new(JmapHistoTool));
         registry.fe_tools.push(Box::new(JstackTool));
+        registry.fe_tools.push(Box::new(FeProfilerTool));
 
         // Register BE tools
         registry.be_tools.push(Box::new(PstackTool));