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