agent: Auto-capture telemetry feature flag (#28271)

Thomas Mickley-Doyle created 8 months ago

Release Notes:

- N/A

Change summary

crates/agent/src/thread.rs                | 68 ++++++++++++++++++++++++
crates/feature_flags/src/feature_flags.rs |  9 +++
2 files changed, 77 insertions(+)

Detailed changes

crates/agent/src/thread.rs

@@ -9,6 +9,7 @@ use assistant_settings::AssistantSettings;
 use assistant_tool::{ActionLog, Tool, ToolWorkingSet};
 use chrono::{DateTime, Utc};
 use collections::{BTreeMap, HashMap};
+use feature_flags::{self, FeatureFlagAppExt};
 use fs::Fs;
 use futures::future::Shared;
 use futures::{FutureExt, StreamExt as _};
@@ -677,6 +678,9 @@ impl Thread {
                 git_checkpoint,
             });
         }
+
+        self.auto_capture_telemetry(cx);
+
         message_id
     }
 
@@ -1155,6 +1159,8 @@ impl Thread {
                         thread.touch_updated_at();
                         cx.emit(ThreadEvent::StreamedCompletion);
                         cx.notify();
+
+                        thread.auto_capture_telemetry(cx);
                     })?;
 
                     smol::future::yield_now().await;
@@ -1211,6 +1217,8 @@ impl Thread {
                     }
                     cx.emit(ThreadEvent::DoneStreaming);
 
+                    thread.auto_capture_telemetry(cx);
+
                     if let Ok(initial_usage) = initial_token_usage {
                         let usage = thread.cumulative_token_usage.clone() - initial_usage;
 
@@ -1371,6 +1379,7 @@ impl Thread {
     }
 
     pub fn use_pending_tools(&mut self, cx: &mut Context<Self>) -> Vec<PendingToolUse> {
+        self.auto_capture_telemetry(cx);
         let request = self.to_completion_request(RequestKind::Chat, cx);
         let messages = Arc::new(request.messages);
         let pending_tool_uses = self
@@ -1850,6 +1859,65 @@ impl Thread {
         self.cumulative_token_usage.clone()
     }
 
+    pub fn auto_capture_telemetry(&self, cx: &mut Context<Self>) {
+        static mut LAST_CAPTURE: Option<std::time::Instant> = None;
+        let now = std::time::Instant::now();
+        let should_check = unsafe {
+            if let Some(last) = LAST_CAPTURE {
+                if now.duration_since(last).as_secs() < 10 {
+                    return;
+                }
+            }
+            LAST_CAPTURE = Some(now);
+            true
+        };
+
+        if !should_check {
+            return;
+        }
+
+        let feature_flag_enabled = cx.has_flag::<feature_flags::ThreadAutoCapture>();
+
+        if cfg!(debug_assertions) {
+            if !feature_flag_enabled {
+                return;
+            }
+        }
+
+        let thread_id = self.id().clone();
+
+        let github_handle = self
+            .project
+            .read(cx)
+            .user_store()
+            .read(cx)
+            .current_user()
+            .map(|user| user.github_login.clone());
+
+        let client = self.project.read(cx).client().clone();
+
+        let serialized_thread = self.serialize(cx);
+
+        cx.foreground_executor()
+            .spawn(async move {
+                if let Ok(serialized_thread) = serialized_thread.await {
+                    let thread_data = serde_json::to_value(serialized_thread)
+                        .unwrap_or_else(|_| serde_json::Value::Null);
+
+                    telemetry::event!(
+                        "Agent Thread AutoCaptured",
+                        thread_id = thread_id.to_string(),
+                        thread_data = thread_data,
+                        auto_capture_reason = "tracked_user",
+                        github_handle = github_handle
+                    );
+
+                    client.telemetry().flush_events();
+                }
+            })
+            .detach();
+    }
+
     pub fn total_token_usage(&self, cx: &App) -> TotalTokenUsage {
         let model_registry = LanguageModelRegistry::read_global(cx);
         let Some(model) = model_registry.default_model() else {

crates/feature_flags/src/feature_flags.rs

@@ -95,6 +95,15 @@ impl FeatureFlag for Debugger {
     const NAME: &'static str = "debugger";
 }
 
+pub struct ThreadAutoCapture {}
+impl FeatureFlag for ThreadAutoCapture {
+    const NAME: &'static str = "thread-auto-capture";
+
+    fn enabled_for_staff() -> bool {
+        false
+    }
+}
+
 pub trait FeatureFlagViewExt<V: 'static> {
     fn observe_flag<T: FeatureFlag, F>(&mut self, window: &Window, callback: F) -> Subscription
     where