feat(node): Migrate to @fastify/otel

dev-packages/e2e-tests/test-applications/nestjs-fastify/tests/transactions.test.ts

@@ -49,40 +49,6 @@ test('Sends an API route transaction', async ({ baseURL }) => {
   expect(transactionEvent).toEqual(
     expect.objectContaining({
       spans: expect.arrayContaining([
-        {
-          span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          trace_id: expect.stringMatching(/[a-f0-9]{32}/),
-          data: {
-            'sentry.origin': 'manual',
-            'fastify.type': 'middleware',
-            'plugin.name': 'fastify -> @fastify/middie',
-            'hook.name': 'onRequest',
-          },
-          description: 'middleware - runMiddie',
-          parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
-          status: 'ok',
-          origin: 'manual',
-        },
-        {
-          span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          trace_id: expect.stringMatching(/[a-f0-9]{32}/),
-          data: {
-            'sentry.origin': 'auto.http.otel.fastify',
-            'sentry.op': 'request_handler.fastify',
-            'plugin.name': 'fastify -> @fastify/middie',
-            'fastify.type': 'request_handler',
-            'http.route': '/test-transaction',
-          },
-          description: '@fastify/middie',
-          parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
-          status: 'ok',
-          op: 'request_handler.fastify',
-          origin: 'auto.http.otel.fastify',
-        },
         {
           span_id: expect.stringMatching(/[a-f0-9]{16}/),
           trace_id: expect.stringMatching(/[a-f0-9]{32}/),

dev-packages/e2e-tests/test-applications/node-connect/tsconfig.json

@@ -4,7 +4,8 @@
     "esModuleInterop": true,
     "lib": ["dom", "dom.iterable", "esnext"],
     "strict": true,
-    "noEmit": true
+    "noEmit": true,
+    "skipLibCheck": true
   },
   "include": ["src/*.ts"]
 }

dev-packages/e2e-tests/test-applications/node-express-incorrect-instrumentation/tsconfig.json

@@ -4,7 +4,8 @@
     "esModuleInterop": true,
     "lib": ["es2018"],
     "strict": true,
-    "outDir": "dist"
+    "outDir": "dist",
+    "skipLibCheck": true
   },
   "include": ["src/**/*.ts"]
 }

dev-packages/e2e-tests/test-applications/node-express-send-to-sentry/tsconfig.json

@@ -4,7 +4,8 @@
     "esModuleInterop": true,
     "lib": ["es2018"],
     "strict": true,
-    "outDir": "dist"
+    "outDir": "dist",
+    "skipLibCheck": true
   },
   "include": ["src/**/*.ts"]
 }

dev-packages/e2e-tests/test-applications/node-express/tsconfig.json

@@ -4,7 +4,8 @@
     "esModuleInterop": true,
     "lib": ["es2020"],
     "strict": true,
-    "outDir": "dist"
+    "outDir": "dist",
+    "skipLibCheck": true
   },
   "include": ["src/**/*.ts"]
 }

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

@@ -1,5 +1,5 @@
 {
-  "name": "node-fastify",
+  "name": "node-fastify-3",
   "version": "1.0.0",
   "private": true,
   "scripts": {
@@ -15,7 +15,7 @@
     "@sentry/core": "latest || *",
     "@sentry/opentelemetry": "latest || *",
     "@types/node": "^18.19.1",
-    "fastify": "4.23.2",
+    "fastify": "3.29.5",
     "typescript": "~5.0.0",
     "ts-node": "10.9.1"
   },

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

@@ -0,0 +1,153 @@
+import type * as S from '@sentry/node';
+const Sentry = require('@sentry/node') as typeof S;
+
+// We wrap console.warn to find out if a warning is incorrectly logged
+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: [],
+  tracesSampleRate: 1,
+  tunnel: 'http://localhost:3031/', // proxy server
+  tracePropagationTargets: ['http://localhost:3030', '/external-allowed'],
+});
+
+import type * as H from 'http';
+import type * as F from 'fastify';
+
+// Make sure fastify is imported after Sentry is initialized
+const { fastify } = require('fastify') as typeof F;
+const http = require('http') as typeof H;
+
+const app = fastify();
+const port = 3030;
+const port2 = 3040;
+
+Sentry.setupFastifyErrorHandler(app);
+
+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 });
+});
+
+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.listen({ port: port });
+
+// A second app so we can test header propagation between external URLs
+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/start-event-proxy.mjs → dev-packages/e2e-tests/test-applications/node-fastify-3/start-event-proxy.mjs

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

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

@@ -0,0 +1,30 @@
+import { expect, test } from '@playwright/test';
+import { waitForError } from '@sentry-internal/test-utils';
+
+test('Sends correct error event', async ({ baseURL }) => {
+  const errorEventPromise = waitForError('node-fastify-3', event => {
+    return !event.type && event.exception?.values?.[0]?.value === 'This is an exception with id 123';
+  });
+
+  await fetch(`${baseURL}/test-exception/123`);
+
+  const errorEvent = await errorEventPromise;
+
+  expect(errorEvent.exception?.values).toHaveLength(1);
+  expect(errorEvent.exception?.values?.[0]?.value).toBe('This is an exception with id 123');
+
+  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}/),
+  });
+});

