test(e2e): Add Fastify v6 e2e app

dev-packages/e2e-tests/test-applications/node-fastify-6/.gitignore

@@ -0,0 +1 @@
+dist

dev-packages/e2e-tests/test-applications/node-fastify-6/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "node-fastify-6",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "start": "ts-node src/app.ts",
+    "test": "playwright test",
+    "clean": "npx rimraf node_modules pnpm-lock.yaml",
+    "typecheck": "tsc",
+    "test:build": "pnpm install && pnpm run typecheck",
+    "test:assert": "pnpm test"
+  },
+  "dependencies": {
+    "@sentry/node": "file:../../packed/sentry-node-packed.tgz",
+    "@types/node": "^18.19.1",
+    "fastify": "6.0.0-alpha.3",
+    "typescript": "5.6.3",
+    "ts-node": "10.9.2"
+  },
+  "devDependencies": {
+    "@playwright/test": "~1.56.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils"
+  },
+  "volta": {
+    "node": "22.22.0",
+    "extends": "../../package.json"
+  },
+  "sentryTest": {
+    "optional": true,
+    "optionalVariants": [
+      {
+        "build-command": "E2E_TEST_OTEL_SETUP=true pnpm test:build",
+        "assert-command": "E2E_TEST_OTEL_SETUP=true pnpm test:assert",
+        "label": "node-fastify-6 (tracer provider)"
+      }
+    ]
+  }
+}

dev-packages/e2e-tests/test-applications/node-fastify-6/playwright.config.mjs

@@ -0,0 +1,7 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+const config = getPlaywrightConfig({
+  startCommand: `pnpm start`,
+});
+
+export default config;

dev-packages/e2e-tests/test-applications/node-fastify-6/src/app.ts

