Fix compilation errors after log to tracing migration

Co-authored-by: jsturtevant <648372+jsturtevant@users.noreply.github.com>

Author: Copilot

Cargo.lock

@@ -15,12 +15,22 @@ limitations under the License.
 */
 
 use anyhow::{Error, Result, bail};
-use log::Level;
 #[cfg(feature = "tracing")]
 use tracing::{Span, instrument};
 
 use crate::flatbuffers::hyperlight::generated::LogLevel as FbLogLevel;
 
+// Define a minimal Level enum for conversions.
+// This mirrors log::Level/tracing::Level but is no_std compatible.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum Level {
+    Trace,
+    Debug,
+    Info,
+    Warn,
+    Error,
+}
+
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum LogLevel {

src/hyperlight_common/src/flatbuffer_wrappers/guest_log_level.rs

@@ -30,6 +30,23 @@ use tracing::{Span, instrument};
 #[cfg(feature = "trace_guest")]
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
+// Helper function to convert LevelFilter to u64 for guest
+fn level_filter_to_u64(filter: LevelFilter) -> u64 {
+    // Map LevelFilter to numeric values matching the guest expectations
+    // OFF = 5, ERROR = 4, WARN = 3, INFO = 2, DEBUG = 1, TRACE = 0
+    if filter >= LevelFilter::ERROR {
+        4
+    } else if filter >= LevelFilter::WARN {
+        3
+    } else if filter >= LevelFilter::INFO {
+        2
+    } else if filter >= LevelFilter::DEBUG {
+        1
+    } else {
+        0
+    }
+}
+
 #[cfg(gdb)]
 use super::gdb::{DebugCommChannel, DebugMsg, DebugResponse, DebuggableVm, VcpuStopReason, arch};
 use super::regs::{CommonFpu, CommonRegisters};
@@ -229,7 +246,7 @@ 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,
+            Some(level) => level_filter_to_u64(level),
             None => get_max_log_level().into(),
         };
 

src/hyperlight_host/src/hypervisor/hyperlight_vm.rs

@@ -44,7 +44,7 @@ pub(crate) fn is_hypervisor_present() -> bool {
     match Mshv::new() {
         Ok(_) => true,
         Err(_) => {
-            log::info!("MSHV is not available on this system");
+            tracing::info!("MSHV is not available on this system");
             false
         }
     }

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -37,16 +37,16 @@ pub(crate) fn is_hypervisor_present() -> bool {
         match api_version {
             version if version == 12 && kvm.check_extension(UserMemory) => true,
             12 => {
-                log::info!("KVM does not have KVM_CAP_USER_MEMORY capability");
+                tracing::info!("KVM does not have KVM_CAP_USER_MEMORY capability");
                 false
             }
             version => {
-                log::info!("KVM GET_API_VERSION returned {}, expected 12", version);
+                tracing::info!("KVM GET_API_VERSION returned {}, expected 12", version);
                 false
             }
         }
     } else {
-        log::info!("KVM is not available on this system");
+        tracing::info!("KVM is not available on this system");
         false
     }
 }
