Chore: Demote a lot of INFO log levels to DEBUG

- A lot less noise now!

Author: vdavid

apps/desktop/src-tauri/src/file_system/mod.rs

@@ -83,19 +83,19 @@ pub fn init_volume_manager() {
     #[cfg(target_os = "macos")]
     {
         let attached = crate::volumes::get_attached_volumes();
-        log::info!("Registering {} attached volume(s)", attached.len());
+        log::debug!("Registering {} attached volume(s)", attached.len());
         for location in attached {
             let volume = Arc::new(LocalPosixVolume::new(&location.name, &location.path));
             VOLUME_MANAGER.register(&location.id, volume);
-            log::info!("  Registered attached volume: {} -> {}", location.id, location.path);
+            log::debug!("  Registered attached volume: {} -> {}", location.id, location.path);
         }
 
         let cloud = crate::volumes::get_cloud_drives();
-        log::info!("Registering {} cloud drive(s)", cloud.len());
+        log::debug!("Registering {} cloud drive(s)", cloud.len());
         for location in cloud {
             let volume = Arc::new(LocalPosixVolume::new(&location.name, &location.path));
             VOLUME_MANAGER.register(&location.id, volume);
-            log::info!("  Registered cloud drive: {} -> {}", location.id, location.path);
+            log::debug!("  Registered cloud drive: {} -> {}", location.id, location.path);
         }
     }
 
@@ -107,11 +107,11 @@ pub fn init_volume_manager() {
             .iter()
             .filter(|l| l.category != crate::volumes_linux::LocationCategory::Favorite)
             .collect();
-        log::info!("Registering {} volume(s)", non_fav.len());
+        log::debug!("Registering {} volume(s)", non_fav.len());
         for location in non_fav {
             let volume = Arc::new(LocalPosixVolume::new(&location.name, &location.path));
             VOLUME_MANAGER.register(&location.id, volume);
-            log::info!("  Registered volume: {} -> {}", location.id, location.path);
+            log::debug!("  Registered volume: {} -> {}", location.id, location.path);
         }
     }
 }

apps/desktop/src-tauri/src/indexing/aggregator.rs

@@ -46,7 +46,7 @@ pub fn compute_subtree_aggregates(conn: &Connection, root: &str) -> Result<u64,
 
     let start = std::time::Instant::now();
     let dir_count = dirs.len();
-    log::info!("Subtree aggregation: starting bottom-up computation for {dir_count} directories under {root}");
+    log::debug!("Subtree aggregation: starting bottom-up computation for {dir_count} directories under {root}");
 
     // Phase 1: Load direct children stats scoped to this subtree only
     let direct_stats = scoped_get_children_stats(conn, root)?;
@@ -110,7 +110,7 @@ pub fn compute_subtree_aggregates(conn: &Connection, root: &str) -> Result<u64,
         IndexStore::upsert_dir_stats(conn, chunk)?;
     }
 
