Migrate more events to telemetry::event! macro (#24102)

I believe this takes care of the remaining events running through the
old flow that requires transformation at the collab server level. I
think all events are now going through `telemetry::event!()`.

For anyone curious where the new telemetry names are coming from, you
can check the `for_snowflake` function within
`crates/collab/src/api/events.rs`, to see how collab is currently
transforming the events going through the old flow.

Release Notes:

- N/A

crates/client/src/telemetry.rs

@@ -3,7 +3,6 @@ mod event_coalescer;
 use crate::TelemetrySettings;
 use anyhow::Result;
 use clock::SystemClock;
-use collections::{HashMap, HashSet};
 use futures::channel::mpsc;
 use futures::{Future, StreamExt};
 use gpui::{App, BackgroundExecutor, Task};
@@ -12,14 +11,13 @@ use parking_lot::Mutex;
 use release_channel::ReleaseChannel;
 use settings::{Settings, SettingsStore};
 use sha2::{Digest, Sha256};
+use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::io::Write;
 use std::sync::LazyLock;
 use std::time::Instant;
 use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
-use telemetry_events::{
-    AppEvent, AssistantEvent, AssistantPhase, EditEvent, Event, EventRequestBody, EventWrapper,
-};
+use telemetry_events::{AssistantEvent, AssistantPhase, Event, EventRequestBody, EventWrapper};
 use util::{ResultExt, TryFutureExt};
 use worktree::{UpdatedEntriesSet, WorktreeId};
 
@@ -285,7 +283,7 @@ impl Telemetry {
     // TestAppContext ends up calling this function on shutdown and it panics when trying to find the TelemetrySettings
     #[cfg(not(any(test, feature = "test-support")))]
     fn shutdown_telemetry(self: &Arc<Self>) -> impl Future<Output = ()> {
-        self.report_app_event("close".to_string());
+        telemetry::event!("App Closed");
         // TODO: close final edit period and make sure it's sent
         Task::ready(())
     }
@@ -355,30 +353,23 @@ impl Telemetry {
         );
     }
 
-    pub fn report_app_event(self: &Arc<Self>, operation: String) -> Event {
-        let event = Event::App(AppEvent { operation });
-
-        self.report_event(event.clone());
-
-        event
-    }
-
     pub fn log_edit_event(self: &Arc<Self>, environment: &'static str, is_via_ssh: bool) {
         let mut state = self.state.lock();
         let period_data = state.event_coalescer.log_event(environment);
         drop(state);
 
         if let Some((start, end, environment)) = period_data {
-            let event = Event::Edit(EditEvent {
-                duration: end
-                    .saturating_duration_since(start)
-                    .min(Duration::from_secs(60 * 60 * 24))
-                    .as_millis() as i64,
-                environment: environment.to_string(),
-                is_via_ssh,
-            });
+            let duration_milliseconds = end
+                .saturating_duration_since(start)
+                .min(Duration::from_secs(60 * 60 * 24))
+                .as_millis() as i64;
 
-            self.report_event(event);
+            telemetry::event!(
+                "Editor Edited",
+                duration_milliseconds = duration_milliseconds,
+                environment = environment.to_string(),
+                is_via_ssh = is_via_ssh
+            );
         }
     }
 
@@ -422,9 +413,8 @@ impl Telemetry {
                 .collect()
         };
 
-        // Done on purpose to avoid calling `self.state.lock()` multiple times
         for project_type_name in project_type_names {
-            self.report_app_event(format!("open {} project", project_type_name));
+            telemetry::event!("Project Opened", project_type = project_type_name);
         }
     }
 
@@ -590,6 +580,7 @@ mod tests {
     use clock::FakeSystemClock;
     use gpui::TestAppContext;
     use http_client::FakeHttpClient;
+    use telemetry_events::FlexibleEvent;
 
     #[gpui::test]
     fn test_telemetry_flush_on_max_queue_size(cx: &mut TestAppContext) {
@@ -609,15 +600,17 @@ mod tests {
             assert!(is_empty_state(&telemetry));
 
             let first_date_time = clock.utc_now();
-            let operation = "test".to_string();
+            let event_properties = HashMap::from_iter([(
+                "test_key".to_string(),
+                serde_json::Value::String("test_value".to_string()),
+            )]);
 
-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
+            let event = FlexibleEvent {
+                event_type: "test".to_string(),
+                event_properties,
+            };
+
+            telemetry.report_event(Event::Flexible(event.clone()));
             assert_eq!(telemetry.state.lock().events_queue.len(), 1);
             assert!(telemetry.state.lock().flush_events_task.is_some());
             assert_eq!(
@@ -627,13 +620,7 @@ mod tests {
 
             clock.advance(Duration::from_millis(100));
 
-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
+            telemetry.report_event(Event::Flexible(event.clone()));
             assert_eq!(telemetry.state.lock().events_queue.len(), 2);
             assert!(telemetry.state.lock().flush_events_task.is_some());
             assert_eq!(
@@ -643,13 +630,7 @@ mod tests {
 
             clock.advance(Duration::from_millis(100));
 
-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
+            telemetry.report_event(Event::Flexible(event.clone()));
             assert_eq!(telemetry.state.lock().events_queue.len(), 3);
             assert!(telemetry.state.lock().flush_events_task.is_some());
             assert_eq!(
@@ -660,14 +641,7 @@ mod tests {
             clock.advance(Duration::from_millis(100));
 
             // Adding a 4th event should cause a flush
-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
-
+            telemetry.report_event(Event::Flexible(event));
             assert!(is_empty_state(&telemetry));
         });
     }
@@ -690,17 +664,19 @@ mod tests {
             telemetry.start(system_id, installation_id, session_id, cx);
 
             assert!(is_empty_state(&telemetry));
-
             let first_date_time = clock.utc_now();
-            let operation = "test".to_string();
 
-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
+            let event_properties = HashMap::from_iter([(
+                "test_key".to_string(),
+                serde_json::Value::String("test_value".to_string()),
+            )]);
+
+            let event = FlexibleEvent {
+                event_type: "test".to_string(),
+                event_properties,
+            };
+
+            telemetry.report_event(Event::Flexible(event));
             assert_eq!(telemetry.state.lock().events_queue.len(), 1);
             assert!(telemetry.state.lock().flush_events_task.is_some());
             assert_eq!(