Fix test code to use tracing::log for compatibility layer

Co-authored-by: dblnz <[email protected]>

Author: Copilot

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -21,8 +21,6 @@ use std::fmt::{Debug, Formatter};
 use std::sync::atomic::{AtomicBool, AtomicU8, AtomicU64};
 use std::sync::{Arc, Mutex};
 
-use tracing::{Span, error, info, instrument};
-use tracing::log::LevelFilter;
 use mshv_bindings::{
     FloatingPointUnit, SpecialRegisters, StandardRegisters, hv_message_type,
     hv_message_type_HVMSG_GPA_INTERCEPT, hv_message_type_HVMSG_UNMAPPED_GPA,
@@ -38,6 +36,8 @@ use mshv_bindings::{
     mshv_install_intercept,
 };
 use mshv_ioctls::{Mshv, VcpuFd, VmFd};
+use tracing::log::LevelFilter;
+use tracing::{Span, error, info, instrument};
 #[cfg(feature = "trace_guest")]
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 #[cfg(crashdump)]

src/hyperlight_host/src/hypervisor/hyperv_windows.rs

@@ -20,8 +20,8 @@ use std::string::String;
 use std::sync::atomic::{AtomicBool, AtomicU8};
 use std::sync::{Arc, Mutex};
 
-use tracing::{Level, Span, error, debug, instrument};
 use tracing::log::LevelFilter;
+use tracing::{Level, Span, debug, error, instrument};
 #[cfg(feature = "trace_guest")]
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 use windows::Win32::System::Hypervisor::{WHV_MEMORY_ACCESS_TYPE, WHV_RUN_VP_EXIT_REASON};

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -21,8 +21,8 @@ use std::sync::{Arc, Mutex};
 use kvm_bindings::{kvm_fpu, kvm_regs, kvm_sregs, kvm_userspace_memory_region};
 use kvm_ioctls::Cap::UserMemory;
 use kvm_ioctls::{Kvm, VcpuExit, VcpuFd, VmFd};
-use tracing::{Span, info, instrument};
 use tracing::log::LevelFilter;
+use tracing::{Span, info, instrument};
 #[cfg(feature = "trace_guest")]
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 #[cfg(crashdump)]

src/hyperlight_host/src/hypervisor/mod.rs

@@ -885,6 +885,7 @@ pub(crate) mod tests {
 
         use crate::mem::ptr::RawPtr;
         use crate::sandbox::host_funcs::FunctionRegistry;
+        use tracing::log::LevelFilter;
 
         let filename = dummy_guest_as_string().map_err(|e| new_error!("{}", e))?;
 
@@ -907,7 +908,7 @@ pub(crate) mod tests {
         let seed = 12345u64; // Random seed
         let page_size = 4096u32; // Standard page size
         let host_funcs = Arc::new(Mutex::new(FunctionRegistry::default()));
-        let guest_max_log_level = Some(log::LevelFilter::Error);
+        let guest_max_log_level = Some(LevelFilter::Error);
 
         #[cfg(gdb)]
         let dbg_mem_access_fn = Arc::new(Mutex::new(mem_mgr.clone()));

src/hyperlight_host/src/sandbox/outb.rs

@@ -46,7 +46,7 @@ pub(super) fn outb_log(mgr: &mut SandboxMemoryManager<HostSharedMemory>) -> Resu
 
     // Convert from our LogLevel to tracing::Level
     let tracing_level: tracing::Level = (&log_data.level).into();
-    
+
     // Convert tracing::Level to log::Level for the Record API
     let record_level: Level = match tracing_level {
         tracing::Level::TRACE => Level::Trace,
@@ -207,7 +207,7 @@ pub(crate) fn handle_outb(
 mod tests {
     use hyperlight_common::flatbuffer_wrappers::guest_log_level::LogLevel;
     use hyperlight_testing::logger::{LOGGER, Logger};
-    use log::Level;
+    use tracing::log::{Level, LevelFilter};
     use tracing_core::callsite::rebuild_interest_cache;
 
     use super::outb_log;
@@ -234,7 +234,7 @@ mod tests {
     #[ignore]
     fn test_log_outb_log() {
         Logger::initialize_test_logger();
-        LOGGER.set_max_level(log::LevelFilter::Off);
+        LOGGER.set_max_level(LevelFilter::Off);
 
         let sandbox_cfg = SandboxConfiguration::default();
 
@@ -281,7 +281,7 @@ mod tests {
         }
         {
             // now, test logging
-            LOGGER.set_max_level(log::LevelFilter::Trace);
+            LOGGER.set_max_level(LevelFilter::Trace);
             let mut mgr = new_mgr();
             LOGGER.clear_log_calls();
 
@@ -314,7 +314,15 @@ mod tests {
                 outb_log(&mut mgr).unwrap();
 
                 LOGGER.test_log_records(|log_calls| {
-                    let expected_level: Level = (&level).into();
+                    // Convert through tracing::Level first
+                    let tracing_level: tracing::Level = (&level).into();
+                    let expected_level: Level = match tracing_level {
+                        tracing::Level::TRACE => Level::Trace,
+                        tracing::Level::DEBUG => Level::Debug,
+                        tracing::Level::INFO => Level::Info,
+                        tracing::Level::WARN => Level::Warn,
+                        tracing::Level::ERROR => Level::Error,
+                    };
 
                     assert!(
                         log_calls

src/hyperlight_host/src/sandbox/uninitialized.rs

@@ -19,8 +19,8 @@ use std::option::Option;
 use std::path::Path;
 use std::sync::{Arc, Mutex};
 
-use tracing::{Span, instrument};
 use tracing::log::LevelFilter;
+use tracing::{Span, instrument};
 
 use super::host_funcs::{FunctionRegistry, default_writer_func};
 use super::uninitialized_evolve::evolve_impl_multi_use;
@@ -906,12 +906,13 @@ mod tests {
         use std::path::PathBuf;
 
         use hyperlight_testing::logger::{LOGGER as TEST_LOGGER, Logger as TestLogger};
-        use log::Level;
+        use tracing::log::Level;
+        use tracing::log::LevelFilter;
         use tracing_core::callsite::rebuild_interest_cache;
 
         {
             TestLogger::initialize_test_logger();
-            TEST_LOGGER.set_max_level(log::LevelFilter::Trace);
+            TEST_LOGGER.set_max_level(LevelFilter::Trace);
 
             // This makes sure that the metadata interest cache is rebuilt so that
             // the log records are emitted for the trace records
@@ -983,7 +984,7 @@ mod tests {
         {
             // test to ensure an invalid binary logs & traces properly
             TEST_LOGGER.clear_log_calls();
-            TEST_LOGGER.set_max_level(log::LevelFilter::Info);
+            TEST_LOGGER.set_max_level(LevelFilter::Info);
 
             let mut valid_binary_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
             valid_binary_path.push("src");
@@ -1022,7 +1023,7 @@ mod tests {
         }
         {
             TEST_LOGGER.clear_log_calls();
-            TEST_LOGGER.set_max_level(log::LevelFilter::Error);
+            TEST_LOGGER.set_max_level(LevelFilter::Error);
 
             let sbox = {
                 let res = UninitializedSandbox::new(

src/hyperlight_host/tests/integration_test.rs

@@ -25,7 +25,7 @@ use hyperlight_host::sandbox::SandboxConfiguration;
 use hyperlight_host::{GuestBinary, HyperlightError, MultiUseSandbox, UninitializedSandbox};
 use hyperlight_testing::simplelogger::{LOGGER, SimpleLogger};
 use hyperlight_testing::{c_simple_guest_as_string, simple_guest_as_string};
-use log::LevelFilter;
+use tracing::log::LevelFilter;
 
 pub mod common; // pub to disable dead_code warning
 use crate::common::{new_uninit, new_uninit_c, new_uninit_rust};
@@ -774,10 +774,10 @@ fn log_message() {
     assert_eq!(1, LOGGER.num_log_calls());
 }
 
-fn log_test_messages(levelfilter: Option<log::LevelFilter>) {
+fn log_test_messages(levelfilter: Option<LevelFilter>) {
     LOGGER.clear_log_calls();
     assert_eq!(0, LOGGER.num_log_calls());
-    for level in log::LevelFilter::iter() {
+    for level in LevelFilter::iter() {
         let mut sbox = new_uninit().unwrap();
         if let Some(levelfilter) = levelfilter {
             sbox.set_max_guest_log_level(levelfilter);
@@ -903,7 +903,7 @@ fn interrupt_random_kill_stress_test() {
     use std::sync::atomic::AtomicUsize;
 
     use hyperlight_host::sandbox::snapshot::Snapshot;
-    use log::{error, trace};
+    use tracing::log::{error, trace};
 
     const POOL_SIZE: usize = 100;
     const NUM_THREADS: usize = 100;