-    log::info!(
+    log::debug!(
         "Subtree aggregation: complete. {count} directories processed in {:.1}ms",
         start.elapsed().as_secs_f64() * 1000.0,
     );
@@ -220,21 +220,21 @@ fn compute_root_stats(conn: &Connection) -> Result<(), IndexStoreError> {
 fn compute_aggregates_for_dirs(conn: &Connection, dirs: &[String]) -> Result<u64, IndexStoreError> {
     let start = std::time::Instant::now();
     let dir_count = dirs.len();
-    log::info!("Aggregation: starting bottom-up computation for {dir_count} directories");
+    log::debug!("Aggregation: starting bottom-up computation for {dir_count} directories");
 
     // Phase 1: Bulk-load direct children stats for ALL parent paths in two SQL queries.
     // This replaces N individual get_children_stats + get_child_directory_paths calls.
-    log::info!("Aggregation: loading direct children stats (bulk query)...");
+    log::debug!("Aggregation: loading direct children stats (bulk query)...");
     let direct_stats = bulk_get_children_stats(conn)?;
-    log::info!(
+    log::debug!(
         "Aggregation: loaded stats for {} parent paths in {:.1}s",
         direct_stats.len(),
         start.elapsed().as_secs_f64()
     );
 
-    log::info!("Aggregation: loading child directory relationships (bulk query)...");
+    log::debug!("Aggregation: loading child directory relationships (bulk query)...");
     let child_dirs_map = bulk_get_child_directory_paths(conn)?;
-    log::info!(
+    log::debug!(
         "Aggregation: loaded child dirs for {} parent paths in {:.1}s",
         child_dirs_map.len(),
         start.elapsed().as_secs_f64()
@@ -276,7 +276,7 @@ fn compute_aggregates_for_dirs(conn: &Connection, dirs: &[String]) -> Result<u64
         );
 
         if (i + 1) % 100_000 == 0 {
-            log::info!(
+            log::debug!(
                 "Aggregation: processed {}/{dir_count} directories ({:.1}s)",
                 i + 1,
                 start.elapsed().as_secs_f64()
@@ -285,15 +285,15 @@ fn compute_aggregates_for_dirs(conn: &Connection, dirs: &[String]) -> Result<u64
     }
 
     // Phase 3: Batch-write all computed stats in chunks of 1000
-    log::info!("Aggregation: writing {} dir_stats rows to DB...", computed.len());
+    log::debug!("Aggregation: writing {} dir_stats rows to DB...", computed.len());
     let all_stats: Vec<DirStats> = computed.into_values().collect();
     let count = all_stats.len() as u64;
 
     for chunk in all_stats.chunks(1000) {
         IndexStore::upsert_dir_stats(conn, chunk)?;
     }
 
-    log::info!(
+    log::debug!(
         "Aggregation: complete. {count} directories processed in {:.1}s",
         start.elapsed().as_secs_f64()
     );

apps/desktop/src-tauri/src/indexing/mod.rs

@@ -238,7 +238,7 @@ impl IndexManager {
             Err(e) => log::warn!("Failed to open global index read connection: {e}"),
         }
 
-        log::info!(
+        log::debug!(
             "IndexManager created for volume '{volume_id}' at {}",
             volume_root.display()
         );
@@ -282,19 +282,19 @@ impl IndexManager {
             if let Some(ref last_event_id_str) = status.last_event_id {
                 let last_event_id: u64 = last_event_id_str.parse().unwrap_or(0);
                 if last_event_id > 0 {
-                    log::info!(
+                    log::debug!(
                         "Existing index found (scan_completed_at={}, last_event_id={last_event_id}), \
                          attempting sinceWhen replay",
                         status.scan_completed_at.as_deref().unwrap_or("?"),
                     );
                     return self.start_replay(last_event_id);
                 }
             }
-            log::info!("Existing index found but no last_event_id, starting fresh scan");
+            log::debug!("Existing index found but no last_event_id, starting fresh scan");
         } else if status.scan_completed_at.is_some() {
-            log::info!("Existing index found, starting rescan (no event replay on this platform)");
+            log::debug!("Existing index found, starting rescan (no event replay on this platform)");
         } else {
-            log::info!("No existing index (scan_completed_at not set), starting fresh scan");
+            log::debug!("No existing index (scan_completed_at not set), starting fresh scan");
         }
 
         self.start_scan()
@@ -312,7 +312,7 @@ impl IndexManager {
         match DriveWatcher::start(&self.volume_root, since_event_id, event_tx) {
             Ok(watcher) => {
                 self.drive_watcher = Some(watcher);
-                log::info!("DriveWatcher started for replay (sinceWhen={since_event_id}, current={current_id})");
+                log::debug!("DriveWatcher started for replay (sinceWhen={since_event_id}, current={current_id})");
             }
             Err(e) => {
                 log::warn!("Failed to start DriveWatcher for replay: {e}, falling back to full scan");
@@ -419,7 +419,7 @@ impl IndexManager {
         match DriveWatcher::start(&self.volume_root, 0, event_tx) {
             Ok(watcher) => {
                 self.drive_watcher = Some(watcher);
-                log::info!("DriveWatcher started (scan_start_event_id={scan_start_event_id})");
+                log::debug!("DriveWatcher started (scan_start_event_id={scan_start_event_id})");
             }
             Err(e) => {
                 // Watcher failure is non-fatal: scan works without it, just no live updates
@@ -503,7 +503,7 @@ impl IndexManager {
 
             match result {
                 Ok(Ok(summary)) => {
-                    log::info!(
+                    log::debug!(
                         "Volume scan complete: {} entries, {} dirs, {}ms",
                         summary.total_entries,
                         summary.total_dirs,
@@ -520,12 +520,12 @@ impl IndexManager {
                         reconciler.buffer_event(event);
                         buffered_count += 1;
                     }
-                    log::info!("Reconciler: buffered {buffered_count} events during scan");
+                    log::debug!("Reconciler: buffered {buffered_count} events during scan");
 
                     // Replay events that arrived after the scan read their paths
                     match reconciler.replay(scan_start_event_id, &writer, &app) {
                         Ok(last_id) => {
-                            log::info!("Reconciler: replay complete (last_event_id={last_id})");
+                            log::debug!("Reconciler: replay complete (last_event_id={last_id})");
                         }
                         Err(e) => {
                             log::warn!("Reconciler: replay failed: {e}");
@@ -688,7 +688,7 @@ impl IndexManager {
         self.stop_scan();
         self.writer.shutdown();
         clear_global_index_store();
-        log::info!("IndexManager shut down for volume '{}'", self.volume_id);
+        log::debug!("IndexManager shut down for volume '{}'", self.volume_id);
     }
 }
 
@@ -706,7 +706,7 @@ async fn run_live_event_loop(
     writer: IndexWriter,
     app: AppHandle,
 ) {
-    log::info!("Live event processing started");
+    log::debug!("Live event processing started");
     let mut event_count = 0u64;
     let mut pending_paths = std::collections::HashSet::<String>::new();
     let mut flush_interval = tokio::time::interval(Duration::from_millis(300));
@@ -720,7 +720,7 @@ async fn run_live_event_loop(
                         reconciler.process_live_event(&event, &writer, &mut pending_paths);
                         event_count += 1;
                         if event_count.is_multiple_of(10_000) {
-                            log::info!("Live event processing: {event_count} events processed so far");
+                            log::debug!("Live event processing: {event_count} events processed so far");
                         }
                     }
                     None => {
@@ -740,7 +740,7 @@ async fn run_live_event_loop(
         }
     }
 
-    log::info!("Live event processing stopped after {event_count} events");
+    log::debug!("Live event processing stopped after {event_count} events");
 }
 
 // ── Replay event loop (cold start sinceWhen) ─────────────────────────
@@ -788,7 +788,7 @@ async fn run_replay_event_loop(
         since_event_id,
         estimated_total,
     } = config;
-    log::info!("Replay event processing started (since_event_id={since_event_id})");
+    log::debug!("Replay event processing started (since_event_id={since_event_id})");
 
     let mut event_count = 0u64;
     let mut first_event_checked = false;
@@ -832,7 +832,7 @@ async fn run_replay_event_loop(
                 }
                 return Ok(());
             }
-            log::info!(
+            log::debug!(
                 "Replay: first event_id={}, gap from stored={}, journal appears available",
                 event.event_id,
                 event.event_id.saturating_sub(since_event_id),
@@ -841,7 +841,7 @@ async fn run_replay_event_loop(
 
         // HistoryDone marks end of replay phase
         if event.flags.history_done {
-            log::info!("Replay: HistoryDone received after {event_count} events");
+            log::debug!("Replay: HistoryDone received after {event_count} events");
 
             // Process the HistoryDone event itself (it may carry other flags)
             if let Some(paths) = reconciler::process_fs_event(&event, &writer) {
@@ -892,7 +892,7 @@ async fn run_replay_event_loop(
 
         // Log milestone counts
         if event_count.is_multiple_of(10_000) {
-            log::info!("Replay: {event_count} events processed so far");
+            log::debug!("Replay: {event_count} events processed so far");
         }
     }
 
@@ -915,7 +915,7 @@ async fn run_replay_event_loop(
     match writer.flush().await {
         Ok(()) => {
             let flush_ms = flush_start.elapsed().as_millis();
-            log::info!(
+            log::debug!(
                 "Replay complete: {event_count} events, {} affected dirs, {flush_ms}ms writer flush, \
                  {}ms total",
                 affected_paths.len(),
@@ -944,7 +944,7 @@ async fn run_replay_event_loop(
 
     // ── Switch to live mode immediately (before verification) ────────
 
-    log::info!("Replay: switching to live mode");
+    log::debug!("Replay: switching to live mode");
     micro_scans.set_replay_active(false);
     log::debug!("Replay: micro-scans re-enabled for live mode");
     let mut reconciler = EventReconciler::new();
@@ -976,7 +976,7 @@ async fn run_replay_event_loop(
                         reconciler.process_live_event(&event, &writer, &mut live_pending_paths);
                         live_count += 1;
                         if live_count.is_multiple_of(10_000) {
-                            log::info!("Live event processing (post-replay): {live_count} events");
+                            log::debug!("Live event processing (post-replay): {live_count} events");
                         }
                     }
                     None => {
@@ -995,7 +995,7 @@ async fn run_replay_event_loop(
         }
     }
 
-    log::info!("Replay event loop stopped ({event_count} replay + {live_count} live events)");
+    log::debug!("Replay event loop stopped ({event_count} replay + {live_count} live events)");
     Ok(())
 }
 
@@ -1012,7 +1012,7 @@ async fn run_background_verification(
     app: AppHandle,
 ) {
     let verify_start = std::time::Instant::now();
-    log::info!(
+    log::debug!(
         "Background verification started ({} affected dirs)",
         affected_paths.len(),
     );
@@ -1046,7 +1046,7 @@ async fn run_background_verification(
         verify_result.stale_count > 0 || verify_result.new_file_count > 0 || !verify_result.new_dir_paths.is_empty();
 
     if has_changes {
-        log::info!(
+        log::debug!(
             "Background verification found {} stale, {} new files, {} new dirs; flushing",
             verify_result.stale_count,
             verify_result.new_file_count,
@@ -1106,7 +1106,7 @@ async fn run_background_verification(
         reconciler::emit_dir_updated(&app, corrected_paths);
     }
 
-    log::info!(
+    log::debug!(
         "Background verification completed in {}ms",
         verify_start.elapsed().as_millis(),
     );
@@ -1262,7 +1262,7 @@ fn verify_affected_dirs(affected_paths: &std::collections::HashSet<String>, writ
     }
 
     if stale_count > 0 || new_file_count > 0 || !new_dir_paths.is_empty() {
-        log::info!(
+        log::debug!(
             "Replay verification: {stale_count} stale, {new_file_count} new files, \
              {} new dirs across {} affected dirs",
             new_dir_paths.len(),
@@ -1334,7 +1334,7 @@ pub fn start_indexing(app: &AppHandle) -> Result<(), String> {
     let mut guard = state.0.lock().map_err(|e| format!("Failed to lock state: {e}"))?;
     *guard = Some(manager);
 
-    log::info!("Indexing system initialized for root volume");
+    log::debug!("Indexing system initialized for root volume");
     Ok(())
 }
 

apps/desktop/src-tauri/src/indexing/reconciler.rs

@@ -111,7 +111,7 @@ impl EventReconciler {
         let mut last_event_id = scan_start_event_id;
         let mut affected_paths: Vec<String> = Vec::new();
 
-        log::info!("Reconciler: replaying {total} buffered events (scan_start_event_id={scan_start_event_id})");
+        log::debug!("Reconciler: replaying {total} buffered events (scan_start_event_id={scan_start_event_id})");
 
         for event in &self.buffer {
             // Skip events that the scan already covered
@@ -137,7 +137,7 @@ impl EventReconciler {
             let _ = writer.send(WriteMessage::UpdateLastEventId(last_event_id));
         }
 
-        log::info!("Reconciler: replayed {processed}/{total} events (last_event_id={last_event_id})");
+        log::debug!("Reconciler: replayed {processed}/{total} events (last_event_id={last_event_id})");
         Ok(last_event_id)
     }
 
@@ -146,7 +146,7 @@ impl EventReconciler {
         self.buffering = false;
         self.buffer.clear();
         self.buffer.shrink_to_fit();
-        log::info!("Reconciler: switched to live mode");
+        log::debug!("Reconciler: switched to live mode");
     }
 
     /// Process a single event in live mode.
@@ -209,7 +209,7 @@ impl EventReconciler {
         let writer = writer.clone();
         let rescan_active = Arc::clone(&self.rescan_active);
 
-        log::info!("Reconciler: starting MustScanSubDirs rescan for {}", path.display());
+        log::debug!("Reconciler: starting MustScanSubDirs rescan for {}", path.display());
 
         tokio::task::spawn_blocking(move || {
             let start = Instant::now();