chore(deps): Switch humantime to jiff

Humantime seems to be unmaintained and jiff provides same
functionality.

Author: oherrala

Cargo.lock

@@ -120,14 +120,14 @@ pre-release-replacements = [
 default = ["auto-color", "humantime", "regex"]
 color = ["dep:anstream", "dep:anstyle"]
 auto-color = ["color", "anstream/auto"]
-humantime = ["dep:humantime"]
+humantime = ["dep:jiff"]
 regex = ["env_filter/regex"]
 unstable-kv = ["log/kv"]
 
 [dependencies]
 log = { version = "0.4.21", features = ["std"] }
 env_filter = { version = "0.1.0", path = "crates/env_filter", default-features = false }
-humantime = { version = "2.0.0", optional = true }
+jiff = { version = "0.2.3", optional = true }
 anstream = { version = "0.6.11", default-features = false, features = ["wincon"], optional = true }
 anstyle = { version = "1.0.6", optional = true }
 

Cargo.toml

@@ -1,10 +1,6 @@
 use std::fmt;
 use std::time::SystemTime;
 
-use humantime::{
-    format_rfc3339_micros, format_rfc3339_millis, format_rfc3339_nanos, format_rfc3339_seconds,
-};
-
 use crate::fmt::{Formatter, TimestampPrecision};
 
 impl Formatter {
@@ -99,13 +95,44 @@ impl fmt::Debug for Timestamp {
 
 impl fmt::Display for Timestamp {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use jiff::fmt::strtime;
+
+        let Ok(ts) = jiff::Timestamp::try_from(self.time) else {
+            return Err(fmt::Error);
+        };
+
         let formatter = match self.precision {
-            TimestampPrecision::Seconds => format_rfc3339_seconds,
-            TimestampPrecision::Millis => format_rfc3339_millis,
-            TimestampPrecision::Micros => format_rfc3339_micros,
-            TimestampPrecision::Nanos => format_rfc3339_nanos,
+            TimestampPrecision::Seconds => |t| strtime::format("%FT%TZ", t),
+            TimestampPrecision::Millis  => |t| strtime::format("%FT%T%.3fZ", t),
+            TimestampPrecision::Micros  => |t| strtime::format("%FT%T%.6fZ", t),
+            TimestampPrecision::Nanos   => |t| strtime::format("%FT%T%.9fZ", t),
+        };
+
+        formatter(ts).map_err(|_| fmt::Error).and_then(|s| f.write_str(&s))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::TimestampPrecision;
+    use super::Timestamp;
+
+    #[test]
+    fn test_display_timestamp() {
+        let mut ts = Timestamp {
+            time: std::time::SystemTime::UNIX_EPOCH,
+            precision: TimestampPrecision::Nanos,
         };
 
-        formatter(self.time).fmt(f)
+        assert_eq!("1970-01-01T00:00:00.000000000Z", format!("{ts}"));
+
+        ts.precision = TimestampPrecision::Micros;
+        assert_eq!("1970-01-01T00:00:00.000000Z", format!("{ts}"));
+
+        ts.precision = TimestampPrecision::Millis;
+        assert_eq!("1970-01-01T00:00:00.000Z", format!("{ts}"));
+
+        ts.precision = TimestampPrecision::Seconds;
+        assert_eq!("1970-01-01T00:00:00Z", format!("{ts}"));
     }
 }