debug: add tracing to identify nested runtime panic location

Author: githubrobbi

crates/uffs-cli/src/commands.rs

@@ -824,6 +824,7 @@ async fn load_and_filter_data(
     if let Some(drive_letter) = effective_drive {
         // Single drive search with proper path resolution
         let t_read = std::time::Instant::now();
+        eprintln!("[DEBUG] search_dataframe: before load_or_build_dataframe_cached drive={drive_letter}");
 
         // Use cached DataFrame path for performance (Windows only)
         #[cfg(windows)]
@@ -832,6 +833,8 @@ async fn load_and_filter_data(
                 .await
                 .with_context(|| format!("Failed to read MFT for drive {drive_letter}:"))?;
 
+        eprintln!("[DEBUG] search_dataframe: after load_or_build_dataframe_cached");
+
         // Non-Windows: read directly (no caching)
         #[cfg(not(windows))]
         let full_df = {

crates/uffs-mft/src/cache.rs

@@ -330,12 +330,18 @@ pub async fn load_or_build_dataframe_cached(
     drive: char,
     ttl_seconds: u64,
 ) -> crate::Result<uffs_polars::DataFrame> {
+    eprintln!("[DEBUG] load_or_build_dataframe_cached: ENTER drive={drive}");
     // Use spawn_blocking to run all MFT reading and polars operations on a
     // dedicated blocking thread. This avoids nested tokio runtime issues since
     // polars uses tokio internally for some operations.
-    tokio::task::spawn_blocking(move || load_or_build_dataframe_cached_sync(drive, ttl_seconds))
-        .await
-        .map_err(|e| crate::MftError::InvalidInput(format!("Task join error: {e}")))?
+    let result = tokio::task::spawn_blocking(move || {
+        eprintln!("[DEBUG] load_or_build_dataframe_cached: INSIDE spawn_blocking drive={drive}");
+        load_or_build_dataframe_cached_sync(drive, ttl_seconds)
+    })
+    .await
+    .map_err(|e| crate::MftError::InvalidInput(format!("Task join error: {e}")))?;
+    eprintln!("[DEBUG] load_or_build_dataframe_cached: EXIT drive={drive}");
+    result
 }
 
 /// Synchronous version of `load_or_build_dataframe_cached`.
@@ -351,16 +357,24 @@ fn load_or_build_dataframe_cached_sync(
     use crate::reader::MftReader;
     use crate::usn::query_usn_journal;
 
+    eprintln!("[DEBUG] load_or_build_dataframe_cached_sync: ENTER drive={drive}");
+
     // Try to load from cache first
     if let Some((index, _header)) = load_cached_index(drive, ttl_seconds) {
+        eprintln!("[DEBUG] load_or_build_dataframe_cached_sync: cache HIT, calling to_dataframe");
         tracing::info!(drive = %drive, records = index.records.len(), "📦 Cache hit - converting to DataFrame");
-        return index.to_dataframe();
+        let df = index.to_dataframe();
+        eprintln!("[DEBUG] load_or_build_dataframe_cached_sync: to_dataframe done");
+        return df;
     }
 
     // Cache miss - read fresh
+    eprintln!("[DEBUG] load_or_build_dataframe_cached_sync: cache MISS, reading MFT fresh");
     tracing::info!(drive = %drive, "📖 Cache miss - reading MFT fresh");
     let reader = MftReader::open_sync(drive)?;
+    eprintln!("[DEBUG] load_or_build_dataframe_cached_sync: reader opened, calling read_all_index_sync");
     let index = reader.read_all_index_sync()?;
+    eprintln!("[DEBUG] load_or_build_dataframe_cached_sync: read_all_index_sync done, records={}", index.len());
 
     // Save to cache for next time
     let handle = VolumeHandle::open(drive)?;
@@ -375,7 +389,10 @@ fn load_or_build_dataframe_cached_sync(
     }
 
     // Convert to DataFrame
-    index.to_dataframe()
+    eprintln!("[DEBUG] load_or_build_dataframe_cached_sync: calling to_dataframe");
+    let df = index.to_dataframe();
+    eprintln!("[DEBUG] load_or_build_dataframe_cached_sync: to_dataframe done");
+    df
 }
 
 /// Multi-drive cache status for coordinated operations.

crates/uffs-mft/src/reader.rs

@@ -927,14 +927,16 @@ impl MftReader {
     /// Returns an error if MFT reading fails.
     #[cfg(windows)]
     pub async fn read_all_index(&self) -> Result<crate::index::MftIndex> {
+        eprintln!("[DEBUG] read_all_index: ENTER volume={}", self.volume);
         // Capture configuration to recreate reader in blocking thread
         let volume = self.volume;
         let mode = self.mode;
         let merge_extensions = self.merge_extensions;
         let use_bitmap = self.use_bitmap;
         let expand_hardlinks = self.expand_hardlinks;
 
-        tokio::task::spawn_blocking(move || {
+        let result = tokio::task::spawn_blocking(move || {
+            eprintln!("[DEBUG] read_all_index: INSIDE spawn_blocking volume={volume}");
             // Create a new reader in the blocking thread
             let handle = crate::platform::VolumeHandle::open(volume)?;
             let reader = MftReader {
@@ -945,10 +947,14 @@ impl MftReader {
                 use_bitmap,
                 expand_hardlinks,
             };
-            reader.read_mft_index_internal(None::<fn(MftProgress)>)
+            let idx = reader.read_mft_index_internal(None::<fn(MftProgress)>);
+            eprintln!("[DEBUG] read_all_index: read_mft_index_internal done");
+            idx
         })
         .await
-        .map_err(|e| MftError::InvalidInput(format!("Task join error: {e}")))?
+        .map_err(|e| MftError::InvalidInput(format!("Task join error: {e}")))?;
+        eprintln!("[DEBUG] read_all_index: EXIT volume={volume}");
+        result
     }
 
     /// Read MFT into lean index (non-Windows stub).