Use Instant not chrono for telemetry (#20756)

We occasionally see dates in the future appearing in our telemetry. One
hypothesis is that this is caused by a clock change while Zed is running
causing date math based on chrono to be incorrect.

Instant *should* be a more stable source of relative timestamps.

Release Notes:

- N/A

crates/clock/Cargo.toml

@@ -16,7 +16,6 @@ doctest = false
 test-support = ["dep:parking_lot"]
 
 [dependencies]
-chrono.workspace = true
 parking_lot = { workspace = true, optional = true }
 serde.workspace = true
 smallvec.workspace = true

crates/clock/src/system_clock.rs

@@ -1,21 +1,21 @@
-use chrono::{DateTime, Utc};
+use std::time::Instant;
 
 pub trait SystemClock: Send + Sync {
     /// Returns the current date and time in UTC.
-    fn utc_now(&self) -> DateTime<Utc>;
+    fn utc_now(&self) -> Instant;
 }
 
 pub struct RealSystemClock;
 
 impl SystemClock for RealSystemClock {
-    fn utc_now(&self) -> DateTime<Utc> {
-        Utc::now()
+    fn utc_now(&self) -> Instant {
+        Instant::now()
     }
 }
 
 #[cfg(any(test, feature = "test-support"))]
 pub struct FakeSystemClockState {
-    now: DateTime<Utc>,
+    now: Instant,
 }
 
 #[cfg(any(test, feature = "test-support"))]
@@ -24,36 +24,30 @@ pub struct FakeSystemClock {
     state: parking_lot::Mutex<FakeSystemClockState>,
 }
 
-#[cfg(any(test, feature = "test-support"))]
-impl Default for FakeSystemClock {
-    fn default() -> Self {
-        Self::new(Utc::now())
-    }
-}
-
 #[cfg(any(test, feature = "test-support"))]
 impl FakeSystemClock {
-    pub fn new(now: DateTime<Utc>) -> Self {
-        let state = FakeSystemClockState { now };
+    pub fn new() -> Self {
+        let state = FakeSystemClockState {
+            now: Instant::now(),
+        };
 
         Self {
             state: parking_lot::Mutex::new(state),
         }
     }
 
-    pub fn set_now(&self, now: DateTime<Utc>) {
+    pub fn set_now(&self, now: Instant) {
         self.state.lock().now = now;
     }
 
-    /// Advances the [`FakeSystemClock`] by the specified [`Duration`](chrono::Duration).
-    pub fn advance(&self, duration: chrono::Duration) {
+    pub fn advance(&self, duration: std::time::Duration) {
         self.state.lock().now += duration;
     }
 }
 
 #[cfg(any(test, feature = "test-support"))]
 impl SystemClock for FakeSystemClock {
-    fn utc_now(&self) -> DateTime<Utc> {
+    fn utc_now(&self) -> Instant {
         self.state.lock().now
     }
 }