Use MetricId instead of UUID::new_v4

Author: gotocoding-DB

kernel/src/metrics/mod.rs

@@ -4,7 +4,7 @@
 //! snapshot creation, scans, and transactions. Metrics are collected during operations
 //! and reported as events via the `MetricsReporter` trait.
 //!
-//! Each operation (Snapshot, Transaction, Scan) is assigned a unique operation ID (UUID)
+//! Each operation (Snapshot, Transaction, Scan) is assigned a unique operation ID ([`MetricId`])
 //! when it starts, and all subsequent events for that operation reference this ID.
 //! This allows reporters to correlate events and track operation lifecycles.
 //!
@@ -58,9 +58,36 @@
 //! }
 //! ```
 
+use std::fmt;
 use std::time::{Duration, Instant};
 use uuid::Uuid;
 
+/// Unique identifier for a metrics operation.
+///
+/// Each operation (Snapshot, Transaction, Scan) gets a unique MetricId that
+/// is used to correlate all events from that operation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct MetricId(Uuid);
+
+impl MetricId {
+    /// Generate a new unique MetricId.
+    pub fn new() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+impl Default for MetricId {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl fmt::Display for MetricId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 /// Trait for reporting metrics events from Delta operations.
 ///
 /// Implementations of this trait receive metric events as they occur during operations
@@ -74,19 +101,19 @@ pub trait MetricsReporter: Send + Sync {
 
 /// Metric events emitted during Delta Kernel operations.
 ///
-/// Each event includes an `operation_id` (UUID) that uniquely identifies the operation
+/// Each event includes an `operation_id` (MetricId) that uniquely identifies the operation
 /// instance. This allows correlating multiple events from the same operation.
 #[derive(Debug, Clone)]
 pub enum MetricEvent {
     /// A snapshot creation operation has started.
     SnapshotStarted {
-        operation_id: Uuid,
+        operation_id: MetricId,
         table_path: String,
     },
 
     /// Log segment loading completed (listing and organizing log files).
     LogSegmentLoaded {
-        operation_id: Uuid,
+        operation_id: MetricId,
         duration: Duration,
         num_commit_files: u64,
         num_checkpoint_files: u64,
@@ -95,19 +122,65 @@ pub enum MetricEvent {
 
     /// Protocol and metadata loading completed.
     ProtocolMetadataLoaded {
-        operation_id: Uuid,
+        operation_id: MetricId,
         duration: Duration,
     },
 
     /// Snapshot creation completed successfully.
     SnapshotCompleted {
-        operation_id: Uuid,
+        operation_id: MetricId,
         version: u64,
         total_duration: Duration,
     },
 
     /// Snapshot creation failed.
-    SnapshotFailed { operation_id: Uuid },
+    SnapshotFailed { operation_id: MetricId },
+}
+
+impl fmt::Display for MetricEvent {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            MetricEvent::SnapshotStarted {
+                operation_id,
+                table_path,
+            } => write!(
+                f,
+                "SnapshotStarted(id={}, table={})",
+                operation_id, table_path
+            ),
+            MetricEvent::LogSegmentLoaded {
+                operation_id,
+                duration,
+                num_commit_files,
+                num_checkpoint_files,
+                num_compaction_files,
+            } => write!(
+                f,
+                "LogSegmentLoaded(id={}, duration={:?}, commits={}, checkpoints={}, compactions={})",
+                operation_id, duration, num_commit_files, num_checkpoint_files, num_compaction_files
+            ),
+            MetricEvent::ProtocolMetadataLoaded {
+                operation_id,
+                duration,
+            } => write!(
+                f,
+                "ProtocolMetadataLoaded(id={}, duration={:?})",
+                operation_id, duration
+            ),
+            MetricEvent::SnapshotCompleted {
+                operation_id,
+                version,
+                total_duration,
+            } => write!(
+                f,
+                "SnapshotCompleted(id={}, version={}, duration={:?})",
+                operation_id, version, total_duration
+            ),
+            MetricEvent::SnapshotFailed { operation_id } => {
+                write!(f, "SnapshotFailed(id={})", operation_id)
+            }
+        }
+    }
 }
 
 /// A simple timer for tracking operation durations.

kernel/src/snapshot.rs

@@ -11,7 +11,7 @@ use crate::checkpoint::CheckpointWriter;
 use crate::committer::Committer;
 use crate::listed_log_files::ListedLogFiles;
 use crate::log_segment::LogSegment;
-use crate::metrics::{MetricEvent, Timer};
+use crate::metrics::{MetricEvent, MetricId, Timer};
 use crate::path::ParsedLogPath;
 use crate::scan::ScanBuilder;
 use crate::schema::SchemaRef;
@@ -21,7 +21,6 @@ use crate::transaction::Transaction;
 use crate::LogCompactionWriter;
 use crate::{DeltaResult, Engine, Error, Version};
 use delta_kernel_derive::internal_api;
-use uuid::Uuid;
 
 mod builder;
 pub use builder::SnapshotBuilder;
@@ -263,9 +262,9 @@ impl Snapshot {
         location: Url,
         log_segment: LogSegment,
         engine: &dyn Engine,
-        operation_id: Option<Uuid>,
+        operation_id: Option<MetricId>,
     ) -> DeltaResult<Self> {
-        let operation_id = operation_id.unwrap_or_else(Uuid::new_v4);
+        let operation_id = operation_id.unwrap_or_else(MetricId::new);
         let reporter = engine.get_metrics_reporter();
         let timer = Timer::new();
 
@@ -280,12 +279,8 @@ impl Snapshot {
                 });
             }
 
-            let table_configuration = TableConfiguration::try_new(
-                metadata,
-                protocol,
-                location,
-                log_segment.end_version,
-            )?;
+            let table_configuration =
+                TableConfiguration::try_new(metadata, protocol, location, log_segment.end_version)?;
 
             Ok(Self {
                 log_segment,

kernel/src/snapshot/builder.rs

@@ -1,10 +1,9 @@
 //! Builder for creating [`Snapshot`] instances.
 use crate::log_path::LogPath;
 use crate::log_segment::LogSegment;
-use crate::metrics::{MetricEvent, Timer};
+use crate::metrics::{MetricEvent, MetricId, Timer};
 use crate::snapshot::SnapshotRef;
 use crate::{DeltaResult, Engine, Error, Snapshot, Version};
-use uuid::Uuid;
 
 use url::Url;
 
@@ -85,7 +84,7 @@ impl SnapshotBuilder {
     pub fn build(self, engine: &dyn Engine) -> DeltaResult<SnapshotRef> {
         let log_tail = self.log_tail.into_iter().map(Into::into).collect();
         if let Some(table_root) = self.table_root {
-            let operation_id = Uuid::new_v4();
+            let operation_id = MetricId::new();
             let reporter = engine.get_metrics_reporter();
 
             if let Some(ref r) = reporter {