@sentry/node 9.16.1 → 9.17.0

package/build/{types/integrations/tracing/fastify.d.ts → types-ts3.8/integrations/tracing/fastify/index.d.ts}

@@ -1,103 +1,83 @@
-import { FastifyInstrumentation } from '@opentelemetry/instrumentation-fastify';
-/**
- * Minimal request type containing properties around route information.
- * Works for Fastify 3, 4 and presumably 5.
- *
- * Based on https://github.com/fastify/fastify/blob/ce3811f5f718be278bbcd4392c615d64230065a6/types/request.d.ts
- */
-interface MinimalFastifyRequest extends Record<string, any> {
-    method?: string;
-    routeOptions?: {
-        url?: string;
-    };
-    routerPath?: string;
-}
-/**
- * Minimal reply type containing properties needed for error handling.
- *
- * Based on https://github.com/fastify/fastify/blob/ce3811f5f718be278bbcd4392c615d64230065a6/types/reply.d.ts
- */
-interface MinimalFastifyReply extends Record<string, any> {
-    statusCode: number;
-}
-interface Fastify {
-    register: (plugin: any) => void;
-    addHook: (hook: string, handler: (...params: unknown[]) => void) => void;
-}
-interface FastifyHandlerOptions {
-    /**
-     * Callback method deciding whether error should be captured and sent to Sentry
-     *
-     * @param error Captured Fastify error
-     * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)
-     * @param reply Fastify reply (or any object containing at least statusCode)
-     *
-     * @example
-     *
-     * ```javascript
-     * setupFastifyErrorHandler(app, {
-     *   shouldHandleError(_error, _request, reply) {
-     *     return reply.statusCode >= 400;
-     *   },
-     * });
-     * ```
-     *
-     * If using TypeScript, you can cast the request and reply to get full type safety.
-     *
-     * ```typescript
-     * import type { FastifyRequest, FastifyReply } from 'fastify';
-     *
-     * setupFastifyErrorHandler(app, {
-     *   shouldHandleError(error, minimalRequest, minimalReply) {
-     *     const request = minimalRequest as FastifyRequest;
-     *     const reply = minimalReply as FastifyReply;
-     *     return reply.statusCode >= 500;
-     *   },
-     * });
-     * ```
-     */
-    shouldHandleError: (error: Error, request: MinimalFastifyRequest, reply: MinimalFastifyReply) => boolean;
-}
-export declare const instrumentFastify: ((options?: unknown) => FastifyInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
- *
- * If you also want to capture errors, you need to call `setupFastifyErrorHandler(app)` after you set up your Fastify server.
- *
- * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *   integrations: [Sentry.fastifyIntegration()],
- * })
- * ```
- */
-export declare const fastifyIntegration: () => import("@sentry/core").Integration;
-/**
- * Add an Fastify error handler to capture errors to Sentry.
- *
- * @param fastify The Fastify instance to which to add the error handler
- * @param options Configuration options for the handler
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- * const Fastify = require("fastify");
- *
- * const app = Fastify();
- *
- * Sentry.setupFastifyErrorHandler(app);
- *
- * // Add your routes, etc.
- *
- * app.listen({ port: 3000 });
- * ```
- */
-export declare function setupFastifyErrorHandler(fastify: Fastify, options?: Partial<FastifyHandlerOptions>): void;
-export {};
-//# sourceMappingURL=fastify.d.ts.map
+import { Instrumentation, InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { FastifyInstance, FastifyReply, FastifyRequest } from './types';
+import { FastifyInstrumentationV3 } from './v3/instrumentation';
+interface FastifyHandlerOptions {
+    /**
+     * Callback method deciding whether error should be captured and sent to Sentry
+     *
+     * @param error Captured Fastify error
+     * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)
+     * @param reply Fastify reply (or any object containing at least statusCode)
+     *
+     * @example
+     *
+     * ```javascript
+     * setupFastifyErrorHandler(app, {
+     *   shouldHandleError(_error, _request, reply) {
+     *     return reply.statusCode >= 400;
+     *   },
+     * });
+     * ```
+     *
+     * If using TypeScript, you can cast the request and reply to get full type safety.
+     *
+     * ```typescript
+     * import type { FastifyRequest, FastifyReply } from 'fastify';
+     *
+     * setupFastifyErrorHandler(app, {
+     *   shouldHandleError(error, minimalRequest, minimalReply) {
+     *     const request = minimalRequest as FastifyRequest;
+     *     const reply = minimalReply as FastifyReply;
+     *     return reply.statusCode >= 500;
+     *   },
+     * });
+     * ```
+     */
+    shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;
+}
+export declare const instrumentFastifyV3: ((options?: unknown) => FastifyInstrumentationV3) & {
+    id: string;
+};
+export declare const instrumentFastify: ((options?: unknown) => Instrumentation<InstrumentationConfig>) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
+ *
+ * If you also want to capture errors, you need to call `setupFastifyErrorHandler(app)` after you set up your Fastify server.
+ *
+ * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.fastifyIntegration()],
+ * })
+ * ```
+ */
+export declare const fastifyIntegration: () => import("@sentry/core").Integration;
+/**
+ * Add an Fastify error handler to capture errors to Sentry.
+ *
+ * @param fastify The Fastify instance to which to add the error handler
+ * @param options Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Fastify = require("fastify");
+ *
+ * const app = Fastify();
+ *
+ * Sentry.setupFastifyErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ *
+ * app.listen({ port: 3000 });
+ * ```
+ */
+export declare function setupFastifyErrorHandler(fastify: FastifyInstance, options?: Partial<FastifyHandlerOptions>): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/types.d.ts

