chore: Add telemetry event for slash command execution (#2285)

* first pass

* parse command name

* add ssoRegion in telemetry definitions and fix format

* update telemetry definitions with existing result and reason

* add com & sub's name function

* update command name

Author: evanliu048

crates/chat-cli/src/cli/chat/cli/context.rs

@@ -322,4 +322,14 @@ impl ContextSubcommand {
             skip_printing_tools: true,
         })
     }
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            ContextSubcommand::Show { .. } => "show",
+            ContextSubcommand::Add { .. } => "add",
+            ContextSubcommand::Remove { .. } => "remove",
+            ContextSubcommand::Clear => "clear",
+            ContextSubcommand::Hooks => "hooks",
+        }
+    }
 }

crates/chat-cli/src/cli/chat/cli/hooks.rs

@@ -449,6 +449,10 @@ impl HooksArgs {
             skip_printing_tools: true,
         })
     }
+
+    pub fn subcommand_name(&self) -> Option<&'static str> {
+        self.subcommand.as_ref().map(|s| s.name())
+    }
 }
 
 #[deny(missing_docs)]
@@ -634,6 +638,18 @@ impl HooksSubcommand {
             skip_printing_tools: true,
         })
     }
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            HooksSubcommand::Add { .. } => "add",
+            HooksSubcommand::Remove { .. } => "remove",
+            HooksSubcommand::Enable { .. } => "enable",
+            HooksSubcommand::Disable { .. } => "disable",
+            HooksSubcommand::EnableAll => "enable-all",
+            HooksSubcommand::DisableAll => "disable-all",
+            HooksSubcommand::Show => "show",
+        }
+    }
 }
 
 /// Prints hook configuration grouped by trigger: conversation session start or per user message

crates/chat-cli/src/cli/chat/cli/knowledge.rs

@@ -478,4 +478,16 @@ impl KnowledgeSubcommand {
             },
         }
     }
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            KnowledgeSubcommand::Show => "show",
+            KnowledgeSubcommand::Add { .. } => "add",
+            KnowledgeSubcommand::Remove { .. } => "remove",
+            KnowledgeSubcommand::Update { .. } => "update",
+            KnowledgeSubcommand::Clear => "clear",
+            KnowledgeSubcommand::Status => "status",
+            KnowledgeSubcommand::Cancel { .. } => "cancel",
+        }
+    }
 }

crates/chat-cli/src/cli/chat/cli/mod.rs

@@ -122,4 +122,40 @@ impl SlashCommand {
             // },
         }
     }
+
+    pub fn command_name(&self) -> &'static str {
+        match self {
+            Self::Quit => "quit",
+            Self::Clear(_) => "clear",
+            Self::Agent(_) => "agent",
+            Self::Context(_) => "context",
+            Self::Knowledge(_) => "knowledge",
+            Self::PromptEditor(_) => "editor",
+            Self::Compact(_) => "compact",
+            Self::Tools(_) => "tools",
+            Self::Issue(_) => "issue",
+            Self::Prompts(_) => "prompts",
+            Self::Hooks(_) => "hooks",
+            Self::Usage(_) => "usage",
+            Self::Mcp(_) => "mcp",
+            Self::Model(_) => "model",
+            Self::Subscribe(_) => "subscribe",
+            Self::Persist(sub) => match sub {
+                PersistSubcommand::Save { .. } => "save",
+                PersistSubcommand::Load { .. } => "load",
+            },
+        }
+    }
+
+    pub fn subcommand_name(&self) -> Option<&'static str> {
+        match self {
+            SlashCommand::Agent(sub) => Some(sub.name()),
+            SlashCommand::Context(sub) => Some(sub.name()),
+            SlashCommand::Knowledge(sub) => Some(sub.name()),
+            SlashCommand::Tools(arg) => arg.subcommand_name(),
+            SlashCommand::Prompts(arg) => arg.subcommand_name(),
+            SlashCommand::Hooks(arg) => arg.subcommand_name(),
+            _ => None,
+        }
+    }
 }

crates/chat-cli/src/cli/chat/cli/profile.rs

@@ -138,6 +138,16 @@ impl AgentSubcommand {
             skip_printing_tools: true,
         })
     }
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::List => "list",
+            Self::Create { .. } => "create",
+            Self::Delete { .. } => "delete",
+            Self::Set { .. } => "set",
+            Self::Rename { .. } => "rename",
+        }
+    }
 }
 
 fn highlight_json(output: &mut impl Write, json_str: &str) -> eyre::Result<()> {

crates/chat-cli/src/cli/chat/cli/prompts.rs

@@ -200,6 +200,10 @@ impl PromptsArgs {
             skip_printing_tools: true,
         })
     }
+
+    pub fn subcommand_name(&self) -> Option<&'static str> {
+        self.subcommand.as_ref().map(|s| s.name())
+    }
 }
 
 #[deny(missing_docs)]
@@ -305,4 +309,11 @@ impl PromptsSubcommand {
             skip_printing_tools: true,
         })
     }
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            PromptsSubcommand::List { .. } => "list",
+            PromptsSubcommand::Get { .. } => "get",
+        }
+    }
 }

crates/chat-cli/src/cli/chat/cli/tools.rs

@@ -166,6 +166,10 @@ impl ToolsArgs {
 
         Ok(ChatState::default())
     }
+
+    pub fn subcommand_name(&self) -> Option<&'static str> {
+        self.subcommand.as_ref().map(|s| s.name())
+    }
 }
 
 #[deny(missing_docs)]
