feat(telemetry): add client application and additional info from tool (#2514)

Author: mukeshsahay

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

@@ -1885,6 +1885,18 @@ impl ChatSession {
                 ev.is_accepted = true;
             });
 
+            // Extract AWS service name and operation name if available
+            if let Some(additional_info) = tool.tool.get_additional_info() {
+                if let Some(aws_service_name) = additional_info.get("aws_service_name").and_then(|v| v.as_str()) {
+                    tool_telemetry =
+                        tool_telemetry.and_modify(|ev| ev.aws_service_name = Some(aws_service_name.to_string()));
+                }
+                if let Some(aws_operation_name) = additional_info.get("aws_operation_name").and_then(|v| v.as_str()) {
+                    tool_telemetry =
+                        tool_telemetry.and_modify(|ev| ev.aws_operation_name = Some(aws_operation_name.to_string()));
+                }
+            }
+
             let invoke_result = tool.tool.invoke(os, &mut self.stdout).await;
 
             if self.spinner.is_some() {
@@ -2557,7 +2569,7 @@ impl ChatSession {
             }
             .map(|v| v.to_string());
 
-            os.telemetry.send_tool_use_suggested(event).ok();
+            os.telemetry.send_tool_use_suggested(&os.database, event).await.ok();
         }
     }
 

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

@@ -147,6 +147,15 @@ impl Tool {
             Tool::Thinking(think) => think.validate(os).await,
         }
     }
+
+    /// Returns additional information about the tool if available
+    pub fn get_additional_info(&self) -> Option<serde_json::Value> {
+        match self {
+            Tool::UseAws(use_aws) => Some(use_aws.get_additional_info()),
+            // Add other tool types here as they implement get_additional_info()
+            _ => None,
+        }
+    }
 }
 
 /// A tool specification to be sent to the model as part of a conversation. Maps to

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

@@ -178,6 +178,13 @@ impl UseAws {
         Ok(())
     }
 
