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