fix(cloudflare): Don't hold Durable Object invocations open with the segment-end flush timer (#25490)

Since span streaming became the default (#22642) and segment-end
flushing turned on for server runtimes (#23714), every root span end
schedules `setTimeout(flush, 500)`, sampled or not. #23714 relies on
`safeUnref` to stop that timer holding a server open, but workerd timers
have no `unref()`. A Durable Object invocation stays open until its
pending timers fire, so every instrumented DO `fetch`, alarm,
`webSocketMessage` and propagated RPC call runs about 500 ms longer.
That time is billed as duration, and the pending timer also blocks
hibernation. This happens at `tracesSampleRate: 0` too.

The 500 ms delay comes from the browser (#19643): `http.client` spans
stay open up to 300 ms waiting for resource timing, so they can end
after their segment. Neither that nor the buffer-memory reason for
flushing at segment end on servers (#23714) applies to Workers, where
nothing waits for resource timing and spans are flushed at the end of
every invocation.

The Cloudflare client now registers `spanStreamingIntegration({
flushOnSegmentEnd: false })` unless the user supplies their own. The
runtime doesn't need the timer: the boundary flush in
`wrapMethodWithSentry` runs after the method span ends, and the cached
client's eager drain covers spans that end after the flush point. This
matches the existing `_flushInterval: 0` for the log and metric buffers.
Plain Worker handlers lose the timer too: it doesn't hold their requests
open, so it cost them nothing, but `withSentry`'s boundary flush already
delivers their spans. In workerd, with the same change applied to
11.6.0, DO `fetch` and alarm wall time drops from about 505 ms to about
6 ms, and at `tracesSampleRate: 1.0` the same span envelopes still
arrive.

Fixes #25489

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: philipatkinson

packages/cloudflare/src/client.ts

@@ -6,6 +6,7 @@ import {
   applySdkMetadata,
   debug,
   spanIsSampled,
+  spanStreamingIntegration,
 } from '@sentry/core';
 import type { ServerRuntimeClientOptions } from '@sentry/core/server';
 import { ServerRuntimeClient } from '@sentry/core/server';
@@ -15,6 +16,10 @@ import type { makeFlushLock } from './flush';
 import type { CloudflareTransportOptions } from './transport';
 import { getInvocationState, getInvocationWaitUntil } from './utils/invocationContext';
 
+declare const __SENTRY_TRACING__: boolean;
+
+const SPAN_STREAMING_INTEGRATION_NAME = 'SpanStreaming';
+
 /**
  * The Sentry Cloudflare SDK Client.
  *
@@ -59,6 +64,17 @@ export class CloudflareClient extends ServerRuntimeClient {
       _flushInterval: 0,
     };
 
+    // workerd can't unref timers, so the default 500ms segment-end flush timer holds every
+    // Durable Object invocation open (and billed) until it fires, sampled or not. The boundary
+    // flush and the eager drain already deliver streamed spans here.
+    if (
+      (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) &&
+      clientOptions.traceLifecycle !== 'static' &&
+      !clientOptions.integrations.some(i => i.name === SPAN_STREAMING_INTEGRATION_NAME)
+    ) {
+      clientOptions.integrations.push(spanStreamingIntegration({ flushOnSegmentEnd: false }));
+    }
+
     super(clientOptions);
     this._flushLock = flushLock;
     this.isCachedClient = options.cacheClient === true;

packages/cloudflare/test/sdk.test.ts

@@ -1,6 +1,6 @@
 import * as SentryCore from '@sentry/core';
 import type { Envelope, Integration } from '@sentry/core';
-import { getClient } from '@sentry/core';
+import { getClient, startSpan } from '@sentry/core';
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
 import type { CloudflareOptions } from '../src/client';
 import { CloudflareClient } from '../src/client';
@@ -69,6 +69,32 @@ describe('init', () => {
     );
   });
 
+  test('does not leave a timer pending when a segment span ends', () => {
+    vi.useFakeTimers();
+    try {
+      init({ dsn: 'https://public@dsn.ingest.sentry.io/1337', tracesSampleRate: 0 });
+
+      startSpan({ name: 'alarm' }, () => undefined);
+
+      // A pending timer keeps a Durable Object invocation open until it fires.
+      expect(vi.getTimerCount()).toBe(0);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  test("doesn't add spanStreamingIntegration when tracing is excluded from the bundle", () => {
+    vi.stubGlobal('__SENTRY_TRACING__', false);
+    try {
+      const client = init({ dsn: 'https://public@dsn.ingest.sentry.io/1337' });
+      const integrations = client?.getOptions().integrations.filter(i => i.name === 'SpanStreaming');
+
+      expect(integrations).toEqual([]);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
   type MarkedIntegration = Integration & { _custom?: boolean };
 
   test("doesn't add spanStreamingIntegration if user added it manually", () => {