@@ -0,0 +1,193 @@
+import type * as S from '@sentry/node';
+const Sentry = require('@sentry/node') as typeof S;
+
+// Fail the app on any SDK warning
+console.warn = new Proxy(console.warn, {
+  apply: function (target, thisArg, argumentsList) {
+    const msg = argumentsList[0];
+    if (typeof msg === 'string' && msg.startsWith('[Sentry]')) {
+      console.error(`Sentry warning was triggered: ${msg}`);
+      process.exit(1);
+    }
+
+    return target.apply(thisArg, argumentsList);
+  },
+});
+
+Sentry.init({
+  environment: 'qa', // dynamic sampling bias to keep transactions
+  dsn: process.env.E2E_TEST_DSN,
+  integrations: [
+    Sentry.fastifyIntegration({
+      shouldHandleError: (_error, request, _reply) => {
+        if (request.routeOptions?.url?.includes('/test-error-not-captured')) {
+          return false;
+        }
+
+        if (request.routeOptions?.url?.includes('/test-error-ignored') && _reply.statusCode === 500) {
+          return false;
+        }
+
+        return true;
+      },
+    }),
+  ],
+  tracesSampleRate: 1,
+  tunnel: 'http://localhost:3031/', // proxy server
+  tracePropagationTargets: ['http://localhost:3030', '/external-allowed'],
+  // Only the "(tracer provider)" variant opts in; `undefined` keeps the SDK default
+  enableOpenTelemetrySetup: process.env.E2E_TEST_OTEL_SETUP === 'true' ? true : undefined,
+});
+
+import type * as H from 'http';
+import type * as F from 'fastify';
+
+// Fastify must load after Sentry.init()
+const { fastify } = require('fastify') as typeof F;
+const http = require('http') as typeof H;
+
+const app = fastify();
+const port = 3030;
+const port2 = 3040;
+
+app.get('/test-success', function (_req, res) {
+  res.send({ version: 'v1' });
+});
+
+app.get<{ Params: { param: string } }>('/test-param/:param', function (req, res) {
+  res.send({ paramWas: req.params.param });
+});
+
+app.get<{ Params: { id: string } }>('/test-inbound-headers/:id', function (req, res) {
+  const headers = req.headers;
+
+  res.send({ headers, id: req.params.id });
+});
+
+app.get<{ Params: { id: string } }>('/test-outgoing-http/:id', async function (req, res) {
+  const id = req.params.id;
+  const data = await makeHttpRequest(`http://localhost:3030/test-inbound-headers/${id}`);
+
+  res.send(data);
+});
+
+app.get<{ Params: { id: string } }>('/test-outgoing-fetch/:id', async function (req, res) {
+  const id = req.params.id;
+  const response = await fetch(`http://localhost:3030/test-inbound-headers/${id}`);
+  const data = await response.json();
+
+  res.send(data);
+});
+
+app.get('/test-transaction', async function (req, res) {
+  Sentry.startSpan({ name: 'test-span' }, () => {
+    Sentry.startSpan({ name: 'child-span' }, () => {});
+  });
+
+  res.send({});
+});
+
+app.get('/test-error', async function (req, res) {
+  const exceptionId = Sentry.captureException(new Error('This is an error'));
+
+  await Sentry.flush(2000);
+
+  res.send({ exceptionId });
+});
+
+// Regression test for https://github.com/fastify/fastify/issues/6409 (fixed in Fastify 5.7.0)
+app.register((childApp: F.FastifyInstance, _options: F.FastifyPluginOptions, next: (err?: Error) => void) => {
+  childApp.setErrorHandler((error: Error, _request: F.FastifyRequest, reply: F.FastifyReply) => {
+    reply.send({ ok: false });
+  });
+
+  childApp.get('/test-error-ignored', async function () {
+    throw new Error('This is an error that will not be captured');
+  });
+
+  next();
+});
+
+app.get('/test-error-not-captured', async function () {
+  throw new Error('This is an error that will not be captured');
+});
+
+app.get<{ Params: { id: string } }>('/test-exception/:id', async function (req, res) {
+  throw new Error(`This is an exception with id ${req.params.id}`);
+});
+
+app.get('/test-outgoing-fetch-external-allowed', async function (req, res) {
+  const fetchResponse = await fetch(`http://localhost:${port2}/external-allowed`);
+  const data = await fetchResponse.json();
+
+  res.send(data);
+});
+
+app.get('/test-outgoing-fetch-external-disallowed', async function (req, res) {
+  const fetchResponse = await fetch(`http://localhost:${port2}/external-disallowed`);
+  const data = await fetchResponse.json();
+
+  res.send(data);
+});
+
+app.get('/test-outgoing-http-external-allowed', async function (req, res) {
+  const data = await makeHttpRequest(`http://localhost:${port2}/external-allowed`);
+  res.send(data);
+});
+
+app.get('/test-outgoing-http-external-disallowed', async function (req, res) {
+  const data = await makeHttpRequest(`http://localhost:${port2}/external-disallowed`);
+  res.send(data);
+});
+
+app.post('/test-post', function (req, res) {
+  res.send({ status: 'ok', body: req.body });
+});
+
+app.get('/flush', async function (_req, res) {
+  await Sentry.flush();
+  res.send({ ok: true });
+});
+
+app.listen({ port: port });
+
+// External target for propagation tests
+const app2 = fastify();
+app2.get('/external-allowed', function (req, res) {
+  const headers = req.headers;
+
+  res.send({ headers, route: '/external-allowed' });
+});
+
+app2.get('/external-disallowed', function (req, res) {
+  const headers = req.headers;
+
+  res.send({ headers, route: '/external-disallowed' });
+});
+
+app2.listen({ port: port2 });
+
+function makeHttpRequest(url: string) {
+  return new Promise(resolve => {
+    const data: any[] = [];
+
+    http
+      .request(url, httpRes => {
+        httpRes.on('data', chunk => {
+          data.push(chunk);
+        });
+        httpRes.on('error', error => {
+          resolve({ error: error.message, url });
+        });
+        httpRes.on('end', () => {
+          try {
+            const json = JSON.parse(Buffer.concat(data).toString());
+            resolve(json);
+          } catch {
+            resolve({ data: Buffer.concat(data).toString(), url });
+          }
+        });
+      })
+      .end();
+  });
+}

dev-packages/e2e-tests/test-applications/node-fastify-6/start-event-proxy.mjs

@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'node-fastify-6',
+});

dev-packages/e2e-tests/test-applications/node-fastify-6/tests/errors.test.ts

