1mod event_coalescer;
2
3use crate::TelemetrySettings;
4use anyhow::Result;
5use clock::SystemClock;
6use futures::channel::mpsc;
7use futures::{Future, FutureExt, StreamExt};
8use gpui::{App, AppContext as _, BackgroundExecutor, Task};
9use http_client::{self, AsyncBody, HttpClient, HttpClientWithUrl, Method, Request};
10use parking_lot::Mutex;
11use regex::Regex;
12use release_channel::ReleaseChannel;
13use settings::{Settings, SettingsStore};
14use sha2::{Digest, Sha256};
15use std::collections::HashSet;
16use std::fs::File;
17use std::io::Write;
18use std::sync::LazyLock;
19use std::time::Instant;
20use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
21use telemetry_events::{AssistantEventData, AssistantPhase, Event, EventRequestBody, EventWrapper};
22use util::TryFutureExt;
23use worktree::{UpdatedEntriesSet, WorktreeId};
24
25use self::event_coalescer::EventCoalescer;
26
27pub struct Telemetry {
28 clock: Arc<dyn SystemClock>,
29 http_client: Arc<HttpClientWithUrl>,
30 executor: BackgroundExecutor,
31 state: Arc<Mutex<TelemetryState>>,
32}
33
34struct TelemetryState {
35 settings: TelemetrySettings,
36 system_id: Option<Arc<str>>, // Per system
37 installation_id: Option<Arc<str>>, // Per app installation (different for dev, nightly, preview, and stable)
38 session_id: Option<String>, // Per app launch
39 metrics_id: Option<Arc<str>>, // Per logged-in user
40 release_channel: Option<&'static str>,
41 architecture: &'static str,
42 events_queue: Vec<EventWrapper>,
43 flush_events_task: Option<Task<()>>,
44 log_file: Option<File>,
45 is_staff: Option<bool>,
46 first_event_date_time: Option<Instant>,
47 event_coalescer: EventCoalescer,
48 max_queue_size: usize,
49 worktrees_with_project_type_events_sent: HashSet<WorktreeId>,
50
51 os_name: String,
52 app_version: String,
53 os_version: Option<String>,
54}
55
56#[cfg(debug_assertions)]
57const MAX_QUEUE_LEN: usize = 5;
58
59#[cfg(not(debug_assertions))]
60const MAX_QUEUE_LEN: usize = 50;
61
62#[cfg(debug_assertions)]
63const FLUSH_INTERVAL: Duration = Duration::from_secs(1);
64
65#[cfg(not(debug_assertions))]
66const FLUSH_INTERVAL: Duration = Duration::from_secs(60 * 5);
67static ZED_CLIENT_CHECKSUM_SEED: LazyLock<Option<Vec<u8>>> = LazyLock::new(|| {
68 option_env!("ZED_CLIENT_CHECKSUM_SEED")
69 .map(|s| s.as_bytes().into())
70 .or_else(|| {
71 env::var("ZED_CLIENT_CHECKSUM_SEED")
72 .ok()
73 .map(|s| s.as_bytes().into())
74 })
75});
76
77pub static MINIDUMP_ENDPOINT: LazyLock<Option<String>> = LazyLock::new(|| {
78 option_env!("ZED_MINIDUMP_ENDPOINT")
79 .map(str::to_string)
80 .or_else(|| env::var("ZED_MINIDUMP_ENDPOINT").ok())
81});
82
83static DOTNET_PROJECT_FILES_REGEX: LazyLock<Regex> = LazyLock::new(|| {
84 Regex::new(r"^(global\.json|Directory\.Build\.props|.*\.(csproj|fsproj|vbproj|sln))$").unwrap()
85});
86
87#[cfg(target_os = "macos")]
88static MACOS_VERSION_REGEX: LazyLock<Regex> =
89 LazyLock::new(|| Regex::new(r"(\s*\(Build [^)]*[0-9]\))").unwrap());
90
91pub fn os_name() -> String {
92 #[cfg(target_os = "macos")]
93 {
94 "macOS".to_string()
95 }
96 #[cfg(target_os = "linux")]
97 {
98 format!("Linux {}", gpui::guess_compositor())
99 }
100 #[cfg(target_os = "freebsd")]
101 {
102 format!("FreeBSD {}", gpui::guess_compositor())
103 }
104
105 #[cfg(target_os = "windows")]
106 {
107 "Windows".to_string()
108 }
109}
110
111/// Note: This might do blocking IO! Only call from background threads
112pub fn os_version() -> String {
113 #[cfg(target_os = "macos")]
114 {
115 use objc2_foundation::NSProcessInfo;
116 let process_info = NSProcessInfo::processInfo();
117 let version_nsstring = unsafe { process_info.operatingSystemVersionString() };
118 // "Version 15.6.1 (Build 24G90)" -> "15.6.1 (Build 24G90)"
119 let version_string = version_nsstring.to_string().replace("Version ", "");
120 // "15.6.1 (Build 24G90)" -> "15.6.1"
121 // "26.0.0 (Build 25A5349a)" -> unchanged (Beta or Rapid Security Response; ends with letter)
122 MACOS_VERSION_REGEX
123 .replace_all(&version_string, "")
124 .to_string()
125 }
126 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
127 {
128 use std::path::Path;
129
130 let content = if let Ok(file) = std::fs::read_to_string(&Path::new("/etc/os-release")) {
131 file
132 } else if let Ok(file) = std::fs::read_to_string(&Path::new("/usr/lib/os-release")) {
133 file
134 } else if let Ok(file) = std::fs::read_to_string(&Path::new("/var/run/os-release")) {
135 file
136 } else {
137 log::error!(
138 "Failed to load /etc/os-release, /usr/lib/os-release, or /var/run/os-release"
139 );
140 "".to_string()
141 };
142 let mut name = "unknown";
143 let mut version = "unknown";
144
145 for line in content.lines() {
146 match line.split_once('=') {
147 Some(("ID", val)) => name = val.trim_matches('"'),
148 Some(("VERSION_ID", val)) => version = val.trim_matches('"'),
149 _ => {}
150 }
151 }
152
153 format!("{} {}", name, version)
154 }
155
156 #[cfg(target_os = "windows")]
157 {
158 let mut info = unsafe { std::mem::zeroed() };
159 let status = unsafe { windows::Wdk::System::SystemServices::RtlGetVersion(&mut info) };
160 if status.is_ok() {
161 gpui::SemanticVersion::new(
162 info.dwMajorVersion as _,
163 info.dwMinorVersion as _,
164 info.dwBuildNumber as _,
165 )
166 .to_string()
167 } else {
168 "unknown".to_string()
169 }
170 }
171}
172
173impl Telemetry {
174 pub fn new(
175 clock: Arc<dyn SystemClock>,
176 client: Arc<HttpClientWithUrl>,
177 cx: &mut App,
178 ) -> Arc<Self> {
179 let release_channel =
180 ReleaseChannel::try_global(cx).map(|release_channel| release_channel.display_name());
181
182 let state = Arc::new(Mutex::new(TelemetryState {
183 settings: *TelemetrySettings::get_global(cx),
184 architecture: env::consts::ARCH,
185 release_channel,
186 system_id: None,
187 installation_id: None,
188 session_id: None,
189 metrics_id: None,
190 events_queue: Vec::new(),
191 flush_events_task: None,
192 log_file: None,
193 is_staff: None,
194 first_event_date_time: None,
195 event_coalescer: EventCoalescer::new(clock.clone()),
196 max_queue_size: MAX_QUEUE_LEN,
197 worktrees_with_project_type_events_sent: HashSet::new(),
198
199 os_version: None,
200 os_name: os_name(),
201 app_version: release_channel::AppVersion::global(cx).to_string(),
202 }));
203 Self::log_file_path();
204
205 cx.background_spawn({
206 let state = state.clone();
207 let os_version = os_version();
208 state.lock().os_version = Some(os_version);
209 async move {
210 if let Some(tempfile) = File::create(Self::log_file_path()).ok() {
211 state.lock().log_file = Some(tempfile);
212 }
213 }
214 })
215 .detach();
216
217 cx.observe_global::<SettingsStore>({
218 let state = state.clone();
219
220 move |cx| {
221 let mut state = state.lock();
222 state.settings = *TelemetrySettings::get_global(cx);
223 }
224 })
225 .detach();
226
227 let this = Arc::new(Self {
228 clock,
229 http_client: client,
230 executor: cx.background_executor().clone(),
231 state,
232 });
233
234 let (tx, mut rx) = mpsc::unbounded();
235 ::telemetry::init(tx);
236
237 cx.background_spawn({
238 let this = Arc::downgrade(&this);
239 async move {
240 while let Some(event) = rx.next().await {
241 let Some(state) = this.upgrade() else { break };
242 state.report_event(Event::Flexible(event))
243 }
244 }
245 })
246 .detach();
247
248 // We should only ever have one instance of Telemetry, leak the subscription to keep it alive
249 // rather than store in TelemetryState, complicating spawn as subscriptions are not Send
250 std::mem::forget(cx.on_app_quit({
251 let this = this.clone();
252 move |_| this.shutdown_telemetry()
253 }));
254
255 this
256 }
257
258 #[cfg(any(test, feature = "test-support"))]
259 fn shutdown_telemetry(self: &Arc<Self>) -> impl Future<Output = ()> + use<> {
260 Task::ready(())
261 }
262
263 // Skip calling this function in tests.
264 // TestAppContext ends up calling this function on shutdown and it panics when trying to find the TelemetrySettings
265 #[cfg(not(any(test, feature = "test-support")))]
266 fn shutdown_telemetry(self: &Arc<Self>) -> impl Future<Output = ()> + use<> {
267 telemetry::event!("App Closed");
268 // TODO: close final edit period and make sure it's sent
269 Task::ready(())
270 }
271
272 pub fn log_file_path() -> PathBuf {
273 paths::logs_dir().join("telemetry.log")
274 }
275
276 pub fn has_checksum_seed(&self) -> bool {
277 ZED_CLIENT_CHECKSUM_SEED.is_some()
278 }
279
280 pub fn start(
281 self: &Arc<Self>,
282 system_id: Option<String>,
283 installation_id: Option<String>,
284 session_id: String,
285 cx: &App,
286 ) {
287 let mut state = self.state.lock();
288 state.system_id = system_id.map(|id| id.into());
289 state.installation_id = installation_id.map(|id| id.into());
290 state.session_id = Some(session_id);
291 state.app_version = release_channel::AppVersion::global(cx).to_string();
292 state.os_name = os_name();
293 }
294
295 pub fn metrics_enabled(self: &Arc<Self>) -> bool {
296 let state = self.state.lock();
297 let enabled = state.settings.metrics;
298 drop(state);
299 enabled
300 }
301
302 pub fn set_authenticated_user_info(
303 self: &Arc<Self>,
304 metrics_id: Option<String>,
305 is_staff: bool,
306 ) {
307 let mut state = self.state.lock();
308
309 if !state.settings.metrics {
310 return;
311 }
312
313 let metrics_id: Option<Arc<str>> = metrics_id.map(|id| id.into());
314 state.metrics_id.clone_from(&metrics_id);
315 state.is_staff = Some(is_staff);
316 drop(state);
317 }
318
319 pub fn report_assistant_event(self: &Arc<Self>, event: AssistantEventData) {
320 let event_type = match event.phase {
321 AssistantPhase::Response => "Assistant Responded",
322 AssistantPhase::Invoked => "Assistant Invoked",
323 AssistantPhase::Accepted => "Assistant Response Accepted",
324 AssistantPhase::Rejected => "Assistant Response Rejected",
325 };
326
327 telemetry::event!(
328 event_type,
329 conversation_id = event.conversation_id,
330 kind = event.kind,
331 phase = event.phase,
332 message_id = event.message_id,
333 model = event.model,
334 model_provider = event.model_provider,
335 response_latency = event.response_latency,
336 error_message = event.error_message,
337 language_name = event.language_name,
338 );
339 }
340
341 pub fn log_edit_event(self: &Arc<Self>, environment: &'static str, is_via_ssh: bool) {
342 static LAST_EVENT_TIME: Mutex<Option<Instant>> = Mutex::new(None);
343
344 let mut state = self.state.lock();
345 let period_data = state.event_coalescer.log_event(environment);
346 drop(state);
347
348 if let Some(mut last_event) = LAST_EVENT_TIME.try_lock() {
349 let current_time = std::time::Instant::now();
350 let last_time = last_event.get_or_insert(current_time);
351
352 if current_time.duration_since(*last_time) > Duration::from_secs(60 * 10) {
353 *last_time = current_time;
354 } else {
355 return;
356 }
357
358 if let Some((start, end, environment)) = period_data {
359 let duration = end
360 .saturating_duration_since(start)
361 .min(Duration::from_secs(60 * 60 * 24))
362 .as_millis() as i64;
363
364 telemetry::event!(
365 "Editor Edited",
366 duration = duration,
367 environment = environment,
368 is_via_ssh = is_via_ssh
369 );
370 }
371 }
372 }
373
374 pub fn report_discovered_project_type_events(
375 self: &Arc<Self>,
376 worktree_id: WorktreeId,
377 updated_entries_set: &UpdatedEntriesSet,
378 ) {
379 let Some(project_types) = self.detect_project_types(worktree_id, updated_entries_set)
380 else {
381 return;
382 };
383
384 for project_type in project_types {
385 telemetry::event!("Project Opened", project_type = project_type);
386 }
387 }
388
389 fn detect_project_types(
390 self: &Arc<Self>,
391 worktree_id: WorktreeId,
392 updated_entries_set: &UpdatedEntriesSet,
393 ) -> Option<Vec<String>> {
394 let mut state = self.state.lock();
395
396 if state
397 .worktrees_with_project_type_events_sent
398 .contains(&worktree_id)
399 {
400 return None;
401 }
402
403 let mut project_types: HashSet<&str> = HashSet::new();
404
405 for (path, _, _) in updated_entries_set.iter() {
406 let Some(file_name) = path.file_name() else {
407 continue;
408 };
409
410 let project_type = if file_name == "pnpm-lock.yaml" {
411 Some("pnpm")
412 } else if file_name == "yarn.lock" {
413 Some("yarn")
414 } else if file_name == "package.json" {
415 Some("node")
416 } else if DOTNET_PROJECT_FILES_REGEX.is_match(file_name) {
417 Some("dotnet")
418 } else {
419 None
420 };
421
422 if let Some(project_type) = project_type {
423 project_types.insert(project_type);
424 };
425 }
426
427 if !project_types.is_empty() {
428 state
429 .worktrees_with_project_type_events_sent
430 .insert(worktree_id);
431 }
432
433 let mut project_types: Vec<_> = project_types.into_iter().map(String::from).collect();
434 project_types.sort();
435 Some(project_types)
436 }
437
438 fn report_event(self: &Arc<Self>, mut event: Event) {
439 let mut state = self.state.lock();
440 // RUST_LOG=telemetry=trace to debug telemetry events
441 log::trace!(target: "telemetry", "{:?}", event);
442
443 if !state.settings.metrics {
444 return;
445 }
446
447 match &mut event {
448 Event::Flexible(event) => event
449 .event_properties
450 .insert("event_source".into(), "zed".into()),
451 };
452
453 if state.flush_events_task.is_none() {
454 let this = self.clone();
455 state.flush_events_task = Some(self.executor.spawn(async move {
456 this.executor.timer(FLUSH_INTERVAL).await;
457 this.flush_events().detach();
458 }));
459 }
460
461 let date_time = self.clock.utc_now();
462
463 let milliseconds_since_first_event = match state.first_event_date_time {
464 Some(first_event_date_time) => date_time
465 .saturating_duration_since(first_event_date_time)
466 .min(Duration::from_secs(60 * 60 * 24))
467 .as_millis() as i64,
468 None => {
469 state.first_event_date_time = Some(date_time);
470 0
471 }
472 };
473
474 let signed_in = state.metrics_id.is_some();
475 state.events_queue.push(EventWrapper {
476 signed_in,
477 milliseconds_since_first_event,
478 event,
479 });
480
481 if state.installation_id.is_some() && state.events_queue.len() >= state.max_queue_size {
482 drop(state);
483 self.flush_events().detach();
484 }
485 }
486
487 pub fn metrics_id(self: &Arc<Self>) -> Option<Arc<str>> {
488 self.state.lock().metrics_id.clone()
489 }
490
491 pub fn system_id(self: &Arc<Self>) -> Option<Arc<str>> {
492 self.state.lock().system_id.clone()
493 }
494
495 pub fn installation_id(self: &Arc<Self>) -> Option<Arc<str>> {
496 self.state.lock().installation_id.clone()
497 }
498
499 pub fn is_staff(self: &Arc<Self>) -> Option<bool> {
500 self.state.lock().is_staff
501 }
502
503 fn build_request(
504 self: &Arc<Self>,
505 // We take in the JSON bytes buffer so we can reuse the existing allocation.
506 mut json_bytes: Vec<u8>,
507 event_request: &EventRequestBody,
508 ) -> Result<Request<AsyncBody>> {
509 json_bytes.clear();
510 serde_json::to_writer(&mut json_bytes, event_request)?;
511
512 let checksum = calculate_json_checksum(&json_bytes).unwrap_or_default();
513
514 Ok(Request::builder()
515 .method(Method::POST)
516 .uri(
517 self.http_client
518 .build_zed_api_url("/telemetry/events", &[])?
519 .as_ref(),
520 )
521 .header("Content-Type", "application/json")
522 .header("x-zed-checksum", checksum)
523 .body(json_bytes.into())?)
524 }
525
526 pub fn flush_events(self: &Arc<Self>) -> Task<()> {
527 let mut state = self.state.lock();
528 state.first_event_date_time = None;
529 let events = mem::take(&mut state.events_queue);
530 state.flush_events_task.take();
531 drop(state);
532 if events.is_empty() {
533 return Task::ready(());
534 }
535
536 let this = self.clone();
537 self.executor.spawn(
538 async move {
539 let mut json_bytes = Vec::new();
540
541 if let Some(file) = &mut this.state.lock().log_file {
542 for event in &events {
543 json_bytes.clear();
544 serde_json::to_writer(&mut json_bytes, event)?;
545 file.write_all(&json_bytes)?;
546 file.write_all(b"\n")?;
547 }
548 }
549
550 let request_body = {
551 let state = this.state.lock();
552
553 EventRequestBody {
554 system_id: state.system_id.as_deref().map(Into::into),
555 installation_id: state.installation_id.as_deref().map(Into::into),
556 session_id: state.session_id.clone(),
557 metrics_id: state.metrics_id.as_deref().map(Into::into),
558 is_staff: state.is_staff,
559 app_version: state.app_version.clone(),
560 os_name: state.os_name.clone(),
561 os_version: state.os_version.clone(),
562 architecture: state.architecture.to_string(),
563
564 release_channel: state.release_channel.map(Into::into),
565 events,
566 }
567 };
568
569 let request = this.build_request(json_bytes, &request_body)?;
570 let response = this.http_client.send(request).await?;
571 if response.status() != 200 {
572 log::error!("Failed to send events: HTTP {:?}", response.status());
573 }
574 anyhow::Ok(())
575 }
576 .log_err()
577 .map(|_| ()),
578 )
579 }
580}
581
582pub fn calculate_json_checksum(json: &impl AsRef<[u8]>) -> Option<String> {
583 let Some(checksum_seed) = &*ZED_CLIENT_CHECKSUM_SEED else {
584 return None;
585 };
586
587 let mut summer = Sha256::new();
588 summer.update(checksum_seed);
589 summer.update(json);
590 summer.update(checksum_seed);
591 let mut checksum = String::new();
592 for byte in summer.finalize().as_slice() {
593 use std::fmt::Write;
594 write!(&mut checksum, "{:02x}", byte).unwrap();
595 }
596
597 Some(checksum)
598}
599
600#[cfg(test)]
601mod tests {
602 use super::*;
603 use clock::FakeSystemClock;
604 use gpui::TestAppContext;
605 use http_client::FakeHttpClient;
606 use std::collections::HashMap;
607 use telemetry_events::FlexibleEvent;
608 use util::rel_path::RelPath;
609 use worktree::{PathChange, ProjectEntryId, WorktreeId};
610
611 #[gpui::test]
612 fn test_telemetry_flush_on_max_queue_size(cx: &mut TestAppContext) {
613 init_test(cx);
614 let clock = Arc::new(FakeSystemClock::new());
615 let http = FakeHttpClient::with_200_response();
616 let system_id = Some("system_id".to_string());
617 let installation_id = Some("installation_id".to_string());
618 let session_id = "session_id".to_string();
619
620 cx.update(|cx| {
621 let telemetry = Telemetry::new(clock.clone(), http, cx);
622
623 telemetry.state.lock().max_queue_size = 4;
624 telemetry.start(system_id, installation_id, session_id, cx);
625
626 assert!(is_empty_state(&telemetry));
627
628 let first_date_time = clock.utc_now();
629 let event_properties = HashMap::from_iter([(
630 "test_key".to_string(),
631 serde_json::Value::String("test_value".to_string()),
632 )]);
633
634 let event = FlexibleEvent {
635 event_type: "test".to_string(),
636 event_properties,
637 };
638
639 telemetry.report_event(Event::Flexible(event.clone()));
640 assert_eq!(telemetry.state.lock().events_queue.len(), 1);
641 assert!(telemetry.state.lock().flush_events_task.is_some());
642 assert_eq!(
643 telemetry.state.lock().first_event_date_time,
644 Some(first_date_time)
645 );
646
647 clock.advance(Duration::from_millis(100));
648
649 telemetry.report_event(Event::Flexible(event.clone()));
650 assert_eq!(telemetry.state.lock().events_queue.len(), 2);
651 assert!(telemetry.state.lock().flush_events_task.is_some());
652 assert_eq!(
653 telemetry.state.lock().first_event_date_time,
654 Some(first_date_time)
655 );
656
657 clock.advance(Duration::from_millis(100));
658
659 telemetry.report_event(Event::Flexible(event.clone()));
660 assert_eq!(telemetry.state.lock().events_queue.len(), 3);
661 assert!(telemetry.state.lock().flush_events_task.is_some());
662 assert_eq!(
663 telemetry.state.lock().first_event_date_time,
664 Some(first_date_time)
665 );
666
667 clock.advance(Duration::from_millis(100));
668
669 // Adding a 4th event should cause a flush
670 telemetry.report_event(Event::Flexible(event));
671 assert!(is_empty_state(&telemetry));
672 });
673 }
674
675 #[gpui::test]
676 async fn test_telemetry_flush_on_flush_interval(
677 executor: BackgroundExecutor,
678 cx: &mut TestAppContext,
679 ) {
680 init_test(cx);
681 let clock = Arc::new(FakeSystemClock::new());
682 let http = FakeHttpClient::with_200_response();
683 let system_id = Some("system_id".to_string());
684 let installation_id = Some("installation_id".to_string());
685 let session_id = "session_id".to_string();
686
687 cx.update(|cx| {
688 let telemetry = Telemetry::new(clock.clone(), http, cx);
689 telemetry.state.lock().max_queue_size = 4;
690 telemetry.start(system_id, installation_id, session_id, cx);
691
692 assert!(is_empty_state(&telemetry));
693 let first_date_time = clock.utc_now();
694
695 let event_properties = HashMap::from_iter([(
696 "test_key".to_string(),
697 serde_json::Value::String("test_value".to_string()),
698 )]);
699
700 let event = FlexibleEvent {
701 event_type: "test".to_string(),
702 event_properties,
703 };
704
705 telemetry.report_event(Event::Flexible(event));
706 assert_eq!(telemetry.state.lock().events_queue.len(), 1);
707 assert!(telemetry.state.lock().flush_events_task.is_some());
708 assert_eq!(
709 telemetry.state.lock().first_event_date_time,
710 Some(first_date_time)
711 );
712
713 let duration = Duration::from_millis(1);
714
715 // Test 1 millisecond before the flush interval limit is met
716 executor.advance_clock(FLUSH_INTERVAL - duration);
717
718 assert!(!is_empty_state(&telemetry));
719
720 // Test the exact moment the flush interval limit is met
721 executor.advance_clock(duration);
722
723 assert!(is_empty_state(&telemetry));
724 });
725 }
726
727 #[gpui::test]
728 fn test_project_discovery_does_not_double_report(cx: &mut gpui::TestAppContext) {
729 init_test(cx);
730
731 let clock = Arc::new(FakeSystemClock::new());
732 let http = FakeHttpClient::with_200_response();
733 let telemetry = cx.update(|cx| Telemetry::new(clock.clone(), http, cx));
734 let worktree_id = 1;
735
736 // Scan of empty worktree finds nothing
737 test_project_discovery_helper(telemetry.clone(), vec![], Some(vec![]), worktree_id);
738
739 // Files added, second scan of worktree 1 finds project type
740 test_project_discovery_helper(
741 telemetry.clone(),
742 vec!["package.json"],
743 Some(vec!["node"]),
744 worktree_id,
745 );
746
747 // Third scan of worktree does not double report, as we already reported
748 test_project_discovery_helper(telemetry, vec!["package.json"], None, worktree_id);
749 }
750
751 #[gpui::test]
752 fn test_pnpm_project_discovery(cx: &mut gpui::TestAppContext) {
753 init_test(cx);
754
755 let clock = Arc::new(FakeSystemClock::new());
756 let http = FakeHttpClient::with_200_response();
757 let telemetry = cx.update(|cx| Telemetry::new(clock.clone(), http, cx));
758
759 test_project_discovery_helper(
760 telemetry,
761 vec!["package.json", "pnpm-lock.yaml"],
762 Some(vec!["node", "pnpm"]),
763 1,
764 );
765 }
766
767 #[gpui::test]
768 fn test_yarn_project_discovery(cx: &mut gpui::TestAppContext) {
769 init_test(cx);
770
771 let clock = Arc::new(FakeSystemClock::new());
772 let http = FakeHttpClient::with_200_response();
773 let telemetry = cx.update(|cx| Telemetry::new(clock.clone(), http, cx));
774
775 test_project_discovery_helper(
776 telemetry,
777 vec!["package.json", "yarn.lock"],
778 Some(vec!["node", "yarn"]),
779 1,
780 );
781 }
782
783 #[gpui::test]
784 fn test_dotnet_project_discovery(cx: &mut gpui::TestAppContext) {
785 init_test(cx);
786
787 let clock = Arc::new(FakeSystemClock::new());
788 let http = FakeHttpClient::with_200_response();
789 let telemetry = cx.update(|cx| Telemetry::new(clock.clone(), http, cx));
790
791 // Using different worktrees, as production code blocks from reporting a
792 // project type for the same worktree multiple times
793
794 test_project_discovery_helper(
795 telemetry.clone(),
796 vec!["global.json"],
797 Some(vec!["dotnet"]),
798 1,
799 );
800 test_project_discovery_helper(
801 telemetry.clone(),
802 vec!["Directory.Build.props"],
803 Some(vec!["dotnet"]),
804 2,
805 );
806 test_project_discovery_helper(
807 telemetry.clone(),
808 vec!["file.csproj"],
809 Some(vec!["dotnet"]),
810 3,
811 );
812 test_project_discovery_helper(
813 telemetry.clone(),
814 vec!["file.fsproj"],
815 Some(vec!["dotnet"]),
816 4,
817 );
818 test_project_discovery_helper(
819 telemetry.clone(),
820 vec!["file.vbproj"],
821 Some(vec!["dotnet"]),
822 5,
823 );
824 test_project_discovery_helper(telemetry.clone(), vec!["file.sln"], Some(vec!["dotnet"]), 6);
825
826 // Each worktree should only send a single project type event, even when
827 // encountering multiple files associated with that project type
828 test_project_discovery_helper(
829 telemetry,
830 vec!["global.json", "Directory.Build.props"],
831 Some(vec!["dotnet"]),
832 7,
833 );
834 }
835
836 // TODO:
837 // Test settings
838 // Update FakeHTTPClient to keep track of the number of requests and assert on it
839
840 fn init_test(cx: &mut TestAppContext) {
841 cx.update(|cx| {
842 let settings_store = SettingsStore::test(cx);
843 cx.set_global(settings_store);
844 });
845 }
846
847 fn is_empty_state(telemetry: &Telemetry) -> bool {
848 telemetry.state.lock().events_queue.is_empty()
849 && telemetry.state.lock().flush_events_task.is_none()
850 && telemetry.state.lock().first_event_date_time.is_none()
851 }
852
853 fn test_project_discovery_helper(
854 telemetry: Arc<Telemetry>,
855 file_paths: Vec<&str>,
856 expected_project_types: Option<Vec<&str>>,
857 worktree_id_num: usize,
858 ) {
859 let worktree_id = WorktreeId::from_usize(worktree_id_num);
860 let entries: Vec<_> = file_paths
861 .into_iter()
862 .enumerate()
863 .filter_map(|(i, path)| {
864 Some((
865 Arc::from(RelPath::unix(path).ok()?),
866 ProjectEntryId::from_proto(i as u64 + 1),
867 PathChange::Added,
868 ))
869 })
870 .collect();
871 let updated_entries: UpdatedEntriesSet = Arc::from(entries.as_slice());
872
873 let detected_project_types = telemetry.detect_project_types(worktree_id, &updated_entries);
874
875 let expected_project_types =
876 expected_project_types.map(|types| types.iter().map(|&t| t.to_string()).collect());
877
878 assert_eq!(detected_project_types, expected_project_types);
879 }
880}