1mod event_coalescer;
2
3use crate::{ChannelId, TelemetrySettings};
4use anyhow::Result;
5use chrono::{DateTime, Utc};
6use clock::SystemClock;
7use collections::{HashMap, HashSet};
8use futures::Future;
9use gpui::{AppContext, BackgroundExecutor, Task};
10use http_client::{self, AsyncBody, HttpClient, HttpClientWithUrl, Method, Request};
11use once_cell::sync::Lazy;
12use parking_lot::Mutex;
13use release_channel::ReleaseChannel;
14use settings::{Settings, SettingsStore};
15use sha2::{Digest, Sha256};
16use std::io::Write;
17use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
18use sysinfo::{CpuRefreshKind, Pid, ProcessRefreshKind, RefreshKind, System};
19use telemetry_events::{
20 ActionEvent, AppEvent, AssistantEvent, CallEvent, CpuEvent, EditEvent, EditorEvent, Event,
21 EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, MemoryEvent, ReplEvent,
22 SettingEvent,
23};
24use tempfile::NamedTempFile;
25#[cfg(not(debug_assertions))]
26use util::ResultExt;
27use util::TryFutureExt;
28use worktree::{UpdatedEntriesSet, WorktreeId};
29
30use self::event_coalescer::EventCoalescer;
31
32pub struct Telemetry {
33 clock: Arc<dyn SystemClock>,
34 http_client: Arc<HttpClientWithUrl>,
35 executor: BackgroundExecutor,
36 state: Arc<Mutex<TelemetryState>>,
37}
38
39struct TelemetryState {
40 settings: TelemetrySettings,
41 system_id: Option<Arc<str>>, // Per system
42 installation_id: Option<Arc<str>>, // Per app installation (different for dev, nightly, preview, and stable)
43 session_id: Option<String>, // Per app launch
44 metrics_id: Option<Arc<str>>, // Per logged-in user
45 release_channel: Option<&'static str>,
46 architecture: &'static str,
47 events_queue: Vec<EventWrapper>,
48 flush_events_task: Option<Task<()>>,
49 log_file: Option<NamedTempFile>,
50 is_staff: Option<bool>,
51 first_event_date_time: Option<DateTime<Utc>>,
52 event_coalescer: EventCoalescer,
53 max_queue_size: usize,
54 worktree_id_map: WorktreeIdMap,
55
56 os_name: String,
57 app_version: String,
58 os_version: Option<String>,
59}
60
61#[derive(Debug)]
62struct WorktreeIdMap(HashMap<String, ProjectCache>);
63
64#[derive(Debug)]
65struct ProjectCache {
66 name: String,
67 worktree_ids_reported: HashSet<WorktreeId>,
68}
69
70impl ProjectCache {
71 fn new(name: String) -> Self {
72 Self {
73 name,
74 worktree_ids_reported: HashSet::default(),
75 }
76 }
77}
78
79#[cfg(debug_assertions)]
80const MAX_QUEUE_LEN: usize = 5;
81
82#[cfg(not(debug_assertions))]
83const MAX_QUEUE_LEN: usize = 50;
84
85#[cfg(debug_assertions)]
86const FLUSH_INTERVAL: Duration = Duration::from_secs(1);
87
88#[cfg(not(debug_assertions))]
89const FLUSH_INTERVAL: Duration = Duration::from_secs(60 * 5);
90static ZED_CLIENT_CHECKSUM_SEED: Lazy<Option<Vec<u8>>> = Lazy::new(|| {
91 option_env!("ZED_CLIENT_CHECKSUM_SEED")
92 .map(|s| s.as_bytes().into())
93 .or_else(|| {
94 env::var("ZED_CLIENT_CHECKSUM_SEED")
95 .ok()
96 .map(|s| s.as_bytes().into())
97 })
98});
99
100pub fn os_name() -> String {
101 #[cfg(target_os = "macos")]
102 {
103 "macOS".to_string()
104 }
105 #[cfg(target_os = "linux")]
106 {
107 format!("Linux {}", gpui::guess_compositor())
108 }
109
110 #[cfg(target_os = "windows")]
111 {
112 "Windows".to_string()
113 }
114}
115
116/// Note: This might do blocking IO! Only call from background threads
117pub fn os_version() -> String {
118 #[cfg(target_os = "macos")]
119 {
120 use cocoa::base::nil;
121 use cocoa::foundation::NSProcessInfo;
122
123 unsafe {
124 let process_info = cocoa::foundation::NSProcessInfo::processInfo(nil);
125 let version = process_info.operatingSystemVersion();
126 gpui::SemanticVersion::new(
127 version.majorVersion as usize,
128 version.minorVersion as usize,
129 version.patchVersion as usize,
130 )
131 .to_string()
132 }
133 }
134 #[cfg(target_os = "linux")]
135 {
136 use std::path::Path;
137
138 let content = if let Ok(file) = std::fs::read_to_string(&Path::new("/etc/os-release")) {
139 file
140 } else if let Ok(file) = std::fs::read_to_string(&Path::new("/usr/lib/os-release")) {
141 file
142 } else {
143 log::error!("Failed to load /etc/os-release, /usr/lib/os-release");
144 "".to_string()
145 };
146 let mut name = "unknown".to_string();
147 let mut version = "unknown".to_string();
148
149 for line in content.lines() {
150 if line.starts_with("ID=") {
151 name = line.trim_start_matches("ID=").trim_matches('"').to_string();
152 }
153 if line.starts_with("VERSION_ID=") {
154 version = line
155 .trim_start_matches("VERSION_ID=")
156 .trim_matches('"')
157 .to_string();
158 }
159 }
160
161 format!("{} {}", name, version)
162 }
163
164 #[cfg(target_os = "windows")]
165 {
166 let mut info = unsafe { std::mem::zeroed() };
167 let status = unsafe { windows::Wdk::System::SystemServices::RtlGetVersion(&mut info) };
168 if status.is_ok() {
169 gpui::SemanticVersion::new(
170 info.dwMajorVersion as _,
171 info.dwMinorVersion as _,
172 info.dwBuildNumber as _,
173 )
174 .to_string()
175 } else {
176 "unknown".to_string()
177 }
178 }
179}
180
181impl Telemetry {
182 pub fn new(
183 clock: Arc<dyn SystemClock>,
184 client: Arc<HttpClientWithUrl>,
185 cx: &mut AppContext,
186 ) -> Arc<Self> {
187 let release_channel =
188 ReleaseChannel::try_global(cx).map(|release_channel| release_channel.display_name());
189
190 TelemetrySettings::register(cx);
191
192 let state = Arc::new(Mutex::new(TelemetryState {
193 settings: *TelemetrySettings::get_global(cx),
194 architecture: env::consts::ARCH,
195 release_channel,
196 system_id: None,
197 installation_id: None,
198 session_id: None,
199 metrics_id: None,
200 events_queue: Vec::new(),
201 flush_events_task: None,
202 log_file: None,
203 is_staff: None,
204 first_event_date_time: None,
205 event_coalescer: EventCoalescer::new(clock.clone()),
206 max_queue_size: MAX_QUEUE_LEN,
207 worktree_id_map: WorktreeIdMap(HashMap::from_iter([
208 (
209 "pnpm-lock.yaml".to_string(),
210 ProjectCache::new("pnpm".to_string()),
211 ),
212 (
213 "yarn.lock".to_string(),
214 ProjectCache::new("yarn".to_string()),
215 ),
216 (
217 "package.json".to_string(),
218 ProjectCache::new("node".to_string()),
219 ),
220 ])),
221
222 os_version: None,
223 os_name: os_name(),
224 app_version: release_channel::AppVersion::global(cx).to_string(),
225 }));
226
227 #[cfg(not(debug_assertions))]
228 cx.background_executor()
229 .spawn({
230 let state = state.clone();
231 async move {
232 if let Some(tempfile) =
233 NamedTempFile::new_in(paths::logs_dir().as_path()).log_err()
234 {
235 state.lock().log_file = Some(tempfile);
236 }
237 }
238 })
239 .detach();
240
241 cx.observe_global::<SettingsStore>({
242 let state = state.clone();
243
244 move |cx| {
245 let mut state = state.lock();
246 state.settings = *TelemetrySettings::get_global(cx);
247 }
248 })
249 .detach();
250
251 // TODO: Replace all hardware stuff with nested SystemSpecs json
252 let this = Arc::new(Self {
253 clock,
254 http_client: client,
255 executor: cx.background_executor().clone(),
256 state,
257 });
258
259 // We should only ever have one instance of Telemetry, leak the subscription to keep it alive
260 // rather than store in TelemetryState, complicating spawn as subscriptions are not Send
261 std::mem::forget(cx.on_app_quit({
262 let this = this.clone();
263 move |_| this.shutdown_telemetry()
264 }));
265
266 this
267 }
268
269 #[cfg(any(test, feature = "test-support"))]
270 fn shutdown_telemetry(self: &Arc<Self>) -> impl Future<Output = ()> {
271 Task::ready(())
272 }
273
274 // Skip calling this function in tests.
275 // TestAppContext ends up calling this function on shutdown and it panics when trying to find the TelemetrySettings
276 #[cfg(not(any(test, feature = "test-support")))]
277 fn shutdown_telemetry(self: &Arc<Self>) -> impl Future<Output = ()> {
278 self.report_app_event("close".to_string());
279 // TODO: close final edit period and make sure it's sent
280 Task::ready(())
281 }
282
283 pub fn log_file_path(&self) -> Option<PathBuf> {
284 Some(self.state.lock().log_file.as_ref()?.path().to_path_buf())
285 }
286
287 pub fn start(
288 self: &Arc<Self>,
289 system_id: Option<String>,
290 installation_id: Option<String>,
291 session_id: String,
292 cx: &AppContext,
293 ) {
294 let mut state = self.state.lock();
295 state.system_id = system_id.map(|id| id.into());
296 state.installation_id = installation_id.map(|id| id.into());
297 state.session_id = Some(session_id);
298 state.app_version = release_channel::AppVersion::global(cx).to_string();
299 state.os_name = os_name();
300
301 drop(state);
302
303 let this = self.clone();
304 cx.background_executor()
305 .spawn(async move {
306 let mut system = System::new_with_specifics(
307 RefreshKind::new().with_cpu(CpuRefreshKind::everything()),
308 );
309
310 let refresh_kind = ProcessRefreshKind::new().with_cpu().with_memory();
311 let current_process = Pid::from_u32(std::process::id());
312 system.refresh_processes_specifics(
313 sysinfo::ProcessesToUpdate::Some(&[current_process]),
314 refresh_kind,
315 );
316
317 // Waiting some amount of time before the first query is important to get a reasonable value
318 // https://docs.rs/sysinfo/0.29.10/sysinfo/trait.ProcessExt.html#tymethod.cpu_usage
319 const DURATION_BETWEEN_SYSTEM_EVENTS: Duration = Duration::from_secs(4 * 60);
320
321 loop {
322 smol::Timer::after(DURATION_BETWEEN_SYSTEM_EVENTS).await;
323
324 let current_process = Pid::from_u32(std::process::id());
325 system.refresh_processes_specifics(
326 sysinfo::ProcessesToUpdate::Some(&[current_process]),
327 refresh_kind,
328 );
329 let Some(process) = system.process(current_process) else {
330 log::error!(
331 "Failed to find own process {current_process:?} in system process table"
332 );
333 // TODO: Fire an error telemetry event
334 return;
335 };
336
337 this.report_memory_event(process.memory(), process.virtual_memory());
338 this.report_cpu_event(process.cpu_usage(), system.cpus().len() as u32);
339 }
340 })
341 .detach();
342 }
343
344 pub fn metrics_enabled(self: &Arc<Self>) -> bool {
345 let state = self.state.lock();
346 let enabled = state.settings.metrics;
347 drop(state);
348 return enabled;
349 }
350
351 pub fn set_authenticated_user_info(
352 self: &Arc<Self>,
353 metrics_id: Option<String>,
354 is_staff: bool,
355 ) {
356 let mut state = self.state.lock();
357
358 if !state.settings.metrics {
359 return;
360 }
361
362 let metrics_id: Option<Arc<str>> = metrics_id.map(|id| id.into());
363 state.metrics_id.clone_from(&metrics_id);
364 state.is_staff = Some(is_staff);
365 drop(state);
366 }
367
368 pub fn report_editor_event(
369 self: &Arc<Self>,
370 file_extension: Option<String>,
371 vim_mode: bool,
372 operation: &'static str,
373 copilot_enabled: bool,
374 copilot_enabled_for_language: bool,
375 is_via_ssh: bool,
376 ) {
377 let event = Event::Editor(EditorEvent {
378 file_extension,
379 vim_mode,
380 operation: operation.into(),
381 copilot_enabled,
382 copilot_enabled_for_language,
383 is_via_ssh,
384 });
385
386 self.report_event(event)
387 }
388
389 pub fn report_inline_completion_event(
390 self: &Arc<Self>,
391 provider: String,
392 suggestion_accepted: bool,
393 file_extension: Option<String>,
394 ) {
395 let event = Event::InlineCompletion(InlineCompletionEvent {
396 provider,
397 suggestion_accepted,
398 file_extension,
399 });
400
401 self.report_event(event)
402 }
403
404 pub fn report_assistant_event(self: &Arc<Self>, event: AssistantEvent) {
405 self.report_event(Event::Assistant(event));
406 }
407
408 pub fn report_call_event(
409 self: &Arc<Self>,
410 operation: &'static str,
411 room_id: Option<u64>,
412 channel_id: Option<ChannelId>,
413 ) {
414 let event = Event::Call(CallEvent {
415 operation: operation.to_string(),
416 room_id,
417 channel_id: channel_id.map(|cid| cid.0),
418 });
419
420 self.report_event(event)
421 }
422
423 pub fn report_cpu_event(self: &Arc<Self>, usage_as_percentage: f32, core_count: u32) {
424 let event = Event::Cpu(CpuEvent {
425 usage_as_percentage,
426 core_count,
427 });
428
429 self.report_event(event)
430 }
431
432 pub fn report_memory_event(
433 self: &Arc<Self>,
434 memory_in_bytes: u64,
435 virtual_memory_in_bytes: u64,
436 ) {
437 let event = Event::Memory(MemoryEvent {
438 memory_in_bytes,
439 virtual_memory_in_bytes,
440 });
441
442 self.report_event(event)
443 }
444
445 pub fn report_app_event(self: &Arc<Self>, operation: String) -> Event {
446 let event = Event::App(AppEvent { operation });
447
448 self.report_event(event.clone());
449
450 event
451 }
452
453 pub fn report_setting_event(self: &Arc<Self>, setting: &'static str, value: String) {
454 let event = Event::Setting(SettingEvent {
455 setting: setting.to_string(),
456 value,
457 });
458
459 self.report_event(event)
460 }
461
462 pub fn report_extension_event(self: &Arc<Self>, extension_id: Arc<str>, version: Arc<str>) {
463 self.report_event(Event::Extension(ExtensionEvent {
464 extension_id,
465 version,
466 }))
467 }
468
469 pub fn log_edit_event(self: &Arc<Self>, environment: &'static str, is_via_ssh: bool) {
470 let mut state = self.state.lock();
471 let period_data = state.event_coalescer.log_event(environment);
472 drop(state);
473
474 if let Some((start, end, environment)) = period_data {
475 let event = Event::Edit(EditEvent {
476 duration: end.timestamp_millis() - start.timestamp_millis(),
477 environment: environment.to_string(),
478 is_via_ssh,
479 });
480
481 self.report_event(event);
482 }
483 }
484
485 pub fn report_action_event(self: &Arc<Self>, source: &'static str, action: String) {
486 let event = Event::Action(ActionEvent {
487 source: source.to_string(),
488 action,
489 });
490
491 self.report_event(event)
492 }
493
494 pub fn report_discovered_project_events(
495 self: &Arc<Self>,
496 worktree_id: WorktreeId,
497 updated_entries_set: &UpdatedEntriesSet,
498 ) {
499 let project_type_names: Vec<String> = {
500 let mut state = self.state.lock();
501 state
502 .worktree_id_map
503 .0
504 .iter_mut()
505 .filter_map(|(project_file_name, project_type_telemetry)| {
506 if project_type_telemetry
507 .worktree_ids_reported
508 .contains(&worktree_id)
509 {
510 return None;
511 }
512
513 let project_file_found = updated_entries_set.iter().any(|(path, _, _)| {
514 path.as_ref()
515 .file_name()
516 .and_then(|name| name.to_str())
517 .map(|name_str| name_str == project_file_name)
518 .unwrap_or(false)
519 });
520
521 if !project_file_found {
522 return None;
523 }
524
525 project_type_telemetry
526 .worktree_ids_reported
527 .insert(worktree_id);
528
529 Some(project_type_telemetry.name.clone())
530 })
531 .collect()
532 };
533
534 // Done on purpose to avoid calling `self.state.lock()` multiple times
535 for project_type_name in project_type_names {
536 self.report_app_event(format!("open {} project", project_type_name));
537 }
538 }
539
540 pub fn report_repl_event(
541 self: &Arc<Self>,
542 kernel_language: String,
543 kernel_status: String,
544 repl_session_id: String,
545 ) {
546 let event = Event::Repl(ReplEvent {
547 kernel_language,
548 kernel_status,
549 repl_session_id,
550 });
551
552 self.report_event(event)
553 }
554
555 fn report_event(self: &Arc<Self>, event: Event) {
556 let mut state = self.state.lock();
557
558 if !state.settings.metrics {
559 return;
560 }
561
562 if state.flush_events_task.is_none() {
563 let this = self.clone();
564 let executor = self.executor.clone();
565 state.flush_events_task = Some(self.executor.spawn(async move {
566 executor.timer(FLUSH_INTERVAL).await;
567 this.flush_events();
568 }));
569 }
570
571 let date_time = self.clock.utc_now();
572
573 let milliseconds_since_first_event = match state.first_event_date_time {
574 Some(first_event_date_time) => {
575 date_time.timestamp_millis() - first_event_date_time.timestamp_millis()
576 }
577 None => {
578 state.first_event_date_time = Some(date_time);
579 0
580 }
581 };
582
583 let signed_in = state.metrics_id.is_some();
584 state.events_queue.push(EventWrapper {
585 signed_in,
586 milliseconds_since_first_event,
587 event,
588 });
589
590 if state.installation_id.is_some() && state.events_queue.len() >= state.max_queue_size {
591 drop(state);
592 self.flush_events();
593 }
594 }
595
596 pub fn metrics_id(self: &Arc<Self>) -> Option<Arc<str>> {
597 self.state.lock().metrics_id.clone()
598 }
599
600 pub fn installation_id(self: &Arc<Self>) -> Option<Arc<str>> {
601 self.state.lock().installation_id.clone()
602 }
603
604 pub fn is_staff(self: &Arc<Self>) -> Option<bool> {
605 self.state.lock().is_staff
606 }
607
608 fn build_request(
609 self: &Arc<Self>,
610 // We take in the JSON bytes buffer so we can reuse the existing allocation.
611 mut json_bytes: Vec<u8>,
612 event_request: EventRequestBody,
613 ) -> Result<Request<AsyncBody>> {
614 json_bytes.clear();
615 serde_json::to_writer(&mut json_bytes, &event_request)?;
616
617 let checksum = calculate_json_checksum(&json_bytes).unwrap_or("".to_string());
618
619 Ok(Request::builder()
620 .method(Method::POST)
621 .uri(
622 self.http_client
623 .build_zed_api_url("/telemetry/events", &[])?
624 .as_ref(),
625 )
626 .header("Content-Type", "application/json")
627 .header("x-zed-checksum", checksum)
628 .body(json_bytes.into())?)
629 }
630
631 pub fn flush_events(self: &Arc<Self>) {
632 let mut state = self.state.lock();
633 state.first_event_date_time = None;
634 let mut events = mem::take(&mut state.events_queue);
635 state.flush_events_task.take();
636 drop(state);
637 if events.is_empty() {
638 return;
639 }
640
641 let this = self.clone();
642 self.executor
643 .spawn(
644 async move {
645 let mut json_bytes = Vec::new();
646
647 if let Some(file) = &mut this.state.lock().log_file {
648 let file = file.as_file_mut();
649 for event in &mut events {
650 json_bytes.clear();
651 serde_json::to_writer(&mut json_bytes, event)?;
652 file.write_all(&json_bytes)?;
653 file.write_all(b"\n")?;
654 }
655 }
656
657 let request_body = {
658 let state = this.state.lock();
659
660 EventRequestBody {
661 system_id: state.system_id.as_deref().map(Into::into),
662 installation_id: state.installation_id.as_deref().map(Into::into),
663 session_id: state.session_id.clone(),
664 metrics_id: state.metrics_id.as_deref().map(Into::into),
665 is_staff: state.is_staff,
666 app_version: state.app_version.clone(),
667 os_name: state.os_name.clone(),
668 os_version: state.os_version.clone(),
669 architecture: state.architecture.to_string(),
670
671 release_channel: state.release_channel.map(Into::into),
672 events,
673 }
674 };
675
676 let request = this.build_request(json_bytes, request_body)?;
677 let response = this.http_client.send(request).await?;
678 if response.status() != 200 {
679 log::error!("Failed to send events: HTTP {:?}", response.status());
680 }
681 anyhow::Ok(())
682 }
683 .log_err(),
684 )
685 .detach();
686 }
687}
688
689pub fn calculate_json_checksum(json: &impl AsRef<[u8]>) -> Option<String> {
690 let Some(checksum_seed) = &*ZED_CLIENT_CHECKSUM_SEED else {
691 return None;
692 };
693
694 let mut summer = Sha256::new();
695 summer.update(checksum_seed);
696 summer.update(json);
697 summer.update(checksum_seed);
698 let mut checksum = String::new();
699 for byte in summer.finalize().as_slice() {
700 use std::fmt::Write;
701 write!(&mut checksum, "{:02x}", byte).unwrap();
702 }
703
704 Some(checksum)
705}
706
707#[cfg(test)]
708mod tests {
709 use super::*;
710 use chrono::TimeZone;
711 use clock::FakeSystemClock;
712 use gpui::TestAppContext;
713 use http_client::FakeHttpClient;
714
715 #[gpui::test]
716 fn test_telemetry_flush_on_max_queue_size(cx: &mut TestAppContext) {
717 init_test(cx);
718 let clock = Arc::new(FakeSystemClock::new(
719 Utc.with_ymd_and_hms(1990, 4, 12, 12, 0, 0).unwrap(),
720 ));
721 let http = FakeHttpClient::with_200_response();
722 let system_id = Some("system_id".to_string());
723 let installation_id = Some("installation_id".to_string());
724 let session_id = "session_id".to_string();
725
726 cx.update(|cx| {
727 let telemetry = Telemetry::new(clock.clone(), http, cx);
728
729 telemetry.state.lock().max_queue_size = 4;
730 telemetry.start(system_id, installation_id, session_id, cx);
731
732 assert!(is_empty_state(&telemetry));
733
734 let first_date_time = clock.utc_now();
735 let operation = "test".to_string();
736
737 let event = telemetry.report_app_event(operation.clone());
738 assert_eq!(
739 event,
740 Event::App(AppEvent {
741 operation: operation.clone(),
742 })
743 );
744 assert_eq!(telemetry.state.lock().events_queue.len(), 1);
745 assert!(telemetry.state.lock().flush_events_task.is_some());
746 assert_eq!(
747 telemetry.state.lock().first_event_date_time,
748 Some(first_date_time)
749 );
750
751 clock.advance(chrono::Duration::milliseconds(100));
752
753 let event = telemetry.report_app_event(operation.clone());
754 assert_eq!(
755 event,
756 Event::App(AppEvent {
757 operation: operation.clone(),
758 })
759 );
760 assert_eq!(telemetry.state.lock().events_queue.len(), 2);
761 assert!(telemetry.state.lock().flush_events_task.is_some());
762 assert_eq!(
763 telemetry.state.lock().first_event_date_time,
764 Some(first_date_time)
765 );
766
767 clock.advance(chrono::Duration::milliseconds(100));
768
769 let event = telemetry.report_app_event(operation.clone());
770 assert_eq!(
771 event,
772 Event::App(AppEvent {
773 operation: operation.clone(),
774 })
775 );
776 assert_eq!(telemetry.state.lock().events_queue.len(), 3);
777 assert!(telemetry.state.lock().flush_events_task.is_some());
778 assert_eq!(
779 telemetry.state.lock().first_event_date_time,
780 Some(first_date_time)
781 );
782
783 clock.advance(chrono::Duration::milliseconds(100));
784
785 // Adding a 4th event should cause a flush
786 let event = telemetry.report_app_event(operation.clone());
787 assert_eq!(
788 event,
789 Event::App(AppEvent {
790 operation: operation.clone(),
791 })
792 );
793
794 assert!(is_empty_state(&telemetry));
795 });
796 }
797
798 #[gpui::test]
799 async fn test_telemetry_flush_on_flush_interval(
800 executor: BackgroundExecutor,
801 cx: &mut TestAppContext,
802 ) {
803 init_test(cx);
804 let clock = Arc::new(FakeSystemClock::new(
805 Utc.with_ymd_and_hms(1990, 4, 12, 12, 0, 0).unwrap(),
806 ));
807 let http = FakeHttpClient::with_200_response();
808 let system_id = Some("system_id".to_string());
809 let installation_id = Some("installation_id".to_string());
810 let session_id = "session_id".to_string();
811
812 cx.update(|cx| {
813 let telemetry = Telemetry::new(clock.clone(), http, cx);
814 telemetry.state.lock().max_queue_size = 4;
815 telemetry.start(system_id, installation_id, session_id, cx);
816
817 assert!(is_empty_state(&telemetry));
818
819 let first_date_time = clock.utc_now();
820 let operation = "test".to_string();
821
822 let event = telemetry.report_app_event(operation.clone());
823 assert_eq!(
824 event,
825 Event::App(AppEvent {
826 operation: operation.clone(),
827 })
828 );
829 assert_eq!(telemetry.state.lock().events_queue.len(), 1);
830 assert!(telemetry.state.lock().flush_events_task.is_some());
831 assert_eq!(
832 telemetry.state.lock().first_event_date_time,
833 Some(first_date_time)
834 );
835
836 let duration = Duration::from_millis(1);
837
838 // Test 1 millisecond before the flush interval limit is met
839 executor.advance_clock(FLUSH_INTERVAL - duration);
840
841 assert!(!is_empty_state(&telemetry));
842
843 // Test the exact moment the flush interval limit is met
844 executor.advance_clock(duration);
845
846 assert!(is_empty_state(&telemetry));
847 });
848 }
849
850 // TODO:
851 // Test settings
852 // Update FakeHTTPClient to keep track of the number of requests and assert on it
853
854 fn init_test(cx: &mut TestAppContext) {
855 cx.update(|cx| {
856 let settings_store = SettingsStore::test(cx);
857 cx.set_global(settings_store);
858 });
859 }
860
861 fn is_empty_state(telemetry: &Telemetry) -> bool {
862 telemetry.state.lock().events_queue.is_empty()
863 && telemetry.state.lock().flush_events_task.is_none()
864 && telemetry.state.lock().first_event_date_time.is_none()
865 }
866}