@@ -0,0 +1,106 @@
+import { expect, test } from '@playwright/test';
+import { waitForError, waitForStreamedSpan, collectStreamedSpansUntilSegment } from '@sentry-internal/test-utils';
+
+test('Sends correct error event', async ({ baseURL }) => {
+  const errorEventPromise = waitForError('node-fastify-6', event => {
+    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception with id 123';
+  });
+
+  const segmentEventPromise = collectStreamedSpansUntilSegment('node-fastify-6', 'GET /test-exception/:id');
+
+  await fetch(`${baseURL}/test-exception/123`);
+
+  const errorEvent = await errorEventPromise;
+  const segmentEventSpans = await segmentEventPromise;
+  const segmentEvent = segmentEventSpans.find(
+    segment => segment.is_segment && segment.name === 'GET /test-exception/:id',
+  )!;
+
+  expect(errorEvent.exception?.values).toHaveLength(1);
+  const exception = errorEvent.exception?.values?.[0];
+  expect(exception?.value).toBe('This is an exception with id 123');
+  expect(exception?.mechanism).toEqual({
+    type: 'auto.function.fastify',
+    handled: false,
+  });
+
+  expect(errorEvent.request).toEqual({
+    method: 'GET',
+    cookies: {},
+    headers: expect.any(Object),
+    url: 'http://localhost:3030/test-exception/123',
+  });
+
+  expect(errorEvent.transaction).toEqual('GET /test-exception/:id');
+
+  expect(errorEvent.contexts?.trace).toEqual({
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+  });
+
+  // The error belongs to the request segment's trace and one of its spans
+  const segmentTrace = segmentEvent;
+  expect(errorEvent.contexts?.trace?.trace_id).toBe(segmentTrace?.trace_id);
+
+  const segmentSpanIds = [
+    segmentTrace?.span_id,
+    ...segmentEventSpans
+      .filter(span => !span.is_segment && span.attributes['sentry.segment.id']?.value === segmentEvent.span_id)
+      .map(span => span.span_id),
+  ];
+  expect(segmentSpanIds).toContain(errorEvent.contexts?.trace?.span_id);
+});
+
+test('Does not send error when shouldHandleError returns false', async ({ baseURL }) => {
+  let errorEventOccurred = false;
+
+  waitForError('node-fastify-6', event => {
+    if (!event.type && event.exception?.values?.[0]?.value === 'This is an error that will not be captured') {
+      errorEventOccurred = true;
+    }
+    return event?.transaction === 'GET /test-error-not-captured';
+  });
+
+  const segmentEventPromise = waitForStreamedSpan(
+    'node-fastify-6',
+    segment => segment.is_segment && segment.name === 'GET /test-error-not-captured',
+  );
+
+  const response = await fetch(`${baseURL}/test-error-not-captured`);
+
+  await segmentEventPromise;
+
+  const flushResponse = await fetch(`${baseURL}/flush`);
+
+  expect(response.status).toBe(500);
+  expect(flushResponse.status).toBe(200);
+  expect(errorEventOccurred).toBe(false);
+});
+
+// Regression test for https://github.com/fastify/fastify/issues/6409 (fixed in Fastify 5.7.0)
+test('Error in child plugin with rethrown error handler reports correct 500 status', async ({ baseURL }) => {
+  let errorEventOccurred = false;
+
+  waitForError('node-fastify-6', event => {
+    if (!event.type && event.exception?.values?.[0]?.value === 'This is an error that will not be captured') {
+      errorEventOccurred = true;
+    }
+    return event?.transaction === 'GET /test-error-ignored';
+  });
+
+  const segmentEventPromise = waitForStreamedSpan(
+    'node-fastify-6',
+    segment => segment.is_segment && segment.name === 'GET /test-error-ignored',
+  );
+
+  const response = await fetch(`${baseURL}/test-error-ignored`);
+
+  await segmentEventPromise;
+
+  const flushResponse = await fetch(`${baseURL}/flush`);
+
+  expect(response.status).toBe(500);
+  expect(flushResponse.status).toBe(200);
+  expect(errorEventOccurred).toBe(false);
+});