test(deno): Add orchestrion-fastify integration test

Mirror the other orchestrion Deno suites: assert the Fastify integration is in the defaults and that
the native `tracing:fastify.request.handler:error` channel captures the error (with mechanism
`auto.function.fastify`). Adds a shared `errorSink` helper alongside `transactionSink`.

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

Author: mydea

dev-packages/deno-integration-tests/src/index.ts

@@ -1,4 +1,4 @@
-import type { TransactionEvent } from '@sentry/core';
+import type { Event, TransactionEvent } from '@sentry/core';
 import { getAsyncContextStrategy, getMainCarrier, setAsyncContextStrategy } from '@sentry/core';
 
 /**
@@ -51,6 +51,40 @@ export function transactionSink(): TransactionSink {
   };
 }
 
+export interface ErrorSink {
+  beforeSend: (event: Event) => null;
+  waitFor: (predicate: (event: Event) => boolean) => Promise<Event>;
+}
+
+/**
+ * A `beforeSend` hook that records every error event and lets a test `await` the
+ * first one matching a predicate. Mirrors {@link transactionSink} for error events.
+ */
+export function errorSink(): ErrorSink {
+  const events: Event[] = [];
+  const waiters: { predicate: (e: Event) => boolean; resolve: (e: Event) => void }[] = [];
+  return {
+    beforeSend(event) {
+      events.push(event);
+      for (let i = waiters.length - 1; i >= 0; i--) {
+        const w = waiters[i]!;
+        if (w.predicate(event)) {
+          waiters.splice(i, 1);
+          w.resolve(event);
+        }
+      }
+      return null;
+    },
+    waitFor(predicate) {
+      const already = events.find(predicate);
+      if (already) return Promise.resolve(already);
+      return new Promise<Event>(resolve => {
+        waiters.push({ predicate, resolve });
+      });
+    },
+  };
+}
+
 /** Reject with a descriptive message if `p` does not settle within `ms`. */
 export function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T> {
   let timer: ReturnType<typeof setTimeout> | undefined;

dev-packages/deno-integration-tests/suites/orchestrion-fastify/test.ts

@@ -0,0 +1,47 @@
+// <reference lib="deno.ns" />
+
+import { channel } from 'node:diagnostics_channel';
+import type { DenoClient } from '@sentry/deno';
+import { init } from '@sentry/deno';
+import { assert } from 'https://deno.land/std@0.212.0/assert/assert.ts';
+import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.ts';
+import { assertExists } from 'https://deno.land/std@0.212.0/assert/assert_exists.ts';
+import { errorSink, resetGlobals, withTimeout } from '../../src/index.ts';
+
+Deno.test('fastify instrumentation: included in default integrations (Deno 2.8.0+)', () => {
+  resetGlobals();
+  const client = init({ traceLifecycle: 'static', dsn: 'https://username@domain/123' }) as DenoClient;
+  const names = client.getOptions().integrations.map(i => i.name);
+  assert(names.includes('Fastify'), `Fastify should be in defaults, got ${names.join(', ')}`);
+});
+
+Deno.test('fastify instrumentation: tracing:fastify.request.handler:error channel captures the error', async () => {
+  resetGlobals();
+  const sink = errorSink();
+  init({
+    traceLifecycle: 'static',
+    dsn: 'https://username@domain/123',
+    beforeSend: sink.beforeSend,
+  });
+
+  const error = new Error('fastify boom');
+
+  // Fastify v5 publishes this native diagnostics channel when a request handler errors; the
+  // integration subscribes to it directly (no orchestrion injection needed). A 5xx reply passes the
+  // default `shouldHandleError`, so the error is captured.
+  channel('tracing:fastify.request.handler:error').publish({
+    error,
+    request: { method: 'GET', routeOptions: { url: '/boom' } },
+    reply: { statusCode: 500 },
+  });
+
+  const event = await withTimeout(
+    sink.waitFor(e => e.exception?.values?.[0]?.value === 'fastify boom'),
+    5000,
+    "the captured 'fastify boom' error",
+  );
+
+  assertExists(event.exception?.values?.[0]);
+  assertEquals(event.exception?.values?.[0]?.mechanism?.type, 'auto.function.fastify');
+  assertEquals(event.exception?.values?.[0]?.mechanism?.handled, false);
+});