fix(webapp): seed mollifier run traceContext + propagate drainer trace

Mollified runs were materialising with `TaskRun.traceContext = {}`, so every
downstream `recordRunDebugLog` (engine QUEUED/EXECUTING/FINISHED, run:notify,
attempt events) drew a fresh traceId with null parentId. The run-detail
trace view rendered only the root span; the rest of the tree was orphaned.

The pass-through path gets traceContext for free via `traceEventConcern.traceRun`
populating the W3C traceparent. The mollifier path skips that wrapper, so seed
`traceContext.traceparent` from the queued span at the call site before
handing the snapshot to engine.trigger.

Also fixes the drainer side: wrap the `mollifier.drained` span + `engine.trigger`
call in a `context.with(parentContext, ...)` built from the snapshot's
traceId/spanId. Without this `mollifier.drained` lived in a fresh trace and
the engine instrumentation inside it inherited an empty active context.

Regression tests:
- `triggerTask.test.ts` — asserts the buffered snapshot carries a valid W3C
  traceparent that references the snapshot's traceId/spanId.
- `mollifierDrainerHandler.test.ts` — captures the active traceId at the
  moment engine.trigger is invoked and asserts it matches the snapshot's
  traceId.

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

Author: d-cs

apps/webapp/app/runEngine/services/triggerTask.server.ts

@@ -388,11 +388,23 @@ export class RunEngineTriggerTaskService {
                 mollifierOutcome.decision.threshold
               );
               mollifierSpan.setAttribute("runId", runFriendlyId);
+              mollifierSpan.setAttribute("taskRunId", runFriendlyId);
 
               const payloadPacket = await this.payloadProcessor.process(triggerRequest);
               const taskEventStore = parentRun?.taskEventStore ?? "taskEvent";
+              // Seed the W3C `traceparent` from the queued span so downstream
+              // `recordRunDebugLog` calls (engine QUEUED/EXECUTING/FINISHED,
+              // run:notify, etc.) emit TaskEvent rows that join the run's trace.
+              // Pass-through gets this for free via `traceEventConcern.traceRun`
+              // populating `event.traceContext`; the mollifier path skips that
+              // wrapper so we have to build the same shape ourselves.
               const traceContext = this.#propagateExternalTraceContext(
-                {},
+                {
+                  traceparent: serializeTraceparent(
+                    mollifierSpan.spanContext().traceId,
+                    mollifierSpan.spanContext().spanId
+                  ),
+                },
                 parentRun?.traceContext,
                 undefined
               );

apps/webapp/app/v3/mollifier/mollifierDrainerHandler.server.ts

@@ -1,4 +1,4 @@
-import { trace } from "@opentelemetry/api";
+import { context, trace, TraceFlags } from "@opentelemetry/api";
 import type { RunEngine } from "@internal/run-engine";
 import type { PrismaClientOrTransaction } from "@trigger.dev/database";
 import type { MollifierDrainerHandler } from "@trigger.dev/redis-worker";
