fix(deno): Don't throw in Deno.serve wrapper when no client is bound (#24030)

Replaces the throw with a debug.warn plus pass-through to the user's
handler. Cloudflare's wrapper never blocks the request when the client
is missing, this brings Deno in line.

One correction to the issue's mechanism from testing it: Sentry.close()
doesn't actually leave getClient() undefined, it flushes and disables
but the client stays bound, and a failed second init leaves the first
client bound too, so neither path hit this throw. What does reproduce it
is a directly constructed client, new DenoClient plus client.init()
installs the Deno.serve patch without ever calling setCurrentClient, so
the patch is live with no client bound and every request 500s. Either
way the wrapper shouldn't be the thing that kills the request.

Trade-off stated plainly: this turns a loud failure into a silent one,
the warn only shows with debug enabled, and Cloudflare's equivalent
doesn't warn at all there.

Two tests, own file since they wipe the carrier: a plain request comes
back 200, and a throwing handler still yields a 500 rather than a crash.
Both assert Deno.serve was actually patched first so they can't pass
vacuously.

Closes #23894

Author: JosephDoUrden

packages/deno/src/wrap-deno-request-handler.ts

@@ -11,6 +11,7 @@ import {
   captureBodyFromWinterCGRequest,
   captureException,
   continueTrace,
+  debug,
   getClient,
   getHttpSpanDetailsFromUrlObject,
   hasSpanStreamingEnabled,
@@ -48,7 +49,12 @@ export const wrapDenoRequestHandler = <Addr extends Deno.Addr = Deno.Addr>(
 
     const client = getClient();
     if (!client) {
-      throw new Error('could not get Deno client. Did you run Sentry.init?');
+      // `denoServeIntegration` patches `Deno.serve` from `Client.init()`, which a
+      // directly-constructed client also runs — that path never calls
+      // `setCurrentClient`, so the patch can be live with no client bound. Keep
+      // requests flowing to the user's handler, uninstrumented.
+      debug.warn('Cannot instrument Deno.serve request. No client defined.');
+      return handler();
     }
     isolationScope.setClient(client);
 

packages/deno/test/deno-serve-no-client.test.ts

@@ -0,0 +1,67 @@
+// <reference lib="deno.ns" />
+
+/**
+ * Lives in its own file because it wipes the global carrier; Deno gives each test
+ * file a fresh module graph, so the wipe stays contained here.
+ */
+
+import { getMainCarrier } from '@sentry/core';
+import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.ts';
+import { assertNotEquals } from 'https://deno.land/std@0.212.0/assert/assert_not_equals.ts';
+import { init } from '../build/esm/index.js';
+
+function resetGlobals(): void {
+  getMainCarrier().__SENTRY__ = undefined;
+}
+
+// Captured before any init() so the patch assertion below compares against the
+// genuinely unpatched function; the patch installs once per module graph.
+const unpatchedServe = Deno.serve;
+
+function initPatchedServeWithoutClient(): void {
+  // Install the Deno.serve patch, then unbind the client. The patch is installed by
+  // `Client.init()`, which a directly-constructed client also runs without ever
+  // calling `setCurrentClient` — so a live patch with no bound client is a real state.
+  resetGlobals();
+  init({ dsn: 'https://username@domain/123' });
+  assertNotEquals(Deno.serve, unpatchedServe, 'Deno.serve was not patched; test would pass vacuously');
+  resetGlobals();
+}
+
+Deno.test('Deno.serve keeps serving when no client is bound', async () => {
+  initPatchedServeWithoutClient();
+
+  const abortController = new AbortController();
+  let onListen: ((_: unknown) => void) | undefined = undefined;
+  const p = new Promise(resolve => (onListen = resolve));
+  const server = Deno.serve({ port: 0, signal: abortController.signal, onListen }, () => {
+    return new Response('Hello World');
+  });
+  await p;
+
+  const response = await fetch(`http://localhost:${server.addr.port}/test`);
+  assertEquals(response.status, 200);
+  assertEquals(await response.text(), 'Hello World');
+
+  abortController.abort();
+  await server.finished;
+});
+
+Deno.test('Deno.serve propagates handler errors as 500 when no client is bound', async () => {
+  initPatchedServeWithoutClient();
+
+  const abortController = new AbortController();
+  let onListen: ((_: unknown) => void) | undefined = undefined;
+  const p = new Promise(resolve => (onListen = resolve));
+  const server = Deno.serve({ port: 0, signal: abortController.signal, onListen }, () => {
+    throw new Error('handler blew up');
+  });
+  await p;
+
+  const response = await fetch(`http://localhost:${server.addr.port}/boom`);
+  assertEquals(response.status, 500);
+  await response.body?.cancel();
+
+  abortController.abort();
+  await server.finished;
+});