fix(cloudflare): Wait for span links to be set

dev-packages/cloudflare-integration-tests/suites/tracing/durableobject-alarm-links-sync/index.ts

@@ -0,0 +1,54 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+  SENTRY_DSN: string;
+  TEST_DURABLE_OBJECT: DurableObjectNamespace;
+}
+
+class SyncAlarmDurableObjectBase extends DurableObject<Env> {
+  public constructor(ctx: DurableObjectState, env: Env) {
+    super(ctx, env);
+  }
+
+  async setAlarm(): Promise<void> {
+    await this.ctx.storage.setAlarm(Date.now() + 100);
+  }
+
+  // Synchronous alarm handler - this is the case we're testing
+  alarm(): void {
+    // Intentionally synchronous - no async/await
+    const _ = 'sync alarm executed';
+  }
+}
+
+export const TestDurableObject = Sentry.instrumentDurableObjectWithSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    tracesSampleRate: 1.0,
+    enableRpcTracePropagation: true,
+  }),
+  SyncAlarmDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    tracesSampleRate: 1.0,
+  }),
+  {
+    async fetch(request: Request, env: Env): Promise<Response> {
+      const url = new URL(request.url);
+
+      if (url.pathname === '/set-alarm') {
+        const id = url.searchParams.get('id') || 'default';
+        const doId = env.TEST_DURABLE_OBJECT.idFromName(id);
+        const stub = env.TEST_DURABLE_OBJECT.get(doId) as unknown as SyncAlarmDurableObjectBase;
+        await stub.setAlarm();
+        return new Response('Alarm scheduled');
+      }
+
+      return new Response('OK');
+    },
+  } satisfies ExportedHandler<Env>,
+);

dev-packages/cloudflare-integration-tests/suites/tracing/durableobject-alarm-links-sync/test.ts

@@ -0,0 +1,67 @@
+import { expect, it } from 'vitest';
+import type { TransactionEvent } from '@sentry/core';
+import { createRunner } from '../../../runner';
+
+it('sync alarm links to the trace that scheduled it via sentry.previous_trace', async ({ signal }) => {
+  let setAlarmTransaction: TransactionEvent | undefined;
+  let alarmTransaction: TransactionEvent | undefined;
+  const testId = Date.now().toString();
+
+  const runner = createRunner(__dirname)
+    .expect(envelope => {
+      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
+      expect(transactionEvent).toEqual(
+        expect.objectContaining({
+          transaction: expect.stringContaining('/set-alarm'),
+        }),
+      );
+    })
+    .expect(envelope => {
+      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
+      expect(transactionEvent).toEqual(
+        expect.objectContaining({
+          transaction: 'setAlarm',
+          contexts: expect.objectContaining({
+            trace: expect.objectContaining({
+              op: 'rpc',
+              origin: 'auto.faas.cloudflare.durable_object',
+            }),
+          }),
+        }),
+      );
+      setAlarmTransaction = transactionEvent;
+    })
+    .expect(envelope => {
+      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
+      expect(transactionEvent).toEqual(
+        expect.objectContaining({
+          type: 'transaction',
+          transaction: 'alarm',
+          contexts: expect.objectContaining({
+            trace: expect.objectContaining({
+              op: 'function',
+              origin: 'auto.faas.cloudflare.durable_object',
+            }),
+          }),
+        }),
+      );
+      alarmTransaction = transactionEvent;
+    })
+    .unordered()
+    .start(signal);
+
+  await runner.makeRequest('get', `/set-alarm?id=${testId}`);
+  await runner.completed();
+
+  // This is the key assertion: even though the alarm handler is synchronous,
+  // sentry.previous_trace should still be set because we await the linkPromise
+  // before teardown in the sync path
+  const traceData = alarmTransaction!.contexts?.trace?.data as Record<string, unknown> | undefined;
+  const previousTrace = traceData?.['sentry.previous_trace'] as string | undefined;
+
+  expect(previousTrace).toBeDefined();
+  expect(previousTrace).toMatch(/^[a-f0-9]{32}-[a-f0-9]{16}-[01]$/);
+
+  const [linkedTraceId] = previousTrace!.split('-');
+  expect(linkedTraceId).toBe(setAlarmTransaction!.contexts?.trace?.trace_id);
+});

