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

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,109 @@
+/*
+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,
+        }
+    }
+}

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

@@ -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

src/hyperlight_guest_tracing/src/subscriber.rs

@@ -18,15 +18,17 @@ limitations under the License.
 use std::collections::HashMap;
 #[cfg(crashdump)]
 use std::path::Path;
+use std::str::FromStr;
 #[cfg(any(kvm, mshv3))]
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicU8;
 #[cfg(any(kvm, mshv3))]
 use std::sync::atomic::AtomicU64;
 use std::sync::{Arc, Mutex};
 
-use log::LevelFilter;
+use hyperlight_common::log_level::GuestLogFilter;
 use tracing::{Span, instrument};
+use tracing_core::LevelFilter;
 
 #[cfg(gdb)]
 use super::gdb::arch::VcpuStopReasonError;
@@ -59,7 +61,7 @@ use crate::hypervisor::virtual_machine::{
     HypervisorType, MapMemoryError, RegisterError, RunVcpuError, UnmapMemoryError, VmError, VmExit,
     get_available_hypervisor,
 };
-use crate::hypervisor::{InterruptHandle, InterruptHandleImpl, get_max_log_level};
+use crate::hypervisor::{InterruptHandle, InterruptHandleImpl};
 use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags, MemoryRegionType};
 use crate::mem::mgr::SandboxMemoryManager;
 use crate::mem::ptr::RawPtr;
@@ -73,6 +75,52 @@ use crate::sandbox::trace::MemTraceInfo;
 #[cfg(crashdump)]
 use crate::sandbox::uninitialized::SandboxRuntimeConfig;
 
+/// Get the logging level filter to pass to the guest entrypoint
+fn get_max_log_level_filter() -> LevelFilter {
+    // Check to see if the RUST_LOG environment variable is set
+    // and if so, parse it to get the log_level for hyperlight_guest
+    // if that is not set get the log level for the hyperlight_host
+
+    // This is done as the guest will produce logs based on the log level returned here
+    // producing those logs is expensive and we don't want to do it if the host is not
+    // going to process them
+
+    let val = std::env::var("RUST_LOG").unwrap_or_default();
+
+    let level = if val.contains("hyperlight_guest") {
+        val.split(',')
+            .find(|s| s.contains("hyperlight_guest"))
+            .unwrap_or("")
+            .split('=')
+            .nth(1)
+            .unwrap_or("")
+    } else if val.contains("hyperlight_host") {
+        val.split(',')
+            .find(|s| s.contains("hyperlight_host"))
+            .unwrap_or("")
+            .split('=')
+            .nth(1)
+            .unwrap_or("")
+    } else {
+        // look for a value string that does not contain "="
+        val.split(',').find(|s| !s.contains("=")).unwrap_or("")
+    };
+
+    tracing::info!("Determined guest log level: {}", level);
+    // Convert the log level string to a LevelFilter
+    // If no value is found, default to Error
+    LevelFilter::from_str(level).unwrap_or(LevelFilter::ERROR)
+}
+
+/// Converts a given [`Option<LevelFilter>`] to a `u64` value to be passed to the guest entrypoint
+fn get_guest_log_filter(guest_max_log_level: Option<LevelFilter>) -> u64 {
+    let guest_log_level_filter = match guest_max_log_level {
+        Some(level) => level,
+        None => get_max_log_level_filter(),
+    };
+    GuestLogFilter::from(guest_log_level_filter).into()
+}
+
 /// Represents a Hyperlight Virtual Machine instance.
 ///
 /// This struct manages the lifecycle of the VM, including:
@@ -468,11 +516,6 @@ impl HyperlightVm {
 
         self.page_size = page_size as usize;
 
-        let guest_max_log_level: u64 = match guest_max_log_level {
-            Some(level) => level as u64,
-            None => get_max_log_level().into(),
-        };
-
         let regs = CommonRegisters {
             rip: entrypoint,
             // We usually keep the top of the stack 16-byte
@@ -487,7 +530,7 @@ impl HyperlightVm {
             rdi: peb_addr.into(),
             rsi: seed,
             rdx: page_size.into(),
-            rcx: guest_max_log_level,
+            rcx: get_guest_log_filter(guest_max_log_level),
             rflags: 1 << 1,
 
             ..Default::default()

src/hyperlight_host/src/hypervisor/hyperlight_vm.rs

@@ -14,8 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-use log::LevelFilter;
-
 /// GDB debugging support
 #[cfg(gdb)]
 pub(crate) mod gdb;
@@ -41,51 +39,13 @@ pub(crate) mod crashdump;
 pub(crate) mod hyperlight_vm;
 
 use std::fmt::Debug;
-use std::str::FromStr;
 #[cfg(any(kvm, mshv3))]
 use std::sync::atomic::{AtomicBool, AtomicU8, AtomicU64, Ordering};
 #[cfg(target_os = "windows")]
 use std::sync::atomic::{AtomicU8, Ordering};
 #[cfg(any(kvm, mshv3))]
 use std::time::Duration;
 
-/// Get the logging level to pass to the guest entrypoint
-fn get_max_log_level() -> u32 {
-    // Check to see if the RUST_LOG environment variable is set
-    // and if so, parse it to get the log_level for hyperlight_guest
-    // if that is not set get the log level for the hyperlight_host
-
-    // This is done as the guest will produce logs based on the log level returned here
-    // producing those logs is expensive and we don't want to do it if the host is not
-    // going to process them
-
-    let val = std::env::var("RUST_LOG").unwrap_or_default();
-
-    let level = if val.contains("hyperlight_guest") {
-        val.split(',')
-            .find(|s| s.contains("hyperlight_guest"))
-            .unwrap_or("")
-            .split('=')
-            .nth(1)
-            .unwrap_or("")
-    } else if val.contains("hyperlight_host") {
-        val.split(',')
-            .find(|s| s.contains("hyperlight_host"))
-            .unwrap_or("")
-            .split('=')
-            .nth(1)
-            .unwrap_or("")
-    } else {
-        // look for a value string that does not contain "="
-        val.split(',').find(|s| !s.contains("=")).unwrap_or("")
-    };
-
-    log::info!("Determined guest log level: {}", level);
-    // Convert the log level string to a LevelFilter
-    // If no value is found, default to Error
-    LevelFilter::from_str(level).unwrap_or(LevelFilter::Error) as u32
-}
-
 /// A trait for platform-specific interrupt handle implementation details
 pub(crate) trait InterruptHandleImpl: InterruptHandle {
     /// Set the thread ID for the vcpu thread