fix: [AI-190] prevent tracing exporter timeout from leaking timers (#191)

- Add `clearTimeout` in `.finally()` to `withTimeout` so the event loop
  exits immediately after `endTrace()` instead of hanging for 5 seconds
- Log a `console.warn` when an exporter times out (uses the previously
  unused `name` parameter for diagnostics)
- Align `HttpExporter` internal `AbortSignal.timeout` from 10s to 5s to
  match the per-exporter wrapper timeout
- Clean up safety-net timer in adversarial test to prevent open handles

Closes #190

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: anandgupta42

.github/meta/commit.txt

@@ -1,10 +1,13 @@
-docs: update site-wide docs for training and new agent modes
+fix: [AI-190] prevent tracing exporter timeout from leaking timers
 
-- Homepage: update from "Four agents" to "Seven agents" — add Researcher,
-  Trainer, Executive cards with descriptions
-- Getting Started: update training link to match new pitch
-  "Corrections That Stick"
-- Tools index: add Training row (3 tools + 3 skills) with link
-- All references now consistent with simplified training system
+- Add `clearTimeout` in `.finally()` to `withTimeout` so the event loop
+  exits immediately after `endTrace()` instead of hanging for 5 seconds
+- Log a `console.warn` when an exporter times out (uses the previously
+  unused `name` parameter for diagnostics)
+- Align `HttpExporter` internal `AbortSignal.timeout` from 10s to 5s to
+  match the per-exporter wrapper timeout
+- Clean up safety-net timer in adversarial test to prevent open handles
+
+Closes #190
 
 Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

packages/opencode/src/altimate/observability/tracing.ts

@@ -219,7 +219,7 @@ export class HttpExporter implements TraceExporter {
         method: "POST",
         headers: { "Content-Type": "application/json", ...this.headers },
         body: JSON.stringify(trace),
-        signal: AbortSignal.timeout(10_000),
+        signal: AbortSignal.timeout(5_000),
       })
 
       if (!res.ok) return undefined
@@ -735,11 +735,24 @@ export class Tracer {
 
     const trace = this.buildTraceFile(error)
 
-    // Wrap each exporter call to catch synchronous throws as well as rejections
+    // Wrap each exporter call with a timeout to prevent hanging exporters
+    // from blocking the entire endTrace call
+    const EXPORTER_TIMEOUT_MS = 5_000
+    const withTimeout = (p: Promise<string | undefined>, name: string) => {
+      let timer: ReturnType<typeof setTimeout>
+      const timeout = new Promise<undefined>((resolve) => {
+        timer = setTimeout(() => {
+          console.warn(`[tracing] Exporter "${name}" timed out after ${EXPORTER_TIMEOUT_MS}ms`)
+          resolve(undefined)
+        }, EXPORTER_TIMEOUT_MS)
+      })
+      return Promise.race([p, timeout]).finally(() => clearTimeout(timer))
+    }
+
     const results = await Promise.allSettled(
       this.exporters.map((e) => {
         try {
-          return e.export(trace)
+          return withTimeout(Promise.resolve(e.export(trace)), e.name)
         } catch {
           return Promise.resolve(undefined)
         }

packages/opencode/test/altimate/tracing-adversarial.test.ts

@@ -548,18 +548,24 @@ describe("Adversarial — exporter failures", () => {
     }
     const fileExporter = makeExporter()
 
+    // Put FileExporter first so its result is returned
     const tracer = Tracer.withExporters([fileExporter, hangingExporter])
     tracer.startTrace("s-hang", { prompt: "test" })
 
-    // Use Promise.race to prevent test from hanging
+    // endTrace has a per-exporter timeout (5s), so the hanging exporter
+    // will be timed out and the FileExporter result returned.
+    // Use a generous outer timeout just as a safety net.
+    let safetyTimer: ReturnType<typeof setTimeout>
     const result = await Promise.race([
       tracer.endTrace(),
-      new Promise<string>((resolve) => setTimeout(() => resolve("timeout"), 5000)),
-    ])
+      new Promise<string>((resolve) => {
+        safetyTimer = setTimeout(() => resolve("timeout"), 8000)
+      }),
+    ]).finally(() => clearTimeout(safetyTimer!))
 
-    // This will either return the file path or "timeout" — either way no crash
-    expect(typeof result).toBe("string")
-  })
+    // Should get the file path from FileExporter, not "timeout"
+    expect(result).toContain(".json")
+  }, 10000)
 
   test("exporter that returns null/undefined", async () => {
     const nullExporter: TraceExporter = {