feat(logging): optimize log handling by early level filtering

This commit improves logging efficiency by checking if a log level is
enabled before generating the log message. Specifically:

- Introduced `is_enabled_for_level(Level)` checks to filter logs earlier.
- Removed redundant filtering logic inside `generate_log`.
- (If applicable) Switched subscriber initialization from
  `tracing_subscriber::fmt().init()` to `tracing_subscriber::fmt::init()`
  to enable environment-based log filtering (e.g., RUST_LOG).

Benefits:
- Reduces unnecessary computation for disabled log levels.
- Ensures logging respects the subscriber's configuration.
- Aligns better with `tracing-subscriber` best practices.

Author: DAIMENGEN

examples/simple/src/main.rs

@@ -138,7 +138,8 @@ fn main() -> Result<()> {
     } = Args::parse();
 
     if verbose {
-        tracing_subscriber::fmt().init();
+        // tracing_subscriber::fmt().init();
+        tracing_subscriber::fmt::init();
     }
     send_logs_to_tracing(LogOptions::default().with_logs_enabled(verbose));
 

llama-cpp-2/src/lib.rs

@@ -375,6 +375,11 @@ extern "C" fn logs_to_trace(
 
     let log_state = unsafe { &*(data as *const log::State) };
 
+    // If the log level is disabled, we can just return early
+    if !log_state.is_enabled_for_level(level) {
+        return;
+    }
+
     let text = unsafe { std::ffi::CStr::from_ptr(text) };
     let text = text.to_string_lossy();
     let text: &str = text.borrow();

llama-cpp-2/src/log.rs

@@ -142,18 +142,16 @@ impl State {
         let (meta, fields) = meta_for_level(level);
 
         tracing::dispatcher::get_default(|dispatcher| {
-            if dispatcher.enabled(meta) {
-                dispatcher.event(&tracing::Event::new(
-                    meta,
-                    &meta.fields().value_set(&[
-                        (&fields.message, Some(&text as &dyn tracing::field::Value)),
-                        (
-                            &fields.target,
-                            module.as_ref().map(|s| s as &dyn tracing::field::Value),
-                        ),
-                    ]),
-                ));
-            }
+            dispatcher.event(&tracing::Event::new(
+                meta,
+                &meta.fields().value_set(&[
+                    (&fields.message, Some(&text as &dyn tracing::field::Value)),
+                    (
+                        &fields.target,
+                        module.as_ref().map(|s| s as &dyn tracing::field::Value),
+                    ),
+                ]),
+            ));
         });
     }
 
@@ -253,6 +251,16 @@ impl State {
             }
         }
     }
+
+    /// Checks whether the given log level is enabled by the current tracing subscriber.
+    pub(super) fn is_enabled_for_level(&self, level: llama_cpp_sys_2::ggml_log_level) -> bool {
+        // CONT logs do not need to check if they are enabled.
+        if level == llama_cpp_sys_2::GGML_LOG_LEVEL_CONT {
+            return true;
+        }
+        let (meta, _) = meta_for_level(level);
+        tracing::dispatcher::get_default(|dispatcher| dispatcher.enabled(meta))
+    }
 }
 
 pub(super) static LLAMA_STATE: OnceLock<Box<State>> = OnceLock::new();