Separating general tracing and kvp logic, adding Instant struct, and creating diagnostic kvps for events and status logging.

Author: peytonr18

azurekvp/src/kvp.rs

@@ -25,8 +25,7 @@ use tracing_subscriber::registry::LookupSpan;
 
 use nix::fcntl::{flock, FlockArg};
 use std::fs::OpenOptions;
-use std::io::ErrorKind;
-use std::io::{Error, Write};
+use std::io::{self, Error, ErrorKind, Write};
 use std::os::fd::AsRawFd;
 use std::os::unix::fs::MetadataExt;
 use std::path::Path;
@@ -42,13 +41,6 @@ const EVENT_PREFIX: &str = concat!("azure-init-", env!("CARGO_PKG_VERSION"));
 ///
 /// This visitor is primarily used in the `on_event` method of the `EmitKVPLayer`
 /// to extract event messages and log them as key-value pairs.
-///
-/// # Example
-/// ```rust
-/// let mut event_message = String::new();
-/// let mut visitor = StringVisitor { string: &mut event_message };
-/// event.record(&mut visitor);
-/// ```
 pub struct StringVisitor<'a> {
     string: &'a mut String,
 }
@@ -95,6 +87,7 @@ where
     ///
     /// # Example
     /// ```rust
+    /// use tracing::{event, Level};
     /// event!(Level::INFO, msg = "Event message");
     /// ```
     fn on_event(&self, event: &tracing::Event<'_>, ctx: TracingContext<'_, S>) {
@@ -182,7 +175,9 @@ pub fn handle_kvp_operation(
     let event_key = generate_event_key(event_level, event_name, span_id);
 
     let encoded_kvp = encode_kvp_item(&event_key, event_value);
-    write_to_kvp_file(file_path, &encoded_kvp);
+    if let Err(e) = write_to_kvp_file(file_path, &encoded_kvp) {
+        eprintln!("Error writing to KVP file: {}", e);
+    }
 }
 
 /// Generates a unique event key by combining the event level, name, and span ID.
@@ -207,25 +202,50 @@ fn generate_event_key(
 /// This function appends the provided encoded KVP data to the specified file and ensures
 /// that file locking is handled properly to avoid race conditions. It locks the file exclusively,
 /// writes the data, flushes the output, and then unlocks the file.
-fn write_to_kvp_file(file_path: &Path, encoded_kvp: &Vec<Vec<u8>>) {
-    let mut file = OpenOptions::new()
-        .append(true)
-        .create(true)
-        .open(file_path)
-        .expect("Failed to open log file");
+fn write_to_kvp_file(
+    file_path: &Path,
+    encoded_kvp: &Vec<Vec<u8>>,
+) -> io::Result<()> {
+    let mut file =
+        match OpenOptions::new().append(true).create(true).open(file_path) {
+            Ok(file) => file,
+            Err(e) => {
+                eprintln!("Failed to open log file: {}", e);
+                return Err(e); // Return the error if the file can't be opened
+            }
+        };
 
     let fd = file.as_raw_fd();
-    flock(fd, FlockArg::LockExclusive).expect("Failed to lock the file");
+    if let Err(e) = flock(fd, FlockArg::LockExclusive) {
+        eprintln!("Failed to lock the file: {}", e);
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            "File locking failed",
+        ));
+    }
 
-    // Dereference kvp to get a slice &[u8]
+    // Write the encoded KVP data
     for kvp in encoded_kvp {
-        file.write_all(&kvp[..])
-            .expect("Failed to write to log file");
+        if let Err(e) = file.write_all(&kvp[..]) {
+            eprintln!("Failed to write to log file: {}", e);
+            return Err(e); // Return the error if writing fails
+        }
     }
 
-    file.flush().expect("Failed to flush the log file");
+    if let Err(e) = file.flush() {
+        eprintln!("Failed to flush the log file: {}", e);
+        return Err(e); // Return the error if flushing fails
+    }
 
-    flock(fd, FlockArg::Unlock).expect("Failed to unlock the file");
+    if let Err(e) = flock(fd, FlockArg::Unlock) {
+        eprintln!("Failed to unlock the file: {}", e);
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            "File unlocking failed",
+        ));
+    }
+
+    Ok(())
 }
 
 /// Encodes a key-value pair (KVP) into one or more byte slices. If the value