feat: detect uninstrumented task spawns and surface in viewer (#293)

* feat: detect uninstrumented task spawns and surface in viewer

Track whether each task was spawned via TelemetryHandle::spawn (with
wake tracking) or raw tokio::spawn. Carries an `instrumented` flag
through the wire format, logs a
per-location summary on shutdown via tracing::debug, and shows a
"no wake data" badge in the viewer's task detail panel.

* Add instrumented field to bench

* Add summary popup and filter for uninstrumented tasks

* Drop collecting spawn locations in-app

* Make TaskSpawnEvent.instrumented bool, move Option to TelemetryEvent

Author: yulnr

dial9-tokio-telemetry/benches/writer_encode.rs

@@ -56,6 +56,7 @@ fn make_encoded_batch(worker: usize) -> Batch {
                 timestamp_ns: base + 2000,
                 task_id: task,
                 spawn_loc: loc,
+                instrumented: true,
             });
         }
         for _ in 0..5 {

dial9-tokio-telemetry/src/telemetry/buffer.rs

@@ -217,12 +217,14 @@ impl Encodable for RawEvent {
                 timestamp_nanos,
                 task_id,
                 location,
+                instrumented,
             } => {
                 let spawn_loc = enc.intern_location(location);
                 enc.encode(&TaskSpawnEvent {
                     timestamp_ns: *timestamp_nanos,
                     task_id: *task_id,
                     spawn_loc,
+                    instrumented: *instrumented,
                 });
             }
             RawEvent::TaskTerminate {

dial9-tokio-telemetry/src/telemetry/events.rs

@@ -133,6 +133,9 @@ pub enum TelemetryEvent {
         task_id: TaskId,
         /// Interned spawn location of the task.
         spawn_loc: InternedString,
+        /// Whether this task was spawned via [`TelemetryHandle::spawn`].
+        /// `None` for traces recorded before this field existed.
+        instrumented: Option<bool>,
     },
     /// A task terminated (completed or was cancelled).
     TaskTerminate {
@@ -319,6 +322,7 @@ pub(crate) enum RawEvent {
         timestamp_nanos: u64,
         task_id: crate::telemetry::task_metadata::TaskId,
         location: &'static std::panic::Location<'static>,
+        instrumented: bool,
     },
     TaskTerminate {
         timestamp_nanos: u64,
@@ -555,6 +559,7 @@ mod tests {
             timestamp_nanos: 5_000_000,
             task_id: TaskId::from_u32(1),
             spawn_loc: InternedString::from_raw(1),
+            instrumented: Some(true),
         };
         assert_eq!(task_spawn.timestamp_nanos(), Some(5_000_000));
     }
@@ -592,6 +597,7 @@ mod tests {
             timestamp_nanos: 5_000_000,
             task_id: TaskId::from_u32(1),
             spawn_loc: InternedString::from_raw(1),
+            instrumented: Some(true),
         };
         assert!(task_spawn.is_runtime_event());
     }

dial9-tokio-telemetry/src/telemetry/format.rs

@@ -176,6 +176,8 @@ pub struct TaskSpawnEvent {
     pub task_id: TaskId,
     /// Interned spawn location.
     pub spawn_loc: InternedString,
+    /// Whether this spawn was instrumented (via `TelemetryHandle::spawn`).
+    pub instrumented: bool,
 }
 
 #[derive(TraceEvent)]
@@ -390,6 +392,7 @@ pub(crate) fn to_owned_event(r: TelemetryEventRef<'_>, pool: &StringPool) -> Tel
             timestamp_nanos: e.timestamp_ns,
             task_id: e.task_id,
             spawn_loc: e.spawn_loc,
+            instrumented: Some(e.instrumented),
         },
         TelemetryEventRef::TaskTerminate(e) => TelemetryEvent::TaskTerminate {
             timestamp_nanos: e.timestamp_ns,

dial9-tokio-telemetry/src/telemetry/recorder/mod.rs

@@ -18,6 +18,7 @@ use crate::telemetry::writer::{RotatingWriter, TraceWriter};
 use metrique::timers::Timer;
 use metrique::unit::Microsecond;
 use metrique::unit_of_work::metrics;
+use std::cell::Cell;
 use std::cell::RefCell;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -28,6 +29,10 @@ thread_local! {
     /// Per-thread [`TelemetryHandle`], populated in `on_thread_start` and
     /// cleared in `on_thread_stop`. Enables [`TelemetryHandle::current`].
     static CURRENT_HANDLE: RefCell<Option<TelemetryHandle>> = const { RefCell::new(None) };
+
+    /// Set by `TelemetryHandle::spawn()` before calling `tokio::spawn()`,
+    /// so the `on_task_spawn` hook can distinguish instrumented from raw spawns.
+    static INSTRUMENTED_SPAWN: Cell<bool> = const { Cell::new(false) };
 }
 
 // ---------------------------------------------------------------------------
@@ -185,10 +190,13 @@ fn register_hooks(
         builder.on_task_spawn(move |meta| {
             let task_id = TaskId::from(meta.id());
             let location = meta.spawned_at();
+            let instrumented = INSTRUMENTED_SPAWN.with(|f| f.get());
+
             s5.record_event(RawEvent::TaskSpawn {
                 timestamp_nanos: crate::telemetry::events::clock_monotonic_ns(),
                 task_id,
                 location,
+                instrumented,
             });
         });
         let s6 = shared.clone();
@@ -399,13 +407,31 @@ impl TelemetryHandle {
         F::Output: Send + 'static,
     {
         let traced_handle = self.traced_handle();
+        let _guard = InstrumentedSpawnGuard::set();
         tokio::spawn(async move {
             let task_id = tokio::task::try_id().map(TaskId::from).unwrap_or_default();
             crate::traced::Traced::new(future, traced_handle, task_id).await
         })
     }
 }
 
+/// RAII guard that sets `INSTRUMENTED_SPAWN` to `true` on creation and
+/// resets it to `false` on drop, even if `tokio::spawn` panics.
+struct InstrumentedSpawnGuard;
+
+impl InstrumentedSpawnGuard {
+    fn set() -> Self {
+        INSTRUMENTED_SPAWN.set(true);
+        Self
+    }
+}
+
+impl Drop for InstrumentedSpawnGuard {
+    fn drop(&mut self) {
+        INSTRUMENTED_SPAWN.set(false);
+    }
+}
+
 /// Handle for spawning wake-tracked futures on a specific runtime.
 ///
 /// Returned by [`TraceRuntimeCoreBuilder::build`]. Unlike [`TelemetryHandle::spawn`]
@@ -428,6 +454,7 @@ impl RuntimeTelemetryHandle {
         F::Output: Send + 'static,
     {
         let traced = self.traced.clone();
+        let _guard = InstrumentedSpawnGuard::set();
         self.runtime.spawn(async move {
             let task_id = tokio::task::try_id().map(TaskId::from).unwrap_or_default();
             crate::traced::Traced::new(future, traced, task_id).await
@@ -581,6 +608,7 @@ impl Drop for TelemetryGuard {
     fn drop(&mut self) {
         // 1. Stop the flush thread (flushes + finalizes)
         self.stop_flush_thread();
+
         // 2. Hard shutdown: drop the sender without sending — worker sees
         // RecvError and exits without draining. No need to join the thread.
         // For graceful drain, use graceful_shutdown() instead.
@@ -1484,6 +1512,7 @@ mod tests {
                     timestamp_nanos: (i as u64 + 1) * 1000,
                     task_id,
                     location: loc,
+                    instrumented: true,
                 },
                 &collector,
                 &drain_epoch,

dial9-tokio-telemetry/tests/end_to_end.rs

@@ -196,3 +196,105 @@ fn custom_event_appears_in_trace() {
         .unwrap();
     assert_eq!(custom_count, 5, "expected 5 MyCustomEvent events in trace");
 }
+
+#[test]
+fn spawn_audit_detects_uninstrumented_spawns() {
+    let dir = tempfile::tempdir().unwrap();
+    let trace_path = dir.path().join("trace.bin");
+
+    const RAW: usize = 5;
+    const INSTRUMENTED: usize = 3;
+
+    let mut builder = tokio::runtime::Builder::new_multi_thread();
+    builder.worker_threads(2).enable_all();
+
+    let writer = RotatingWriter::single_file(&trace_path).unwrap();
+    let (runtime, guard) = TracedRuntime::builder()
+        .with_task_tracking(true)
+        .build_and_start(builder, writer)
+        .unwrap();
+
+    let handle = guard.handle();
+
+    runtime.block_on(async {
+        let mut joins = Vec::new();
+
+        // These go through TelemetryHandle::spawn, should NOT be flagged.
+        for _ in 0..INSTRUMENTED {
+            joins.push(handle.spawn(async {}));
+        }
+
+        // These are raw tokio::spawn, SHOULD be flagged, all at the same line.
+        for _ in 0..RAW {
+            joins.push(tokio::spawn(async {}));
+        }
+
+        for j in joins {
+            j.await.unwrap();
+        }
+
+        // Wait for flush cycle to drain thread-local buffers.
+        tokio::time::sleep(Duration::from_millis(200)).await;
+    });
+
+    drop(runtime);
+    drop(guard);
+
+    // Read the trace back from disk and check the instrumented flag.
+    let sealed_path = dir.path().join("trace.0.bin");
+    let reader = TraceReader::new(sealed_path.to_str().unwrap()).unwrap();
+    let events = &reader.all_events;
+
+    let instrumented_count = events
+        .iter()
+        .filter(|e| {
+            matches!(
+                e,
+                TelemetryEvent::TaskSpawn {
+                    instrumented: Some(true),
+                    ..
+                }
+            )
+        })
+        .count();
+    let uninstrumented_count = events
+        .iter()
+        .filter(|e| {
+            matches!(
+                e,
+                TelemetryEvent::TaskSpawn {
+                    instrumented: Some(false),
+                    ..
+                }
+            )
+        })
+        .count();
+
+    assert_eq!(
+        instrumented_count, INSTRUMENTED,
+        "expected {INSTRUMENTED} instrumented spawns, got {instrumented_count}"
+    );
+    assert_eq!(
+        uninstrumented_count, RAW,
+        "expected {RAW} uninstrumented spawns, got {uninstrumented_count}"
+    );
+
+    // Verify spawn locations resolve and point to this test file.
+    for event in events {
+        if let TelemetryEvent::TaskSpawn {
+            spawn_loc,
+            instrumented: Some(false),
+            ..
+        } = event
+        {
+            let loc = reader
+                .spawn_locations
+                .get(spawn_loc)
+                .expect("uninstrumented spawn_loc should resolve");
+            assert!(
+                loc.contains("end_to_end.rs"),
+                "uninstrumented spawn should point to this test file, got: {loc}"
+            );
+        }
+    }
+}

dial9-viewer/ui/trace_analysis.js

@@ -393,6 +393,22 @@
       }
     }
 
+    if (filterType === "uninstrumented" && opts && opts.taskInstrumented) {
+      for (const w of workerIds) {
+        for (const s of workerSpans[w].polls) {
+          if (s.taskId && opts.taskInstrumented.get(s.taskId) === false) {
+            points.push({
+              time: s.start,
+              worker: w,
+              type: "uninstrumented",
+              value: (s.end - s.start) / 1e6,
+              span: s,
+            });
+          }
+        }
+      }
+    }
+
     if (opts && opts.sortByWorst) {
       points.sort((a, b) => b.value - a.value);
     } else {

dial9-viewer/ui/trace_parser.js

@@ -93,6 +93,7 @@
    *   taskSpawnLocs: Map<number, string|null>,
    *   taskSpawnTimes: Map<number, number>,
    *   taskTerminateTimes: Map<number, number>,
+   *   taskInstrumented: Map<number, boolean>,
    *   cpuSamples: CpuSample[],
    *   callframeSymbols: Map<string, SymbolFrame|SymbolFrame[]>,
    *   threadNames: Map<number, string>,
@@ -186,6 +187,7 @@
     const taskSpawnLocs = new Map();
     const taskSpawnTimes = new Map();
     const taskTerminateTimes = new Map();
+    const taskInstrumented = new Map(); // taskId -> bool (true if spawned via TelemetryHandle::spawn)
     const callframeSymbols = new Map();
     const cpuSamples = [];
     const threadNames = new Map();
@@ -323,9 +325,11 @@
         case "TaskSpawnEvent": {
           const taskId = num(v.task_id);
           const spawnLoc = v.spawn_loc || null;
+          const instrumented = v.instrumented ?? true;
           if (spawnLoc) spawnLocations.set(spawnLoc, spawnLoc);
           taskSpawnLocs.set(taskId, spawnLoc);
           taskSpawnTimes.set(taskId, ts);
+          taskInstrumented.set(taskId, !!instrumented);
           break;
         }
         case "TaskTerminateEvent":
@@ -474,6 +478,7 @@
       spawnLocations,
       taskSpawnLocs,
       taskSpawnTimes,
+      taskInstrumented,
       cpuSamples,
       callframeSymbols,
       threadNames,