[debug commit]

Signed-off-by: Ludvig Liljenberg <4257730+ludfjig@users.noreply.github.com>

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

@@ -767,12 +767,22 @@ mod tests {
     /// 1. Spans are created with correct attributes (correlation_id)
     /// 2. Nested spans from UninitializedSandbox::new are properly parented
     /// 3. Error events are emitted when sandbox creation fails
+    ///
+    /// NOTE: The `#[instrument]` callsite on `UninitializedSandbox::new` uses
+    /// tracing's global interest cache. If another test thread registers that
+    /// callsite first (with the no-op subscriber), the cached `Interest::never()`
+    /// will suppress span creation on our thread. To work around this, we:
+    /// 1. Make a warmup call to force-register the callsite
+    /// 2. Call `rebuild_interest_cache()` to overwrite the cached interest with
+    ///    our subscriber's `Interest::sometimes()`
+    /// 3. Clear recorded state and run the real test
     #[test]
     #[cfg(feature = "build-metadata")]
     fn test_trace_trace() {
         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,39 +803,68 @@ mod tests {
         let subscriber = TracingSubscriber::new(Level::TRACE);
 
         tracing::subscriber::with_default(subscriber.clone(), || {
+            // Warmup: force-register the #[instrument] callsite on
+            // UninitializedSandbox::new by calling it once. This ensures the
+            // callsite exists in the global registry regardless of whether
+            // another thread already registered it.
+            let bad_path = simple_guest_as_string().unwrap() + "does_not_exist";
+            let _ = UninitializedSandbox::new(GuestBinary::FilePath(bad_path.clone()), None);
+
+            // Rebuild the interest cache. Now that the callsite is guaranteed
+            // to be registered, this will overwrite any cached Interest::never()
+            // (from another thread's no-op subscriber) with our subscriber's
+            // Interest::sometimes(), ensuring subsequent calls create spans.
+            rebuild_interest_cache();
+
+            // Clear all state from the warmup call
+            subscriber.clear();
+
             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);
 
             // Try to create a sandbox with a non-existent binary - this should fail
             // and emit an error event
-            let bad_path = simple_guest_as_string().unwrap() + "does_not_exist";
             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();