@@ -190,7 +190,7 @@ impl DebuggableVm for KvmVm {
     fn set_debug(&mut self, enable: bool) -> Result<()> {
         use kvm_bindings::{KVM_GUESTDBG_ENABLE, KVM_GUESTDBG_USE_HW_BP, KVM_GUESTDBG_USE_SW_BP};
 
-        log::info!("Setting debug to {}", enable);
+        tracing::info!("Setting debug to {}", enable);
         if enable {
             self.debug_regs.control |=
                 KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_HW_BP | KVM_GUESTDBG_USE_SW_BP;
@@ -205,7 +205,7 @@ impl DebuggableVm for KvmVm {
     fn set_single_step(&mut self, enable: bool) -> Result<()> {
         use kvm_bindings::KVM_GUESTDBG_SINGLESTEP;
 
-        log::info!("Setting single step to {}", enable);
+        tracing::info!("Setting single step to {}", enable);
         if enable {
             self.debug_regs.control |= KVM_GUESTDBG_SINGLESTEP;
         } else {

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -14,7 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-use tracing::level_filters::LevelFilter;
 
 use crate::Result;
 use crate::hypervisor::regs::{CommonFpu, CommonRegisters, CommonSpecialRegisters};
@@ -53,7 +52,6 @@ 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")]
@@ -169,10 +167,19 @@ fn get_max_log_level() -> u32 {
         val.split(',').find(|s| !s.contains("=")).unwrap_or("")
     };
 
-    log::info!("Determined guest log level: {}", level);
+    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) as u32
+    // tracing::LevelFilter doesn't implement FromStr or as u32, so we need to convert via string matching
+    let level_filter = match level.to_lowercase().as_str() {
+        "trace" => 0u32,
+        "debug" => 1u32,
+        "info" => 2u32,
+        "warn" => 3u32,
+        "error" => 4u32,
+        _ => 4u32, // Default to Error
+    };
+    level_filter
 }
 
 /// A trait for platform-specific interrupt handle implementation details
@@ -299,7 +306,7 @@ impl LinuxInterruptHandle {
                 break;
             }
 
-            log::info!("Sending signal to kill vcpu thread...");
+            tracing::info!("Sending signal to kill vcpu thread...");
             sent_signal = true;
             // Acquire ordering to synchronize with the Release store in set_tid()
             // This ensures we see the correct tid value for the currently running vcpu

src/hyperlight_host/src/hypervisor/mod.rs

@@ -109,33 +109,33 @@ macro_rules! log_then_return {
             None => std::format!($msg),
         };
         let __err = $crate::HyperlightError::Error(__err_msg);
-        log::error!("{}", __err);
+        tracing::error!("{}", __err);
         return Err(__err);
     }};
     ($err:expr $(,)?) => {
-        log::error!("{}", $err);
+        tracing::error!("{}", $err);
         return Err($err);
     };
     ($err:stmt $(,)?) => {
-        log::error!("{}", $err);
+        tracing::error!("{}", $err);
         return Err($err);
     };
     ($fmtstr:expr, $($arg:tt)*) => {
            let __err_msg = std::format!($fmtstr, $($arg)*);
            let __err = $crate::error::HyperlightError::Error(__err_msg);
-           log::error!("{}", __err);
+           tracing::error!("{}", __err);
            return Err(__err);
     };
 }
 
-/// Same as log::debug!, but will additionally print to stdout if the print_debug feature is enabled
+/// Same as tracing::debug!, but will additionally print to stdout if the print_debug feature is enabled
 #[macro_export]
 macro_rules! debug {
     ($($arg:tt)+) =>
     {
         #[cfg(print_debug)]
         println!($($arg)+);
-        log::debug!($($arg)+);
+        tracing::debug!($($arg)+);
     }
 }
 

src/hyperlight_host/src/lib.rs

@@ -19,12 +19,24 @@ use std::sync::{Arc, Mutex};
 use hyperlight_common::flatbuffer_wrappers::function_types::{FunctionCallResult, ParameterValue};
 use hyperlight_common::flatbuffer_wrappers::guest_error::{ErrorCode, GuestError};
 use hyperlight_common::flatbuffer_wrappers::guest_log_data::GuestLogData;
+use hyperlight_common::flatbuffer_wrappers::guest_log_level::Level as GuestLevel;
 use hyperlight_common::outb::{Exception, OutBAction};
 use tracing::{Span, instrument};
-use tracing_log::{LogTracer, format_trace, log};
+use tracing_log::{format_trace, log};
 
 use log::{Level, Record};
 
+// Convert from guest Level to log Level
+fn guest_level_to_log_level(guest_level: GuestLevel) -> Level {
+    match guest_level {
+        GuestLevel::Trace => Level::Trace,
+        GuestLevel::Debug => Level::Debug,
+        GuestLevel::Info => Level::Info,
+        GuestLevel::Warn => Level::Warn,
+        GuestLevel::Error => Level::Error,
+    }
+}
+
 use super::host_funcs::FunctionRegistry;
 #[cfg(feature = "mem_profile")]
 use crate::hypervisor::regs::CommonRegisters;
@@ -45,7 +57,7 @@ pub(super) fn outb_log(mgr: &mut SandboxMemoryManager<HostSharedMemory>) -> Resu
 
     let log_data: GuestLogData = mgr.read_guest_log_data()?;
 
-    let record_level: Level = (&log_data.level).into();
+    let record_level: Level = guest_level_to_log_level((&log_data.level).into());
 
     // Work out if we need to log or trace
     // this API is marked as follows but it is the easiest way to work out if we should trace or log

src/hyperlight_host/src/sandbox/outb.rs

@@ -46,14 +46,14 @@ impl Logger {
     pub fn initialize_test_logger() {
         INITLOGGER.call_once(|| {
             set_logger(&LOGGER).unwrap();
-            set_max_level(log::LevelFilter::Trace);
+            set_max_level(LevelFilter::Trace);
         });
     }
 
     pub fn initialize_log_tracer() {
         INITLOGGER.call_once(|| {
             set_logger(&*LOG_TRACER).unwrap();
-            set_max_level(log::LevelFilter::Trace);
+            set_max_level(LevelFilter::Trace);
         });
     }
 

src/hyperlight_testing/src/logger.rs

@@ -44,7 +44,7 @@ impl SimpleLogger {
     pub fn initialize_test_logger() {
         INITLOGGER.call_once(|| {
             set_logger(&LOGGER).unwrap();
-            set_max_level(log::LevelFilter::Trace);
+            set_max_level(tracing_log::log::LevelFilter::Trace);
         });
     }
 
@@ -86,7 +86,7 @@ impl Log for SimpleLogger {
             if metadata.target() == "hyperlight_guest" {
                 NUMBER_OF_ENABLED_CALLS += 1;
             }
-            metadata.target() == "hyperlight_guest" && metadata.level() <= log::max_level()
+            metadata.target() == "hyperlight_guest" && metadata.level() <= tracing_log::log::max_level()
         }
     }
     fn log(&self, record: &Record) {