dev-packages/e2e-tests/test-applications/node-fastify/tests/propagation.test.ts → dev-packages/e2e-tests/test-applications/node-fastify-3/tests/propagation.test.ts

@@ -6,14 +6,14 @@ import { SpanJSON } from '@sentry/core';
 test('Propagates trace for outgoing http requests', async ({ baseURL }) => {
   const id = crypto.randomUUID();
 
-  const inboundTransactionPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent.contexts?.trace?.op === 'http.server' &&
       transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-inbound-headers/${id}`
     );
   });
 
-  const outboundTransactionPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const outboundTransactionPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent.contexts?.trace?.op === 'http.server' &&
       transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-http/${id}`
@@ -120,14 +120,14 @@ test('Propagates trace for outgoing http requests', async ({ baseURL }) => {
 test('Propagates trace for outgoing fetch requests', async ({ baseURL }) => {
   const id = crypto.randomUUID();
 
-  const inboundTransactionPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent?.contexts?.trace?.op === 'http.server' &&
       transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-inbound-headers/${id}`
     );
   });
 
-  const outboundTransactionPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const outboundTransactionPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent?.contexts?.trace?.op === 'http.server' &&
       transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-fetch/${id}`
@@ -232,7 +232,7 @@ test('Propagates trace for outgoing fetch requests', async ({ baseURL }) => {
 });
 
 test('Propagates trace for outgoing external http requests', async ({ baseURL }) => {
-  const inboundTransactionPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent?.contexts?.trace?.op === 'http.server' &&
       transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-http-external-allowed`
@@ -269,7 +269,7 @@ test('Propagates trace for outgoing external http requests', async ({ baseURL })
 });
 
 test('Does not propagate outgoing http requests not covered by tracePropagationTargets', async ({ baseURL }) => {
-  const inboundTransactionPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent?.contexts?.trace?.op === 'http.server' &&
       transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-http-external-disallowed`
@@ -293,7 +293,7 @@ test('Does not propagate outgoing http requests not covered by tracePropagationT
 });
 
 test('Propagates trace for outgoing external fetch requests', async ({ baseURL }) => {
-  const inboundTransactionPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent?.contexts?.trace?.op === 'http.server' &&
       transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-fetch-external-allowed`
@@ -330,7 +330,7 @@ test('Propagates trace for outgoing external fetch requests', async ({ baseURL }
 });
 
 test('Does not propagate outgoing fetch requests not covered by tracePropagationTargets', async ({ baseURL }) => {
-  const inboundTransactionPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const inboundTransactionPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent?.contexts?.trace?.op === 'http.server' &&
       transactionEvent.contexts?.trace?.data?.['http.target'] === `/test-outgoing-fetch-external-disallowed`

dev-packages/e2e-tests/test-applications/node-fastify/tests/transactions.test.ts → dev-packages/e2e-tests/test-applications/node-fastify-3/tests/transactions.test.ts

@@ -2,7 +2,7 @@ import { expect, test } from '@playwright/test';
 import { waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Sends an API route transaction', async ({ baseURL }) => {
-  const pageloadTransactionEventPromise = waitForTransaction('node-fastify', transactionEvent => {
+  const pageloadTransactionEventPromise = waitForTransaction('node-fastify-3', transactionEvent => {
     return (
       transactionEvent?.contexts?.trace?.op === 'http.server' &&
       transactionEvent?.transaction === 'GET /test-transaction'
@@ -60,7 +60,7 @@ test('Sends an API route transaction', async ({ baseURL }) => {
 
   expect(spans).toContainEqual({
     data: {
-      'plugin.name': 'fastify -> sentry-fastify-error-handler',
+      'plugin.name': 'sentry-fastify-error-handler',
       'fastify.type': 'middleware',
       'hook.name': 'onRequest',
       'sentry.origin': 'auto.http.otel.fastify',
@@ -79,7 +79,7 @@ test('Sends an API route transaction', async ({ baseURL }) => {
 
   expect(spans).toContainEqual({
     data: {
-      'plugin.name': 'fastify -> sentry-fastify-error-handler',
+      'plugin.name': 'sentry-fastify-error-handler',
       'fastify.type': 'request_handler',
       'http.route': '/test-transaction',
       'sentry.op': 'request_handler.fastify',

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

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

dev-packages/e2e-tests/test-applications/node-fastify-4/.npmrc

@@ -0,0 +1,2 @@
+@sentry:registry=http://127.0.0.1:4873
+@sentry-internal:registry=http://127.0.0.1:4873