@depup/sentry__node 10.44.0-depup.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAKtE,UAAU,0BAA0B;IAClC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAID,eAAO,MAAM,kBAAkB;;CAU9B,CAAC;AAWF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,0FAA0C,CAAC"}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgresjs.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/postgresjs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EACL,mBAAmB,EACnB,mCAAmC,EAGpC,MAAM,gCAAgC,CAAC;AAQxC,OAAO,KAAK,EAAiB,IAAI,EAAE,MAAM,cAAc,CAAC;AAiBxD,KAAK,yBAAyB,GAAG;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAMF,KAAK,+BAA+B,GAAG,qBAAqB,GAAG;IAC7D;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,yBAAyB,CAAC,EAAE,yBAAyB,KAAK,IAAI,CAAC;CACtH,CAAC;AAEF,eAAO,MAAM,oBAAoB;;CAOhC,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,mBAAmB,CAAC,+BAA+B,CAAC;gBAC9E,MAAM,EAAE,+BAA+B;IAI1D;;;;;OAKG;IACI,IAAI,IAAI,mCAAmC;IA+BlD;;;OAGG;IACH,OAAO,CAAC,cAAc;IAqDtB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAkCzB;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAuH5B;;OAEG;IACH,OAAO,CAAC,sBAAsB;CAc/B;AAWD;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,qBAAqB,+FAA4C,CAAC"}

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