@@ -25,13 +25,36 @@ export function createDrainerHandler(deps: {
   return async (input) => {
     const dwellMs = Date.now() - input.createdAt.getTime();
 
-    await startSpan(tracer, "mollifier.drained", async (span) => {
-      span.setAttribute("mollifier.drained", true);
-      span.setAttribute("mollifier.dwell_ms", dwellMs);
-      span.setAttribute("mollifier.attempts", input.attempts);
-      span.setAttribute("mollifier.run_friendly_id", input.runId);
+    // Re-attach to the trace started by the caller's mollifier.queued span
+    // (its traceId + spanId were captured into the snapshot at buffer time).
+    // Without this the drainer would emit mollifier.drained in a brand-new
+    // trace and the engine.trigger instrumentation would inherit an empty
+    // active context — leaving the run-detail page with only the root span.
+    const snapshotTraceId =
+      typeof input.payload.traceId === "string" ? input.payload.traceId : undefined;
+    const snapshotSpanId =
+      typeof input.payload.spanId === "string" ? input.payload.spanId : undefined;
 
-      await deps.engine.trigger(input.payload as any, deps.prisma);
+    const parentContext =
+      snapshotTraceId && snapshotSpanId
+        ? trace.setSpanContext(context.active(), {
+            traceId: snapshotTraceId,
+            spanId: snapshotSpanId,
+            traceFlags: TraceFlags.SAMPLED,
+            isRemote: true,
+          })
+        : context.active();
+
+    await context.with(parentContext, async () => {
+      await startSpan(tracer, "mollifier.drained", async (span) => {
+        span.setAttribute("mollifier.drained", true);
+        span.setAttribute("mollifier.dwell_ms", dwellMs);
+        span.setAttribute("mollifier.attempts", input.attempts);
+        span.setAttribute("mollifier.run_friendly_id", input.runId);
+        span.setAttribute("taskRunId", input.runId);
+
+        await deps.engine.trigger(input.payload as any, deps.prisma);
+      });
     });
   };
 }

apps/webapp/test/engine/triggerTask.test.ts

@@ -1355,7 +1355,26 @@ describe("RunEngineTriggerTaskService", () => {
       // input). Schema is internal to the engine, so we only assert that
       // it parses and references the friendlyId — anything more specific
       // would couple the mollifier-layer test to engine-layer fields.
-      expect(() => JSON.parse(buffer.accepted[0]!.payload)).not.toThrow();
+      const snapshot = JSON.parse(buffer.accepted[0]!.payload) as {
+        traceId?: string;
+        spanId?: string;
+        traceContext?: { traceparent?: string };
+      };
+
+      // Regression guard for the dashboard trace-tree bug: the mollifier
+      // snapshot MUST carry a W3C `traceparent` in `traceContext`, seeded
+      // from the queued span. Without it, the drainer replays through
+      // engine.trigger with empty traceContext and every downstream
+      // `recordRunDebugLog` (QUEUED/EXECUTING/FINISHED/run:notify…) gets a
+      // fresh traceId + null parentId — the run-detail page can only show
+      // the root span. Pass-through gets this for free via
+      // `traceEventConcern.traceRun`; the mollifier path doesn't enter
+      // that wrapper so the seeding has to happen at the call site.
+      expect(snapshot.traceContext?.traceparent).toMatch(
+        /^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/
+      );
+      expect(snapshot.traceContext!.traceparent).toContain(snapshot.traceId);
+      expect(snapshot.traceContext!.traceparent).toContain(snapshot.spanId);
 
       // Postgres has NOT been written: engine.trigger was never called on
       // the mollify path. The run materialises only when the drainer

apps/webapp/test/mollifierDrainerHandler.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
+import { trace } from "@opentelemetry/api";
 
 vi.mock("~/db.server", () => ({
   prisma: {},
@@ -55,6 +56,40 @@ describe("createDrainerHandler", () => {
     expect(callArg.taskIdentifier).toBe("t");
   });
 
+  it("re-attaches the snapshot's traceId so engine.trigger inherits the original trace", async () => {
+    // Captures the active traceId at the moment engine.trigger is invoked.
+    // Without context propagation it would be a fresh traceId, leaving the
+    // run-detail page with only the root span.
+    let observedTraceId: string | undefined;
+    const trigger = vi.fn(async () => {
+      observedTraceId = trace.getActiveSpan()?.spanContext().traceId;
+      return { friendlyId: "run_x" };
+    });
+
+    const handler = createDrainerHandler({
+      engine: { trigger } as any,
+      prisma: {} as any,
+    });
+
+    const snapshotTraceId = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+    const snapshotSpanId = "bbbbbbbbbbbbbbbb";
+
+    await handler({
+      runId: "run_x",
+      envId: "env_a",
+      orgId: "org_1",
+      payload: {
+        taskIdentifier: "t",
+        traceId: snapshotTraceId,
+        spanId: snapshotSpanId,
+      },
+      attempts: 0,
+      createdAt: new Date(),
+    } as any);
+
+    expect(observedTraceId).toBe(snapshotTraceId);
+  });
+
   it("propagates engine.trigger errors so MollifierDrainer can classify them", async () => {
     const trigger = vi.fn(async () => {
       throw new Error("boom");