fix(core): share one fallback trace id across span and log exporters

Address review feedback on the per-run fallback.

Giving each exporter wrapper its own FallbackExternalTraceId reintroduced
the problem it was meant to fix, one signal down: before, every wrapper
got the same generated string, so a run's spans and logs agreed. With
per-wrapper state each one reminted independently, so from the second run
on a warm process the logs carried a different trace id than the spans and
stopped correlating. Construct one instance in the TracingSDK and pass it
to every span and log wrapper.

Also stop treating an empty trace context as a run boundary. The noop
manager returns a fresh object on every call, so its identity always
differs and would remint on every export batch, shattering one run's trace
into many. Not reachable today (the wrappers are only built where a
StandardTraceContextManager is registered) but the invariant was implicit.

Rewrite the changeset for users per AGENTS.md, and format with oxfmt.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: NERLOE

.changeset/external-trace-id-per-run.md

@@ -2,4 +2,4 @@
 "@trigger.dev/core": patch
 ---
 
-Mint the fallback external trace id per run rather than once per `TracingSDK`. Runs that carry no external trace context fall back to a generated trace id, and with `experimental_processKeepAlive` the `TracingSDK` outlives the run — so every run on a warm process was exported to the external OTLP endpoint under one shared trace id, merging unrelated runs into a single trace.
+Runs that don't continue an incoming trace are no longer merged into one trace when they execute on the same warm worker process. Each run now appears as its own trace in your external observability tool, so per-run cost and latency attribution works again.

packages/core/src/v3/otel/tracingSDK.ts

@@ -162,7 +162,8 @@ export class TracingSDK {
       )
     );
 
