feat(cloudflare): Add cacheClient to reuse the client across invocations

.size-limit.js

@@ -485,7 +485,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '522 KiB',
+ limit: '540 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/runner.ts

@@ -161,6 +161,7 @@ export function createRunner(...paths: string[]) {
 
  // controls whether envelopes are expected in predefined order or not
  let unordered = false;
+ let failOnUnexpected = false;
 
  if (!existsSync(testPath)) {
  throw new Error(`Test scenario not found: ${testPath}`);
@@ -195,6 +196,10 @@ export function createRunner(...paths: string[]) {
  unordered = true;
  return this;
  },
+ failOnUnexpected: function () {
+ failOnUnexpected = true;
+ return this;
+ },
  ignore: function (...types: EnvelopeItemType[]) {
  types.forEach(t => ignored.add(t));
  return this;
@@ -222,6 +227,7 @@ export function createRunner(...paths: string[]) {
  const expectedEnvelopeCount = expectedEnvelopes.length;
 
  let envelopeCount = 0;
+ let unexpectedEnvelopeError: Error | undefined;
  const envelopeWaiters: { expected: Expected; resolve: () => void; reject: (e: unknown) => void }[] = [];
  const {
  resolve: setWorkerPort,
@@ -297,6 +303,10 @@ export function createRunner(...paths: string[]) {
 
  // no match found
  if (matchIndex < 0) {
+ if (failOnUnexpected) {
+ unexpectedEnvelopeError ??= new Error('Received an unexpected envelope');
+ reject(unexpectedEnvelopeError);
+ }
  return;
  }
 
@@ -429,7 +439,10 @@ export function createRunner(...paths: string[]) {
 
  return {
  completed: async function (): Promise<void> {
- return isComplete;
+ await isComplete;
+ if (unexpectedEnvelopeError) {
+ throw unexpectedEnvelopeError;
+ }
  },
  makeRequest: async function <T>(
  method: 'get' | 'post',

dev-packages/cloudflare-integration-tests/suites/cache-client/index.ts

@@ -0,0 +1,256 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+ SENTRY_DSN: string;
+ CACHE_DO: DurableObjectNamespace;
+ NO_CACHE_DO: DurableObjectNamespace;
+}
+
+/**
+ * Sync KV and SQL work against the DO's own storage, which the SDK instruments into `db` spans.
+ * Used to check that those spans still reach the transport from inside a Durable Object, where a
+ * cached client never hits an invocation-boundary flush and has to rely on the eager drain.
+ */
+function runStorageOps(ctx: DurableObjectState): { listSize: number; rows: number } {
+ ctx.storage.kv.put('cache-key', { hello: 'sync' });
+ ctx.storage.kv.get('cache-key');
+ const entries = [...ctx.storage.kv.list()];
+ ctx.storage.kv.delete('cache-key');
+
+ ctx.storage.sql.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+ ctx.storage.sql.exec('INSERT INTO users (name) VALUES (?)', 'Alice');
+ const rows = ctx.storage.sql.exec('SELECT * FROM users').toArray();
+
+ return { listSize: entries.length, rows: rows.length };
+}
+
+function startDetachedWork(message: string): string {
+ void (async () => {
+ await new Promise(r => setTimeout(r, 3000));
+ await Sentry.startSpan({ name: 'do.detached-task', op: 'task' }, async () => {
+ Sentry.logger.info(`Detached log: ${message}`);
+ Sentry.metrics.count('do.detached', 1);
+ Sentry.captureException(new Error(message));
+ });
+ })();
+ return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true (the default) — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+ async echo(n: number): Promise<number> {
+ return n;
+ }
+
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`Cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async scopeCheck(seed: boolean): Promise<string> {
+ if (seed) {
+ Sentry.setTag('seeded_tag', 'from-seeding-call');
+ Sentry.setUser({ id: 'user-from-seeding-call' });
+ }
+ Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+ return 'ok';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+ }
+ if (url.pathname === '/streaming') {
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('chunk1'));
+ controller.enqueue(new TextEncoder().encode('chunk2'));
+ controller.close();
+ },
+ });
+ return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+ }
+ return new Response('Cache DO');
+ }
+}
+
+// DO with cacheClient: false — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`No-cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `no-cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+ }
+ return new Response('No-cache DO');
+ }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ cacheClient: false,
+ enableRpcTracePropagation: true,
+ }),
+ NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ {
+ async fetch(request, env, ctx) {
+ const url = new URL(request.url);
+ const instanceId = url.searchParams.get('id') || 'default';
+ const errorMessage = url.searchParams.get('errorMessage') || 'Same error';
+
+ // Work that finishes AFTER the response: a post-response span tree plus a
+ // log, metric and error, all registered via waitUntil. This is the worker-side
+ // half of the #22545 lifecycle (the DO-side half is /detached).
+ if (url.pathname === '/post-response') {
+ ctx.waitUntil(
+ Sentry.startSpan({ name: 'checkout.post-response', op: 'task' }, async () => {
+ Sentry.logger.info('checkout post-response log');
+ Sentry.metrics.count('checkout.processed', 1);
+ await new Promise(r => setTimeout(r, 50));
+ await Sentry.startSpan({ name: 'checkout.notify-webhook', op: 'http.client' }, async () => {
+ await new Promise(r => setTimeout(r, 25));
+ Sentry.captureException(new Error('Webhook delivery failed'));
+ });
+ }),
+ );
+ return new Response('checkout accepted');
+ }
+
+ // Fan a single request out into N sequential DO RPC calls — every RPC span must
+ // land in this request's trace when RPC trace propagation is on.
+ if (url.pathname === '/burst') {
+ const n = Math.min(Number(url.searchParams.get('n')) || 1, 20);
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`burst-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+
+ let sum = 0;
+ for (let i = 0; i < n; i++) {
+ sum += (await stub.echo(i)) as number;
+ }
+ return Response.json({ calls: n, sum });
+ }
+
+ // Cache DO RPC calls
+ if (url.pathname === '/cache/handler-error') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/cache/dedupe') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/cache/scope') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+ }
+
+ // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+ // since the DO fetch handler always initializes the DO's own client
+ if (url.pathname === '/cache/detached') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ if (url.pathname === '/cache/storage') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/cache/streaming') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request('http://do/streaming'));
+ }
+
+ // No-cache DO calls
+ if (url.pathname === '/no-cache/handler-error') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/no-cache/dedupe') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/no-cache/storage') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/no-cache/detached') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ return new Response('Hello World!');
+ },
+ } satisfies ExportedHandler<Env>,
+);

.size-limit.js

@@ -485,7 +485,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '522 KiB',
+ limit: '540 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/runner.ts

@@ -161,6 +161,7 @@ export function createRunner(...paths: string[]) {
 
  // controls whether envelopes are expected in predefined order or not
  let unordered = false;
+ let failOnUnexpected = false;
 
  if (!existsSync(testPath)) {
  throw new Error(`Test scenario not found: ${testPath}`);
@@ -195,6 +196,10 @@ export function createRunner(...paths: string[]) {
  unordered = true;
  return this;
  },
+ failOnUnexpected: function () {
+ failOnUnexpected = true;
+ return this;
+ },
  ignore: function (...types: EnvelopeItemType[]) {
  types.forEach(t => ignored.add(t));
  return this;
@@ -222,6 +227,7 @@ export function createRunner(...paths: string[]) {
  const expectedEnvelopeCount = expectedEnvelopes.length;
 
  let envelopeCount = 0;
+ let unexpectedEnvelopeError: Error | undefined;
  const envelopeWaiters: { expected: Expected; resolve: () => void; reject: (e: unknown) => void }[] = [];
  const {
  resolve: setWorkerPort,
@@ -297,6 +303,10 @@ export function createRunner(...paths: string[]) {
 
  // no match found
  if (matchIndex < 0) {
+ if (failOnUnexpected) {
+ unexpectedEnvelopeError ??= new Error('Received an unexpected envelope');
+ reject(unexpectedEnvelopeError);
+ }
  return;
  }
 
@@ -429,7 +439,10 @@ export function createRunner(...paths: string[]) {
 
  return {
  completed: async function (): Promise<void> {
- return isComplete;
+ await isComplete;
+ if (unexpectedEnvelopeError) {
+ throw unexpectedEnvelopeError;
+ }
  },
  makeRequest: async function <T>(
  method: 'get' | 'post',

dev-packages/cloudflare-integration-tests/suites/cache-client/index.ts

@@ -0,0 +1,256 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+ SENTRY_DSN: string;
+ CACHE_DO: DurableObjectNamespace;
+ NO_CACHE_DO: DurableObjectNamespace;
+}
+
+/**
+ * Sync KV and SQL work against the DO's own storage, which the SDK instruments into `db` spans.
+ * Used to check that those spans still reach the transport from inside a Durable Object, where a
+ * cached client never hits an invocation-boundary flush and has to rely on the eager drain.
+ */
+function runStorageOps(ctx: DurableObjectState): { listSize: number; rows: number } {
+ ctx.storage.kv.put('cache-key', { hello: 'sync' });
+ ctx.storage.kv.get('cache-key');
+ const entries = [...ctx.storage.kv.list()];
+ ctx.storage.kv.delete('cache-key');
+
+ ctx.storage.sql.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+ ctx.storage.sql.exec('INSERT INTO users (name) VALUES (?)', 'Alice');
+ const rows = ctx.storage.sql.exec('SELECT * FROM users').toArray();
+
+ return { listSize: entries.length, rows: rows.length };
+}
+
+function startDetachedWork(message: string): string {
+ void (async () => {
+ await new Promise(r => setTimeout(r, 3000));
+ await Sentry.startSpan({ name: 'do.detached-task', op: 'task' }, async () => {
+ Sentry.logger.info(`Detached log: ${message}`);
+ Sentry.metrics.count('do.detached', 1);
+ Sentry.captureException(new Error(message));
+ });
+ })();
+ return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true (the default) — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+ async echo(n: number): Promise<number> {
+ return n;
+ }
+
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`Cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async scopeCheck(seed: boolean): Promise<string> {
+ if (seed) {
+ Sentry.setTag('seeded_tag', 'from-seeding-call');
+ Sentry.setUser({ id: 'user-from-seeding-call' });
+ }
+ Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+ return 'ok';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+ }
+ if (url.pathname === '/streaming') {
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('chunk1'));
+ controller.enqueue(new TextEncoder().encode('chunk2'));
+ controller.close();
+ },
+ });
+ return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+ }
+ return new Response('Cache DO');
+ }
+}
+
+// DO with cacheClient: false — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`No-cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `no-cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+ }
+ return new Response('No-cache DO');
+ }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ cacheClient: false,
+ enableRpcTracePropagation: true,
+ }),
+ NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ {
+ async fetch(request, env, ctx) {
+ const url = new URL(request.url);
+ const instanceId = url.searchParams.get('id') || 'default';
+ const errorMessage = url.searchParams.get('errorMessage') || 'Same error';
+
+ // Work that finishes AFTER the response: a post-response span tree plus a
+ // log, metric and error, all registered via waitUntil. This is the worker-side
+ // half of the #22545 lifecycle (the DO-side half is /detached).
+ if (url.pathname === '/post-response') {
+ ctx.waitUntil(
+ Sentry.startSpan({ name: 'checkout.post-response', op: 'task' }, async () => {
+ Sentry.logger.info('checkout post-response log');
+ Sentry.metrics.count('checkout.processed', 1);
+ await new Promise(r => setTimeout(r, 50));
+ await Sentry.startSpan({ name: 'checkout.notify-webhook', op: 'http.client' }, async () => {
+ await new Promise(r => setTimeout(r, 25));
+ Sentry.captureException(new Error('Webhook delivery failed'));
+ });
+ }),
+ );
+ return new Response('checkout accepted');
+ }
+
+ // Fan a single request out into N sequential DO RPC calls — every RPC span must
+ // land in this request's trace when RPC trace propagation is on.
+ if (url.pathname === '/burst') {
+ const n = Math.min(Number(url.searchParams.get('n')) || 1, 20);
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`burst-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+
+ let sum = 0;
+ for (let i = 0; i < n; i++) {
+ sum += (await stub.echo(i)) as number;
+ }
+ return Response.json({ calls: n, sum });
+ }
+
+ // Cache DO RPC calls
+ if (url.pathname === '/cache/handler-error') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/cache/dedupe') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/cache/scope') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+ }
+
+ // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+ // since the DO fetch handler always initializes the DO's own client
+ if (url.pathname === '/cache/detached') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ if (url.pathname === '/cache/storage') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/cache/streaming') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request('http://do/streaming'));
+ }
+
+ // No-cache DO calls
+ if (url.pathname === '/no-cache/handler-error') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/no-cache/dedupe') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/no-cache/storage') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/no-cache/detached') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ return new Response('Hello World!');
+ },
+ } satisfies ExportedHandler<Env>,
+);

.size-limit.js

@@ -485,7 +485,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '522 KiB',
+ limit: '540 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/runner.ts

@@ -161,6 +161,7 @@ export function createRunner(...paths: string[]) {
 
  // controls whether envelopes are expected in predefined order or not
  let unordered = false;
+ let failOnUnexpected = false;
 
  if (!existsSync(testPath)) {
  throw new Error(`Test scenario not found: ${testPath}`);
@@ -195,6 +196,10 @@ export function createRunner(...paths: string[]) {
  unordered = true;
  return this;
  },
+ failOnUnexpected: function () {
+ failOnUnexpected = true;
+ return this;
+ },
  ignore: function (...types: EnvelopeItemType[]) {
  types.forEach(t => ignored.add(t));
  return this;
@@ -222,6 +227,7 @@ export function createRunner(...paths: string[]) {
  const expectedEnvelopeCount = expectedEnvelopes.length;
 
  let envelopeCount = 0;
+ let unexpectedEnvelopeError: Error | undefined;
  const envelopeWaiters: { expected: Expected; resolve: () => void; reject: (e: unknown) => void }[] = [];
  const {
  resolve: setWorkerPort,
@@ -297,6 +303,10 @@ export function createRunner(...paths: string[]) {
 
  // no match found
  if (matchIndex < 0) {
+ if (failOnUnexpected) {
+ unexpectedEnvelopeError ??= new Error('Received an unexpected envelope');
+ reject(unexpectedEnvelopeError);
+ }
  return;
  }
 
@@ -429,7 +439,10 @@ export function createRunner(...paths: string[]) {
 
  return {
  completed: async function (): Promise<void> {
- return isComplete;
+ await isComplete;
+ if (unexpectedEnvelopeError) {
+ throw unexpectedEnvelopeError;
+ }
  },
  makeRequest: async function <T>(
  method: 'get' | 'post',

dev-packages/cloudflare-integration-tests/suites/cache-client/index.ts

@@ -0,0 +1,256 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+ SENTRY_DSN: string;
+ CACHE_DO: DurableObjectNamespace;
+ NO_CACHE_DO: DurableObjectNamespace;
+}
+
+/**
+ * Sync KV and SQL work against the DO's own storage, which the SDK instruments into `db` spans.
+ * Used to check that those spans still reach the transport from inside a Durable Object, where a
+ * cached client never hits an invocation-boundary flush and has to rely on the eager drain.
+ */
+function runStorageOps(ctx: DurableObjectState): { listSize: number; rows: number } {
+ ctx.storage.kv.put('cache-key', { hello: 'sync' });
+ ctx.storage.kv.get('cache-key');
+ const entries = [...ctx.storage.kv.list()];
+ ctx.storage.kv.delete('cache-key');
+
+ ctx.storage.sql.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+ ctx.storage.sql.exec('INSERT INTO users (name) VALUES (?)', 'Alice');
+ const rows = ctx.storage.sql.exec('SELECT * FROM users').toArray();
+
+ return { listSize: entries.length, rows: rows.length };
+}
+
+function startDetachedWork(message: string): string {
+ void (async () => {
+ await new Promise(r => setTimeout(r, 3000));
+ await Sentry.startSpan({ name: 'do.detached-task', op: 'task' }, async () => {
+ Sentry.logger.info(`Detached log: ${message}`);
+ Sentry.metrics.count('do.detached', 1);
+ Sentry.captureException(new Error(message));
+ });
+ })();
+ return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true (the default) — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+ async echo(n: number): Promise<number> {
+ return n;
+ }
+
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`Cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async scopeCheck(seed: boolean): Promise<string> {
+ if (seed) {
+ Sentry.setTag('seeded_tag', 'from-seeding-call');
+ Sentry.setUser({ id: 'user-from-seeding-call' });
+ }
+ Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+ return 'ok';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+ }
+ if (url.pathname === '/streaming') {
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('chunk1'));
+ controller.enqueue(new TextEncoder().encode('chunk2'));
+ controller.close();
+ },
+ });
+ return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+ }
+ return new Response('Cache DO');
+ }
+}
+
+// DO with cacheClient: false — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`No-cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `no-cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+ }
+ return new Response('No-cache DO');
+ }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ cacheClient: false,
+ enableRpcTracePropagation: true,
+ }),
+ NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ {
+ async fetch(request, env, ctx) {
+ const url = new URL(request.url);
+ const instanceId = url.searchParams.get('id') || 'default';
+ const errorMessage = url.searchParams.get('errorMessage') || 'Same error';
+
+ // Work that finishes AFTER the response: a post-response span tree plus a
+ // log, metric and error, all registered via waitUntil. This is the worker-side
+ // half of the #22545 lifecycle (the DO-side half is /detached).
+ if (url.pathname === '/post-response') {
+ ctx.waitUntil(
+ Sentry.startSpan({ name: 'checkout.post-response', op: 'task' }, async () => {
+ Sentry.logger.info('checkout post-response log');
+ Sentry.metrics.count('checkout.processed', 1);
+ await new Promise(r => setTimeout(r, 50));
+ await Sentry.startSpan({ name: 'checkout.notify-webhook', op: 'http.client' }, async () => {
+ await new Promise(r => setTimeout(r, 25));
+ Sentry.captureException(new Error('Webhook delivery failed'));
+ });
+ }),
+ );
+ return new Response('checkout accepted');
+ }
+
+ // Fan a single request out into N sequential DO RPC calls — every RPC span must
+ // land in this request's trace when RPC trace propagation is on.
+ if (url.pathname === '/burst') {
+ const n = Math.min(Number(url.searchParams.get('n')) || 1, 20);
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`burst-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+
+ let sum = 0;
+ for (let i = 0; i < n; i++) {
+ sum += (await stub.echo(i)) as number;
+ }
+ return Response.json({ calls: n, sum });
+ }
+
+ // Cache DO RPC calls
+ if (url.pathname === '/cache/handler-error') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/cache/dedupe') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/cache/scope') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+ }
+
+ // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+ // since the DO fetch handler always initializes the DO's own client
+ if (url.pathname === '/cache/detached') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ if (url.pathname === '/cache/storage') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/cache/streaming') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request('http://do/streaming'));
+ }
+
+ // No-cache DO calls
+ if (url.pathname === '/no-cache/handler-error') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/no-cache/dedupe') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/no-cache/storage') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/no-cache/detached') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ return new Response('Hello World!');
+ },
+ } satisfies ExportedHandler<Env>,
+);

.size-limit.js

@@ -485,7 +485,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '522 KiB',
+ limit: '540 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/runner.ts

@@ -161,6 +161,7 @@ export function createRunner(...paths: string[]) {
 
  // controls whether envelopes are expected in predefined order or not
  let unordered = false;
+ let failOnUnexpected = false;
 
  if (!existsSync(testPath)) {
  throw new Error(`Test scenario not found: ${testPath}`);
@@ -195,6 +196,10 @@ export function createRunner(...paths: string[]) {
  unordered = true;
  return this;
  },
+ failOnUnexpected: function () {
+ failOnUnexpected = true;
+ return this;
+ },
  ignore: function (...types: EnvelopeItemType[]) {
  types.forEach(t => ignored.add(t));
  return this;
@@ -222,6 +227,7 @@ export function createRunner(...paths: string[]) {
  const expectedEnvelopeCount = expectedEnvelopes.length;
 
  let envelopeCount = 0;
+ let unexpectedEnvelopeError: Error | undefined;
  const envelopeWaiters: { expected: Expected; resolve: () => void; reject: (e: unknown) => void }[] = [];
  const {
  resolve: setWorkerPort,
@@ -297,6 +303,10 @@ export function createRunner(...paths: string[]) {
 
  // no match found
  if (matchIndex < 0) {
+ if (failOnUnexpected) {
+ unexpectedEnvelopeError ??= new Error('Received an unexpected envelope');
+ reject(unexpectedEnvelopeError);
+ }
  return;
  }
 
@@ -429,7 +439,10 @@ export function createRunner(...paths: string[]) {
 
  return {
  completed: async function (): Promise<void> {
- return isComplete;
+ await isComplete;
+ if (unexpectedEnvelopeError) {
+ throw unexpectedEnvelopeError;
+ }
  },
  makeRequest: async function <T>(
  method: 'get' | 'post',

dev-packages/cloudflare-integration-tests/suites/cache-client/index.ts

@@ -0,0 +1,256 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+ SENTRY_DSN: string;
+ CACHE_DO: DurableObjectNamespace;
+ NO_CACHE_DO: DurableObjectNamespace;
+}
+
+/**
+ * Sync KV and SQL work against the DO's own storage, which the SDK instruments into `db` spans.
+ * Used to check that those spans still reach the transport from inside a Durable Object, where a
+ * cached client never hits an invocation-boundary flush and has to rely on the eager drain.
+ */
+function runStorageOps(ctx: DurableObjectState): { listSize: number; rows: number } {
+ ctx.storage.kv.put('cache-key', { hello: 'sync' });
+ ctx.storage.kv.get('cache-key');
+ const entries = [...ctx.storage.kv.list()];
+ ctx.storage.kv.delete('cache-key');
+
+ ctx.storage.sql.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+ ctx.storage.sql.exec('INSERT INTO users (name) VALUES (?)', 'Alice');
+ const rows = ctx.storage.sql.exec('SELECT * FROM users').toArray();
+
+ return { listSize: entries.length, rows: rows.length };
+}
+
+function startDetachedWork(message: string): string {
+ void (async () => {
+ await new Promise(r => setTimeout(r, 3000));
+ await Sentry.startSpan({ name: 'do.detached-task', op: 'task' }, async () => {
+ Sentry.logger.info(`Detached log: ${message}`);
+ Sentry.metrics.count('do.detached', 1);
+ Sentry.captureException(new Error(message));
+ });
+ })();
+ return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true (the default) — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+ async echo(n: number): Promise<number> {
+ return n;
+ }
+
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`Cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async scopeCheck(seed: boolean): Promise<string> {
+ if (seed) {
+ Sentry.setTag('seeded_tag', 'from-seeding-call');
+ Sentry.setUser({ id: 'user-from-seeding-call' });
+ }
+ Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+ return 'ok';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+ }
+ if (url.pathname === '/streaming') {
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('chunk1'));
+ controller.enqueue(new TextEncoder().encode('chunk2'));
+ controller.close();
+ },
+ });
+ return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+ }
+ return new Response('Cache DO');
+ }
+}
+
+// DO with cacheClient: false — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`No-cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `no-cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+ }
+ return new Response('No-cache DO');
+ }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ cacheClient: false,
+ enableRpcTracePropagation: true,
+ }),
+ NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ {
+ async fetch(request, env, ctx) {
+ const url = new URL(request.url);
+ const instanceId = url.searchParams.get('id') || 'default';
+ const errorMessage = url.searchParams.get('errorMessage') || 'Same error';
+
+ // Work that finishes AFTER the response: a post-response span tree plus a
+ // log, metric and error, all registered via waitUntil. This is the worker-side
+ // half of the #22545 lifecycle (the DO-side half is /detached).
+ if (url.pathname === '/post-response') {
+ ctx.waitUntil(
+ Sentry.startSpan({ name: 'checkout.post-response', op: 'task' }, async () => {
+ Sentry.logger.info('checkout post-response log');
+ Sentry.metrics.count('checkout.processed', 1);
+ await new Promise(r => setTimeout(r, 50));
+ await Sentry.startSpan({ name: 'checkout.notify-webhook', op: 'http.client' }, async () => {
+ await new Promise(r => setTimeout(r, 25));
+ Sentry.captureException(new Error('Webhook delivery failed'));
+ });
+ }),
+ );
+ return new Response('checkout accepted');
+ }
+
+ // Fan a single request out into N sequential DO RPC calls — every RPC span must
+ // land in this request's trace when RPC trace propagation is on.
+ if (url.pathname === '/burst') {
+ const n = Math.min(Number(url.searchParams.get('n')) || 1, 20);
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`burst-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+
+ let sum = 0;
+ for (let i = 0; i < n; i++) {
+ sum += (await stub.echo(i)) as number;
+ }
+ return Response.json({ calls: n, sum });
+ }
+
+ // Cache DO RPC calls
+ if (url.pathname === '/cache/handler-error') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/cache/dedupe') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/cache/scope') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+ }
+
+ // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+ // since the DO fetch handler always initializes the DO's own client
+ if (url.pathname === '/cache/detached') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ if (url.pathname === '/cache/storage') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/cache/streaming') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request('http://do/streaming'));
+ }
+
+ // No-cache DO calls
+ if (url.pathname === '/no-cache/handler-error') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/no-cache/dedupe') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/no-cache/storage') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/no-cache/detached') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ return new Response('Hello World!');
+ },
+ } satisfies ExportedHandler<Env>,
+);

.size-limit.js

@@ -485,7 +485,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '522 KiB',
+ limit: '540 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/runner.ts

@@ -161,6 +161,7 @@ export function createRunner(...paths: string[]) {
 
  // controls whether envelopes are expected in predefined order or not
  let unordered = false;
+ let failOnUnexpected = false;
 
  if (!existsSync(testPath)) {
  throw new Error(`Test scenario not found: ${testPath}`);
@@ -195,6 +196,10 @@ export function createRunner(...paths: string[]) {
  unordered = true;
  return this;
  },
+ failOnUnexpected: function () {
+ failOnUnexpected = true;
+ return this;
+ },
  ignore: function (...types: EnvelopeItemType[]) {
  types.forEach(t => ignored.add(t));
  return this;
@@ -222,6 +227,7 @@ export function createRunner(...paths: string[]) {
  const expectedEnvelopeCount = expectedEnvelopes.length;
 
  let envelopeCount = 0;
+ let unexpectedEnvelopeError: Error | undefined;
  const envelopeWaiters: { expected: Expected; resolve: () => void; reject: (e: unknown) => void }[] = [];
  const {
  resolve: setWorkerPort,
@@ -297,6 +303,10 @@ export function createRunner(...paths: string[]) {
 
  // no match found
  if (matchIndex < 0) {
+ if (failOnUnexpected) {
+ unexpectedEnvelopeError ??= new Error('Received an unexpected envelope');
+ reject(unexpectedEnvelopeError);
+ }
  return;
  }
 
@@ -429,7 +439,10 @@ export function createRunner(...paths: string[]) {
 
  return {
  completed: async function (): Promise<void> {
- return isComplete;
+ await isComplete;
+ if (unexpectedEnvelopeError) {
+ throw unexpectedEnvelopeError;
+ }
  },
  makeRequest: async function <T>(
  method: 'get' | 'post',

dev-packages/cloudflare-integration-tests/suites/cache-client/index.ts

@@ -0,0 +1,256 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+ SENTRY_DSN: string;
+ CACHE_DO: DurableObjectNamespace;
+ NO_CACHE_DO: DurableObjectNamespace;
+}
+
+/**
+ * Sync KV and SQL work against the DO's own storage, which the SDK instruments into `db` spans.
+ * Used to check that those spans still reach the transport from inside a Durable Object, where a
+ * cached client never hits an invocation-boundary flush and has to rely on the eager drain.
+ */
+function runStorageOps(ctx: DurableObjectState): { listSize: number; rows: number } {
+ ctx.storage.kv.put('cache-key', { hello: 'sync' });
+ ctx.storage.kv.get('cache-key');
+ const entries = [...ctx.storage.kv.list()];
+ ctx.storage.kv.delete('cache-key');
+
+ ctx.storage.sql.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+ ctx.storage.sql.exec('INSERT INTO users (name) VALUES (?)', 'Alice');
+ const rows = ctx.storage.sql.exec('SELECT * FROM users').toArray();
+
+ return { listSize: entries.length, rows: rows.length };
+}
+
+function startDetachedWork(message: string): string {
+ void (async () => {
+ await new Promise(r => setTimeout(r, 3000));
+ await Sentry.startSpan({ name: 'do.detached-task', op: 'task' }, async () => {
+ Sentry.logger.info(`Detached log: ${message}`);
+ Sentry.metrics.count('do.detached', 1);
+ Sentry.captureException(new Error(message));
+ });
+ })();
+ return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true (the default) — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+ async echo(n: number): Promise<number> {
+ return n;
+ }
+
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`Cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async scopeCheck(seed: boolean): Promise<string> {
+ if (seed) {
+ Sentry.setTag('seeded_tag', 'from-seeding-call');
+ Sentry.setUser({ id: 'user-from-seeding-call' });
+ }
+ Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+ return 'ok';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+ }
+ if (url.pathname === '/streaming') {
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('chunk1'));
+ controller.enqueue(new TextEncoder().encode('chunk2'));
+ controller.close();
+ },
+ });
+ return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+ }
+ return new Response('Cache DO');
+ }
+}
+
+// DO with cacheClient: false — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`No-cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `no-cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+ }
+ return new Response('No-cache DO');
+ }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ cacheClient: false,
+ enableRpcTracePropagation: true,
+ }),
+ NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ {
+ async fetch(request, env, ctx) {
+ const url = new URL(request.url);
+ const instanceId = url.searchParams.get('id') || 'default';
+ const errorMessage = url.searchParams.get('errorMessage') || 'Same error';
+
+ // Work that finishes AFTER the response: a post-response span tree plus a
+ // log, metric and error, all registered via waitUntil. This is the worker-side
+ // half of the #22545 lifecycle (the DO-side half is /detached).
+ if (url.pathname === '/post-response') {
+ ctx.waitUntil(
+ Sentry.startSpan({ name: 'checkout.post-response', op: 'task' }, async () => {
+ Sentry.logger.info('checkout post-response log');
+ Sentry.metrics.count('checkout.processed', 1);
+ await new Promise(r => setTimeout(r, 50));
+ await Sentry.startSpan({ name: 'checkout.notify-webhook', op: 'http.client' }, async () => {
+ await new Promise(r => setTimeout(r, 25));
+ Sentry.captureException(new Error('Webhook delivery failed'));
+ });
+ }),
+ );
+ return new Response('checkout accepted');
+ }
+
+ // Fan a single request out into N sequential DO RPC calls — every RPC span must
+ // land in this request's trace when RPC trace propagation is on.
+ if (url.pathname === '/burst') {
+ const n = Math.min(Number(url.searchParams.get('n')) || 1, 20);
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`burst-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+
+ let sum = 0;
+ for (let i = 0; i < n; i++) {
+ sum += (await stub.echo(i)) as number;
+ }
+ return Response.json({ calls: n, sum });
+ }
+
+ // Cache DO RPC calls
+ if (url.pathname === '/cache/handler-error') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/cache/dedupe') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/cache/scope') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+ }
+
+ // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+ // since the DO fetch handler always initializes the DO's own client
+ if (url.pathname === '/cache/detached') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ if (url.pathname === '/cache/storage') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/cache/streaming') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request('http://do/streaming'));
+ }
+
+ // No-cache DO calls
+ if (url.pathname === '/no-cache/handler-error') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/no-cache/dedupe') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/no-cache/storage') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/no-cache/detached') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ return new Response('Hello World!');
+ },
+ } satisfies ExportedHandler<Env>,
+);

.size-limit.js

@@ -485,7 +485,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '522 KiB',
+ limit: '540 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/runner.ts

@@ -161,6 +161,7 @@ export function createRunner(...paths: string[]) {
 
  // controls whether envelopes are expected in predefined order or not
  let unordered = false;
+ let failOnUnexpected = false;
 
  if (!existsSync(testPath)) {
  throw new Error(`Test scenario not found: ${testPath}`);
@@ -195,6 +196,10 @@ export function createRunner(...paths: string[]) {
  unordered = true;
  return this;
  },
+ failOnUnexpected: function () {
+ failOnUnexpected = true;
+ return this;
+ },
  ignore: function (...types: EnvelopeItemType[]) {
  types.forEach(t => ignored.add(t));
  return this;
@@ -222,6 +227,7 @@ export function createRunner(...paths: string[]) {
  const expectedEnvelopeCount = expectedEnvelopes.length;
 
  let envelopeCount = 0;
+ let unexpectedEnvelopeError: Error | undefined;
  const envelopeWaiters: { expected: Expected; resolve: () => void; reject: (e: unknown) => void }[] = [];
  const {
  resolve: setWorkerPort,
@@ -297,6 +303,10 @@ export function createRunner(...paths: string[]) {
 
  // no match found
  if (matchIndex < 0) {
+ if (failOnUnexpected) {
+ unexpectedEnvelopeError ??= new Error('Received an unexpected envelope');
+ reject(unexpectedEnvelopeError);
+ }
  return;
  }
 
@@ -429,7 +439,10 @@ export function createRunner(...paths: string[]) {
 
  return {
  completed: async function (): Promise<void> {
- return isComplete;
+ await isComplete;
+ if (unexpectedEnvelopeError) {
+ throw unexpectedEnvelopeError;
+ }
  },
  makeRequest: async function <T>(
  method: 'get' | 'post',

dev-packages/cloudflare-integration-tests/suites/cache-client/index.ts

@@ -0,0 +1,256 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+ SENTRY_DSN: string;
+ CACHE_DO: DurableObjectNamespace;
+ NO_CACHE_DO: DurableObjectNamespace;
+}
+
+/**
+ * Sync KV and SQL work against the DO's own storage, which the SDK instruments into `db` spans.
+ * Used to check that those spans still reach the transport from inside a Durable Object, where a
+ * cached client never hits an invocation-boundary flush and has to rely on the eager drain.
+ */
+function runStorageOps(ctx: DurableObjectState): { listSize: number; rows: number } {
+ ctx.storage.kv.put('cache-key', { hello: 'sync' });
+ ctx.storage.kv.get('cache-key');
+ const entries = [...ctx.storage.kv.list()];
+ ctx.storage.kv.delete('cache-key');
+
+ ctx.storage.sql.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+ ctx.storage.sql.exec('INSERT INTO users (name) VALUES (?)', 'Alice');
+ const rows = ctx.storage.sql.exec('SELECT * FROM users').toArray();
+
+ return { listSize: entries.length, rows: rows.length };
+}
+
+function startDetachedWork(message: string): string {
+ void (async () => {
+ await new Promise(r => setTimeout(r, 3000));
+ await Sentry.startSpan({ name: 'do.detached-task', op: 'task' }, async () => {
+ Sentry.logger.info(`Detached log: ${message}`);
+ Sentry.metrics.count('do.detached', 1);
+ Sentry.captureException(new Error(message));
+ });
+ })();
+ return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true (the default) — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+ async echo(n: number): Promise<number> {
+ return n;
+ }
+
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`Cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async scopeCheck(seed: boolean): Promise<string> {
+ if (seed) {
+ Sentry.setTag('seeded_tag', 'from-seeding-call');
+ Sentry.setUser({ id: 'user-from-seeding-call' });
+ }
+ Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+ return 'ok';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+ }
+ if (url.pathname === '/streaming') {
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('chunk1'));
+ controller.enqueue(new TextEncoder().encode('chunk2'));
+ controller.close();
+ },
+ });
+ return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+ }
+ return new Response('Cache DO');
+ }
+}
+
+// DO with cacheClient: false — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`No-cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `no-cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+ }
+ return new Response('No-cache DO');
+ }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ cacheClient: false,
+ enableRpcTracePropagation: true,
+ }),
+ NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ {
+ async fetch(request, env, ctx) {
+ const url = new URL(request.url);
+ const instanceId = url.searchParams.get('id') || 'default';
+ const errorMessage = url.searchParams.get('errorMessage') || 'Same error';
+
+ // Work that finishes AFTER the response: a post-response span tree plus a
+ // log, metric and error, all registered via waitUntil. This is the worker-side
+ // half of the #22545 lifecycle (the DO-side half is /detached).
+ if (url.pathname === '/post-response') {
+ ctx.waitUntil(
+ Sentry.startSpan({ name: 'checkout.post-response', op: 'task' }, async () => {
+ Sentry.logger.info('checkout post-response log');
+ Sentry.metrics.count('checkout.processed', 1);
+ await new Promise(r => setTimeout(r, 50));
+ await Sentry.startSpan({ name: 'checkout.notify-webhook', op: 'http.client' }, async () => {
+ await new Promise(r => setTimeout(r, 25));
+ Sentry.captureException(new Error('Webhook delivery failed'));
+ });
+ }),
+ );
+ return new Response('checkout accepted');
+ }
+
+ // Fan a single request out into N sequential DO RPC calls — every RPC span must
+ // land in this request's trace when RPC trace propagation is on.
+ if (url.pathname === '/burst') {
+ const n = Math.min(Number(url.searchParams.get('n')) || 1, 20);
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`burst-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+
+ let sum = 0;
+ for (let i = 0; i < n; i++) {
+ sum += (await stub.echo(i)) as number;
+ }
+ return Response.json({ calls: n, sum });
+ }
+
+ // Cache DO RPC calls
+ if (url.pathname === '/cache/handler-error') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/cache/dedupe') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/cache/scope') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+ }
+
+ // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+ // since the DO fetch handler always initializes the DO's own client
+ if (url.pathname === '/cache/detached') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ if (url.pathname === '/cache/storage') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/cache/streaming') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request('http://do/streaming'));
+ }
+
+ // No-cache DO calls
+ if (url.pathname === '/no-cache/handler-error') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/no-cache/dedupe') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/no-cache/storage') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/no-cache/detached') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ return new Response('Hello World!');
+ },
+ } satisfies ExportedHandler<Env>,
+);

.size-limit.js

@@ -485,7 +485,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '522 KiB',
+ limit: '540 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/runner.ts

@@ -161,6 +161,7 @@ export function createRunner(...paths: string[]) {
 
  // controls whether envelopes are expected in predefined order or not
  let unordered = false;
+ let failOnUnexpected = false;
 
  if (!existsSync(testPath)) {
  throw new Error(`Test scenario not found: ${testPath}`);
@@ -195,6 +196,10 @@ export function createRunner(...paths: string[]) {
  unordered = true;
  return this;
  },
+ failOnUnexpected: function () {
+ failOnUnexpected = true;
+ return this;
+ },
  ignore: function (...types: EnvelopeItemType[]) {
  types.forEach(t => ignored.add(t));
  return this;
@@ -222,6 +227,7 @@ export function createRunner(...paths: string[]) {
  const expectedEnvelopeCount = expectedEnvelopes.length;
 
  let envelopeCount = 0;
+ let unexpectedEnvelopeError: Error | undefined;
  const envelopeWaiters: { expected: Expected; resolve: () => void; reject: (e: unknown) => void }[] = [];
  const {
  resolve: setWorkerPort,
@@ -297,6 +303,10 @@ export function createRunner(...paths: string[]) {
 
  // no match found
  if (matchIndex < 0) {
+ if (failOnUnexpected) {
+ unexpectedEnvelopeError ??= new Error('Received an unexpected envelope');
+ reject(unexpectedEnvelopeError);
+ }
  return;
  }
 
@@ -429,7 +439,10 @@ export function createRunner(...paths: string[]) {
 
  return {
  completed: async function (): Promise<void> {
- return isComplete;
+ await isComplete;
+ if (unexpectedEnvelopeError) {
+ throw unexpectedEnvelopeError;
+ }
  },
  makeRequest: async function <T>(
  method: 'get' | 'post',

dev-packages/cloudflare-integration-tests/suites/cache-client/index.ts

@@ -0,0 +1,256 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+ SENTRY_DSN: string;
+ CACHE_DO: DurableObjectNamespace;
+ NO_CACHE_DO: DurableObjectNamespace;
+}
+
+/**
+ * Sync KV and SQL work against the DO's own storage, which the SDK instruments into `db` spans.
+ * Used to check that those spans still reach the transport from inside a Durable Object, where a
+ * cached client never hits an invocation-boundary flush and has to rely on the eager drain.
+ */
+function runStorageOps(ctx: DurableObjectState): { listSize: number; rows: number } {
+ ctx.storage.kv.put('cache-key', { hello: 'sync' });
+ ctx.storage.kv.get('cache-key');
+ const entries = [...ctx.storage.kv.list()];
+ ctx.storage.kv.delete('cache-key');
+
+ ctx.storage.sql.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+ ctx.storage.sql.exec('INSERT INTO users (name) VALUES (?)', 'Alice');
+ const rows = ctx.storage.sql.exec('SELECT * FROM users').toArray();
+
+ return { listSize: entries.length, rows: rows.length };
+}
+
+function startDetachedWork(message: string): string {
+ void (async () => {
+ await new Promise(r => setTimeout(r, 3000));
+ await Sentry.startSpan({ name: 'do.detached-task', op: 'task' }, async () => {
+ Sentry.logger.info(`Detached log: ${message}`);
+ Sentry.metrics.count('do.detached', 1);
+ Sentry.captureException(new Error(message));
+ });
+ })();
+ return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true (the default) — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+ async echo(n: number): Promise<number> {
+ return n;
+ }
+
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`Cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async scopeCheck(seed: boolean): Promise<string> {
+ if (seed) {
+ Sentry.setTag('seeded_tag', 'from-seeding-call');
+ Sentry.setUser({ id: 'user-from-seeding-call' });
+ }
+ Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+ return 'ok';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+ }
+ if (url.pathname === '/streaming') {
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('chunk1'));
+ controller.enqueue(new TextEncoder().encode('chunk2'));
+ controller.close();
+ },
+ });
+ return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+ }
+ return new Response('Cache DO');
+ }
+}
+
+// DO with cacheClient: false — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`No-cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `no-cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+ }
+ return new Response('No-cache DO');
+ }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ cacheClient: false,
+ enableRpcTracePropagation: true,
+ }),
+ NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ {
+ async fetch(request, env, ctx) {
+ const url = new URL(request.url);
+ const instanceId = url.searchParams.get('id') || 'default';
+ const errorMessage = url.searchParams.get('errorMessage') || 'Same error';
+
+ // Work that finishes AFTER the response: a post-response span tree plus a
+ // log, metric and error, all registered via waitUntil. This is the worker-side
+ // half of the #22545 lifecycle (the DO-side half is /detached).
+ if (url.pathname === '/post-response') {
+ ctx.waitUntil(
+ Sentry.startSpan({ name: 'checkout.post-response', op: 'task' }, async () => {
+ Sentry.logger.info('checkout post-response log');
+ Sentry.metrics.count('checkout.processed', 1);
+ await new Promise(r => setTimeout(r, 50));
+ await Sentry.startSpan({ name: 'checkout.notify-webhook', op: 'http.client' }, async () => {
+ await new Promise(r => setTimeout(r, 25));
+ Sentry.captureException(new Error('Webhook delivery failed'));
+ });
+ }),
+ );
+ return new Response('checkout accepted');
+ }
+
+ // Fan a single request out into N sequential DO RPC calls — every RPC span must
+ // land in this request's trace when RPC trace propagation is on.
+ if (url.pathname === '/burst') {
+ const n = Math.min(Number(url.searchParams.get('n')) || 1, 20);
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`burst-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+
+ let sum = 0;
+ for (let i = 0; i < n; i++) {
+ sum += (await stub.echo(i)) as number;
+ }
+ return Response.json({ calls: n, sum });
+ }
+
+ // Cache DO RPC calls
+ if (url.pathname === '/cache/handler-error') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/cache/dedupe') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/cache/scope') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+ }
+
+ // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+ // since the DO fetch handler always initializes the DO's own client
+ if (url.pathname === '/cache/detached') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ if (url.pathname === '/cache/storage') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/cache/streaming') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request('http://do/streaming'));
+ }
+
+ // No-cache DO calls
+ if (url.pathname === '/no-cache/handler-error') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/no-cache/dedupe') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/no-cache/storage') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/no-cache/detached') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ return new Response('Hello World!');
+ },
+ } satisfies ExportedHandler<Env>,
+);

.size-limit.js

@@ -485,7 +485,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '522 KiB',
+ limit: '540 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/runner.ts

@@ -161,6 +161,7 @@ export function createRunner(...paths: string[]) {
 
  // controls whether envelopes are expected in predefined order or not
  let unordered = false;
+ let failOnUnexpected = false;
 
  if (!existsSync(testPath)) {
  throw new Error(`Test scenario not found: ${testPath}`);
@@ -195,6 +196,10 @@ export function createRunner(...paths: string[]) {
  unordered = true;
  return this;
  },
+ failOnUnexpected: function () {
+ failOnUnexpected = true;
+ return this;
+ },
  ignore: function (...types: EnvelopeItemType[]) {
  types.forEach(t => ignored.add(t));
  return this;
@@ -222,6 +227,7 @@ export function createRunner(...paths: string[]) {
  const expectedEnvelopeCount = expectedEnvelopes.length;
 
  let envelopeCount = 0;
+ let unexpectedEnvelopeError: Error | undefined;
  const envelopeWaiters: { expected: Expected; resolve: () => void; reject: (e: unknown) => void }[] = [];
  const {
  resolve: setWorkerPort,
@@ -297,6 +303,10 @@ export function createRunner(...paths: string[]) {
 
  // no match found
  if (matchIndex < 0) {
+ if (failOnUnexpected) {
+ unexpectedEnvelopeError ??= new Error('Received an unexpected envelope');
+ reject(unexpectedEnvelopeError);
+ }
  return;
  }
 
@@ -429,7 +439,10 @@ export function createRunner(...paths: string[]) {
 
  return {
  completed: async function (): Promise<void> {
- return isComplete;
+ await isComplete;
+ if (unexpectedEnvelopeError) {
+ throw unexpectedEnvelopeError;
+ }
  },
  makeRequest: async function <T>(
  method: 'get' | 'post',

dev-packages/cloudflare-integration-tests/suites/cache-client/index.ts

@@ -0,0 +1,256 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+ SENTRY_DSN: string;
+ CACHE_DO: DurableObjectNamespace;
+ NO_CACHE_DO: DurableObjectNamespace;
+}
+
+/**
+ * Sync KV and SQL work against the DO's own storage, which the SDK instruments into `db` spans.
+ * Used to check that those spans still reach the transport from inside a Durable Object, where a
+ * cached client never hits an invocation-boundary flush and has to rely on the eager drain.
+ */
+function runStorageOps(ctx: DurableObjectState): { listSize: number; rows: number } {
+ ctx.storage.kv.put('cache-key', { hello: 'sync' });
+ ctx.storage.kv.get('cache-key');
+ const entries = [...ctx.storage.kv.list()];
+ ctx.storage.kv.delete('cache-key');
+
+ ctx.storage.sql.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+ ctx.storage.sql.exec('INSERT INTO users (name) VALUES (?)', 'Alice');
+ const rows = ctx.storage.sql.exec('SELECT * FROM users').toArray();
+
+ return { listSize: entries.length, rows: rows.length };
+}
+
+function startDetachedWork(message: string): string {
+ void (async () => {
+ await new Promise(r => setTimeout(r, 3000));
+ await Sentry.startSpan({ name: 'do.detached-task', op: 'task' }, async () => {
+ Sentry.logger.info(`Detached log: ${message}`);
+ Sentry.metrics.count('do.detached', 1);
+ Sentry.captureException(new Error(message));
+ });
+ })();
+ return `Detached work started: ${message}`;
+}
+
+// DO with cacheClient: true (the default) — detached work events SHOULD be captured
+class CacheDurableObjectBase extends DurableObject<Env> {
+ async echo(n: number): Promise<number> {
+ return n;
+ }
+
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`Cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async scopeCheck(seed: boolean): Promise<string> {
+ if (seed) {
+ Sentry.setTag('seeded_tag', 'from-seeding-call');
+ Sentry.setUser({ id: 'user-from-seeding-call' });
+ }
+ Sentry.captureException(new Error(seed ? 'Cache scope seed' : 'Cache scope probe'));
+ return 'ok';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from cache DO ${url.searchParams.get('id')}`));
+ }
+ if (url.pathname === '/streaming') {
+ const stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('chunk1'));
+ controller.enqueue(new TextEncoder().encode('chunk2'));
+ controller.close();
+ },
+ });
+ return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+ }
+ return new Response('Cache DO');
+ }
+}
+
+// DO with cacheClient: false — detached work events should NOT be captured
+class NoCacheDurableObjectBase extends DurableObject<Env> {
+ async handlerError(instanceId: string): Promise<void> {
+ throw new Error(`No-cache DO handler error from ${instanceId}`);
+ }
+
+ async dedupe(errorMessage: string): Promise<string> {
+ Sentry.captureException(new Error(errorMessage));
+ return 'dedupe test';
+ }
+
+ async storage(): Promise<string> {
+ const { listSize, rows } = runStorageOps(this.ctx);
+ return `no-cache storage ${listSize}/${rows}`;
+ }
+
+ async fetch(request: Request): Promise<Response> {
+ const url = new URL(request.url);
+ if (url.pathname === '/detached') {
+ return new Response(startDetachedWork(`Detached work from no-cache DO ${url.searchParams.get('id')}`));
+ }
+ return new Response('No-cache DO');
+ }
+}
+
+export const CacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ CacheDurableObjectBase,
+);
+
+export const NoCacheDurableObject = Sentry.instrumentDurableObjectWithSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ cacheClient: false,
+ enableRpcTracePropagation: true,
+ }),
+ NoCacheDurableObjectBase,
+);
+
+export default Sentry.withSentry(
+ (env: Env) => ({
+ dsn: env.SENTRY_DSN,
+ tracesSampleRate: 1,
+ enableRpcTracePropagation: true,
+ }),
+ {
+ async fetch(request, env, ctx) {
+ const url = new URL(request.url);
+ const instanceId = url.searchParams.get('id') || 'default';
+ const errorMessage = url.searchParams.get('errorMessage') || 'Same error';
+
+ // Work that finishes AFTER the response: a post-response span tree plus a
+ // log, metric and error, all registered via waitUntil. This is the worker-side
+ // half of the #22545 lifecycle (the DO-side half is /detached).
+ if (url.pathname === '/post-response') {
+ ctx.waitUntil(
+ Sentry.startSpan({ name: 'checkout.post-response', op: 'task' }, async () => {
+ Sentry.logger.info('checkout post-response log');
+ Sentry.metrics.count('checkout.processed', 1);
+ await new Promise(r => setTimeout(r, 50));
+ await Sentry.startSpan({ name: 'checkout.notify-webhook', op: 'http.client' }, async () => {
+ await new Promise(r => setTimeout(r, 25));
+ Sentry.captureException(new Error('Webhook delivery failed'));
+ });
+ }),
+ );
+ return new Response('checkout accepted');
+ }
+
+ // Fan a single request out into N sequential DO RPC calls — every RPC span must
+ // land in this request's trace when RPC trace propagation is on.
+ if (url.pathname === '/burst') {
+ const n = Math.min(Number(url.searchParams.get('n')) || 1, 20);
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`burst-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+
+ let sum = 0;
+ for (let i = 0; i < n; i++) {
+ sum += (await stub.echo(i)) as number;
+ }
+ return Response.json({ calls: n, sum });
+ }
+
+ // Cache DO RPC calls
+ if (url.pathname === '/cache/handler-error') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/cache/dedupe') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/cache/scope') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.scopeCheck(url.searchParams.get('seed') === '1'));
+ }
+
+ // Cache DO fetch calls — detached work goes through fetch (matching the #22545 repro),
+ // since the DO fetch handler always initializes the DO's own client
+ if (url.pathname === '/cache/detached') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ if (url.pathname === '/cache/storage') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/cache/streaming') {
+ const stub = env.CACHE_DO.get(
+ env.CACHE_DO.idFromName(`cache-do-${instanceId}`),
+ ) as DurableObjectStub<CacheDurableObjectBase>;
+ return stub.fetch(new Request('http://do/streaming'));
+ }
+
+ // No-cache DO calls
+ if (url.pathname === '/no-cache/handler-error') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ await stub.handlerError(instanceId);
+ }
+
+ if (url.pathname === '/no-cache/dedupe') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ const result = await stub.dedupe(errorMessage);
+ return new Response(String(result));
+ }
+
+ if (url.pathname === '/no-cache/storage') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return new Response(await stub.storage());
+ }
+
+ if (url.pathname === '/no-cache/detached') {
+ const stub = env.NO_CACHE_DO.get(
+ env.NO_CACHE_DO.idFromName(`no-cache-do-${instanceId}`),
+ ) as DurableObjectStub<NoCacheDurableObjectBase>;
+ return stub.fetch(new Request(`http://do/detached?id=${instanceId}`));
+ }
+
+ return new Response('Hello World!');
+ },
+ } satisfies ExportedHandler<Env>,
+);