feat: add tracing logs to remaining files (#48)

sapphi-red · web-flow · commit f08ad6a5a8b6 · 2025-11-26T00:09:40.000+09:00
close #37
diff --git a/notify-debouncer-full/src/lib.rs b/notify-debouncer-full/src/lib.rs
@@ -130,20 +130,29 @@ where
 #[cfg(feature = "crossbeam-channel")]
 impl DebounceEventHandler for crossbeam_channel::Sender<DebounceEventResult> {
     fn handle_event(&mut self, event: DebounceEventResult) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send debounce event result");
+        }
     }
 }
 
 #[cfg(feature = "flume")]
 impl DebounceEventHandler for flume::Sender<DebounceEventResult> {
     fn handle_event(&mut self, event: DebounceEventResult) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send debounce event result");
+        }
     }
 }
 
 impl DebounceEventHandler for std::sync::mpsc::Sender<DebounceEventResult> {
     fn handle_event(&mut self, event: DebounceEventResult) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send debounce event result");
+        }
     }
 }
 
@@ -214,7 +223,7 @@ impl<T: FileIdCache> DebounceDataInner<T> {
 
         if let Some(event) = self.rescan_event.take() {
             if now.saturating_duration_since(event.time) >= self.timeout {
-                tracing::trace!("debounced event: {event:?}");
+                tracing::trace!("debounce candidate rescan event: {event:?}");
                 events_expired.push(event);
             } else {
                 self.rescan_event = Some(event);
@@ -229,6 +238,7 @@ impl<T: FileIdCache> DebounceDataInner<T> {
             while let Some(event) = queue.events.pop_front() {
                 // remove previous event of the same kind
                 if let Some(idx) = kind_index.get(&event.kind).copied() {
+                    tracing::trace!("removed candidate event: {event:?}");
                     events_expired.remove(idx);
 
                     kind_index.values_mut().for_each(|i| {
@@ -239,6 +249,7 @@ impl<T: FileIdCache> DebounceDataInner<T> {
                 }
 
                 if now.saturating_duration_since(event.time) >= self.timeout {
+                    tracing::trace!("debounce candidate event: {event:?}");
                     kind_index.insert(event.kind, events_expired.len());
 
                     events_expired.push(event);
@@ -553,7 +564,10 @@ impl<T: Watcher, C: FileIdCache> Debouncer<T, C> {
     pub fn stop(mut self) {
         self.set_stop();
         if let Some(t) = self.debouncer_thread.take() {
-            let _ = t.join();
+            let result = t.join();
+            if let Err(e) = result {
+                tracing::error!(?e, "failed to join debouncer thread");
+            }
         }
     }
 
@@ -634,6 +648,7 @@ impl<T: Watcher, C: FileIdCache> Drop for Debouncer<T, C> {
 /// Timeout is the amount of time after which a debounced event is emitted.
 ///
 /// If `tick_rate` is `None`, notify will select a tick rate that is 1/4 of the provided timeout.
+#[tracing::instrument(level = "debug", skip(event_handler, file_id_cache))]
 pub fn new_debouncer_opt<F: DebounceEventHandler, T: Watcher, C: FileIdCache + Send + 'static>(
     timeout: Duration,
     tick_rate: Option<Duration>,
@@ -730,6 +745,7 @@ pub fn new_debouncer<F: DebounceEventHandler>(
     )
 }
 
+#[tracing::instrument(level = "trace", ret)]
 fn sort_events(events: Vec<DebouncedEvent>) -> Vec<DebouncedEvent> {
     let mut sorted = Vec::with_capacity(events.len());
 
diff --git a/notify-debouncer-mini/src/lib.rs b/notify-debouncer-mini/src/lib.rs
@@ -158,20 +158,29 @@ where
 #[cfg(feature = "crossbeam-channel")]
 impl DebounceEventHandler for crossbeam_channel::Sender<DebounceEventResult> {
     fn handle_event(&mut self, event: DebounceEventResult) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send debounce event result");
+        }
     }
 }
 
 #[cfg(feature = "flume")]
 impl DebounceEventHandler for flume::Sender<DebounceEventResult> {
     fn handle_event(&mut self, event: DebounceEventResult) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send debounce event result");
+        }
     }
 }
 
 impl DebounceEventHandler for std::sync::mpsc::Sender<DebounceEventResult> {
     fn handle_event(&mut self, event: DebounceEventResult) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send debounce event result");
+        }
     }
 }
 
@@ -329,11 +338,15 @@ impl<T: Watcher> Debouncer<T> {
 impl<T: Watcher> Drop for Debouncer<T> {
     fn drop(&mut self) {
         // send error just means that it is stopped, can't do much else
-        let _ = self.stop_channel.send(InnerEvent::Shutdown);
+        let result = self.stop_channel.send(InnerEvent::Shutdown);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send shutdown event");
+        }
     }
 }
 
 /// Creates a new debounced watcher with custom configuration.
+#[tracing::instrument(level = "debug", skip(event_handler))]
 pub fn new_debouncer_opt<F: DebounceEventHandler, T: Watcher>(
     config: Config,
     mut event_handler: F,
@@ -383,7 +396,10 @@ pub fn new_debouncer_opt<F: DebounceEventHandler, T: Watcher>(
         move |e: Result<Event, Error>| {
             // send failure can't be handled, would need a working channel to signal that
             // also probably means that we're in the process of shutting down
-            let _ = tx_c.send(InnerEvent::NotifyEvent(e));
+            let result = tx_c.send(InnerEvent::NotifyEvent(e));
+            if let Err(e) = result {
+                tracing::error!(?e, "failed to send notify event");
+            }
         },
         config.notify_config,
     )?;
diff --git a/notify/src/poll.rs b/notify/src/poll.rs
@@ -10,6 +10,7 @@ use std::{
     sync::{
         Arc, Mutex,
         atomic::{AtomicBool, Ordering},
+        mpsc,
     },
     thread,
     time::Duration,
@@ -39,20 +40,29 @@ where
 #[cfg(feature = "crossbeam-channel")]
 impl ScanEventHandler for crossbeam_channel::Sender<ScanEvent> {
     fn handle_event(&mut self, event: ScanEvent) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send scan event result");
+        }
     }
 }
 
 #[cfg(feature = "flume")]
 impl ScanEventHandler for flume::Sender<ScanEvent> {
     fn handle_event(&mut self, event: ScanEvent) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send scan event result");
+        }
     }
 }
 
 impl ScanEventHandler for std::sync::mpsc::Sender<ScanEvent> {
     fn handle_event(&mut self, event: ScanEvent) {
-        let _ = self.send(event);
+        let result = self.send(event);
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to send scan event result");
+        }
     }
 }
 
@@ -573,7 +583,7 @@ impl PollWatcher {
         let want_to_stop = Arc::clone(&self.want_to_stop);
         let delay = self.delay;
 
-        let _ = thread::Builder::new()
+        let result = thread::Builder::new()
             .name("notify-rs poll loop".to_string())
             .spawn(move || {
                 loop {
@@ -596,13 +606,22 @@ impl PollWatcher {
                         }
                     }
                     // TODO: v7.0 use delay - (Instant::now().saturating_duration_since(start))
-                    if let Some(delay) = delay {
-                        let _ = rx.recv_timeout(delay);
+                    let result = if let Some(delay) = delay {
+                        rx.recv_timeout(delay).or_else(|e| match e {
+                            mpsc::RecvTimeoutError::Timeout => Ok(()),
+                            mpsc::RecvTimeoutError::Disconnected => Err(mpsc::RecvError),
+                        })
                     } else {
-                        let _ = rx.recv();
+                        rx.recv()
+                    };
+                    if let Err(e) = result {
+                        tracing::error!(?e, "failed to receive poll message");
                     }
                 }
             });
+        if let Err(e) = result {
+            tracing::error!(?e, "failed to start poll watcher thread");
+        }
     }
 
     /// Watch a path location.
@@ -647,16 +666,19 @@ impl PollWatcher {
 
 impl Watcher for PollWatcher {
     /// Create a new [`PollWatcher`].
+    #[tracing::instrument(level = "debug", skip(event_handler))]
     fn new<F: EventHandler>(event_handler: F, config: Config) -> crate::Result<Self> {
         Self::new(event_handler, config)
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     fn watch(&mut self, path: &Path, watch_mode: WatchMode) -> crate::Result<()> {
         self.watch_inner(path, watch_mode);
 
         Ok(())
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     fn unwatch(&mut self, path: &Path) -> crate::Result<()> {
         self.unwatch_inner(path)
     }
