feat(cli): add tracing instrumentation to QueryArgs and improve error handling

Author: TeamDman

src/cli/command/query.rs

@@ -6,6 +6,7 @@ use clap::Args;
 use eyre::Context;
 use rayon::iter::IntoParallelRefIterator;
 use rayon::iter::ParallelIterator;
+use tracing::instrument;
 use std::ffi::OsString;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -27,6 +28,7 @@ pub struct QueryArgs {
 
 impl QueryArgs {
     pub fn invoke(self) -> eyre::Result<()> {
+        info!("Running query with args: {:?}", self);
         if self.query.trim().is_empty() {
             eyre::bail!("query string required")
         }
@@ -59,9 +61,9 @@ impl QueryArgs {
             .par_iter()
             .map(|(drive_letter, mft_path)| {
                 let drive_letter = drive_letter.to_string();
-                let files = process_mft_file(&drive_letter, mft_path).wrap_err(
-                    format!("Failed to process MFT file for drive {drive_letter}"),
-                )?;
+                let files = process_mft_file(&drive_letter, mft_path).wrap_err(format!(
+                    "Failed to process MFT file for drive {drive_letter}"
+                ))?;
                 info!(
                     drive_letter = &drive_letter,
                     "Found {} paths to be queried against",
@@ -95,7 +97,9 @@ impl QueryArgs {
         let snapshot = nucleo.snapshot();
         info!("Found {} matching items", snapshot.matched_item_count());
         for (i, item) in snapshot.matched_items(..).enumerate() {
-            if i >= self.limit { break; }
+            if i >= self.limit {
+                break;
+            }
             println!("{}", item.data.display());
         }
 

src/drive_letter_pattern.rs

@@ -1,5 +1,7 @@
 use arbitrary::Arbitrary;
 use color_eyre::eyre::{self as eyre};
+use serde::Deserialize;
+use serde::Serialize;
 use std::fmt;
 use std::str::FromStr;
 
@@ -45,6 +47,44 @@ impl FromStr for DriveLetterPattern {
     }
 }
 
+impl<'de> Deserialize<'de> for DriveLetterPattern {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        s.parse().map_err(serde::de::Error::custom)
+    }
+}
+
+impl Serialize for DriveLetterPattern {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.0)
+    }
+}
+#[cfg(test)]
+mod test {
+    use crate::drive_letter_pattern::DriveLetterPattern;
+
+    #[tokio::test]
+    async fn serialize() -> eyre::Result<()> {
+        let pattern = DriveLetterPattern("C,D;E F".to_string());
+        let serialized = serde_json::to_string(&pattern)?;
+        assert_eq!(serialized, "\"C,D;E F\"");
+        Ok(())
+    }
+    #[tokio::test]
+    async fn deserialize() -> eyre::Result<()> {
+        let s = "\"C,D;E F\"";
+        let deserialized: DriveLetterPattern = serde_json::from_str(s)?;
+        assert_eq!(deserialized, DriveLetterPattern("C,D;E F".to_string()));
+        Ok(())
+    }
+}
+
 impl<'a> Arbitrary<'a> for DriveLetterPattern {
     fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
         // 20% chance wildcard, 80% chance letters