@depup/sentry__node 10.44.0-depup.0

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

@@ -0,0 +1,74 @@
+import { 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-ts3.8/integrations/tracing/langgraph/instrumentation.d.ts

@@ -0,0 +1,19 @@
+import { InstrumentationBase, InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+import { 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-ts3.8/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-ts3.8/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-ts3.8/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-ts3.8/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-ts3.8/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-ts3.8/integrations/tracing/openai/index.d.ts

@@ -0,0 +1,59 @@
+import { 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-ts3.8/integrations/tracing/openai/instrumentation.d.ts

@@ -0,0 +1,26 @@
+import { InstrumentationBase, InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+import { 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-ts3.8/integrations/tracing/postgres.d.ts

@@ -0,0 +1,24 @@
+import { PgInstrumentation } from '@opentelemetry/instrumentation-pg';
+interface PostgresIntegrationOptions {
+    ignoreConnectSpans?: boolean;
+}
+export declare const instrumentPostgres: ((options: PostgresIntegrationOptions | undefined) => PgInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [pg](https://www.npmjs.com/package/pg) library.
+ *
+ * For more information, see the [`postgresIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/postgres/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.postgresIntegration()],
+ * });
+ * ```
+ */
+export declare const postgresIntegration: (options?: PostgresIntegrationOptions | undefined) => import("@sentry/core").Integration;
+export {};
+//# sourceMappingURL=postgres.d.ts.map

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

@@ -0,0 +1,101 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { Span } from '@sentry/core';
+type PostgresConnectionContext = {
+    ATTR_DB_NAMESPACE?: string;
+    ATTR_SERVER_ADDRESS?: string;
+    ATTR_SERVER_PORT?: string;
+};
+type PostgresJsInstrumentationConfig = InstrumentationConfig & {
+    /**
+     * Whether to require a parent span for the instrumentation.
+     * If set to true, the instrumentation will only create spans if there is a parent span
+     * available in the current scope.
+     * @default true
+     */
+    requireParentSpan?: boolean;
+    /**
+     * Hook to modify the span before it is started.
+     * This can be used to set additional attributes or modify the span in any way.
+     */
+    requestHook?: (span: Span, sanitizedSqlQuery: string, postgresConnectionContext?: PostgresConnectionContext) => void;
+};
+export declare const instrumentPostgresJs: ((options?: PostgresJsInstrumentationConfig | undefined) => PostgresJsInstrumentation) & {
+    id: string;
+};
+/**
+ * Instrumentation for the [postgres](https://www.npmjs.com/package/postgres) library.
+ * This instrumentation captures postgresjs queries and their attributes.
+ *
+ * Uses internal Sentry patching patterns to support both CommonJS and ESM environments.
+ */
+export declare class PostgresJsInstrumentation extends InstrumentationBase<PostgresJsInstrumentationConfig> {
+    constructor(config: PostgresJsInstrumentationConfig);
+    /**
+     * Initializes the instrumentation by patching the postgres module.
+     * Uses two complementary approaches:
+     * 1. Main function wrapper: instruments sql instances created AFTER instrumentation is set up (CJS + ESM)
+     * 2. Query.prototype patch: fallback for sql instances created BEFORE instrumentation (CJS only)
+     */
+    init(): InstrumentationNodeModuleDefinition;
+    /**
+     * Patches the postgres module by wrapping the main export function.
+     * This intercepts the creation of sql instances and instruments them.
+     */
+    private _patchPostgres;
+    /**
+     * Determines whether a span should be created based on the current context.
+     * If `requireParentSpan` is set to true in the configuration, a span will
+     * only be created if there is a parent span available.
+     */
+    private _shouldCreateSpans;
+    /**
+     * Extracts DB operation name from SQL query and sets it on the span.
+     */
+    private _setOperationName;
+    /**
+     * Reconstructs the full SQL query from template strings with PostgreSQL placeholders.
+     *
+     * For sql`SELECT * FROM users WHERE id = ${123} AND name = ${'foo'}`:
+     *   strings = ["SELECT * FROM users WHERE id = ", " AND name = ", ""]
+     *   returns: "SELECT * FROM users WHERE id = $1 AND name = $2"
+     */
+    private _reconstructQuery;
+    /**
+     * Sanitize SQL query as per the OTEL semantic conventions
+     * https://opentelemetry.io/docs/specs/semconv/database/database-spans/#sanitization-of-dbquerytext
+     *
+     * PostgreSQL $n placeholders are preserved per OTEL spec - they're parameterized queries,
+     * not sensitive literals. Only actual values (strings, numbers, booleans) are sanitized.
+     */
+    private _sanitizeSqlQuery;
+    /**
+     * Fallback patch for Query.prototype.handle to instrument queries from pre-existing sql instances.
+     * This catches queries from sql instances created BEFORE Sentry was initialized (CJS only).
+     *
+     * Note: Queries from pre-existing instances won't have connection context (database, host, port)
+     * because the sql instance wasn't created through our instrumented wrapper.
+     */
+    private _patchQueryPrototype;
+    /**
+     * Restores the original Query.prototype.handle method.
+     */
+    private _unpatchQueryPrototype;
+}
+/**
+ * Adds Sentry tracing instrumentation for the [postgres](https://www.npmjs.com/package/postgres) library.
+ *
+ * For more information, see the [`postgresIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/postgres/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.postgresJsIntegration()],
+ * });
+ * ```
+ */
+export declare const postgresJsIntegration: (options?: PostgresJsInstrumentationConfig | undefined) => import("@sentry/core").Integration;
+export {};
+//# sourceMappingURL=postgresjs.d.ts.map

package/build/types-ts3.8/integrations/tracing/prisma/vendor/v5-tracing-helper.d.ts

@@ -0,0 +1,44 @@
+import { Context, Span, SpanOptions } from '@opentelemetry/api';
+type V5SpanCallback<R> = (span?: Span, context?: Context) => R;
+type V5ExtendedSpanOptions = SpanOptions & {
+    name: string;
+    internal?: boolean;
+    middleware?: boolean;
+    active?: boolean;
+    context?: Context;
+};
+type EngineSpanEvent = {
+    span: boolean;
+    spans: V5EngineSpan[];
+};
+type V5EngineSpanKind = 'client' | 'internal';
+type V5EngineSpan = {
+    span: boolean;
+    name: string;
+    trace_id: string;
+    span_id: string;
+    parent_span_id: string;
+    start_time: [
+        number,
+        number
+    ];
+    end_time: [
+        number,
+        number
+    ];
+    attributes?: Record<string, string>;
+    links?: {
+        trace_id: string;
+        span_id: string;
+    }[];
+    kind: V5EngineSpanKind;
+};
+export interface PrismaV5TracingHelper {
+    isEnabled(): boolean;
+    getTraceParent(context?: Context): string;
+    createEngineSpan(engineSpanEvent: EngineSpanEvent): void;
+    getActiveContext(): Context | undefined;
+    runInChildSpan<R>(nameOrOptions: string | V5ExtendedSpanOptions, callback: V5SpanCallback<R>): R;
+}
+export {};
+//# sourceMappingURL=v5-tracing-helper.d.ts.map

package/build/types-ts3.8/integrations/tracing/prisma/vendor/v6-tracing-helper.d.ts

@@ -0,0 +1,34 @@
+import { Context, Span, SpanOptions } from '@opentelemetry/api';
+type V6SpanCallback<R> = (span?: Span, context?: Context) => R;
+type V6ExtendedSpanOptions = SpanOptions & {
+    name: string;
+    internal?: boolean;
+    middleware?: boolean;
+    active?: boolean;
+    context?: Context;
+};
+type V6EngineSpanId = string;
+type V6HrTime = [
+    number,
+    number
+];
+type EngineSpanKind = 'client' | 'internal';
+type PrismaV6EngineSpan = {
+    id: V6EngineSpanId;
+    parentId: string | null;
+    name: string;
+    startTime: V6HrTime;
+    endTime: V6HrTime;
+    kind: EngineSpanKind;
+    attributes?: Record<string, unknown>;
+    links?: V6EngineSpanId[];
+};
+export interface PrismaV6TracingHelper {
+    isEnabled(): boolean;
+    getTraceParent(context?: Context): string;
+    dispatchEngineSpans(spans: PrismaV6EngineSpan[]): void;
+    getActiveContext(): Context | undefined;
+    runInChildSpan<R>(nameOrOptions: string | V6ExtendedSpanOptions, callback: V6SpanCallback<R>): R;
+}
+export {};
+//# sourceMappingURL=v6-tracing-helper.d.ts.map

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

@@ -0,0 +1,50 @@
+import { Instrumentation } from '@opentelemetry/instrumentation';
+import { PrismaInstrumentation } from '@prisma/instrumentation';
+interface PrismaOptions {
+    /**
+     * @deprecated This is no longer used, v5 works out of the box.
+     */
+    prismaInstrumentation?: Instrumentation;
+    /**
+     * Configuration passed through to the {@link PrismaInstrumentation} constructor.
+     */
+    instrumentationConfig?: ConstructorParameters<typeof PrismaInstrumentation>[0];
+}
+export declare const instrumentPrisma: ((options?: PrismaOptions | undefined) => Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [prisma](https://www.npmjs.com/package/prisma) library.
+ * For more information, see the [`prismaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma/).
+ *
+ * NOTE: By default, this integration works with Prisma version 6.
+ * To get performance instrumentation for other Prisma versions,
+ * 1. Install the `@prisma/instrumentation` package with the desired version.
+ * 1. Pass a `new PrismaInstrumentation()` instance as exported from `@prisma/instrumentation` to the `prismaInstrumentation` option of this integration:
+ *
+ *    ```js
+ *    import { PrismaInstrumentation } from '@prisma/instrumentation'
+ *
+ *    Sentry.init({
+ *      integrations: [
+ *        prismaIntegration({
+ *          // Override the default instrumentation that Sentry uses
+ *          prismaInstrumentation: new PrismaInstrumentation()
+ *        })
+ *      ]
+ *    })
+ *    ```
+ *
+ *    The passed instrumentation instance will override the default instrumentation instance the integration would use, while the `prismaIntegration` will still ensure data compatibility for the various Prisma versions.
+ * 1. Depending on your Prisma version (prior to version 6), add `previewFeatures = ["tracing"]` to the client generator block of your Prisma schema:
+ *
+ *    ```
+ *    generator client {
+ *      provider = "prisma-client-js"
+ *      previewFeatures = ["tracing"]
+ *    }
+ *    ```
+ */
+export declare const prismaIntegration: (options?: PrismaOptions | undefined) => import("@sentry/core").Integration;
+export {};
+//# sourceMappingURL=prisma.d.ts.map

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

@@ -0,0 +1,41 @@
+import { RedisResponseCustomAttributeFunction } from '@opentelemetry/instrumentation-ioredis';
+interface RedisOptions {
+    /**
+     * Define cache prefixes for cache keys that should be captured as a cache span.
+     *
+     * Setting this to, for example, `['user:']` will capture cache keys that start with `user:`.
+     */
+    cachePrefixes?: string[];
+    /**
+     * Maximum length of the cache key added to the span description. If the key exceeds this length, it will be truncated.
+     *
+     * Passing `0` will use the full cache key without truncation.
+     *
+     * By default, the full cache key is used.
+     */
+    maxCacheKeyLength?: number;
+}
+export declare let _redisOptions: RedisOptions;
+export declare const cacheResponseHook: RedisResponseCustomAttributeFunction;
+/** To be able to preload all Redis OTel instrumentations with just one ID ("Redis"), all the instrumentations are generated in this one function  */
+export declare const instrumentRedis: (() => void) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [redis](https://www.npmjs.com/package/redis) and
+ * [ioredis](https://www.npmjs.com/package/ioredis) libraries.
+ *
+ * For more information, see the [`redisIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/redis/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.redisIntegration()],
+ * });
+ * ```
+ */
+export declare const redisIntegration: (options?: RedisOptions | undefined) => import("@sentry/core").Integration;
+export {};
+//# sourceMappingURL=redis.d.ts.map

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

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

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

@@ -0,0 +1,2 @@
+export declare const INTEGRATION_NAME = "VercelAI";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1,43 @@
+import { SentryVercelAiInstrumentation } from './instrumentation';
+import { VercelAiOptions } from './types';
+export declare const instrumentVercelAi: ((options?: unknown) => SentryVercelAiInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
+ * This integration is not enabled by default, you need to manually add it.
+ *
+ * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.vercelAIIntegration()],
+ * });
+ * ```
+ *
+ * This integration adds tracing support to all `ai` function calls.
+ * You need to opt-in to collecting spans for a specific call,
+ * you can do so by setting `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.
+ *
+ * ```javascript
+ * const result = await generateText({
+ *   model: openai('gpt-4-turbo'),
+ *   experimental_telemetry: { isEnabled: true },
+ * });
+ * ```
+ *
+ * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each
+ * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`
+ * to `true`.
+ *
+ * ```javascript
+ * const result = await generateText({
+ *  model: openai('gpt-4-turbo'),
+ *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
+ * });
+ */
+export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration;
+//# sourceMappingURL=index.d.ts.map