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