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