@@ -0,0 +1,38 @@
+import type { 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/integrations/tracing/prisma/vendor/v5-tracing-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v5-tracing-helper.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/prisma/vendor/v5-tracing-helper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAErE,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC;AAE/D,KAAK,qBAAqB,GAAG,WAAW,GAAG;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB,CAAC;AAEF,KAAK,gBAAgB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9C,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAChD,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,SAAS,IAAI,OAAO,CAAC;IACrB,cAAc,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1C,gBAAgB,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACzD,gBAAgB,IAAI,OAAO,GAAG,SAAS,CAAC;IACxC,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,qBAAqB,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;CAClG"}

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

@@ -0,0 +1,31 @@
+import type { 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/integrations/tracing/prisma/vendor/v6-tracing-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v6-tracing-helper.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/prisma/vendor/v6-tracing-helper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAErE,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC;AAE/D,KAAK,qBAAqB,GAAG,WAAW,GAAG;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,cAAc,GAAG,MAAM,CAAC;AAE7B,KAAK,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEjC,KAAK,cAAc,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE5C,KAAK,kBAAkB,GAAG;IACxB,EAAE,EAAE,cAAc,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,QAAQ,CAAC;IACpB,OAAO,EAAE,QAAQ,CAAC;IAClB,IAAI,EAAE,cAAc,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,SAAS,IAAI,OAAO,CAAC;IACrB,cAAc,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1C,mBAAmB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,IAAI,CAAC;IACvD,gBAAgB,IAAI,OAAO,GAAG,SAAS,CAAC;IACxC,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,qBAAqB,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;CAClG"}

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

@@ -0,0 +1,50 @@
+import type { 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/integrations/tracing/prisma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/prisma.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAmDhE,UAAU,aAAa;IACrB;;OAEG;IACH,qBAAqB,CAAC,EAAE,eAAe,CAAC;IACxC;;OAEG;IACH,qBAAqB,CAAC,EAAE,qBAAqB,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;CAChF;AA2GD,eAAO,MAAM,gBAAgB;;CAE3B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,iBAAiB,6EAgC5B,CAAC"}

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

@@ -0,0 +1,41 @@
+import type { 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/integrations/tracing/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/redis.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,wCAAwC,CAAC;AAwBnG,UAAU,YAAY;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAKD,eAAO,IAAI,aAAa,EAAE,YAAiB,CAAC;AAG5C,eAAO,MAAM,iBAAiB,EAAE,oCAkD/B,CAAC;AAcF,qJAAqJ;AACrJ,eAAO,MAAM,eAAe,SACtB,IAAI;;CAQT,CAAC;AAYF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,4EAAuC,CAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"tedious.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/tedious.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAgBhF,eAAO,MAAM,iBAAiB;;CAAiF,CAAC;AA+BhH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,0CAAyC,CAAC"}

package/build/types/integrations/tracing/vercelai/constants.d.ts

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

package/build/types/integrations/tracing/vercelai/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,aAAa,CAAC"}

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

@@ -0,0 +1,43 @@
+import { SentryVercelAiInstrumentation } from './instrumentation';
+import type { 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,eAAO,MAAM,kBAAkB;;CAAwF,CAAC;AAkCxH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,mBAAmB,+EAA0C,CAAC"}

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

@@ -0,0 +1,56 @@
+import type { InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+interface RecordingOptions {
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+}
+/**
+ * Process tool call results: capture tool errors and clean up span context mappings.
+ *
+ * Error checking runs first (needs span context for linking), then cleanup removes all entries.
+ * Tool errors are not rejected in Vercel AI V5 — they appear as metadata in the result content.
+ */
+export declare function processToolCallResults(result: unknown): void;
+/**
+ * Remove span context entries for all completed tool calls in the content array.
+ */
+export declare function cleanupToolCallSpanContexts(content: Array<object>): void;
+/**
+ * Determines whether to record inputs and outputs for Vercel AI telemetry based on the configuration hierarchy.
+ *
+ * The order of precedence is:
+ * 1. The vercel ai integration options
+ * 2. The experimental_telemetry options in the vercel ai method calls
+ * 3. When telemetry is explicitly enabled (isEnabled: true), default to recording
+ * 4. Otherwise, use the sendDefaultPii option from client options
+ */
+export declare function determineRecordingSettings(integrationRecordingOptions: RecordingOptions | undefined, methodTelemetryOptions: RecordingOptions, telemetryExplicitlyEnabled: boolean | undefined, defaultRecordingEnabled: boolean): {
+    recordInputs: boolean;
+    recordOutputs: boolean;
+};
+/**
+ * This detects is added by the Sentry Vercel AI Integration to detect if the integration should
+ * be enabled.
+ *
+ * It also patches the `ai` module to enable Vercel AI telemetry automatically for all methods.
+ */
+export declare class SentryVercelAiInstrumentation extends InstrumentationBase {
+    private _isPatched;
+    private _callbacks;
+    constructor(config?: InstrumentationConfig);
+    /**
+     * Initializes the instrumentation by defining the modules to be patched.
+     */
+    init(): InstrumentationModuleDefinition;
+    /**
+     * Call the provided callback when the module is patched.
+     * If it has already been patched, the callback will be called immediately.
+     */
+    callWhenPatched(callback: () => void): void;
+    /**
+     * Patches module exports to enable Vercel AI telemetry.
+     */
+    private _patch;
+}
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,+BAA+B,EAAE,MAAM,gCAAgC,CAAC;AAC7G,OAAO,EAAE,mBAAmB,EAAuC,MAAM,gCAAgC,CAAC;AAsC1G,UAAU,gBAAgB;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AA6BD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAY5D;AAgDD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAWxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,2BAA2B,EAAE,gBAAgB,GAAG,SAAS,EACzD,sBAAsB,EAAE,gBAAgB,EACxC,0BAA0B,EAAE,OAAO,GAAG,SAAS,EAC/C,uBAAuB,EAAE,OAAO,GAC/B;IAAE,YAAY,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAoBnD;AAED;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,mBAAmB;IACpE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAsB;gBAErB,MAAM,GAAE,qBAA0B;IAIrD;;OAEG;IACI,IAAI,IAAI,+BAA+B;IAK9C;;;OAGG;IACI,eAAe,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAQlD;;OAEG;IACH,OAAO,CAAC,MAAM;CA6Ef"}

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

@@ -0,0 +1,59 @@
+import type { Integration } from '@sentry/core';
+/**
+ * Telemetry configuration.
+ */
+export type TelemetrySettings = {
+    /**
+     * Enable or disable telemetry. Disabled by default while experimental.
+     */
+    isEnabled?: boolean;
+    /**
+     * Enable or disable input recording. Enabled by default.
+     *
+     * You might want to disable input recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled by default.
+     *
+     * You might want to disable output recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordOutputs?: boolean;
+    /**
+     * Identifier for this function. Used to group telemetry data by function.
+     */
+    functionId?: string;
+    /**
+     * Additional information to include in the telemetry data.
+     */
+    metadata?: Record<string, AttributeValue>;
+};
+/**
+ * Attribute values may be any non-nullish primitive value except an object.
+ *
+ * null or undefined attribute values are invalid and will result in undefined behavior.
+ */
+export declare type AttributeValue = string | number | boolean | Array<null | undefined | string> | Array<null | undefined | number> | Array<null | undefined | boolean>;
+export interface VercelAiOptions {
+    /**
+     * Enable or disable input recording. Enabled if `sendDefaultPii` is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled if `sendDefaultPii` is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings
+     */
+    recordOutputs?: boolean;
+    /**
+     * By default, the instrumentation will register span processors only when the ai package is used.
+     * If you want to register the span processors even when the ai package usage cannot be detected, you can set `force` to `true`.
+     */
+    force?: boolean;
+}
+export interface VercelAiIntegration extends Integration {
+    options: VercelAiOptions;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC3C,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,OAAO,MAAM,cAAc,GAC9B,MAAM,GACN,MAAM,GACN,OAAO,GACP,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC,GAChC,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC,GAChC,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC;AAEtC,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,OAAO,EAAE,eAAe,CAAC;CAC1B"}

package/build/types/preload.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=preload.d.ts.map

package/build/types/preload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../../src/preload.ts"],"names":[],"mappings":""}

package/build/types/sdk/index.d.ts

@@ -0,0 +1,18 @@
+import type { Integration, Options } from '@sentry/core';
+import type { NodeClient } from '@sentry/node-core';
+import type { NodeOptions } from '../types';
+/**
+ * Get default integrations, excluding performance.
+ */
+export declare function getDefaultIntegrationsWithoutPerformance(): Integration[];
+/** Get the default integrations for the Node SDK. */
+export declare function getDefaultIntegrations(options: Options): Integration[];
+/**
+ * Initialize Sentry for Node.
+ */
+export declare function init(options?: NodeOptions | undefined): NodeClient | undefined;
+/**
+ * Initialize Sentry for Node, without any integrations added by default.
+ */
+export declare function initWithoutDefaultIntegrations(options?: NodeOptions | undefined): NodeClient | undefined;
+//# sourceMappingURL=index.d.ts.map

package/build/types/sdk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AASpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5C;;GAEG;AACH,wBAAgB,wCAAwC,IAAI,WAAW,EAAE,CAOxE;AAED,qDAAqD;AACrD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,EAAE,CAStE;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAElF;AA4BD;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAE5G"}

package/build/types/sdk/initOtel.d.ts

@@ -0,0 +1,28 @@
+import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
+import { type NodeClient } from '@sentry/node-core';
+import { type AsyncLocalStorageLookup } from '@sentry/opentelemetry';
+interface AdditionalOpenTelemetryOptions {
+    /** Additional SpanProcessor instances that should be used. */
+    spanProcessors?: SpanProcessor[];
+}
+/**
+ * Initialize OpenTelemetry for Node.
+ */
+export declare function initOpenTelemetry(client: NodeClient, options?: AdditionalOpenTelemetryOptions): void;
+interface NodePreloadOptions {
+    debug?: boolean;
+    integrations?: string[];
+}
+/**
+ * Preload OpenTelemetry for Node.
+ * This can be used to preload instrumentation early, but set up Sentry later.
+ * By preloading the OTEL instrumentation wrapping still happens early enough that everything works.
+ */
+export declare function preloadOpenTelemetry(options?: NodePreloadOptions): void;
+/** Just exported for tests. */
+export declare function setupOtel(client: NodeClient, options?: AdditionalOpenTelemetryOptions): [BasicTracerProvider, AsyncLocalStorageLookup];
+/** Just exported for tests. */
+export declare function _clampSpanProcessorTimeout(maxSpanWaitDuration: number | undefined): number | undefined;
+export {};
+//# sourceMappingURL=initOtel.d.ts.map

package/build/types/sdk/initOtel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initOtel.d.ts","sourceRoot":"","sources":["../../../src/sdk/initOtel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAOpE,OAAO,EAEL,KAAK,UAAU,EAGhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,uBAAuB,EAI7B,MAAM,uBAAuB,CAAC;AAO/B,UAAU,8BAA8B;IACtC,8DAA8D;IAC9D,cAAc,CAAC,EAAE,aAAa,EAAE,CAAC;CAClC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,8BAAmC,GAAG,IAAI,CAQxG;AAED,UAAU,kBAAkB;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,kBAAuB,GAAG,IAAI,CAiB3E;AAgBD,+BAA+B;AAC/B,wBAAgB,SAAS,CACvB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,8BAAmC,GAC3C,CAAC,mBAAmB,EAAE,uBAAuB,CAAC,CA6BhD;AAED,+BAA+B;AAC/B,wBAAgB,0BAA0B,CAAC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAiBtG"}