dev-packages/cloudflare-integration-tests/suites/tracing/durableobject-alarm-links-sync/wrangler.jsonc

@@ -0,0 +1,20 @@
+{
+  "name": "durableobject-alarm-links-sync",
+  "main": "index.ts",
+  "compatibility_date": "2025-06-17",
+  "migrations": [
+    {
+      "new_sqlite_classes": ["TestDurableObject"],
+      "tag": "v1",
+    },
+  ],
+  "durable_objects": {
+    "bindings": [
+      {
+        "class_name": "TestDurableObject",
+        "name": "TEST_DURABLE_OBJECT",
+      },
+    ],
+  },
+  "compatibility_flags": ["nodejs_als"],
+}

dev-packages/cloudflare-integration-tests/suites/tracing/durableobject-alarm-links/index.ts

@@ -0,0 +1,52 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+  SENTRY_DSN: string;
+  TEST_DURABLE_OBJECT: DurableObjectNamespace;
+}
+
+class AlarmDurableObjectBase extends DurableObject<Env> {
+  public constructor(ctx: DurableObjectState, env: Env) {
+    super(ctx, env);
+  }
+
+  async setAlarm(): Promise<void> {
+    await this.ctx.storage.setAlarm(Date.now() + 100);
+  }
+
+  async alarm(): Promise<void> {
+    await new Promise<void>(resolve => setTimeout(resolve, 10));
+  }
+}
+
+export const TestDurableObject = Sentry.instrumentDurableObjectWithSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    tracesSampleRate: 1.0,
+    enableRpcTracePropagation: true,
+  }),
+  AlarmDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    tracesSampleRate: 1.0,
+  }),
+  {
+    async fetch(request: Request, env: Env): Promise<Response> {
+      const url = new URL(request.url);
+
+      if (url.pathname === '/set-alarm') {
+        const id = url.searchParams.get('id') || 'default';
+        const doId = env.TEST_DURABLE_OBJECT.idFromName(id);
+        const stub = env.TEST_DURABLE_OBJECT.get(doId) as unknown as AlarmDurableObjectBase;
+        await stub.setAlarm();
+        return new Response('Alarm scheduled');
+      }
+
+      return new Response('OK');
+    },
+  } satisfies ExportedHandler<Env>,
+);

dev-packages/cloudflare-integration-tests/suites/tracing/durableobject-alarm-links/test.ts

@@ -0,0 +1,64 @@
+import { expect, it } from 'vitest';
+import type { TransactionEvent } from '@sentry/core';
+import { createRunner } from '../../../runner';
+
+it('alarm links to the trace that scheduled it via sentry.previous_trace', async ({ signal }) => {
+  let setAlarmTransaction: TransactionEvent | undefined;
+  let alarmTransaction: TransactionEvent | undefined;
+  const testId = Date.now().toString();
+
+  const runner = createRunner(__dirname)
+    .expect(envelope => {
+      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
+      expect(transactionEvent).toEqual(
+        expect.objectContaining({
+          transaction: expect.stringContaining('/set-alarm'),
+        }),
+      );
+    })
+    .expect(envelope => {
+      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
+      expect(transactionEvent).toEqual(
+        expect.objectContaining({
+          transaction: 'setAlarm',
+          contexts: expect.objectContaining({
+            trace: expect.objectContaining({
+              op: 'rpc',
+              origin: 'auto.faas.cloudflare.durable_object',
+            }),
+          }),
+        }),
+      );
+      setAlarmTransaction = transactionEvent;
+    })
+    .expect(envelope => {
+      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
+      expect(transactionEvent).toEqual(
+        expect.objectContaining({
+          type: 'transaction',
+          transaction: 'alarm',
+          contexts: expect.objectContaining({
+            trace: expect.objectContaining({
+              op: 'function',
+              origin: 'auto.faas.cloudflare.durable_object',
+            }),
+          }),
+        }),
+      );
+      alarmTransaction = transactionEvent;
+    })
+    .unordered()
+    .start(signal);
+
+  await runner.makeRequest('get', `/set-alarm?id=${testId}`);
+  await runner.completed();
+
+  const traceData = alarmTransaction!.contexts?.trace?.data as Record<string, unknown> | undefined;
+  const previousTrace = traceData?.['sentry.previous_trace'] as string | undefined;
+
+  expect(previousTrace).toBeDefined();
+  expect(previousTrace).toMatch(/^[a-f0-9]{32}-[a-f0-9]{16}-[01]$/);
+
+  const [linkedTraceId] = previousTrace!.split('-');
+  expect(linkedTraceId).toBe(setAlarmTransaction!.contexts?.trace?.trace_id);
+});

