[debug commit]

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

.github/workflows/ValidatePullRequest.yml

@@ -67,7 +67,7 @@ jobs:
       - docs-pr
       - build-guests
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         hypervisor: [hyperv, 'hyperv-ws2025', mshv3, kvm]
         cpu: [amd, intel]

src/hyperlight_host/src/sandbox/uninitialized.rs

@@ -773,6 +773,7 @@ mod tests {
         use hyperlight_testing::tracing_subscriber::TracingSubscriber;
         use tracing::Level;
         use tracing_core::Subscriber;
+        use tracing_core::callsite::rebuild_interest_cache;
         use uuid::Uuid;
 
         /// Helper to extract a string value from nested JSON: obj["span"]["attributes"][key]
@@ -793,19 +794,25 @@ mod tests {
         let subscriber = TracingSubscriber::new(Level::TRACE);
 
         tracing::subscriber::with_default(subscriber.clone(), || {
+            // Rebuild the global callsite interest cache so that all callsites
+            // (including those already registered by other test threads with the
+            // no-op subscriber) are re-evaluated against our TracingSubscriber.
+            // Without this, a race condition can cause #[instrument] spans in
+            // production code to be permanently disabled via Interest::never().
+            rebuild_interest_cache();
+
             let correlation_id = Uuid::new_v4().to_string();
             let _span = tracing::error_span!("test_trace_logs", %correlation_id).entered();
 
-            // Verify we're in span 1 with correct name
-            let (span_id, span_meta) = subscriber
+            // Verify we're in a span with correct name
+            let (test_span_id, span_meta) = subscriber
                 .current_span()
                 .into_inner()
                 .expect("Should be inside a span");
-            assert_eq!(span_id.into_u64(), 1, "Should be in span 1");
             assert_eq!(span_meta.name(), "test_trace_logs");
 
             // Verify correlation_id was recorded
-            let span_data = subscriber.get_span(1);
+            let span_data = subscriber.get_span(test_span_id.into_u64());
             let recorded_id =
                 get_span_attr(&span_data, "correlation_id").expect("correlation_id not found");
             assert_eq!(recorded_id, correlation_id);
@@ -816,16 +823,31 @@ mod tests {
             let result = UninitializedSandbox::new(GuestBinary::FilePath(bad_path), None);
             assert!(result.is_err(), "Sandbox creation should fail");
 
-            // Verify we're still in span 1 (our test span)
-            let (span_id, _) = subscriber
+            // Verify we're still in our test span
+            let (current_id, _) = subscriber
                 .current_span()
                 .into_inner()
                 .expect("Should still be inside a span");
-            assert_eq!(span_id.into_u64(), 1, "Should still be in span 1");
+            assert_eq!(
+                current_id.into_u64(),
+                test_span_id.into_u64(),
+                "Should still be in the test span"
+            );
 
-            // Verify span 2 was created by UninitializedSandbox::new
-            let inner_span_meta = subscriber.get_span_metadata(2);
-            assert_eq!(inner_span_meta.name(), "new");
+            // Verify a span named "new" was created by UninitializedSandbox::new
+            // (look up by name rather than hardcoded ID to avoid fragility)
+            let all_spans = subscriber.get_all_spans();
+            let new_span_entry = all_spans
+                .iter()
+                .find(|(&id, _)| {
+                    id != test_span_id.into_u64()
+                        && subscriber.get_span_metadata(id).name() == "new"
+                })
+                .expect("Expected a span named 'new' from UninitializedSandbox::new");
+            assert_eq!(
+                subscriber.get_span_metadata(*new_span_entry.0).name(),
+                "new"
+            );
 
             // Verify the error event was emitted
             let events = subscriber.get_events();

src/hyperlight_testing/src/tracing_subscriber.rs

@@ -22,7 +22,7 @@ use tracing::Subscriber;
 use tracing_core::event::Event;
 use tracing_core::metadata::Metadata;
 use tracing_core::span::{Attributes, Current, Id, Record};
-use tracing_core::{Level, LevelFilter};
+use tracing_core::{Interest, Level, LevelFilter};
 use tracing_serde::AsSerde;
 
 #[derive(Debug, Clone)]
@@ -69,6 +69,11 @@ impl TracingSubscriber {
         EVENTS.with(|events| events.borrow().clone())
     }
 
+    /// Returns all recorded spans as a HashMap
+    pub fn get_all_spans(&self) -> HashMap<u64, Value> {
+        SPANS.with(|spans| spans.borrow().clone())
+    }
+
     pub fn test_trace_records<F: Fn(&HashMap<u64, Value>, &Vec<Value>)>(&self, f: F) {
         SPANS.with(|spans| {
             EVENTS.with(|events| {
@@ -88,6 +93,13 @@ impl TracingSubscriber {
 }
 
 impl Subscriber for TracingSubscriber {
+    fn register_callsite(&self, _metadata: &'static Metadata<'static>) -> Interest {
+        // Return Interest::sometimes() to prevent the global interest cache from caching
+        // our decision. This avoids race conditions when running tests in parallel,
+        // since each call to enabled() will be re-evaluated per-thread.
+        Interest::sometimes()
+    }
+
     fn enabled(&self, metadata: &Metadata<'_>) -> bool {
         LEVEL_FILTER.with(|level_filter| metadata.level() <= &*level_filter.borrow())
     }