@sentry/node 9.39.0 → 9.41.0

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

@@ -1,6 +1,40 @@
 import { Instrumentation, InstrumentationConfig } from '@opentelemetry/instrumentation';
 import { FastifyInstance, FastifyReply, FastifyRequest } from './types';
 import { FastifyInstrumentationV3 } from './v3/instrumentation';
+/**
+ * Options for the Fastify integration.
+ *
+ * `shouldHandleError` - Callback method deciding whether error should be captured and sent to Sentry
+ * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.
+ * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.
+ *
+ * @example
+ *
+ * ```javascript
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.fastifyIntegration({
+ *       shouldHandleError(_error, _request, reply) {
+ *         return reply.statusCode >= 500;
+ *       },
+ *     });
+ *   },
+ * });
+ * ```
+ *
+ */
+interface FastifyIntegrationOptions {
+    /**
+     * Callback method deciding whether error should be captured and sent to Sentry
+     * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.
+     * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.
+     *
+     * @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)
+     */
+    shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;
+}
 interface FastifyHandlerOptions {
     /**
      * Callback method deciding whether error should be captured and sent to Sentry
@@ -11,6 +45,7 @@ interface FastifyHandlerOptions {
      *
      * @example
      *
+     *
      * ```javascript
      * setupFastifyErrorHandler(app, {
      *   shouldHandleError(_error, _request, reply) {
@@ -19,6 +54,7 @@ interface FastifyHandlerOptions {
      * });
      * ```
      *
+     *
      * If using TypeScript, you can cast the request and reply to get full type safety.
      *
      * ```typescript
@@ -38,7 +74,7 @@ interface FastifyHandlerOptions {
 export declare const instrumentFastifyV3: ((options?: unknown) => FastifyInstrumentationV3) & {
     id: string;
 };
-export declare const instrumentFastify: ((options?: unknown) => Instrumentation<InstrumentationConfig & FastifyHandlerOptions>) & {
+export declare const instrumentFastify: ((options?: unknown) => Instrumentation<InstrumentationConfig & FastifyIntegrationOptions>) & {
     id: string;
 };
 /**
@@ -57,7 +93,7 @@ export declare const instrumentFastify: ((options?: unknown) => Instrumentation<
  * })
  * ```
  */
-export declare const fastifyIntegration: () => import("@sentry/core").Integration;
+export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => import("@sentry/core").Integration;
 /**
  * Add an Fastify error handler to capture errors to Sentry.
  *

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

@@ -0,0 +1,60 @@
+import { OpenAiOptions } from '@sentry/core';
+import { SentryOpenAiInstrumentation } from './instrumentation';
+export declare const instrumentOpenAi: ((options?: unknown) => SentryOpenAiInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the OpenAI SDK.
+ *
+ * This integration is enabled by default.
+ *
+ * When configured, this integration automatically instruments OpenAI SDK client instances
+ * to capture telemetry data following OpenTelemetry Semantic Conventions for Generative AI.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.openAIIntegration()],
+ * });
+ * ```
+ *
+ * ## Options
+ *
+ * - `recordInputs`: Whether to record prompt messages (default: respects `sendDefaultPii` client option)
+ * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ *
+ * ### Default Behavior
+ *
+ * By default, the integration will:
+ * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
+ * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
+ *
+ * @example
+ * ```javascript
+ * // Record inputs and outputs when sendDefaultPii is false
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.openAIIntegration({
+ *       recordInputs: true,
+ *       recordOutputs: true
+ *     })
+ *   ],
+ * });
+ *
+ * // Never record inputs/outputs regardless of sendDefaultPii
+ * Sentry.init({
+ *   sendDefaultPii: true,
+ *   integrations: [
+ *     Sentry.openAIIntegration({
+ *       recordInputs: false,
+ *       recordOutputs: false
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ */
+export declare const openAIIntegration: (options?: OpenAiOptions | undefined) => import("@sentry/core").Integration;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,20 @@
+import { InstrumentationConfig, InstrumentationModuleDefinition, InstrumentationBase } from '@opentelemetry/instrumentation';
+import { Integration, OpenAiOptions } from '@sentry/core';
+export interface OpenAiIntegration extends Integration {
+    options: OpenAiOptions;
+}
+/**
+ * Sentry OpenAI instrumentation using OpenTelemetry.
+ */
+export declare class SentryOpenAiInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
+    /**
+     * Initializes the instrumentation by defining the modules to be patched.
+     */
+    init(): InstrumentationModuleDefinition;
+    /**
+     * Core patch logic applying instrumentation to the OpenAI client constructor.
+     */
+    private _patch;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/node",
-  "version": "9.39.0",
+  "version": "9.41.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",
@@ -95,9 +95,9 @@
     "@opentelemetry/sdk-trace-base": "^1.30.1",
     "@opentelemetry/semantic-conventions": "^1.34.0",
     "@prisma/instrumentation": "6.11.1",
-    "@sentry/core": "9.39.0",
-    "@sentry/node-core": "9.39.0",
-    "@sentry/opentelemetry": "9.39.0",
+    "@sentry/core": "9.41.0",
+    "@sentry/node-core": "9.41.0",
+    "@sentry/opentelemetry": "9.41.0",
     "import-in-the-middle": "^1.14.2",
     "minimatch": "^9.0.0"
   },