log: check category above threshold

gstreamer/src/log.rs

@@ -1067,40 +1067,51 @@ macro_rules! log_with_level(
 );
 
 #[cfg(feature = "log")]
+#[cfg_attr(docsrs, doc(cfg(feature = "log")))]
 #[derive(Debug)]
 pub struct DebugCategoryLogger(DebugCategory);
 
 #[cfg(feature = "log")]
+#[cfg_attr(docsrs, doc(cfg(feature = "log")))]
 impl DebugCategoryLogger {
     pub fn new(cat: DebugCategory) -> Self {
         Self(cat)
     }
-}
 
-#[cfg(feature = "log")]
-impl log::Log for DebugCategoryLogger {
-    fn enabled(&self, _metadata: &log::Metadata) -> bool {
-        true
-    }
-
-    fn log(&self, record: &log::Record) {
-        let lvl = match record.level() {
+    fn to_level(level: log::Level) -> crate::DebugLevel {
+        match level {
             log::Level::Error => DebugLevel::Error,
             log::Level::Warn => DebugLevel::Warning,
             log::Level::Info => DebugLevel::Info,
             log::Level::Debug => DebugLevel::Debug,
             log::Level::Trace => DebugLevel::Trace,
-        };
-        let file = record.file().unwrap_or("");
-        let file = glib::GStr::from_str_until_nul(file).unwrap_or_default();
-        self.0.log(
-            None::<&glib::Object>,
-            lvl,
-            file,
-            record.module_path().unwrap_or(""),
-            record.line().unwrap_or(0),
-            record.args().clone(),
-        );
+        }
+    }
+}
+
+#[cfg(feature = "log")]
+#[cfg_attr(docsrs, doc(cfg(feature = "log")))]
+impl log::Log for DebugCategoryLogger {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        let lvl = DebugCategoryLogger::to_level(metadata.level());
+        self.0.above_threshold(lvl)
+    }
+
+    fn log(&self, record: &log::Record) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+        let lvl = DebugCategoryLogger::to_level(record.level());
+        record.file().unwrap_or("").run_with_gstr(|file| {
+            self.0.log(
+                None::<&glib::Object>,
+                lvl,
+                file,
+                record.module_path().unwrap_or(""),
+                record.line().unwrap_or(0),
+                record.args().clone(),
+            );
+        });
     }
 
     fn flush(&self) {}
@@ -1365,7 +1376,48 @@ mod tests {
         crate::init().unwrap();
 
         log::set_logger(&(*LOGGER)).expect("Failed to set logger");
+        log::set_max_level(log::LevelFilter::Trace);
         log::error!("meh");
+        log::warn!("fish");
+
+        let (sender, receiver) = mpsc::channel();
+        let sender = Arc::new(Mutex::new(sender));
+        let handler = move |category: DebugCategory,
+                            level: DebugLevel,
+                            _file: &glib::GStr,
+                            _function: &glib::GStr,
+                            _line: u32,
+                            _object: Option<&LoggedObject>,
+                            message: &DebugMessage| {
+            let cat = DebugCategory::get("Log_trait").unwrap();
+
+            if category != cat {
+                // This test can run in parallel with other tests, including new_and_log above.
+                // We cannot be certain we only see our own messages.
+                return;
+            }
+
+            assert_eq!(level, DebugLevel::Error);
+            assert_eq!(message.get().unwrap().as_ref(), "meh");
+            let _ = sender.lock().unwrap().send(());
+        };
+
+        remove_default_log_function();
+        add_log_function(handler);
+
+        let cat = LOGGER.0;
+
+        cat.set_threshold(crate::DebugLevel::Warning);
+        log::error!("meh");
+        receiver.recv().unwrap();
+
+        cat.set_threshold(crate::DebugLevel::Error);
+        log::error!("meh");
+        receiver.recv().unwrap();
+
+        cat.set_threshold(crate::DebugLevel::None);
+        log::error!("fish");
+        log::warn!("meh");
     }
 
     #[test]