@@ -0,0 +1,25 @@
+export type HandlerOriginal = ((request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => Promise<void>) | ((request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => void);
+export type FastifyError = any;
+export type HookHandlerDoneFunction = <TError extends Error = FastifyError>(err?: TError) => void;
+export type FastifyErrorCodes = any;
+export type FastifyPlugin = (instance: FastifyInstance, opts: any, done: HookHandlerDoneFunction) => unknown | Promise<unknown>;
+export interface FastifyInstance {
+    version: string;
+    register: (plugin: any) => FastifyInstance;
+    after: (listener?: (err: Error) => void) => FastifyInstance;
+    addHook(hook: string, handler: HandlerOriginal): FastifyInstance;
+    addHook(hook: 'onError', handler: (request: FastifyRequest, reply: FastifyReply, error: Error) => void): FastifyInstance;
+    addHook(hook: 'onRequest', handler: (request: FastifyRequest, reply: FastifyReply) => void): FastifyInstance;
+}
+export interface FastifyReply {
+    send: () => FastifyReply;
+    statusCode: number;
+}
+export interface FastifyRequest {
+    method?: string;
+    routeOptions?: {
+        url?: string;
+    };
+    routerPath?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const spanRequestSymbol: unique symbol;
+export declare const hooksNamesToWrap: Set<string>;
+//# sourceMappingURL=constants.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/enums/AttributeNames.d.ts

@@ -0,0 +1,15 @@
+export declare enum AttributeNames {
+    FASTIFY_NAME = "fastify.name",
+    FASTIFY_TYPE = "fastify.type",
+    HOOK_NAME = "hook.name",
+    PLUGIN_NAME = "plugin.name"
+}
+export declare enum FastifyTypes {
+    MIDDLEWARE = "middleware",
+    REQUEST_HANDLER = "request_handler"
+}
+export declare enum FastifyNames {
+    MIDDLEWARE = "middleware",
+    REQUEST_HANDLER = "request handler"
+}
+//# sourceMappingURL=AttributeNames.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/instrumentation.d.ts

@@ -0,0 +1,16 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { FastifyInstrumentationConfig } from './types';
+/**
+ * Fastify instrumentation for OpenTelemetry
+ */
+export declare class FastifyInstrumentationV3 extends InstrumentationBase<FastifyInstrumentationConfig> {
+    constructor(config?: FastifyInstrumentationConfig);
+    init(): InstrumentationNodeModuleDefinition[];
+    private _hookOnRequest;
+    private _wrapHandler;
+    private _wrapAddHook;
+    private _patchConstructor;
+    private _patchSend;
+    private _hookPreHandler;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/internal-types.d.ts

@@ -0,0 +1,7 @@
+import { Span } from '@opentelemetry/api';
+import { FastifyReply } from '../types';
+import { spanRequestSymbol } from './constants';
+export type PluginFastifyReply = FastifyReply & {
+    [spanRequestSymbol]?: Span[];
+};
+//# sourceMappingURL=internal-types.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/types.d.ts

@@ -0,0 +1,21 @@
+import { Span } from '@opentelemetry/api';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface FastifyRequestInfo {
+    request: any;
+}
+/**
+ * Function that can be used to add custom attributes to the current span
+ * @param span - The Fastify handler span.
+ * @param info - The Fastify request info object.
+ */
+export interface FastifyCustomAttributeFunction {
+    (span: Span, info: FastifyRequestInfo): void;
+}
+/**
+ * Options available for the Fastify Instrumentation
+ */
+export interface FastifyInstrumentationConfig extends InstrumentationConfig {
+    /** Function for adding custom attributes to each handler span */
+    requestHook?: FastifyCustomAttributeFunction;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/utils.d.ts

@@ -0,0 +1,28 @@
+import { Attributes, Span, Tracer } from '@opentelemetry/api';
+import { PluginFastifyReply } from './internal-types';
+/**
+ * Starts Span
+ * @param reply - reply function
+ * @param tracer - tracer
+ * @param spanName - span name
+ * @param spanAttributes - span attributes
+ */
+export declare function startSpan(reply: PluginFastifyReply, tracer: Tracer, spanName: string, spanAttributes?: Attributes): Span;
+/**
+ * Ends span
+ * @param reply - reply function
+ * @param err - error
+ */
+export declare function endSpan(reply: PluginFastifyReply, err?: any): void;
+/**
+ * This function handles the missing case from instrumentation package when
+ * execute can either return a promise or void. And using async is not an
+ * option as it is producing unwanted side effects.
+ * @param execute - function to be executed
+ * @param onFinish - function called when function executed
+ * @param preventThrowingError - prevent to throw error when execute
+ * function fails
+ */
+export declare function safeExecuteInTheMiddleMaybePromise<T>(execute: () => Promise<T>, onFinish: (e: unknown, result?: T) => void, preventThrowingError?: boolean): Promise<T>;
+export declare function safeExecuteInTheMiddleMaybePromise<T>(execute: () => T, onFinish: (e: unknown, result?: T) => void, preventThrowingError?: boolean): T;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/node",
-  "version": "9.16.1",
+  "version": "9.17.0",
   "description": "Sentry Node SDK using OpenTelemetry for performance instrumentation",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/node",
@@ -65,6 +65,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@fastify/otel": "0.6.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/context-async-hooks": "^1.30.1",
     "@opentelemetry/core": "^1.30.1",
@@ -73,7 +74,6 @@
     "@opentelemetry/instrumentation-connect": "0.43.1",
     "@opentelemetry/instrumentation-dataloader": "0.16.1",
     "@opentelemetry/instrumentation-express": "0.47.1",
-    "@opentelemetry/instrumentation-fastify": "0.44.2",
     "@opentelemetry/instrumentation-fs": "0.19.1",
     "@opentelemetry/instrumentation-generic-pool": "0.43.1",
     "@opentelemetry/instrumentation-graphql": "0.47.1",
@@ -96,8 +96,8 @@
     "@opentelemetry/sdk-trace-base": "^1.30.1",
     "@opentelemetry/semantic-conventions": "^1.30.0",
     "@prisma/instrumentation": "6.7.0",
-    "@sentry/core": "9.16.1",
-    "@sentry/opentelemetry": "9.16.1",
+    "@sentry/core": "9.17.0",
+    "@sentry/opentelemetry": "9.17.0",
     "import-in-the-middle": "^1.13.0"
   },
   "devDependencies": {

package/build/cjs/integrations/tracing/fastify.js

@@ -1,160 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const instrumentationFastify = require('@opentelemetry/instrumentation-fastify');
-const core = require('@sentry/core');
-const instrument = require('../../otel/instrument.js');
-const ensureIsWrapped = require('../../utils/ensureIsWrapped.js');
-
-/**
- * Minimal request type containing properties around route information.
- * Works for Fastify 3, 4 and presumably 5.
- *
- * Based on https://github.com/fastify/fastify/blob/ce3811f5f718be278bbcd4392c615d64230065a6/types/request.d.ts
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-const INTEGRATION_NAME = 'Fastify';
-
-const instrumentFastify = instrument.generateInstrumentOnce(
-  INTEGRATION_NAME,
-  () =>
-    // eslint-disable-next-line deprecation/deprecation
-    new instrumentationFastify.FastifyInstrumentation({
-      requestHook(span) {
-        addFastifySpanAttributes(span);
-      },
-    }),
-);
-
-const _fastifyIntegration = (() => {
-  return {
-    name: INTEGRATION_NAME,
-    setupOnce() {
-      instrumentFastify();
-    },
-  };
-}) ;
-
-/**
- * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
- *
- * If you also want to capture errors, you need to call `setupFastifyErrorHandler(app)` after you set up your Fastify server.
- *
- * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *   integrations: [Sentry.fastifyIntegration()],
- * })
- * ```
- */
-const fastifyIntegration = core.defineIntegration(_fastifyIntegration);
-
-/**
- * Default function to determine if an error should be sent to Sentry
- *
- * 3xx and 4xx errors are not sent by default.
- */
-function defaultShouldHandleError(_error, _request, reply) {
-  const statusCode = reply.statusCode;
-  // 3xx and 4xx errors are not sent by default.
-  return statusCode >= 500 || statusCode <= 299;
-}
-
-/**
- * Add an Fastify error handler to capture errors to Sentry.
- *
- * @param fastify The Fastify instance to which to add the error handler
- * @param options Configuration options for the handler
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- * const Fastify = require("fastify");
- *
- * const app = Fastify();
- *
- * Sentry.setupFastifyErrorHandler(app);
- *
- * // Add your routes, etc.
- *
- * app.listen({ port: 3000 });
- * ```
- */
-function setupFastifyErrorHandler(fastify, options) {
-  const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError;
-
-  const plugin = Object.assign(
-    function (fastify, _options, done) {
-      fastify.addHook('onError', async (request, reply, error) => {
-        if (shouldHandleError(error, request, reply)) {
-          core.captureException(error);
-        }
-      });
-
-      // registering `onRequest` hook here instead of using Otel `onRequest` callback b/c `onRequest` hook
-      // is ironically called in the fastify `preHandler` hook which is called later in the lifecycle:
-      // https://fastify.dev/docs/latest/Reference/Lifecycle/
-      fastify.addHook('onRequest', async (request, _reply) => {
-        // Taken from Otel Fastify instrumentation:
-        // https://github.com/open-telemetry/opentelemetry-js-contrib/blob/main/plugins/node/opentelemetry-instrumentation-fastify/src/instrumentation.ts#L94-L96
-        const routeName = request.routeOptions?.url || request.routerPath;
-        const method = request.method || 'GET';
-
-        core.getIsolationScope().setTransactionName(`${method} ${routeName}`);
-      });
-
-      done();
-    },
-    {
-      [Symbol.for('skip-override')]: true,
-      [Symbol.for('fastify.display-name')]: 'sentry-fastify-error-handler',
-    },
-  );
-
-  fastify.register(plugin);
-
-  // Sadly, middleware spans do not go through `requestHook`, so we handle those here
-  // We register this hook in this method, because if we register it in the integration `setup`,
-  // it would always run even for users that are not even using fastify
-  const client = core.getClient();
-  if (client) {
-    client.on('spanStart', span => {
-      addFastifySpanAttributes(span);
-    });
-  }
-
-  ensureIsWrapped.ensureIsWrapped(fastify.addHook, 'fastify');
-}
-
-function addFastifySpanAttributes(span) {
-  const attributes = core.spanToJSON(span).data;
-
-  // this is one of: middleware, request_handler
-  const type = attributes['fastify.type'];
-
-  // If this is already set, or we have no fastify span, no need to process again...
-  if (attributes[core.SEMANTIC_ATTRIBUTE_SENTRY_OP] || !type) {
-    return;
-  }
-
-  span.setAttributes({
-    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.fastify',
-    [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.fastify`,
-  });
-
-  // Also update the name, we don't need to "middleware - " prefix
-  const name = attributes['fastify.name'] || attributes['plugin.name'] || attributes['hook.name'];
-  if (typeof name === 'string') {
-    // Also remove `fastify -> ` prefix
-    span.updateName(name.replace(/^fastify -> /, ''));
-  }
-}
-
-exports.fastifyIntegration = fastifyIntegration;
-exports.instrumentFastify = instrumentFastify;
-exports.setupFastifyErrorHandler = setupFastifyErrorHandler;
-//# sourceMappingURL=fastify.js.map

package/build/cjs/integrations/tracing/fastify.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fastify.js","sources":["../../../../src/integrations/tracing/fastify.ts"],"sourcesContent":["import { FastifyInstrumentation } from '@opentelemetry/instrumentation-fastify';\nimport type { IntegrationFn, Span } from '@sentry/core';\nimport {\n  captureException,\n  defineIntegration,\n  getClient,\n  getIsolationScope,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  spanToJSON,\n} from '@sentry/core';\nimport { generateInstrumentOnce } from '../../otel/instrument';\nimport { ensureIsWrapped } from '../../utils/ensureIsWrapped';\n\n/**\n * Minimal request type containing properties around route information.\n * Works for Fastify 3, 4 and presumably 5.\n *\n * Based on https://github.com/fastify/fastify/blob/ce3811f5f718be278bbcd4392c615d64230065a6/types/request.d.ts\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ninterface MinimalFastifyRequest extends Record<string, any> {\n  method?: string;\n  // since fastify@4.10.0\n  routeOptions?: {\n    url?: string;\n  };\n  routerPath?: string;\n}\n\n/**\n * Minimal reply type containing properties needed for error handling.\n *\n * Based on https://github.com/fastify/fastify/blob/ce3811f5f718be278bbcd4392c615d64230065a6/types/reply.d.ts\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ninterface MinimalFastifyReply extends Record<string, any> {\n  statusCode: number;\n}\n\n// We inline the types we care about here\ninterface Fastify {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  register: (plugin: any) => void;\n  addHook: (hook: string, handler: (...params: unknown[]) => void) => void;\n}\n\ninterface FastifyWithHooks extends Omit<Fastify, 'addHook'> {\n  addHook(\n    hook: 'onError',\n    handler: (request: MinimalFastifyRequest, reply: MinimalFastifyReply, error: Error) => void,\n  ): void;\n  addHook(hook: 'onRequest', handler: (request: MinimalFastifyRequest, reply: MinimalFastifyReply) => void): void;\n}\n\ninterface FastifyHandlerOptions {\n  /**\n   * Callback method deciding whether error should be captured and sent to Sentry\n   *\n   * @param error Captured Fastify error\n   * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)\n   * @param reply Fastify reply (or any object containing at least statusCode)\n   *\n   * @example\n   *\n   * ```javascript\n   * setupFastifyErrorHandler(app, {\n   *   shouldHandleError(_error, _request, reply) {\n   *     return reply.statusCode >= 400;\n   *   },\n   * });\n   * ```\n   *\n   * If using TypeScript, you can cast the request and reply to get full type safety.\n   *\n   * ```typescript\n   * import type { FastifyRequest, FastifyReply } from 'fastify';\n   *\n   * setupFastifyErrorHandler(app, {\n   *   shouldHandleError(error, minimalRequest, minimalReply) {\n   *     const request = minimalRequest as FastifyRequest;\n   *     const reply = minimalReply as FastifyReply;\n   *     return reply.statusCode >= 500;\n   *   },\n   * });\n   * ```\n   */\n  shouldHandleError: (error: Error, request: MinimalFastifyRequest, reply: MinimalFastifyReply) => boolean;\n}\n\nconst INTEGRATION_NAME = 'Fastify';\n\nexport const instrumentFastify = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () =>\n    // eslint-disable-next-line deprecation/deprecation\n    new FastifyInstrumentation({\n      requestHook(span) {\n        addFastifySpanAttributes(span);\n      },\n    }),\n);\n\nconst _fastifyIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentFastify();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).\n *\n * If you also want to capture errors, you need to call `setupFastifyErrorHandler(app)` after you set up your Fastify server.\n *\n * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.fastifyIntegration()],\n * })\n * ```\n */\nexport const fastifyIntegration = defineIntegration(_fastifyIntegration);\n\n/**\n * Default function to determine if an error should be sent to Sentry\n *\n * 3xx and 4xx errors are not sent by default.\n */\nfunction defaultShouldHandleError(_error: Error, _request: MinimalFastifyRequest, reply: MinimalFastifyReply): boolean {\n  const statusCode = reply.statusCode;\n  // 3xx and 4xx errors are not sent by default.\n  return statusCode >= 500 || statusCode <= 299;\n}\n\n/**\n * Add an Fastify error handler to capture errors to Sentry.\n *\n * @param fastify The Fastify instance to which to add the error handler\n * @param options Configuration options for the handler\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const Fastify = require(\"fastify\");\n *\n * const app = Fastify();\n *\n * Sentry.setupFastifyErrorHandler(app);\n *\n * // Add your routes, etc.\n *\n * app.listen({ port: 3000 });\n * ```\n */\nexport function setupFastifyErrorHandler(fastify: Fastify, options?: Partial<FastifyHandlerOptions>): void {\n  const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError;\n\n  const plugin = Object.assign(\n    function (fastify: FastifyWithHooks, _options: unknown, done: () => void): void {\n      fastify.addHook('onError', async (request, reply, error) => {\n        if (shouldHandleError(error, request, reply)) {\n          captureException(error);\n        }\n      });\n\n      // registering `onRequest` hook here instead of using Otel `onRequest` callback b/c `onRequest` hook\n      // is ironically called in the fastify `preHandler` hook which is called later in the lifecycle:\n      // https://fastify.dev/docs/latest/Reference/Lifecycle/\n      fastify.addHook('onRequest', async (request, _reply) => {\n        // Taken from Otel Fastify instrumentation:\n        // https://github.com/open-telemetry/opentelemetry-js-contrib/blob/main/plugins/node/opentelemetry-instrumentation-fastify/src/instrumentation.ts#L94-L96\n        const routeName = request.routeOptions?.url || request.routerPath;\n        const method = request.method || 'GET';\n\n        getIsolationScope().setTransactionName(`${method} ${routeName}`);\n      });\n\n      done();\n    },\n    {\n      [Symbol.for('skip-override')]: true,\n      [Symbol.for('fastify.display-name')]: 'sentry-fastify-error-handler',\n    },\n  );\n\n  fastify.register(plugin);\n\n  // Sadly, middleware spans do not go through `requestHook`, so we handle those here\n  // We register this hook in this method, because if we register it in the integration `setup`,\n  // it would always run even for users that are not even using fastify\n  const client = getClient();\n  if (client) {\n    client.on('spanStart', span => {\n      addFastifySpanAttributes(span);\n    });\n  }\n\n  ensureIsWrapped(fastify.addHook, 'fastify');\n}\n\nfunction addFastifySpanAttributes(span: Span): void {\n  const attributes = spanToJSON(span).data;\n\n  // this is one of: middleware, request_handler\n  const type = attributes['fastify.type'];\n\n  // If this is already set, or we have no fastify span, no need to process again...\n  if (attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] || !type) {\n    return;\n  }\n\n  span.setAttributes({\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.fastify',\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.fastify`,\n  });\n\n  // Also update the name, we don't need to \"middleware - \" prefix\n  const name = attributes['fastify.name'] || attributes['plugin.name'] || attributes['hook.name'];\n  if (typeof name === 'string') {\n    // Also remove `fastify -> ` prefix\n    span.updateName(name.replace(/^fastify -> /, ''));\n  }\n}\n"],"names":["generateInstrumentOnce","FastifyInstrumentation","defineIntegration","captureException","getIsolationScope","getClient","ensureIsWrapped","spanToJSON","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN"],"mappings":"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"}