[trace-guest] Define a common log level filter to be used for tracing and logging

- Adds a `GuestLogFilter` enum that is used as an intermediary type
  between the `u64` used as a register to call the guest entrypoint and
  the `log::LogFilter` or `tracing_core::LogFilter`.
- Adds unit tests for the `GuestLogFilter`

Signed-off-by: Doru Blânzeanu <dblnz@pm.me>

Author: dblnz

Cargo.lock

@@ -22,6 +22,7 @@ tracing = { version = "0.1.44", optional = true }
 arbitrary = {version = "1.4.2", optional = true, features = ["derive"]}
 spin = "0.10.0"
 thiserror = { version = "2.0.18", default-features = false }
+tracing-core = { version = "0.1.36", default-features = false }
 
 [features]
 default = ["tracing"]

src/hyperlight_common/Cargo.toml

@@ -30,6 +30,9 @@ mod flatbuffers;
 // cbindgen:ignore
 pub mod layout;
 
+// cbindgen:ignore
+pub mod log_level;
+
 /// cbindgen:ignore
 pub mod mem;
 

src/hyperlight_common/src/lib.rs

@@ -0,0 +1,184 @@
+/*
+Copyright 2025  The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/// This type is a unified definition of log level filters between the guest and host.
+///
+/// This is needed because currently the guest uses both the `log` and `tracing` crates,
+/// and needs each type of `LevelFilter` from both crates.
+///
+/// To avoid as much as possible the amount of conversions between the two types, we define a
+/// single type that can be converted to both `log::LevelFilter` and `tracing::LevelFilter`.
+/// NOTE: This also takes care of the fact that the `tracing` and `log` enum types for the log
+/// levels are not guaranteed to have the same discriminants, so we can't just cast between them.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GuestLogFilter {
+    Off,
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+
+impl From<GuestLogFilter> for tracing_core::LevelFilter {
+    fn from(filter: GuestLogFilter) -> Self {
+        match filter {
+            GuestLogFilter::Off => tracing_core::LevelFilter::OFF,
+            GuestLogFilter::Error => tracing_core::LevelFilter::ERROR,
+            GuestLogFilter::Warn => tracing_core::LevelFilter::WARN,
+            GuestLogFilter::Info => tracing_core::LevelFilter::INFO,
+            GuestLogFilter::Debug => tracing_core::LevelFilter::DEBUG,
+            GuestLogFilter::Trace => tracing_core::LevelFilter::TRACE,
+        }
+    }
+}
+
+impl From<GuestLogFilter> for log::LevelFilter {
+    fn from(filter: GuestLogFilter) -> Self {
+        match filter {
+            GuestLogFilter::Off => log::LevelFilter::Off,
+            GuestLogFilter::Error => log::LevelFilter::Error,
+            GuestLogFilter::Warn => log::LevelFilter::Warn,
+            GuestLogFilter::Info => log::LevelFilter::Info,
+            GuestLogFilter::Debug => log::LevelFilter::Debug,
+            GuestLogFilter::Trace => log::LevelFilter::Trace,
+        }
+    }
+}
+
+/// Used by the host to convert a [`tracing_core::LevelFilter`] to the intermediary [`GuestLogFilter`]
+/// filter that is later converted to `u64` and passed to the guest via the C API.
+impl From<tracing_core::LevelFilter> for GuestLogFilter {
+    fn from(value: tracing_core::LevelFilter) -> Self {
+        match value {
+            tracing_core::LevelFilter::OFF => Self::Off,
+            tracing_core::LevelFilter::ERROR => Self::Error,
+            tracing_core::LevelFilter::WARN => Self::Warn,
+            tracing_core::LevelFilter::INFO => Self::Info,
+            tracing_core::LevelFilter::DEBUG => Self::Debug,
+            tracing_core::LevelFilter::TRACE => Self::Trace,
+        }
+    }
+}
+
+/// Used by the guest to convert a `u64` value passed from the host via the C API to the
+/// intermediary [`GuestLogFilter`] filter that is later converted to both
+/// `tracing_core::LevelFilter` and `log::LevelFilter`.
+impl TryFrom<u64> for GuestLogFilter {
+    type Error = ();
+
+    fn try_from(value: u64) -> Result<Self, <GuestLogFilter as TryFrom<u64>>::Error> {
+        match value {
+            0 => Ok(Self::Off),
+            1 => Ok(Self::Error),
+            2 => Ok(Self::Warn),
+            3 => Ok(Self::Info),
+            4 => Ok(Self::Debug),
+            5 => Ok(Self::Trace),
+            _ => Err(()),
+        }
+    }
+}
+
+/// Used by the host to convert the [`GuestLogFilter`] to a `u64` that is passed to the guest via
+/// the C API.
+impl From<GuestLogFilter> for u64 {
+    fn from(value: GuestLogFilter) -> Self {
+        match value {
+            GuestLogFilter::Off => 0,
+            GuestLogFilter::Error => 1,
+            GuestLogFilter::Warn => 2,
+            GuestLogFilter::Info => 3,
+            GuestLogFilter::Debug => 4,
+            GuestLogFilter::Trace => 5,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::GuestLogFilter;
+
+    #[test]
+    fn guest_log_filter_u64_roundtrip() {
+        let variants = [
+            GuestLogFilter::Off,
+            GuestLogFilter::Error,
+            GuestLogFilter::Warn,
+            GuestLogFilter::Info,
+            GuestLogFilter::Debug,
+            GuestLogFilter::Trace,
+        ];
+
+        for variant in variants {
+            let as_u64: u64 = variant.into();
+            let back =
+                GuestLogFilter::try_from(as_u64).expect("conversion from u64 should succeed");
+            assert_eq!(variant, back);
+        }
+    }
+
+    #[test]
+    fn guest_log_filter_tracing_roundtrip() {
+        let variants = [
+            GuestLogFilter::Off,
+            GuestLogFilter::Error,
+            GuestLogFilter::Warn,
+            GuestLogFilter::Info,
+            GuestLogFilter::Debug,
+            GuestLogFilter::Trace,
+        ];
+
+        for variant in variants {
+            let tracing_filter: tracing_core::LevelFilter = variant.into();
+            let back: GuestLogFilter = tracing_filter.into();
+            assert_eq!(variant, back);
+        }
+    }
+
+    #[test]
+    fn guest_log_filter_log_conversion() {
+        let variants = [
+            GuestLogFilter::Off,
+            GuestLogFilter::Error,
+            GuestLogFilter::Warn,
+            GuestLogFilter::Info,
+            GuestLogFilter::Debug,
+            GuestLogFilter::Trace,
+        ];
+
+        let log_variants = [
+            log::LevelFilter::Off,
+            log::LevelFilter::Error,
+            log::LevelFilter::Warn,
+            log::LevelFilter::Info,
+            log::LevelFilter::Debug,
+            log::LevelFilter::Trace,
+        ];
+
+        for (variant, log_variant) in variants.into_iter().zip(log_variants) {
+            let tracing_filter = log::LevelFilter::from(variant);
+            assert_eq!(tracing_filter, log_variant);
+        }
+    }
+
+    #[test]
+    fn guest_log_filter_try_from_u64_rejects_invalid() {
+        // Any value outside the defined range [0, 5] should be rejected.
+        assert!(GuestLogFilter::try_from(u64::MAX).is_err());
+        assert!(GuestLogFilter::try_from(6).is_err());
+    }
+}

src/hyperlight_common/src/log_level.rs

@@ -24,11 +24,11 @@ use crate::GUEST_HANDLE;
 // this is private on purpose so that `log` can only be called though the `log!` macros.
 struct GuestLogger {}
 
-pub(crate) fn init_logger(level: LevelFilter) {
+pub(crate) fn init_logger(filter: LevelFilter) {
     // if this `expect` fails we have no way to recover anyway, so we actually prefer a panic here
     // below temporary guest logger is promoted to static by the compiler.
     log::set_logger(&GuestLogger {}).expect("unable to setup guest logger");
-    log::set_max_level(level);
+    log::set_max_level(filter);
 }
 
 impl log::Log for GuestLogger {

src/hyperlight_guest_bin/src/guest_logger.rs

@@ -25,12 +25,12 @@ use guest_function::call::dispatch_function;
 use guest_function::register::GuestFunctionRegister;
 use guest_logger::init_logger;
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
+use hyperlight_common::log_level::GuestLogFilter;
 use hyperlight_common::mem::HyperlightPEB;
 #[cfg(feature = "mem_profile")]
 use hyperlight_common::outb::OutBAction;
 use hyperlight_guest::exit::write_abort;
 use hyperlight_guest::guest_handle::handle::GuestHandle;
-use log::LevelFilter;
 
 // === Modules ===
 #[cfg_attr(target_arch = "x86_64", path = "arch/amd64/mod.rs")]
@@ -212,15 +212,17 @@ pub(crate) extern "C" fn generic_init(peb_address: u64, seed: u64, ops: u64, max
     }
 
     // set up the logger
-    let max_log_level = LevelFilter::iter()
-        .nth(max_log_level as usize)
-        .expect("Invalid log level");
-    init_logger(max_log_level);
+    let guest_log_level_filter =
+        GuestLogFilter::try_from(max_log_level).expect("Invalid log level");
+    init_logger(guest_log_level_filter.into());
 
     // It is important that all the tracing events are produced after the tracing is initialized.
     #[cfg(feature = "trace_guest")]
-    if max_log_level != LevelFilter::Off {
-        hyperlight_guest_tracing::init_guest_tracing(guest_start_tsc, max_log_level);
+    if guest_log_level_filter != GuestLogFilter::Off {
+        hyperlight_guest_tracing::init_guest_tracing(
+            guest_start_tsc,
+            guest_log_level_filter.into(),
+        );
     }
 
     #[cfg(feature = "macros")]

src/hyperlight_guest_bin/src/lib.rs

@@ -12,7 +12,7 @@ description = """Provides the tracing functionality for the hyperlight guest."""
 [dependencies]
 hyperlight-common = { workspace = true, default-features = false }
 spin = "0.10.0"
-tracing = { version = "0.1.44", default-features = false, features = ["attributes", "log"] }
+tracing = { version = "0.1.44", default-features = false, features = ["attributes"] }
 tracing-core = { version = "0.1.36", default-features = false }
 
 [lints]

src/hyperlight_guest_tracing/Cargo.toml

@@ -48,7 +48,7 @@ mod trace {
     use alloc::sync::{Arc, Weak};
 
     use spin::Mutex;
-    use tracing::log::LevelFilter;
+    use tracing_core::LevelFilter;
 
     use crate::state::GuestState;
     use crate::subscriber::GuestSubscriber;

src/hyperlight_guest_tracing/src/lib.rs

@@ -35,25 +35,12 @@ pub(crate) struct GuestSubscriber {
     max_log_level: LevelFilter,
 }
 
-/// Converts a `tracing::log::LevelFilter` to a `tracing_core::LevelFilter`
-/// Used to check if an event should be recorded based on the maximum log level
-fn convert_level_filter(filter: tracing::log::LevelFilter) -> tracing_core::LevelFilter {
-    match filter {
-        tracing::log::LevelFilter::Off => tracing_core::LevelFilter::OFF,
-        tracing::log::LevelFilter::Error => tracing_core::LevelFilter::ERROR,
-        tracing::log::LevelFilter::Warn => tracing_core::LevelFilter::WARN,
-        tracing::log::LevelFilter::Info => tracing_core::LevelFilter::INFO,
-        tracing::log::LevelFilter::Debug => tracing_core::LevelFilter::DEBUG,
-        tracing::log::LevelFilter::Trace => tracing_core::LevelFilter::TRACE,
-    }
-}
-
 impl GuestSubscriber {
     /// Creates a new `GuestSubscriber` with the given guest start TSC and maximum log level
-    pub(crate) fn new(guest_start_tsc: u64, max_log_level: tracing::log::LevelFilter) -> Self {
+    pub(crate) fn new(guest_start_tsc: u64, filter: LevelFilter) -> Self {
         Self {
             state: Arc::new(Mutex::new(GuestState::new(guest_start_tsc))),
-            max_log_level: convert_level_filter(max_log_level),
+            max_log_level: filter,
         }
     }
     /// Returns a reference to the internal state of the subscriber