@sentry/node 9.16.0 → 9.17.0

package/build/{types-ts3.8/integrations/tracing/fastify.d.ts → types/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 type { Instrumentation, InstrumentationConfig } from '@opentelemetry/instrumentation';
+import type { 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/integrations/tracing/fastify/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/fastify/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAc7F,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,UAAU,qBAAqB;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC;CAC5F;AAKD,eAAO,MAAM,mBAAmB;;CAAoF,CAAC;AAErH,eAAO,MAAM,iBAAiB;;CAuB5B,CAAC;AAYH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,0CAAyC,CAAC;AAazE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG,IAAI,CAqBjH"}

package/build/types/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/integrations/tracing/fastify/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/fastify/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,CAAC,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,uBAAuB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,GAChG,CAAC,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,uBAAuB,KAAK,IAAI,CAAC,CAAC;AAE5F,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC;AAE/B,MAAM,MAAM,uBAAuB,GAAG,CAAC,MAAM,SAAS,KAAK,GAAG,YAAY,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAElG,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC;AAEpC,MAAM,MAAM,aAAa,GAAG,CAC1B,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,GAAG,EACT,IAAI,EAAE,uBAAuB,KAC1B,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,eAAe,CAAC;IAC3C,KAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,KAAK,eAAe,CAAC;IAC5D,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,eAAe,CAAC;IACjE,OAAO,CACL,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,GAC5E,eAAe,CAAC;IACnB,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,eAAe,CAAC;CAC9G;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,YAAY,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,YAAY,CAAC,EAAE;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/build/types/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/integrations/tracing/fastify/v3/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/fastify/v3/constants.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,iBAAiB,eAAsE,CAAC;AAMrG,eAAO,MAAM,gBAAgB,aAU3B,CAAC"}

package/build/types/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/integrations/tracing/fastify/v3/enums/AttributeNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeNames.d.ts","sourceRoot":"","sources":["../../../../../../../src/integrations/tracing/fastify/v3/enums/AttributeNames.ts"],"names":[],"mappings":"AAkBA,oBAAY,cAAc;IACxB,YAAY,iBAAiB;IAC7B,YAAY,iBAAiB;IAC7B,SAAS,cAAc;IACvB,WAAW,gBAAgB;CAC5B;AAED,oBAAY,YAAY;IACtB,UAAU,eAAe;IACzB,eAAe,oBAAoB;CACpC;AAED,oBAAY,YAAY;IACtB,UAAU,eAAe;IACzB,eAAe,oBAAoB;CACpC"}

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

@@ -0,0 +1,16 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import type { 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/integrations/tracing/fastify/v3/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/fastify/v3/instrumentation.ts"],"names":[],"mappings":"AAwBA,OAAO,EACL,mBAAmB,EACnB,mCAAmC,EAEpC,MAAM,gCAAgC,CAAC;AAoBxC,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAyB5D;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,mBAAmB,CAAC,4BAA4B,CAAC;gBAC1E,MAAM,GAAE,4BAAiC;IAIrD,IAAI,IAAI,mCAAmC,EAAE;IAQpD,OAAO,CAAC,cAAc;IA0BtB,OAAO,CAAC,YAAY;IAwDpB,OAAO,CAAC,YAAY;IAyBpB,OAAO,CAAC,iBAAiB;IA0BzB,OAAO,CAAC,UAAU;IA4BlB,OAAO,CAAC,eAAe;CA+CxB"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal-types.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/fastify/v3/internal-types.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG;IAC9C,CAAC,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;CAC9B,CAAC"}

package/build/types/integrations/tracing/fastify/v3/types.d.ts

@@ -0,0 +1,21 @@
+import type { Span } from '@opentelemetry/api';
+import type { 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/integrations/tracing/fastify/v3/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/fastify/v3/types.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAE5E,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,GAAG,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,8BAA8B;IAC7C,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAAQ,qBAAqB;IACzE,iEAAiE;IACjE,WAAW,CAAC,EAAE,8BAA8B,CAAC;CAC9C"}

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

@@ -0,0 +1,28 @@
+import { type Attributes, type Span, type Tracer } from '@opentelemetry/api';
+import type { 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/build/types/integrations/tracing/fastify/v3/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/fastify/v3/utils.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,KAAK,MAAM,EAAkB,MAAM,oBAAoB,CAAC;AAE7F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,cAAc,GAAE,UAAe,QAehC;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,CAAC,EAAE,GAAG,QAkB3D;AAKD;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAAC,CAAC,EAClD,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,QAAQ,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,EAC1C,oBAAoB,CAAC,EAAE,OAAO,GAC7B,OAAO,CAAC,CAAC,CAAC,CAAC;AACd,wBAAgB,kCAAkC,CAAC,CAAC,EAClD,OAAO,EAAE,MAAM,CAAC,EAChB,QAAQ,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,EAC1C,oBAAoB,CAAC,EAAE,OAAO,GAC7B,CAAC,CAAC"}

package/build/types/integrations/tracing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAsBhD;;GAEG;AACH,wBAAgB,8BAA8B,IAAI,WAAW,EAAE,CAsB9D;AAED;;GAEG;AAEH,wBAAgB,wCAAwC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,CAwBzG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAsBhD;;GAEG;AACH,wBAAgB,8BAA8B,IAAI,WAAW,EAAE,CAsB9D;AAED;;GAEG;AAEH,wBAAgB,wCAAwC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,CAyBzG"}

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