@@ -383,4 +387,14 @@ impl ToolsSubcommand {
             skip_printing_tools: true,
         })
     }
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            ToolsSubcommand::Schema => "schema",
+            ToolsSubcommand::Trust { .. } => "trust",
+            ToolsSubcommand::Untrust { .. } => "untrust",
+            ToolsSubcommand::TrustAll => "trust-all",
+            ToolsSubcommand::Reset => "reset",
+        }
+    }
 }

crates/chat-cli/src/cli/chat/mod.rs

@@ -1396,16 +1396,30 @@ impl ChatSession {
 
             match SlashCommand::try_parse_from(args) {
                 Ok(command) => {
+                    let command_name = command.command_name().to_string();
+                    let subcommand_name = command.subcommand_name().map(|s| s.to_string());
+
                     match command.execute(os, self).await {
-                        Ok(chat_state)
+                        Ok(chat_state) => {
+                            let _ = self
+                                .send_slash_command_telemetry(
+                                    os,
+                                    command_name,
+                                    subcommand_name,
+                                    TelemetryResult::Succeeded,
+                                    None,
+                                )
+                                .await;
+
                             if matches!(chat_state, ChatState::Exit)
                                 || matches!(chat_state, ChatState::HandleInput { input: _ })
                                 // TODO(bskiser): this is just a hotfix for handling state changes
                                 // from manually running /compact, without impacting behavior of
                                 // other slash commands.
-                                || matches!(chat_state, ChatState::CompactHistory { .. }) =>
-                        {
-                            return Ok(chat_state);
+                                || matches!(chat_state, ChatState::CompactHistory { .. })
+                            {
+                                return Ok(chat_state);
+                            }
                         },
                         Err(err) => {
                             queue!(
@@ -1414,8 +1428,16 @@ impl ChatSession {
                                 style::Print(format!("\nFailed to execute command: {}\n", err)),
                                 style::SetForegroundColor(Color::Reset)
                             )?;
+                            let _ = self
+                                .send_slash_command_telemetry(
+                                    os,
+                                    command_name,
+                                    subcommand_name,
+                                    TelemetryResult::Failed,
+                                    Some(err.to_string()),
+                                )
+                                .await;
                         },
-                        _ => {},
                     }
 
                     writeln!(self.stderr)?;
@@ -2323,6 +2345,24 @@ impl ChatSession {
             .await
             .ok();
     }
+
+    pub async fn send_slash_command_telemetry(
+        &self,
+        os: &Os,
+        command: String,
+        subcommand: Option<String>,
+        result: TelemetryResult,
+        reason: Option<String>,
+    ) {
+        let conversation_id = self.conversation.conversation_id().to_owned();
+        if let Err(e) = os
+            .telemetry
+            .send_chat_slash_command_executed(&os.database, conversation_id, command, subcommand, result, reason)
+            .await
+        {
+            tracing::warn!("Failed to send slash command telemetry: {}", e);
+        }
+    }
 }
 
 /// Replaces amzn_codewhisperer_client::types::SubscriptionStatus with a more descriptive type.

crates/chat-cli/src/telemetry/core.rs

@@ -15,6 +15,7 @@ use crate::telemetry::definitions::metrics::{
     AmazonqProfileState,
     AmazonqStartChat,
     CodewhispererterminalAddChatMessage,
+    CodewhispererterminalChatSlashCommandExecuted,
     CodewhispererterminalCliSubcommandExecuted,
     CodewhispererterminalMcpServerInit,
     CodewhispererterminalRefreshCredentials,
@@ -103,6 +104,27 @@ impl Event {
                 }
                 .into_metric_datum(),
             ),
+            EventType::ChatSlashCommandExecuted {
+                conversation_id,
+                command,
+                subcommand,
+                result,
+                reason,
+            } => Some(
+                CodewhispererterminalChatSlashCommandExecuted {
+                    create_time: self.created_time,
+                    value: None,
+                    credential_start_url: self.credential_start_url.map(Into::into),
+                    sso_region: self.sso_region.map(Into::into),
+                    amazonq_conversation_id: Some(conversation_id.into()),
+                    codewhispererterminal_chat_slash_command: Some(command.into()),
+                    codewhispererterminal_chat_slash_subcommand: subcommand.map(Into::into),
+                    result: Some(result.to_string().into()),
+                    reason: reason.map(Into::into),
+                    codewhispererterminal_in_cloudshell: None,
+                }
+                .into_metric_datum(),
+            ),
             EventType::ChatStart { conversation_id, model } => Some(
                 AmazonqStartChat {
                     create_time: self.created_time,
@@ -287,6 +309,13 @@ pub enum EventType {
     CliSubcommandExecuted {
         subcommand: String,
     },
+    ChatSlashCommandExecuted {
+        conversation_id: String,
+        command: String,
+        subcommand: Option<String>,
+        result: TelemetryResult,
+        reason: Option<String>,
+    },
     ChatStart {
         conversation_id: String,
         model: Option<String>,

crates/chat-cli/src/telemetry/mod.rs

@@ -232,6 +232,26 @@ impl TelemetryThread {
         }))?)
     }
 
+    pub async fn send_chat_slash_command_executed(
+        &self,
+        database: &Database,
+        conversation_id: String,
+        command: String,
+        subcommand: Option<String>,
+        result: TelemetryResult,
+        reason: Option<String>,
+    ) -> Result<(), TelemetryError> {
+        let mut event = Event::new(EventType::ChatSlashCommandExecuted {
+            conversation_id,
+            command,
+            subcommand,
+            result,
+            reason,
+        });
+        set_start_url_and_region(database, &mut event).await;
+        Ok(self.tx.send(event)?)
+    }
+
     #[allow(clippy::too_many_arguments)] // TODO: Should make a parameters struct.
     pub async fn send_chat_added_message(
         &self,