@depup/sentry__node 10.44.0-depup.0

package/build/types/integrations/tracing/hono/types.d.ts

@@ -0,0 +1,36 @@
+export type HonoRequest = {
+    path: string;
+    method: string;
+};
+export type Context = {
+    req: HonoRequest;
+    res: Response;
+    error: Error | undefined;
+};
+export type Next = () => Promise<void>;
+export type Handler = (c: Context, next: Next) => Promise<Response> | Response;
+export type MiddlewareHandler = (c: Context, next: Next) => Promise<Response | void>;
+export type HandlerInterface = {
+    (...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
+    (path: string, ...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
+};
+export type OnHandlerInterface = {
+    (method: string | string[], path: string | string[], ...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
+};
+export type MiddlewareHandlerInterface = {
+    (...handlers: MiddlewareHandler[]): HonoInstance;
+    (path: string, ...handlers: MiddlewareHandler[]): HonoInstance;
+};
+export interface HonoInstance {
+    get: HandlerInterface;
+    post: HandlerInterface;
+    put: HandlerInterface;
+    delete: HandlerInterface;
+    options: HandlerInterface;
+    patch: HandlerInterface;
+    all: HandlerInterface;
+    on: OnHandlerInterface;
+    use: MiddlewareHandlerInterface;
+}
+export type Hono = new (...args: unknown[]) => HonoInstance;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/hono/types.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF,MAAM,MAAM,OAAO,GAAG;IACpB,GAAG,EAAE,WAAW,CAAC;IACjB,GAAG,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;CAC1B,CAAC;AAGF,MAAM,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAGvC,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;AAG/E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC;AAGrF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,GAAG,QAAQ,EAAE,CAAC,OAAO,GAAG,iBAAiB,CAAC,EAAE,GAAG,YAAY,CAAC;IAC7D,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,CAAC,OAAO,GAAG,iBAAiB,CAAC,EAAE,GAAG,YAAY,CAAC;CAC5E,CAAC;AAGF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,QAAQ,EAAE,CAAC,OAAO,GAAG,iBAAiB,CAAC,EAAE,GAAG,YAAY,CAAC;CAClH,CAAC;AAGF,MAAM,MAAM,0BAA0B,GAAG;IACvC,CAAC,GAAG,QAAQ,EAAE,iBAAiB,EAAE,GAAG,YAAY,CAAC;IACjD,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,iBAAiB,EAAE,GAAG,YAAY,CAAC;CAChE,CAAC;AAGF,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,gBAAgB,CAAC;IACtB,IAAI,EAAE,gBAAgB,CAAC;IACvB,GAAG,EAAE,gBAAgB,CAAC;IACtB,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,KAAK,EAAE,gBAAgB,CAAC;IACxB,GAAG,EAAE,gBAAgB,CAAC;IACtB,EAAE,EAAE,kBAAkB,CAAC;IACvB,GAAG,EAAE,0BAA0B,CAAC;CACjC;AAED,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,YAAY,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { Integration } from '@sentry/core';
+/**
+ * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.
+ */
+export declare function getAutoPerformanceIntegrations(): Integration[];
+/**
+ * Get a list of methods to instrument OTEL, when preload instrumentation.
+ */
+export declare function getOpenTelemetryInstrumentationToPreload(): (((options?: any) => void) & {
+    id: string;
+})[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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;AA8BhD;;GAEG;AACH,wBAAgB,8BAA8B,IAAI,WAAW,EAAE,CAgC9D;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,CAiCzG"}

package/build/types/integrations/tracing/kafka.d.ts

@@ -0,0 +1,19 @@
+import { KafkaJsInstrumentation } from '@opentelemetry/instrumentation-kafkajs';
+export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [kafkajs](https://www.npmjs.com/package/kafkajs) library.
+ *
+ * For more information, see the [`kafkaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/kafka/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.kafkaIntegration()],
+ * });
+ */
+export declare const kafkaIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=kafka.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/kafka.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAOhF,eAAO,MAAM,eAAe;;CAW3B,CAAC;AAWF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,0CAAuC,CAAC"}

package/build/types/integrations/tracing/knex.d.ts

@@ -0,0 +1,20 @@
+import { KnexInstrumentation } from '@opentelemetry/instrumentation-knex';
+export declare const instrumentKnex: ((options?: unknown) => KnexInstrumentation) & {
+    id: string;
+};
+/**
+ * Knex integration
+ *
+ * Capture tracing data for [Knex](https://knexjs.org/).
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.knexIntegration()],
+ * });
+ * ```
+ */
+export declare const knexIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=knex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"knex.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/knex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAO1E,eAAO,MAAM,cAAc;;CAG1B,CAAC;AA2BF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,0CAAsC,CAAC"}

package/build/types/integrations/tracing/koa.d.ts

@@ -0,0 +1,70 @@
+import { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';
+interface KoaOptions {
+    /**
+     * Ignore layers of specified types
+     */
+    ignoreLayersType?: Array<'middleware' | 'router'>;
+}
+export declare const instrumentKoa: ((options: KoaOptions | undefined) => KoaInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for [Koa](https://koajs.com/).
+ *
+ * If you also want to capture errors, you need to call `setupKoaErrorHandler(app)` after you set up your Koa server.
+ *
+ * For more information, see the [koa documentation](https://docs.sentry.io/platforms/javascript/guides/koa/).
+ *
+ * @param {KoaOptions} options Configuration options for the Koa integration.
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.koaIntegration()],
+ * })
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // To ignore middleware spans
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.koaIntegration({
+ *       ignoreLayersType: ['middleware']
+ *     })
+ *   ],
+ * })
+ * ```
+ */
+export declare const koaIntegration: (options?: KoaOptions | undefined) => import("@sentry/core").Integration;
+/**
+ * Add an Koa error handler to capture errors to Sentry.
+ *
+ * The error handler must be before any other middleware and after all controllers.
+ *
+ * @param app The Express instances
+ * @param options {ExpressHandlerOptions} Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Koa = require("koa");
+ *
+ * const app = new Koa();
+ *
+ * Sentry.setupKoaErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ *
+ * app.listen(3000);
+ * ```
+ */
+export declare const setupKoaErrorHandler: (app: {
+    use: (arg0: (ctx: any, next: any) => Promise<void>) => void;
+}) => void;
+export {};
+//# sourceMappingURL=koa.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"koa.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/koa.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAexE,UAAU,UAAU;IAClB;;OAEG;IACH,gBAAgB,CAAC,EAAE,KAAK,CAAC,YAAY,GAAG,QAAQ,CAAC,CAAC;CACnD;AAID,eAAO,MAAM,aAAa;;CAsCzB,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,cAAc,0EAAqC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,eAAO,MAAM,oBAAoB,GAAI,KAAK;IAAE,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAA;CAAE,KAAG,IAgB3G,CAAC"}

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

@@ -0,0 +1,97 @@
+import type { LangChainOptions } from '@sentry/core';
+export declare const instrumentLangChain: ((options?: LangChainOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for LangChain.
+ *
+ * This integration is enabled by default.
+ *
+ * When configured, this integration automatically instruments LangChain runnable instances
+ * to capture telemetry data by injecting Sentry callback handlers into all LangChain calls.
+ *
+ * **Important:** This integration automatically skips wrapping the OpenAI, Anthropic, and Google GenAI
+ * providers to prevent duplicate spans when using LangChain with these AI providers.
+ * LangChain handles the instrumentation for all underlying AI providers.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.langChainIntegration()],
+ *   sendDefaultPii: true, // Enable to record inputs/outputs
+ * });
+ *
+ * // LangChain calls are automatically instrumented
+ * const model = new ChatOpenAI();
+ * await model.invoke("What is the capital of France?");
+ * ```
+ *
+ * ## Manual Callback Handler
+ *
+ * You can also manually add the Sentry callback handler alongside other callbacks:
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const sentryHandler = Sentry.createLangChainCallbackHandler({
+ *   recordInputs: true,
+ *   recordOutputs: true
+ * });
+ *
+ * const model = new ChatOpenAI();
+ * await model.invoke(
+ *   "What is the capital of France?",
+ *   { callbacks: [sentryHandler, myOtherCallback] }
+ * );
+ * ```
+ *
+ * ## Options
+ *
+ * - `recordInputs`: Whether to record input messages/prompts (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.langChainIntegration({
+ *       recordInputs: true,
+ *       recordOutputs: true
+ *     })
+ *   ],
+ * });
+ *
+ * // Never record inputs/outputs regardless of sendDefaultPii
+ * Sentry.init({
+ *   sendDefaultPii: true,
+ *   integrations: [
+ *     Sentry.langChainIntegration({
+ *       recordInputs: false,
+ *       recordOutputs: false
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ * ## Supported Events
+ *
+ * The integration captures the following LangChain lifecycle events:
+ * - LLM/Chat Model: start, end, error
+ * - Chain: start, end, error
+ * - Tool: start, end, error
+ *
+ */
+export declare const langChainIntegration: (options?: LangChainOptions | undefined) => import("@sentry/core").Integration;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langchain/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKpE,eAAO,MAAM,mBAAmB;;CAG/B,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AACH,eAAO,MAAM,oBAAoB,gFAA2C,CAAC"}

package/build/types/integrations/tracing/langchain/instrumentation.d.ts

@@ -0,0 +1,29 @@
+import { InstrumentationBase, type InstrumentationConfig, type InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+import type { LangChainOptions } from '@sentry/core';
+type LangChainInstrumentationOptions = InstrumentationConfig & LangChainOptions;
+/**
+ * Sentry LangChain instrumentation using OpenTelemetry.
+ */
+export declare class SentryLangChainInstrumentation extends InstrumentationBase<LangChainInstrumentationOptions> {
+    constructor(config?: LangChainInstrumentationOptions);
+    /**
+     * Initializes the instrumentation by defining the modules to be patched.
+     * We patch the BaseChatModel class methods to inject callbacks
+     *
+     * We hook into provider packages (@langchain/anthropic, @langchain/openai, etc.)
+     * because @langchain/core is often bundled and not loaded as a separate module
+     */
+    init(): InstrumentationModuleDefinition | InstrumentationModuleDefinition[];
+    /**
+     * Core patch logic - patches chat model methods to inject Sentry callbacks
+     * This is called when a LangChain provider package is loaded
+     */
+    private _patch;
+    /**
+     * Patches chat model methods (invoke, stream, batch) to inject Sentry callbacks
+     * Finds a chat model class from the provider package exports and patches its prototype methods
+     */
+    private _patchRunnableMethods;
+}
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map

package/build/types/integrations/tracing/langchain/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langchain/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EAGrC,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAYrD,KAAK,+BAA+B,GAAG,qBAAqB,GAAG,gBAAgB,CAAC;AA0EhF;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,mBAAmB,CAAC,+BAA+B,CAAC;gBACnF,MAAM,GAAE,+BAAoC;IAI/D;;;;;;OAMG;IACI,IAAI,IAAI,+BAA+B,GAAG,+BAA+B,EAAE;IA0DlF;;;OAGG;IACH,OAAO,CAAC,MAAM;IAmBd;;;OAGG;IACH,OAAO,CAAC,qBAAqB;CA8C9B"}

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

@@ -0,0 +1,74 @@
+import type { LangGraphOptions } from '@sentry/core';
+export declare const instrumentLangGraph: ((options?: LangGraphOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for LangGraph.
+ *
+ * This integration is enabled by default.
+ *
+ * When configured, this integration automatically instruments LangGraph StateGraph and compiled graph instances
+ * to capture telemetry data following OpenTelemetry Semantic Conventions for Generative AI.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.langGraphIntegration()],
+ * });
+ * ```
+ *
+ * ## Options
+ *
+ * - `recordInputs`: Whether to record input 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.langGraphIntegration({
+ *       recordInputs: true,
+ *       recordOutputs: true
+ *     })
+ *   ],
+ * });
+ *
+ * // Never record inputs/outputs regardless of sendDefaultPii
+ * Sentry.init({
+ *   sendDefaultPii: true,
+ *   integrations: [
+ *     Sentry.langGraphIntegration({
+ *       recordInputs: false,
+ *       recordOutputs: false
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ * ## Captured Operations
+ *
+ * The integration captures the following LangGraph operations:
+ * - **Agent Creation** (`StateGraph.compile()`) - Creates a `gen_ai.create_agent` span
+ * - **Agent Invocation** (`CompiledGraph.invoke()`) - Creates a `gen_ai.invoke_agent` span
+ *
+ * ## Captured Data
+ *
+ * When `recordInputs` and `recordOutputs` are enabled, the integration captures:
+ * - Input messages from the graph state
+ * - Output messages and LLM responses
+ * - Tool calls made during agent execution
+ * - Agent and graph names
+ * - Available tools configured in the graph
+ *
+ */
+export declare const langGraphIntegration: (options?: LangGraphOptions | undefined) => import("@sentry/core").Integration;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langgraph/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKpE,eAAO,MAAM,mBAAmB;;CAG/B,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,oBAAoB,gFAA2C,CAAC"}

package/build/types/integrations/tracing/langgraph/instrumentation.d.ts

@@ -0,0 +1,19 @@
+import { InstrumentationBase, type InstrumentationConfig, type InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+import type { LangGraphOptions } from '@sentry/core';
+type LangGraphInstrumentationOptions = InstrumentationConfig & LangGraphOptions;
+/**
+ * Sentry LangGraph instrumentation using OpenTelemetry.
+ */
+export declare class SentryLangGraphInstrumentation extends InstrumentationBase<LangGraphInstrumentationOptions> {
+    constructor(config?: LangGraphInstrumentationOptions);
+    /**
+     * Initializes the instrumentation by defining the modules to be patched.
+     */
+    init(): InstrumentationModuleDefinition;
+    /**
+     * Core patch logic applying instrumentation to the LangGraph module.
+     */
+    private _patch;
+}
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map

package/build/types/integrations/tracing/langgraph/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langgraph/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EAGrC,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKrD,KAAK,+BAA+B,GAAG,qBAAqB,GAAG,gBAAgB,CAAC;AAUhF;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,mBAAmB,CAAC,+BAA+B,CAAC;gBACnF,MAAM,GAAE,+BAAoC;IAI/D;;OAEG;IACI,IAAI,IAAI,+BAA+B;IAwB9C;;OAEG;IACH,OAAO,CAAC,MAAM;CAWf"}

package/build/types/integrations/tracing/lrumemoizer.d.ts

@@ -0,0 +1,19 @@
+import { LruMemoizerInstrumentation } from '@opentelemetry/instrumentation-lru-memoizer';
+export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [lru-memoizer](https://www.npmjs.com/package/lru-memoizer) library.
+ *
+ * For more information, see the [`lruMemoizerIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/lrumemoizer/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.lruMemoizerIntegration()],
+ * });
+ */
+export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=lrumemoizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lrumemoizer.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/lrumemoizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,6CAA6C,CAAC;AAOzF,eAAO,MAAM,qBAAqB;;CAAmF,CAAC;AAWtH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,0CAA6C,CAAC"}

package/build/types/integrations/tracing/mongo.d.ts

@@ -0,0 +1,24 @@
+import { MongoDBInstrumentation } from '@opentelemetry/instrumentation-mongodb';
+export declare const instrumentMongo: ((options?: unknown) => MongoDBInstrumentation) & {
+    id: string;
+};
+/**
+ * Replaces values in document with '?', hiding PII and helping grouping.
+ */
+export declare function _defaultDbStatementSerializer(commandObj: Record<string, unknown>): string;
+/**
+ * Adds Sentry tracing instrumentation for the [mongodb](https://www.npmjs.com/package/mongodb) library.
+ *
+ * For more information, see the [`mongoIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mongo/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mongoIntegration()],
+ * });
+ * ```
+ */
+export declare const mongoIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=mongo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mongo.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/mongo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAOhF,eAAO,MAAM,eAAe;;CAS3B,CAAC;AAEF;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAGzF;AAgDD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,0CAAuC,CAAC"}

package/build/types/integrations/tracing/mongoose.d.ts

@@ -0,0 +1,20 @@
+import { MongooseInstrumentation } from '@opentelemetry/instrumentation-mongoose';
+export declare const instrumentMongoose: ((options?: unknown) => MongooseInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [mongoose](https://www.npmjs.com/package/mongoose) library.
+ *
+ * For more information, see the [`mongooseIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mongoose/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mongooseIntegration()],
+ * });
+ * ```
+ */
+export declare const mongooseIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=mongoose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/mongoose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAOlF,eAAO,MAAM,kBAAkB;;CAQ9B,CAAC;AAWF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,0CAA0C,CAAC"}

package/build/types/integrations/tracing/mysql.d.ts

@@ -0,0 +1,20 @@
+import { MySQLInstrumentation } from '@opentelemetry/instrumentation-mysql';
+export declare const instrumentMysql: ((options?: unknown) => MySQLInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [mysql](https://www.npmjs.com/package/mysql) library.
+ *
+ * For more information, see the [`mysqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mysqlIntegration()],
+ * });
+ * ```
+ */
+export declare const mysqlIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=mysql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/mysql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAO5E,eAAO,MAAM,eAAe;;CAA+E,CAAC;AAW5G;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,0CAAuC,CAAC"}

package/build/types/integrations/tracing/mysql2.d.ts

@@ -0,0 +1,20 @@
+import { MySQL2Instrumentation } from '@opentelemetry/instrumentation-mysql2';
+export declare const instrumentMysql2: ((options?: unknown) => MySQL2Instrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [mysql2](https://www.npmjs.com/package/mysql2) library.
+ *
+ * For more information, see the [`mysql2Integration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql2/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mysqlIntegration()],
+ * });
+ * ```
+ */
+export declare const mysql2Integration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=mysql2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mysql2.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/mysql2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAO9E,eAAO,MAAM,gBAAgB;;CAQ5B,CAAC;AAWF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,0CAAwC,CAAC"}

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

@@ -0,0 +1,59 @@
+import type { OpenAiOptions } from '@sentry/core';
+export declare const instrumentOpenAi: ((options?: OpenAiOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    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/integrations/tracing/openai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/openai/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,aAAa,EAAE,MAAM,cAAc,CAAC;AAKjE,eAAO,MAAM,gBAAgB;;CAG5B,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,iBAAiB,6EAAwC,CAAC"}

package/build/types/integrations/tracing/openai/instrumentation.d.ts

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

package/build/types/integrations/tracing/openai/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/openai/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EAErC,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,WAAW,EAAgB,aAAa,EAAE,MAAM,cAAc,CAAC;AAU7E,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,OAAO,EAAE,aAAa,CAAC;CACxB;AAED,KAAK,4BAA4B,GAAG,qBAAqB,GAAG,aAAa,CAAC;AAW1E;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,mBAAmB,CAAC,4BAA4B,CAAC;gBAC7E,MAAM,GAAE,4BAAiC;IAI5D;;OAEG;IACI,IAAI,IAAI,+BAA+B;IAK9C;;OAEG;IACH,OAAO,CAAC,MAAM;IAOd;;OAEG;IACH,OAAO,CAAC,YAAY;CAgErB"}