-    const externalTraceId = idGenerator.generateTraceId();
+    // Shared by every wrapper below so a run's spans and logs agree on the id.
+    const externalTraceId = new FallbackExternalTraceId(idGenerator.generateTraceId());
 
     for (const exporter of config.exporters ?? []) {
       spanProcessors.push(
@@ -393,6 +394,19 @@ function setLogLevel(level: TracingDiagnosticLogLevel) {
   diag.setLogger(new DiagConsoleLogger(), diagLogLevel);
 }
 
+/**
+ * Identity of the current run's trace context, or undefined when no run is
+ * active.
+ *
+ * An empty context is not a run: the noop manager returns a fresh `{}` on every
+ * call, so treating it as a run would mint a new id on every export.
+ */
+function currentRunTraceContext(): object | undefined {
+  const current = traceContext.getTraceContext();
+
+  return current && Object.keys(current).length > 0 ? current : undefined;
+}
+
 /**
  * The external trace id used by runs that carry no external trace context,
  * minted once per run.
@@ -402,17 +416,20 @@ function setLogLevel(level: TracingDiagnosticLogLevel) {
  * — outlive the run, so an id captured at construction merges every run on the
  * process into one trace. The manager's trace context object is reassigned per
  * run, which makes its identity the run boundary.
+ *
+ * One instance is shared by every wrapper, so a run's spans and logs still
+ * agree on the id after a remint.
  */
-class FallbackExternalTraceId {
+export class FallbackExternalTraceId {
   private traceId: string;
-  private seenTraceContext: unknown;
+  private seenTraceContext: object | undefined;
 
   constructor(
     private seed: string,
     private traceIdGenerator: Pick<RandomIdGenerator, "generateTraceId"> = idGenerator
   ) {
     this.traceId = seed;
-    this.seenTraceContext = traceContext.getTraceContext();
+    this.seenTraceContext = currentRunTraceContext();
   }
 
   get(): string {
@@ -422,10 +439,10 @@ class FallbackExternalTraceId {
       return this.seed;
     }
 
-    const currentTraceContext = traceContext.getTraceContext();
+    const current = currentRunTraceContext();
 
-    if (currentTraceContext !== this.seenTraceContext) {
-      this.seenTraceContext = currentTraceContext;
+    if (current && current !== this.seenTraceContext) {
+      this.seenTraceContext = current;
       this.traceId = this.traceIdGenerator.generateTraceId();
     }
 
@@ -434,15 +451,10 @@ class FallbackExternalTraceId {
 }
 
 export class ExternalSpanExporterWrapper {
-  private fallback: FallbackExternalTraceId;
-
   constructor(
     private underlyingExporter: SpanExporter,
-    externalTraceId: string,
-    traceIdGenerator?: Pick<RandomIdGenerator, "generateTraceId">
-  ) {
-    this.fallback = new FallbackExternalTraceId(externalTraceId, traceIdGenerator);
-  }
+    private fallback: FallbackExternalTraceId
+  ) {}
 
   private transformSpan(span: ReadableSpan): ReadableSpan | undefined {
     // Read external context live, so per-run reassignment of
@@ -463,9 +475,7 @@ export class ExternalSpanExporterWrapper {
       return;
     }
 
-    const externalTraceId = externalTraceContext
-      ? externalTraceContext.traceId
-      : fallbackTraceId;
+    const externalTraceId = externalTraceContext ? externalTraceContext.traceId : fallbackTraceId;
 
     const isAttemptSpan = span.attributes[SemanticInternalAttributes.SPAN_ATTEMPT];
 
@@ -524,15 +534,10 @@ export class ExternalSpanExporterWrapper {
 }
 
 class ExternalLogRecordExporterWrapper {
-  private fallback: FallbackExternalTraceId;
-
   constructor(
     private underlyingExporter: LogRecordExporter,
-    externalTraceId: string,
-    traceIdGenerator?: Pick<RandomIdGenerator, "generateTraceId">
-  ) {
-    this.fallback = new FallbackExternalTraceId(externalTraceId, traceIdGenerator);
-  }
+    private fallback: FallbackExternalTraceId
+  ) {}
 
   export(logs: any[], resultCallback: (result: any) => void): void {
     const externalTraceContext = traceContext.getExternalTraceContext();

packages/core/test/externalSpanExporterWrapper.test.ts

@@ -1,7 +1,7 @@
 import { SpanKind, SpanStatusCode, TraceFlags } from "@opentelemetry/api";
 import type { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-node";
 import { beforeEach, describe, expect, it } from "vitest";
-import { ExternalSpanExporterWrapper } from "../src/v3/otel/tracingSDK.js";
+import { ExternalSpanExporterWrapper, FallbackExternalTraceId } from "../src/v3/otel/tracingSDK.js";
 import { SemanticInternalAttributes } from "../src/v3/semanticInternalAttributes.js";
 import { traceContext } from "../src/v3/trace-context-api.js";
 import { StandardTraceContextManager } from "../src/v3/traceContext/manager.js";
@@ -66,7 +66,10 @@ describe("ExternalSpanExporterWrapper warm-start regression", () => {
 
     manager.traceContext = { external: { traceparent: TRACEPARENT_RUN_A } };
 
-    const wrapper = new ExternalSpanExporterWrapper(exporter, "ffffffffffffffffffffffffffffffff");
+    const wrapper = new ExternalSpanExporterWrapper(
+      exporter,
+      new FallbackExternalTraceId("ffffffffffffffffffffffffffffffff")
+    );
 
     manager.traceContext = { external: { traceparent: TRACEPARENT_RUN_B } };
 
@@ -98,8 +101,7 @@ describe("ExternalSpanExporterWrapper warm-start regression", () => {
 
     const wrapper = new ExternalSpanExporterWrapper(
       exporter,
-      "ffffffffffffffffffffffffffffffff",
-      idGenerator
+      new FallbackExternalTraceId("ffffffffffffffffffffffffffffffff", idGenerator)
     );
 
     wrapper.export([createAttemptSpan()], () => {});
@@ -130,8 +132,7 @@ describe("ExternalSpanExporterWrapper warm-start regression", () => {
 
     const wrapper = new ExternalSpanExporterWrapper(
       exporter,
-      "ffffffffffffffffffffffffffffffff",
-      idGenerator
+      new FallbackExternalTraceId("ffffffffffffffffffffffffffffffff", idGenerator)
     );
 
     wrapper.export([createAttemptSpan()], () => {});
@@ -150,12 +151,70 @@ describe("ExternalSpanExporterWrapper warm-start regression", () => {
 
     manager.traceContext = { traceparent: TRACEPARENT_RUN_A };
 
-    const wrapper = new ExternalSpanExporterWrapper(exporter, "", idGenerator);
+    const wrapper = new ExternalSpanExporterWrapper(
+      exporter,
+      new FallbackExternalTraceId("", idGenerator)
+    );
 
     wrapper.export([createAttemptSpan()], () => {});
 
     // Minting an id here would switch external export on for a deployment that
     // never asked for it.
     expect(captured[0]).toHaveLength(0);
   });
+
+  // The TracingSDK shares one FallbackExternalTraceId across every span and log
+  // wrapper. Giving each wrapper its own would remint them independently, so
+  // from the second run on, a run's logs would carry a different trace id than
+  // its spans and stop correlating in the external backend.
+  it("gives every wrapper sharing one fallback the same id after a remint", () => {
+    const first = makeCapturingExporter();
+    const second = makeCapturingExporter();
+
+    let generated = 0;
+    const idGenerator = {
+      generateTraceId: () => `${++generated}`.padStart(32, "0"),
+    };
+
+    manager.traceContext = { traceparent: TRACEPARENT_RUN_A };
+
+    const fallback = new FallbackExternalTraceId("ffffffffffffffffffffffffffffffff", idGenerator);
+    const spanWrapper = new ExternalSpanExporterWrapper(first.exporter, fallback);
+    const otherWrapper = new ExternalSpanExporterWrapper(second.exporter, fallback);
+
+    manager.traceContext = { traceparent: TRACEPARENT_RUN_B };
+
+    spanWrapper.export([createAttemptSpan()], () => {});
+    otherWrapper.export([createAttemptSpan()], () => {});
+
+    expect(second.captured[0]![0]!.spanContext().traceId).toBe(
+      first.captured[0]![0]!.spanContext().traceId
+    );
+    expect(generated).toBe(1);
+  });
+
+  // The noop manager returns a fresh `{}` on every call, so using its identity
+  // as the run boundary would remint on every export and shatter one run's
+  // trace into many.
+  it("holds the id when no trace context manager is registered", () => {
+    const { exporter, captured } = makeCapturingExporter();
+
+    let generated = 0;
+    const idGenerator = {
+      generateTraceId: () => `${++generated}`.padStart(32, "0"),
+    };
+
+    traceContext.disable();
+
+    const wrapper = new ExternalSpanExporterWrapper(
+      exporter,
+      new FallbackExternalTraceId("ffffffffffffffffffffffffffffffff", idGenerator)
+    );
+
+    wrapper.export([createAttemptSpan()], () => {});
+    wrapper.export([createAttemptSpan()], () => {});
+
+    expect(captured[1]![0]!.spanContext().traceId).toBe(captured[0]![0]!.spanContext().traceId);
+    expect(generated).toBe(0);
+  });
 });