feat(node): Add Fastify integration

Author: mydea

packages/node-experimental/README.md

@@ -130,6 +130,51 @@ All of these are auto-discovered, you don't need to configure anything for perfo
 You still need to register middlewares etc. for error capturing.
 Other, non-performance integrations from `@sentry/node` are also available (except for Undici).
 
+## Fully supported Frameworks
+
+### Express
+
+```js
+const Sentry = require('@sentry/node-experimental');
+
+Sentry.init({
+  dsn: '...',
+  tracesSampleRate: 1,
+});
+
+// Ensure `init` was called _before_ you require express!
+const express = require('express');
+const app = express();
+
+// Add your routes
+
+// The error handler must be before any other error middleware and after all controllers
+app.use(Sentry.Handlers.errorHandler());
+
+app.listen(3000);
+```
+
+### Fastify
+
+```js
+const Sentry = require('@sentry/node-experimental');
+
+Sentry.init({
+  dsn: '...',
+  tracesSampleRate: 1,
+});
+
+// Ensure `init` was called _before_ you require fastify!
+const fastify = require('fastify');
+const app = fastify();
+
+app.register(Sentry.SentryFastifyErrorPlugin);
+
+// Add your routes
+
+app.listen();
+```
+
 ## Links
 
 - [Official SDK Docs](https://docs.sentry.io/quickstart/)

packages/node-experimental/src/index.ts

@@ -51,6 +51,7 @@ export {
   trace,
   withScope,
   captureCheckIn,
+  SentryFastifyPlugin,
 } from '@sentry/node';
 
 export type {

packages/node/package.json

@@ -38,6 +38,7 @@
     "@types/lru-cache": "^5.1.0",
     "@types/node": "~10.17.0",
     "express": "^4.17.1",
+    "fastify": "^4.23.2",
     "nock": "^13.0.5",
     "undici": "^5.21.0"
   },
@@ -61,8 +62,9 @@
     "lint": "run-s lint:prettier lint:eslint",
     "lint:eslint": "eslint . --format stylish",
     "lint:prettier": "prettier --check \"{src,test,scripts}/**/**.ts\"",
-    "test": "run-s test:jest test:express test:webpack test:release-health",
+    "test": "run-s test:jest test:express test:fastify test:webpack test:release-health",
     "test:express": "node test/manual/express-scope-separation/start.js",
+    "test:fastify": "node test/manual/fastify-scope-separation/start.js",
     "test:jest": "jest",
     "test:release-health": "node test/manual/release-health/runner.js",
     "test:webpack": "cd test/manual/webpack-async-context/ && yarn --silent && node npm-build.js",

packages/node/src/handlers.ts

@@ -207,12 +207,10 @@ export function requestHandler(
         const client = currentHub.getClient<NodeClient>();
         if (isAutoSessionTrackingEnabled(client)) {
           setImmediate(() => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            if (client && (client as any)._captureRequestSession) {
+            if (client && client['_captureRequestSession']) {
               // Calling _captureRequestSession to capture request session at the end of the request by incrementing
               // the correct SessionAggregates bucket i.e. crashed, errored or exited
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-              (client as any)._captureRequestSession();
+              client['_captureRequestSession']();
             }
           });
         }

packages/node/src/index.ts

@@ -86,3 +86,4 @@ const INTEGRATIONS = {
 };
 
 export { INTEGRATIONS as Integrations, Handlers };
+export { SentryFastifyErrorPlugin } from './integrations/fastify';

packages/node/src/integrations/fastify.ts

@@ -0,0 +1,142 @@
+import { captureException, getCurrentHub, runWithAsyncContext } from '@sentry/core';
+import type { Integration } from '@sentry/types';
+import { logger } from '@sentry/utils';
+import type * as http from 'http';
+
+import type { NodeClient } from '../client';
+import { isAutoSessionTrackingEnabled } from '../sdk';
+
+// We do not want to have fastify as a dependency, so we mock the type here
+
+type RequestHookHandler = (
+  this: FastifyInstance,
+  request: http.IncomingMessage,
+  reply: unknown,
+  done: () => void,
+) => void;
+interface FastifyInstance {
+  register: (plugin: typeof SentryFastifyErrorPlugin | typeof SentryFastifyRequestPlugin) => void;
+
+  /**
+   * `onRequest` is the first hook to be executed in the request lifecycle. There was no previous hook, the next hook will be `preParsing`.
+   *  Notice: in the `onRequest` hook, request.body will always be null, because the body parsing happens before the `preHandler` hook.
+   */
+  /**
+   * `onResponse` is the seventh and last hook in the request hook lifecycle. The previous hook was `onSend`, there is no next hook.
+   * The onResponse hook is executed when a response has been sent, so you will not be able to send more data to the client. It can however be useful for sending data to external services, for example to gather statistics.
+   */
+  addHook(name: 'onRequest' | 'onResponse', hook: RequestHookHandler): void;
+
+  /**
+   * This hook is useful if you need to do some custom error logging or add some specific header in case of error.
+   * It is not intended for changing the error, and calling reply.send will throw an exception.
+   * This hook will be executed only after the customErrorHandler has been executed, and only if the customErrorHandler sends an error back to the user (Note that the default customErrorHandler always sends the error back to the user).
+   * Notice: unlike the other hooks, pass an error to the done function is not supported.
+   */
+  addHook(
+    name: 'onError',
+    hook: (
+      this: FastifyInstance,
+      request: http.IncomingMessage,
+      reply: unknown,
+      error: Error,
+      done: () => void,
+    ) => void,
+  ): void;
+}
+
+const SKIP_OVERRIDE = Symbol.for('skip-override');
+const FASTIFY_DISPLAY_NAME = Symbol.for('fastify.display-name');
+
+interface FastifyOptions {
+  fastify: FastifyInstance;
+}
+
+const SentryFastifyRequestPlugin = Object.assign(
+  (fastify: FastifyInstance, _options: unknown, pluginDone: () => void) => {
+    fastify.addHook('onRequest', (request, _reply, done) => {
+      runWithAsyncContext(() => {
+        const currentHub = getCurrentHub();
+        currentHub.configureScope(scope => {
+          scope.setSDKProcessingMetadata({
+            request,
+          });
+
+          const client = currentHub.getClient<NodeClient>();
+          if (isAutoSessionTrackingEnabled(client)) {
+            const scope = currentHub.getScope();
+            // Set `status` of `RequestSession` to Ok, at the beginning of the request
+            scope.setRequestSession({ status: 'ok' });
+          }
+        });
+
+        done();
+      });
+    });
+
+    fastify.addHook('onResponse', (_request, _reply, done) => {
+      const client = getCurrentHub().getClient<NodeClient>();
+      if (isAutoSessionTrackingEnabled(client)) {
+        setImmediate(() => {
+          if (client && client['_captureRequestSession']) {
+            // Calling _captureRequestSession to capture request session at the end of the request by incrementing
+            // the correct SessionAggregates bucket i.e. crashed, errored or exited
+            client['_captureRequestSession']();
+          }
+        });
+      }
+
+      done();
+    });
+
+    pluginDone();
+  },
+  {
+    [SKIP_OVERRIDE]: true,
+    [FASTIFY_DISPLAY_NAME]: 'SentryFastifyRequestPlugin',
+  },
+);
+
+export const SentryFastifyErrorPlugin = Object.assign(
+  (fastify: FastifyInstance, _options: unknown, pluginDone: () => void) => {
+    fastify.addHook('onError', (_request, _reply, error, done) => {
+      captureException(error);
+      done();
+    });
+
+    pluginDone();
+  },
+  {
+    [SKIP_OVERRIDE]: true,
+    [FASTIFY_DISPLAY_NAME]: 'SentryFastifyErrorPlugin',
+  },
+);
+
+/** Capture errors for your fastify app. */
+export class Fastify implements Integration {
+  public static id: string = 'Fastify';
+  public name: string = Fastify.id;
+
+  private _fastify?: FastifyInstance;
+
+  public constructor(options?: FastifyOptions) {
+    const fastify = options?.fastify;
+    this._fastify = fastify && typeof fastify.register === 'function' ? fastify : undefined;
+
+    if (__DEBUG_BUILD__ && !this._fastify) {
+      logger.warn('The Fastify integration expects a fastify instance to be passed. No errors will be captured.');
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    if (!this._fastify) {
+      return;
+    }
+
+    void this._fastify.register(SentryFastifyErrorPlugin);
+    void this._fastify.register(SentryFastifyRequestPlugin);
+  }
+}

packages/node/src/integrations/index.ts

@@ -9,3 +9,4 @@ export { Context } from './context';
 export { RequestData } from './requestdata';
 export { LocalVariables } from './localvariables';
 export { Undici } from './undici';
+export { Fastify } from './fastify';

packages/node/test/manual/fastify-scope-separation/start.js

@@ -0,0 +1,102 @@
+const http = require('http');
+const fastify = require('fastify');
+const app = fastify();
+const Sentry = require('../../../build/cjs');
+const { colorize } = require('../colorize');
+const { TextEncoder } = require('util');
+
+// don't log the test errors we're going to throw, so at a quick glance it doesn't look like the test itself has failed
+global.console.error = () => null;
+
+function assertTags(actual, expected) {
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    console.log(colorize('FAILED: Scope contains incorrect tags\n', 'red'));
+    console.log(colorize(`Got: ${JSON.stringify(actual)}\n`, 'red'));
+    console.log(colorize(`Expected: ${JSON.stringify(expected)}\n`, 'red'));
+    process.exit(1);
+  }
+}
+
+let remaining = 3;
+
+function makeDummyTransport() {
+  return Sentry.createTransport({ recordDroppedEvent: () => undefined, textEncoder: new TextEncoder() }, req => {
+    --remaining;
+
+    if (!remaining) {
+      console.log(colorize('PASSED: All scopes contain correct tags\n', 'green'));
+      app.close();
+      process.exit(0);
+    }
+
+    return Promise.resolve({
+      statusCode: 200,
+    });
+  });
+}
+
+Sentry.init({
+  dsn: 'http://[email protected]/1337',
+  transport: makeDummyTransport,
+  integrations: [new Sentry.Integrations.Fastify({ fastify: app })],
+  beforeSend(event) {
+    if (event.transaction === 'GET /foo') {
+      assertTags(event.tags, {
+        global: 'wat',
+        foo: 'wat',
+      });
+    } else if (event.transaction === 'GET /bar') {
+      assertTags(event.tags, {
+        global: 'wat',
+        bar: 'wat',
+      });
+    } else if (event.transaction === 'GET /baz') {
+      assertTags(event.tags, {
+        global: 'wat',
+        baz: 'wat',
+      });
+    } else {
+      assertTags(event.tags, {
+        global: 'wat',
+      });
+    }
+
+    return event;
+  },
+});
+
+Sentry.configureScope(scope => {
+  scope.setTag('global', 'wat');
+});
+
+app.get('/foo', req => {
+  Sentry.configureScope(scope => {
+    scope.setTag('foo', 'wat');
+  });
+
+  throw new Error('foo');
+});
+
+app.get('/bar', req => {
+  Sentry.configureScope(scope => {
+    scope.setTag('bar', 'wat');
+  });
+
+  throw new Error('bar');
+});
+
+app.get('/baz', async req => {
+  Sentry.configureScope(scope => {
+    scope.setTag('baz', 'wat');
+  });
+
+  await new Promise(resolve => setTimeout(resolve, 10));
+
+  throw new Error('baz');
+});
+
+app.listen({ port: 0 }, (err, address) => {
+  http.get(`${address}/foo`);
+  http.get(`${address}/bar`);
+  http.get(`${address}/baz`);
+});