dev-packages/cloudflare-integration-tests/suites/tracing/durableobject-alarm-links/wrangler.jsonc

@@ -0,0 +1,20 @@
+{
+  "name": "durableobject-alarm-links",
+  "main": "index.ts",
+  "compatibility_date": "2025-06-17",
+  "migrations": [
+    {
+      "new_sqlite_classes": ["TestDurableObject"],
+      "tag": "v1",
+    },
+  ],
+  "durable_objects": {
+    "bindings": [
+      {
+        "class_name": "TestDurableObject",
+        "name": "TEST_DURABLE_OBJECT",
+      },
+    ],
+  },
+  "compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/instrumentDurableObjectStorage.ts

@@ -63,7 +63,7 @@ export function instrumentDurableObjectStorage(
               // We use the original (uninstrumented) storage (target) to avoid creating a span
               // for this internal operation. The storage is deferred via waitUntil to not block.
               if (methodName === 'setAlarm') {
-                await storeSpanContext(target, 'alarm');
+                storeSpanContext(target, 'alarm');
               }
             };
 

packages/cloudflare/src/utils/traceLinks.ts

@@ -26,7 +26,7 @@ export function getTraceLinkKey(methodName: string): string {
  * Uses the original uninstrumented storage to avoid creating spans for internal operations.
  * Errors are silently ignored to prevent internal storage failures from propagating to user code.
  */
-export async function storeSpanContext(originalStorage: DurableObjectStorage, methodName: string): Promise<void> {
+export function storeSpanContext(originalStorage: DurableObjectStorage, methodName: string): void {
   try {
     const activeSpan = getActiveSpan();
     if (activeSpan) {
@@ -36,7 +36,8 @@ export async function storeSpanContext(originalStorage: DurableObjectStorage, me
         spanId: spanContext.spanId,
         sampled: spanIsSampled(activeSpan),
       };
-      await originalStorage.put(getTraceLinkKey(methodName), storedContext);
+
+      originalStorage.kv.put(getTraceLinkKey(methodName), storedContext);
     }
   } catch (error) {
     // Silently ignore storage errors to prevent internal failures from affecting user code
@@ -47,15 +48,11 @@ export async function storeSpanContext(originalStorage: DurableObjectStorage, me
 /**
  * Retrieves a stored span context from Durable Object storage.
  */
-export async function getStoredSpanContext(
+export function getStoredSpanContext(
   originalStorage: DurableObjectStorage,
   methodName: string,
-): Promise<StoredSpanContext | undefined> {
-  try {
-    return await originalStorage.get<StoredSpanContext>(getTraceLinkKey(methodName));
-  } catch {
-    return undefined;
-  }
+): StoredSpanContext | undefined {
+  return originalStorage.kv.get<StoredSpanContext>(getTraceLinkKey(methodName));
 }
 
 /**