+    pub fn get_additional_info(&self) -> serde_json::Value {
+        serde_json::json!({
+            "aws_service_name": self.service_name.clone(),
+            "aws_operation_name": self.operation_name.clone()
+        })
+    }
+
     /// Returns the CLI arguments properly formatted as kebab case if parameters is
     /// [Option::Some], otherwise None
     fn cli_parameters(&self) -> Option<Vec<(String, String)>> {

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

@@ -141,7 +141,10 @@ impl RootSubcommand {
 
         // Send executed telemetry.
         if self.valid_for_telemetry() {
-            os.telemetry.send_cli_subcommand_executed(&self).ok();
+            os.telemetry
+                .send_cli_subcommand_executed(&os.database, &self)
+                .await
+                .ok();
         }
 
         match self {

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

@@ -49,6 +49,7 @@ pub struct Event {
     pub created_time: Option<SystemTime>,
     pub credential_start_url: Option<String>,
     pub sso_region: Option<String>,
+    pub client_application: Option<String>,
     #[serde(flatten)]
     pub ty: EventType,
 }
@@ -60,6 +61,7 @@ impl Event {
             created_time: Some(SystemTime::now()),
             credential_start_url: None,
             sso_region: None,
+            client_application: None,
         }
     }
 
@@ -71,6 +73,10 @@ impl Event {
         self.sso_region = Some(sso_region);
     }
 
+    pub fn set_client_application(&mut self, client_application: String) {
+        self.client_application = Some(client_application);
+    }
+
     pub fn into_metric_datum(self) -> Option<MetricDatum> {
         match self.ty {
             EventType::UserLoggedIn {} => Some(
@@ -107,6 +113,7 @@ impl Event {
                     credential_start_url: self.credential_start_url.map(Into::into),
                     codewhispererterminal_subcommand: Some(subcommand.into()),
                     codewhispererterminal_in_cloudshell: None,
+                    codewhispererterminal_client_application: self.client_application.map(Into::into),
                 }
                 .into_metric_datum(),
             ),
@@ -209,6 +216,7 @@ impl Event {
                             .join(",")
                             .into(),
                     ),
+                    codewhispererterminal_client_application: self.client_application.map(Into::into),
                 }
                 .into_metric_datum(),
             ),
@@ -294,6 +302,8 @@ impl Event {
                 model,
                 execution_duration,
                 turn_duration,
+                aws_service_name,
+                aws_operation_name,
             } => Some(
                 CodewhispererterminalToolUseSuggested {
                     create_time: self.created_time,
@@ -323,6 +333,9 @@ impl Event {
                     codewhispererterminal_tool_turn_duration_ms: turn_duration
                         .map(|d| d.as_millis() as i64)
                         .map(Into::into),
+                    codewhispererterminal_client_application: self.client_application.map(Into::into),
+                    codewhispererterminal_aws_service_name: aws_service_name.map(Into::into),
+                    codewhispererterminal_aws_operation_name: aws_operation_name.map(Into::into),
                 }
                 .into_metric_datum(),
             ),
@@ -343,6 +356,7 @@ impl Event {
                     codewhispererterminal_tools_per_mcp_server: Some(CodewhispererterminalToolsPerMcpServer(
                         number_of_tools as i64,
                     )),
+                    codewhispererterminal_client_application: self.client_application.map(Into::into),
                 }
                 .into_metric_datum(),
             ),
@@ -431,6 +445,7 @@ impl Event {
                     status_code: status_code.map(|v| v as i64).map(Into::into),
                     request_id: request_id.map(Into::into),
                     codewhispererterminal_utterance_id: message_id.map(Into::into),
+                    codewhispererterminal_client_application: self.client_application.map(Into::into),
                 }
                 .into_metric_datum(),
             ),
@@ -562,6 +577,8 @@ pub enum EventType {
         model: Option<String>,
         execution_duration: Option<Duration>,
         turn_duration: Option<Duration>,
+        aws_service_name: Option<String>,
+        aws_operation_name: Option<String>,
     },
     McpServerInit {
         conversation_id: String,
@@ -617,6 +634,8 @@ pub struct ToolUseEventBuilder {
     pub model: Option<String>,
     pub execution_duration: Option<Duration>,
     pub turn_duration: Option<Duration>,
+    pub aws_service_name: Option<String>,
+    pub aws_operation_name: Option<String>,
 }
 
 impl ToolUseEventBuilder {
@@ -639,6 +658,8 @@ impl ToolUseEventBuilder {
             model,
             execution_duration: None,
             turn_duration: None,
+            aws_service_name: None,
+            aws_operation_name: None,
         }
     }
 

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

@@ -43,6 +43,7 @@ mod tests {
             codewhispererterminal_tool_name: None,
             codewhispererterminal_assistant_response_length: Some(20.into()),
             codewhispererterminal_chat_message_meta_tags: Some([MessageMetaTag::Compact.to_string()].join(",").into()),
+            codewhispererterminal_client_application: None,
         });
 
         let s = serde_json::to_string_pretty(&metric_datum_init).unwrap();

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

@@ -71,6 +71,7 @@ pub use crate::telemetry::core::{
     QProfileSwitchIntent,
     TelemetryResult,
 };
+use crate::util::env_var::Q_CLI_CLIENT_APPLICATION;
 use crate::util::system_info::os_version;
 
 #[derive(thiserror::Error, Debug)]
@@ -231,10 +232,17 @@ impl TelemetryThread {
         Ok(self.tx.send(Event::new(EventType::UserLoggedIn {}))?)
     }
 
-    pub fn send_cli_subcommand_executed(&self, subcommand: &RootSubcommand) -> Result<(), TelemetryError> {
-        Ok(self.tx.send(Event::new(EventType::CliSubcommandExecuted {
+    pub async fn send_cli_subcommand_executed(
+        &self,
+        database: &Database,
+        subcommand: &RootSubcommand,
+    ) -> Result<(), TelemetryError> {
+        let mut telemetry_event = Event::new(EventType::CliSubcommandExecuted {
             subcommand: subcommand.to_string(),
-        }))?)
+        });
+        set_event_metadata(database, &mut telemetry_event).await;
+
+        Ok(self.tx.send(telemetry_event)?)
     }
 
     pub async fn send_chat_slash_command_executed(
@@ -246,15 +254,15 @@ impl TelemetryThread {
         result: TelemetryResult,
         reason: Option<String>,
     ) -> Result<(), TelemetryError> {
-        let mut event = Event::new(EventType::ChatSlashCommandExecuted {
+        let mut telemetry_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)?)
+        set_event_metadata(database, &mut telemetry_event).await;
+        Ok(self.tx.send(telemetry_event)?)
     }
 
     #[allow(clippy::too_many_arguments)] // TODO: Should make a parameters struct.
@@ -265,14 +273,14 @@ impl TelemetryThread {
         result: TelemetryResult,
         data: ChatAddedMessageParams,
     ) -> Result<(), TelemetryError> {
-        let mut event = Event::new(EventType::ChatAddedMessage {
+        let mut telemetry_event = Event::new(EventType::ChatAddedMessage {
             conversation_id,
             result,
             data,
         });
-        set_start_url_and_region(database, &mut event).await;
+        set_event_metadata(database, &mut telemetry_event).await;
 
-        Ok(self.tx.send(event)?)
+        Ok(self.tx.send(telemetry_event)?)
     }
 
     pub async fn send_record_user_turn_completion(
@@ -282,17 +290,21 @@ impl TelemetryThread {
         result: TelemetryResult,
         args: RecordUserTurnCompletionArgs,
     ) -> Result<(), TelemetryError> {
-        let mut event = Event::new(EventType::RecordUserTurnCompletion {
+        let mut telemetry_event = Event::new(EventType::RecordUserTurnCompletion {
             conversation_id,
             result,
             args,
         });
-        set_start_url_and_region(database, &mut event).await;
-        Ok(self.tx.send(event)?)
+        set_event_metadata(database, &mut telemetry_event).await;
+        Ok(self.tx.send(telemetry_event)?)
     }
 
-    pub fn send_tool_use_suggested(&self, event: ToolUseEventBuilder) -> Result<(), TelemetryError> {
-        Ok(self.tx.send(Event::new(EventType::ToolUseSuggested {
+    pub async fn send_tool_use_suggested(
+        &self,
+        database: &Database,
+        event: ToolUseEventBuilder,
+    ) -> Result<(), TelemetryError> {
+        let mut telemetry_event = Event::new(EventType::ToolUseSuggested {
             conversation_id: event.conversation_id,
             utterance_id: event.utterance_id,
             user_input_id: event.user_input_id,
@@ -310,7 +322,12 @@ impl TelemetryThread {
             model: event.model,
             execution_duration: event.execution_duration,
             turn_duration: event.turn_duration,
-        }))?)
+            aws_service_name: event.aws_service_name,
+            aws_operation_name: event.aws_operation_name,
+        });
+        set_event_metadata(database, &mut telemetry_event).await;
+
+        Ok(self.tx.send(telemetry_event)?)
     }
 
     pub async fn send_mcp_server_init(
@@ -321,14 +338,15 @@ impl TelemetryThread {
         init_failure_reason: Option<String>,
         number_of_tools: usize,
     ) -> Result<(), TelemetryError> {
-        let mut event = Event::new(crate::telemetry::EventType::McpServerInit {
+        let mut telemetry_event = Event::new(crate::telemetry::EventType::McpServerInit {
             conversation_id,
             server_name,
             init_failure_reason,
             number_of_tools,
         });
-        set_start_url_and_region(database, &mut event).await;
-        Ok(self.tx.send(event)?)
+        set_event_metadata(database, &mut telemetry_event).await;
+
+        Ok(self.tx.send(telemetry_event)?)
     }
 
     pub async fn send_agent_config_init(
@@ -337,9 +355,9 @@ impl TelemetryThread {
         conversation_id: String,
         args: AgentConfigInitArgs,
     ) -> Result<(), TelemetryError> {
-        let mut event = Event::new(crate::telemetry::EventType::AgentConfigInit { conversation_id, args });
-        set_start_url_and_region(database, &mut event).await;
-        Ok(self.tx.send(event)?)
+        let mut telemetry_event = Event::new(crate::telemetry::EventType::AgentConfigInit { conversation_id, args });
+        set_event_metadata(database, &mut telemetry_event).await;
+        Ok(self.tx.send(telemetry_event)?)
     }
 
     pub fn send_did_select_profile(
@@ -387,7 +405,7 @@ impl TelemetryThread {
         request_id: Option<String>,
         message_id: Option<String>,
     ) -> Result<(), TelemetryError> {
-        let mut event = Event::new(EventType::MessageResponseError {
+        let mut telemetry_event = Event::new(EventType::MessageResponseError {
             result,
             reason,
             reason_desc,
@@ -397,20 +415,25 @@ impl TelemetryThread {
             request_id,
             message_id,
         });
-        set_start_url_and_region(database, &mut event).await;
+        set_event_metadata(database, &mut telemetry_event).await;
 
-        Ok(self.tx.send(event)?)
+        Ok(self.tx.send(telemetry_event)?)
     }
 }
 
-async fn set_start_url_and_region(database: &Database, event: &mut Event) {
+async fn set_event_metadata(database: &Database, event: &mut Event) {
     let (start_url, region) = get_start_url_and_region(database).await;
     if let Some(start_url) = start_url {
         event.set_start_url(start_url);
     }
     if let Some(region) = region {
         event.set_sso_region(region);
     }
+
+    // Set the client application from environment variable
+    if let Ok(client_app) = std::env::var(Q_CLI_CLIENT_APPLICATION) {
+        event.set_client_application(client_app);
+    }
 }
 
 #[derive(Debug)]
@@ -690,7 +713,8 @@ mod test {
 
         thread.send_user_logged_in().ok();
         thread
-            .send_cli_subcommand_executed(&RootSubcommand::Version { changelog: None })
+            .send_cli_subcommand_executed(&database, &RootSubcommand::Version { changelog: None })
+            .await
             .ok();
         thread
             .send_chat_added_message(

crates/chat-cli/src/util/consts.rs

@@ -66,7 +66,10 @@ pub mod env_var {
         Q_USING_ZSH_AUTOSUGGESTIONS = "Q_USING_ZSH_AUTOSUGGESTIONS",
 
         /// Overrides the path to the bundle metadata released with certain desktop builds.
-        Q_BUNDLE_METADATA_PATH = "Q_BUNDLE_METADATA_PATH"
+        Q_BUNDLE_METADATA_PATH = "Q_BUNDLE_METADATA_PATH",
+
+        /// Identifier for the client application or service using the chat-cli
+        Q_CLI_CLIENT_APPLICATION = "Q_CLI_CLIENT_APPLICATION"
     }
 }