refactor(log): generate RunId with time parsing

Author: weihanglo

src/cargo/util/logger.rs

@@ -1,12 +1,14 @@
 //! Build analysis logging infrastructure.
 
+use std::hash::Hash;
 use std::io::{BufWriter, Write};
 use std::mem::ManuallyDrop;
 use std::path::Path;
 use std::sync::mpsc;
 use std::sync::mpsc::Sender;
 use std::thread::JoinHandle;
 
+use anyhow::Context as _;
 use cargo_util::paths;
 
 use crate::CargoResult;
@@ -17,7 +19,7 @@ use crate::util::short_hash;
 /// Logger for `-Zbuild-analysis`.
 pub struct BuildLogger {
     tx: ManuallyDrop<Sender<LogMessage>>,
-    run_id: String,
+    run_id: RunId,
     handle: Option<JoinHandle<()>>,
 }
 
@@ -38,7 +40,7 @@ impl BuildLogger {
     }
 
     fn new(ws: &Workspace<'_>) -> CargoResult<Self> {
-        let run_id = Self::generate_run_id(ws)?;
+        let run_id = Self::generate_run_id(ws);
 
         let log_dir = ws.gctx().home().join("log");
         paths::create_dir_all(log_dir.as_path_unlocked())?;
@@ -52,11 +54,11 @@ impl BuildLogger {
 
         let (tx, rx) = mpsc::channel::<LogMessage>();
 
-        let run_id_clone = run_id.clone();
+        let run_id_str = run_id.to_string();
         let handle = std::thread::spawn(move || {
             let mut writer = BufWriter::new(log_file);
             for msg in rx {
-                let _ = msg.write_json_log(&mut writer, &run_id_clone);
+                let _ = msg.write_json_log(&mut writer, &run_id_str);
             }
             let _ = writer.flush();
         });
@@ -69,18 +71,12 @@ impl BuildLogger {
     }
 
     /// Generates a unique run ID.
-    ///
-    /// The format is `{timestamp}-{hash}`, with `:` and `.` in the timestamp
-    /// removed to make it safe for filenames.
-    /// For example, `20251024T194502773638Z-f891d525d52ecab3`.
-    pub fn generate_run_id(ws: &Workspace<'_>) -> CargoResult<String> {
-        let hash = short_hash(&ws.root());
-        let timestamp = jiff::Timestamp::now().to_string().replace([':', '.'], "");
-        Ok(format!("{timestamp}-{hash}"))
+    pub fn generate_run_id(ws: &Workspace<'_>) -> RunId {
+        RunId::new(&ws.root())
     }
 
     /// Returns the run ID for this build session.
-    pub fn run_id(&self) -> &str {
+    pub fn run_id(&self) -> &RunId {
         &self.run_id
     }
 
@@ -103,3 +99,74 @@ impl Drop for BuildLogger {
         }
     }
 }
+
+/// A unique identifier for a Cargo invocation.
+#[derive(Clone)]
+pub struct RunId {
+    timestamp: jiff::Timestamp,
+    hash: String,
+}
+
+impl RunId {
+    const FORMAT: &str = "%Y-%m-%dT%H%M%S%3fZ";
+
+    pub fn new<H: Hash>(h: &H) -> RunId {
+        RunId {
+            timestamp: jiff::Timestamp::now(),
+            hash: short_hash(h),
+        }
+    }
+
+    pub fn timestamp(&self) -> &jiff::Timestamp {
+        &self.timestamp
+    }
+
+    /// Checks whether ID was generated from the same workspace.
+    pub fn same_workspace(&self, other: &RunId) -> bool {
+        self.hash == other.hash
+    }
+}
+
+impl std::fmt::Display for RunId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let hash = &self.hash;
+        let timestamp = self.timestamp.strftime(Self::FORMAT);
+        write!(f, "{timestamp}-{hash}")
+    }
+}
+
+impl std::str::FromStr for RunId {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let msg =
+            || format!("expect run ID in format `2006-07-24T012128000Z-<16-char-hex>`, got `{s}`");
+        let Some((timestamp, hash)) = s.rsplit_once('-') else {
+            anyhow::bail!(msg());
+        };
+
+        if hash.len() != 16 || !hash.chars().all(|c| c.is_ascii_hexdigit()) {
+            anyhow::bail!(msg());
+        }
+        let timestamp = jiff::civil::DateTime::strptime(Self::FORMAT, timestamp)
+            .and_then(|dt| dt.to_zoned(jiff::tz::TimeZone::UTC))
+            .map(|zoned| zoned.timestamp())
+            .with_context(msg)?;
+
+        Ok(RunId {
+            timestamp,
+            hash: hash.into(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn run_id_round_trip() {
+        let id = "2006-07-24T012128000Z-b0fd440798ab3cfb";
+        assert_eq!(id, &id.parse::<RunId>().unwrap().to_string());
+    }
+}