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