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