@depup/sentry__node 10.48.0-depup.0 → 10.67.0-depup.1

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

@@ -21,18 +21,19 @@ export declare const instrumentOpenAi: ((options?: OpenAiOptions | undefined) =>
  *
  * ## Options
  *
- * - `recordInputs`: Whether to record prompt messages (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ * - `recordInputs`: Whether to record input messages/prompts (default: follows `dataCollection.genAI.inputs`, or the deprecated `sendDefaultPii` option)
+ * - `recordOutputs`: Whether to record response text (default: follows `dataCollection.genAI.outputs`, or the deprecated `sendDefaultPii` 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
+ * - Record inputs and outputs based on `dataCollection.genAI` in your Sentry client options
+ *   (or the deprecated `sendDefaultPii` option, for backwards compatibility)
+ * - Integration-level `recordInputs`/`recordOutputs` options take precedence over global config
  *
  * @example
  * ```javascript
- * // Record inputs and outputs when sendDefaultPii is false
+ * // Always record inputs and outputs regardless of global dataCollection config
  * Sentry.init({
  *   integrations: [
  *     Sentry.openAIIntegration({
@@ -42,9 +43,9 @@ export declare const instrumentOpenAi: ((options?: OpenAiOptions | undefined) =>
  *   ],
  * });
  *
- * // Never record inputs/outputs regardless of sendDefaultPii
+ * // Never record inputs/outputs regardless of global dataCollection config
  * Sentry.init({
- *   sendDefaultPii: true,
+ *   dataCollection: { genAI: { inputs: true, outputs: true } },
  *   integrations: [
  *     Sentry.openAIIntegration({
  *       recordInputs: false,
@@ -55,5 +56,7 @@ export declare const instrumentOpenAi: ((options?: OpenAiOptions | undefined) =>
  * ```
  *
  */
-export declare const openAIIntegration: (options?: OpenAiOptions | undefined) => import("@sentry/core").Integration;
+export declare const openAIIntegration: (options?: OpenAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "OpenAI";
+};
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/{postgres.d.ts → postgres/index.d.ts}

@@ -1,4 +1,4 @@
-import { PgInstrumentation } from '@opentelemetry/instrumentation-pg';
+import { PgInstrumentation } from './vendored/instrumentation';
 interface PostgresIntegrationOptions {
     ignoreConnectSpans?: boolean;
 }
@@ -19,6 +19,8 @@ export declare const instrumentPostgres: ((options: PostgresIntegrationOptions |
  * });
  * ```
  */
-export declare const postgresIntegration: (options?: PostgresIntegrationOptions | undefined) => import("@sentry/core").Integration;
+export declare const postgresIntegration: (options?: PostgresIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Postgres";
+};
 export {};
-//# sourceMappingURL=postgres.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/postgres/vendored/enums/AttributeNames.d.ts

@@ -0,0 +1,6 @@
+export declare enum AttributeNames {
+    PG_PLAN = "db.postgresql.plan",
+    IDLE_TIMEOUT_MILLIS = "db.postgresql.idle.timeout.millis",
+    MAX_CLIENT = "db.postgresql.max.client"
+}
+//# sourceMappingURL=AttributeNames.d.ts.map

package/build/types-ts3.8/integrations/tracing/postgres/vendored/enums/SpanNames.d.ts

@@ -0,0 +1,6 @@
+export declare enum SpanNames {
+    QUERY_PREFIX = "pg.query",
+    CONNECT = "pg.connect",
+    POOL_CONNECT = "pg-pool.connect"
+}
+//# sourceMappingURL=SpanNames.d.ts.map

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

@@ -0,0 +1,12 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { PgInstrumentationConfig } from './types';
+export declare class PgInstrumentation extends InstrumentationBase<PgInstrumentationConfig> {
+    constructor(config?: PgInstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition[];
+    private _patchPgClient;
+    private _unpatchPgClient;
+    private _getClientConnectPatch;
+    private _getClientQueryPatch;
+    private _getPoolConnectPatch;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/postgres/vendored/internal-types.d.ts

@@ -0,0 +1,33 @@
+import { PgClient } from './pg-types';
+import { PgPool } from './pg-pool-types';
+export type PostgresCallback = (err: Error, res: object) => unknown;
+export interface PgParsedConnectionParams {
+    database?: string;
+    host?: string;
+    namespace?: string;
+    port?: number;
+    user?: string;
+}
+export interface PgClientExtended extends PgClient {
+    connectionParameters: PgParsedConnectionParams;
+}
+export type PgPoolCallback = (err: Error, client: any, done: (release?: any) => void) => void;
+export interface PgPoolOptionsParams {
+    allowExitOnIdle: boolean;
+    connectionString?: string;
+    database: string;
+    host: string;
+    idleTimeoutMillis: number;
+    max: number;
+    maxClient: number;
+    maxLifetimeSeconds: number;
+    maxUses: number;
+    namespace: string;
+    port: number;
+    user: string;
+}
+export interface PgPoolExtended extends PgPool {
+    options: PgPoolOptionsParams;
+}
+export type PgClientConnect = (callback?: Function) => Promise<void> | void;
+//# sourceMappingURL=internal-types.d.ts.map

package/build/types-ts3.8/integrations/tracing/postgres/vendored/pg-pool-types.d.ts

@@ -0,0 +1,20 @@
+import { PgPoolClient } from './pg-types';
+export interface PgPool {
+    readonly totalCount: number;
+    readonly idleCount: number;
+    readonly waitingCount: number;
+    readonly expiredCount: number;
+    readonly ending: boolean;
+    readonly ended: boolean;
+    options: any;
+    connect(): Promise<PgPoolClient>;
+    connect(callback: (err: Error | undefined, client: PgPoolClient | undefined, done: (release?: any) => void) => void): void;
+    end(): Promise<void>;
+    end(callback: () => void): void;
+    query(...args: any[]): any;
+    on(event: 'release' | 'error', listener: (err: Error, client: PgPoolClient) => void): this;
+    on(event: 'connect' | 'acquire' | 'remove', listener: (client: PgPoolClient) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    [key: string]: any;
+}
+//# sourceMappingURL=pg-pool-types.d.ts.map

package/build/types-ts3.8/integrations/tracing/postgres/vendored/pg-types.d.ts

@@ -0,0 +1,54 @@
+export interface FieldDef {
+    name: string;
+    tableID: number;
+    columnID: number;
+    dataTypeID: number;
+    dataTypeSize: number;
+    dataTypeModifier: number;
+    format: string;
+}
+export interface QueryResultBase {
+    command: string;
+    rowCount: number | null;
+    oid: number;
+    fields: FieldDef[];
+}
+export interface QueryResult<R = any> extends QueryResultBase {
+    rows: R[];
+}
+export interface QueryArrayResult<R extends any[] = any[]> extends QueryResultBase {
+    rows: R[];
+}
+export interface PgClientBase {
+    connect(): Promise<void>;
+    connect(callback: (err: Error) => void): void;
+    query(...args: any[]): any;
+    copyFrom(queryText: string): any;
+    copyTo(queryText: string): any;
+    pauseDrain(): void;
+    resumeDrain(): void;
+    escapeIdentifier(str: string): string;
+    escapeLiteral(str: string): string;
+    on(event: 'drain', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'notice', listener: (notice: any) => void): this;
+    on(event: 'notification', listener: (message: any) => void): this;
+    on(event: 'end', listener: () => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    [key: string]: any;
+}
+export interface PgClient extends PgClientBase {
+    user?: string | undefined;
+    database?: string | undefined;
+    port: number;
+    host: string;
+    password?: string | undefined;
+    ssl: boolean;
+    readonly connection: any;
+    end(): Promise<void>;
+    end(callback: (err: Error) => void): void;
+}
+export interface PgPoolClient extends PgClientBase {
+    release(err?: Error | boolean): void;
+}
+//# sourceMappingURL=pg-types.d.ts.map

package/build/types-ts3.8/integrations/tracing/postgres/vendored/semconv.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deprecated, use `server.address`, `server.port` attributes instead.
+ *
+ * @example "Server=(localdb)\\v11.0;Integrated Security=true;"
+ *
+ * @deprecated Replaced by `server.address` and `server.port`.
+ */
+export declare const ATTR_DB_CONNECTION_STRING: "db.connection_string";
+/**
+ * Enum value "postgresql" for attribute `db.system`.
+ */
+export declare const DB_SYSTEM_VALUE_POSTGRESQL: "postgresql";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,11 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface PgInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * If true, `pg.connect` and `pg-pool.connect` spans will not be created.
+     * Query spans are still recorded.
+     *
+     * @default false
+     */
+    ignoreConnectSpans?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/postgres/vendored/utils.d.ts

@@ -0,0 +1,56 @@
+import { Span, SpanAttributes } from '@sentry/core';
+import { PgClientExtended, PgParsedConnectionParams, PgPoolCallback, PgPoolOptionsParams, PostgresCallback } from './internal-types';
+export declare const ORIGIN = "auto.db.otel.postgres";
+/**
+ * Helper function to get a low cardinality span name from whatever info we have
+ * about the query.
+ *
+ * This is tricky, because we don't have most of the information (table name,
+ * operation name, etc) the spec recommends using to build a low-cardinality
+ * value w/o parsing. So, we use db.name and assume that, if the query's a named
+ * prepared statement, those `name` values will be low cardinality. If we don't
+ * have a named prepared statement, we try to parse an operation (despite the
+ * spec's warnings).
+ *
+ * @params dbName The name of the db against which this query is being issued,
+ *   which could be missing if no db name was given at the time that the
+ *   connection was established.
+ * @params queryConfig Information we have about the query being issued, typed
+ *   to reflect only the validation we've actually done on the args to
+ *   `client.query()`. This will be undefined if `client.query()` was called
+ *   with invalid arguments.
+ */
+export declare function getQuerySpanName(dbName: string | undefined, queryConfig?: {
+    text: string;
+    name?: unknown;
+}): string;
+export declare function parseNormalizedOperationName(queryText: string): string;
+export declare function parseAndMaskConnectionString(connectionString: string): string;
+export declare function getConnectionString(params: PgParsedConnectionParams | PgPoolOptionsParams): string;
+export declare function getSemanticAttributesFromConnection(params: PgParsedConnectionParams): SpanAttributes;
+export declare function getSemanticAttributesFromPoolConnection(params: PgPoolOptionsParams): SpanAttributes;
+/**
+ * The SDK always requires a parent span (it sets `requireParentSpan: true`), so
+ * we only instrument when there is an active span to parent the new span under.
+ */
+export declare function shouldSkipInstrumentation(): boolean;
+export declare function handleConfigQuery(this: PgClientExtended, queryConfig?: {
+    text: string;
+    values?: unknown;
+    name?: unknown;
+}): Span;
+export declare function patchCallback(span: Span, cb: PostgresCallback): PostgresCallback;
+export declare function patchCallbackPGPool(span: Span, cb: PgPoolCallback): PgPoolCallback;
+export declare function patchClientConnectCallback(span: Span, cb: (...args: unknown[]) => void): (...args: unknown[]) => void;
+/**
+ * Attempt to get a message string from a thrown value, while being quite
+ * defensive, to recognize the fact that, in JS, any kind of value (even
+ * primitives) can be thrown.
+ */
+export declare function getErrorMessage(e: unknown): string | undefined;
+export declare function isObjectWithTextString(it: unknown): it is ObjectWithText;
+export type ObjectWithText = {
+    text: string;
+    [k: string]: unknown;
+};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -96,6 +96,8 @@ export declare class PostgresJsInstrumentation extends InstrumentationBase<Postg
  * });
  * ```
  */
-export declare const postgresJsIntegration: (options?: PostgresJsInstrumentationConfig | undefined) => import("@sentry/core").Integration;
+export declare const postgresJsIntegration: (options?: PostgresJsInstrumentationConfig | undefined) => import("@sentry/core").Integration & {
+    name: "PostgresJs";
+};
 export {};
 //# sourceMappingURL=postgresjs.d.ts.map

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

@@ -0,0 +1,22 @@
+import { IORedisResponseCustomAttributeFunction } from './vendored/types';
+export 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;
+/** Set the options consumed by {@link cacheResponseHook}. */
+export declare function setRedisOptions(options: RedisOptions): void;
+export declare const cacheResponseHook: IORedisResponseCustomAttributeFunction;
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1,28 @@
+import { RedisOptions } from './cache';
+export { _redisOptions, cacheResponseHook } from './cache';
+/**
+ * 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: "Redis";
+};
+/**
+ * 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 & {
+    name: "Redis";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,10 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { IORedisInstrumentationConfig } from './types';
+export declare class IORedisInstrumentation extends InstrumentationBase<IORedisInstrumentationConfig> {
+    constructor(config?: IORedisInstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition[];
+    private _patchSendCommand;
+    private _patchConnection;
+    private _callResponseHook;
+}
+//# sourceMappingURL=ioredis-instrumentation.d.ts.map

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

@@ -0,0 +1,16 @@
+import { TracerProvider } from '@opentelemetry/api';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+import { RedisInstrumentationConfig } from './types';
+export declare class RedisInstrumentation extends InstrumentationBase<RedisInstrumentationConfig> {
+    private instrumentationV2_V3;
+    private instrumentationV4_V5;
+    private initialized;
+    constructor(config?: RedisInstrumentationConfig);
+    setConfig(config?: RedisInstrumentationConfig): void;
+    init(): void;
+    getModuleDefinitions(): import("@opentelemetry/instrumentation").InstrumentationModuleDefinition[];
+    setTracerProvider(tracerProvider: TracerProvider): void;
+    enable(): void;
+    disable(): void;
+}
+//# sourceMappingURL=redis-instrumentation.d.ts.map

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

@@ -0,0 +1,4 @@
+export declare const ATTR_DB_CONNECTION_STRING = "db.connection_string";
+export declare const DB_SYSTEM_NAME_VALUE_REDIS = "redis";
+export declare const DB_SYSTEM_VALUE_REDIS = "redis";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,24 @@
+import { Span } from '@sentry/core';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+/**
+ * Function that can be used to add custom attributes to span on response from redis server
+ */
+export interface RedisResponseCustomAttributeFunction {
+    (span: Span, cmdName: string, cmdArgs: Array<string | Buffer>, response: unknown): void;
+}
+export interface RedisInstrumentationConfig extends InstrumentationConfig {
+    /** Function for adding custom attributes on db response */
+    responseHook?: RedisResponseCustomAttributeFunction;
+}
+export type CommandArgs = Array<string | Buffer | number | any[]>;
+/**
+ * Function that can be used to add custom attributes to span on response from redis server (ioredis)
+ */
+export interface IORedisResponseCustomAttributeFunction {
+    (span: Span, cmdName: string, cmdArgs: CommandArgs, response: unknown): void;
+}
+export interface IORedisInstrumentationConfig extends InstrumentationConfig {
+    /** Function for adding custom attributes on db response */
+    responseHook?: IORedisResponseCustomAttributeFunction;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/{tedious.d.ts → tedious/index.d.ts}

@@ -1,4 +1,4 @@
-import { TediousInstrumentation } from '@opentelemetry/instrumentation-tedious';
+import { TediousInstrumentation } from './vendored/instrumentation';
 export declare const instrumentTedious: ((options?: unknown) => TediousInstrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentTedious: ((options?: unknown) => TediousInstrumen
  * });
  * ```
  */
-export declare const tediousIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=tedious.d.ts.map
+export declare const tediousIntegration: () => import("@sentry/core").Integration & {
+    name: "Tedious";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare class TediousInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    static readonly COMPONENT = "tedious";
+    constructor(config?: InstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition[];
+    private _patchConnect;
+    private _patchQuery;
+    private _patchCallbackQuery;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * Deprecated, use `db.collection.name` instead.
+ *
+ * @example "mytable"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.collection.name`, but only if not extracting the value from `db.query.text`.
+ */
+export declare const ATTR_DB_SQL_TABLE: "db.sql.table";
+/**
+ * Enum value "mssql" for attribute `db.system`.
+ *
+ * Microsoft SQL Server
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const DB_SYSTEM_VALUE_MSSQL: "mssql";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,21 @@
+import { EventEmitter } from 'events';
+export declare class Connection extends EventEmitter {
+    config: any;
+    connect(connectListener?: (err?: Error) => void): void;
+    execSql(request: Request): void;
+    [key: string]: any;
+}
+export declare class Request extends EventEmitter {
+    sqlTextOrProcedure: string | undefined;
+    callback: any;
+    table: string | undefined;
+    parametersByName: any;
+    constructor(sqlTextOrProcedure: string | undefined, callback: (error: Error | null | undefined, rowCount?: number, rows?: any) => void);
+    addParameter(name: string, type: any, value?: unknown, options?: any): void;
+    [key: string]: any;
+}
+export declare const TYPES: {
+    VarBinary: any;
+    [key: string]: any;
+};
+//# sourceMappingURL=tedious-types.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * The span name SHOULD be set to a low cardinality value
+ * representing the statement executed on the database.
+ *
+ * @returns Operation executed on Tedious Connection. Does not map to SQL statement in any way.
+ */
+export declare function getSpanName(operation: string, db: string | undefined, sql: string | undefined, bulkLoadTable: string | undefined): string;
+export declare const once: (fn: Function) => (...args: unknown[]) => any;
+//# sourceMappingURL=utils.d.ts.map

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

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

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

@@ -5,7 +5,6 @@ export declare const instrumentVercelAi: ((options?: unknown) => SentryVercelAiI
 };
 /**
  * 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).
  *
@@ -39,5 +38,7 @@ export declare const instrumentVercelAi: ((options?: unknown) => SentryVercelAiI
  *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
  * });
  */
-export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration;
+export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "VercelAI";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -22,9 +22,9 @@ export declare function cleanupToolCallSpanContexts(content: Array<object>): voi
  * 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
+ * 4. Otherwise, use the dataCollection.genAI settings from client options
  */
-export declare function determineRecordingSettings(integrationRecordingOptions: RecordingOptions | undefined, methodTelemetryOptions: RecordingOptions, telemetryExplicitlyEnabled: boolean | undefined, defaultRecordingEnabled: boolean): {
+export declare function determineRecordingSettings(integrationRecordingOptions: RecordingOptions | undefined, methodTelemetryOptions: RecordingOptions, telemetryExplicitlyEnabled: boolean | undefined, defaultInputsEnabled: boolean, defaultOutputsEnabled: boolean): {
     recordInputs: boolean;
     recordOutputs: boolean;
 };

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

@@ -38,13 +38,15 @@ export type TelemetrySettings = {
 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
+     * Enable or disable input recording. Enabled if `dataCollection.genAI.inputs` (or the deprecated `sendDefaultPii` option) is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
+     * Integration-level options take precedence over global `dataCollection` config.
      */
     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
+     * Enable or disable output recording. Enabled if `dataCollection.genAI.outputs` (or the deprecated `sendDefaultPii` option) is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
+     * Integration-level options take precedence over global `dataCollection` config.
      */
     recordOutputs?: boolean;
     /**
@@ -52,6 +54,11 @@ export interface VercelAiOptions {
      * 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;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
 }
 export interface VercelAiIntegration extends Integration {
     options: VercelAiOptions;

package/build/types-ts3.8/sdk/diagnosticsChannelInjection.d.ts

@@ -0,0 +1,41 @@
+import { Integration } from '@sentry/core';
+/**
+ * The orchestrion-driven pieces, resolved lazily by the opt-in loader.
+ *
+ * IMPORTANT: this module (and everything `init()` imports) must NOT reference
+ * the orchestrion code (`@sentry/server-utils/orchestrion/*`). The only
+ * reference lives inside `experimentalUseDiagnosticsChannelInjection()` (a
+ * separate module, reachable solely through that public export). That's the
+ * tree-shaking boundary: if an app never calls the opt-in function, then a
+ * bundler drops the entire orchestrion subtree, including its transitive
+ * dependencies, while an app that does call it gets it bundled
+ * normally.
+ */
+export interface DiagnosticsChannelInjection {
+    /** Channel-based integrations to register, replacing their OTel equivalents. */
+    integrations: Integration[] | readonly Integration[];
+    /** OTel integration names these replace; filtered out of the default set. */
+    replacedOtelIntegrationNames: string[];
+    /** Installs the module hooks that inject the diagnostics channels. */
+    register: () => void;
+    /** Warns (DEBUG only) about missing or doubled channel injection. */
+    detect: () => void;
+}
+/**
+ * Set by `experimentalUseDiagnosticsChannelInjection()`. The loader
+ * is the only thing that pulls in the orchestrion modules; see
+ * {@link DiagnosticsChannelInjection) re tree-shaking concerns this addresses.
+ *
+ * @internal
+ */
+export declare function setDiagnosticsChannelInjectionLoader(load: () => DiagnosticsChannelInjection): void;
+/** Whether `experimentalUseDiagnosticsChannelInjection()` was called. */
+export declare function isDiagnosticsChannelInjectionEnabled(): boolean;
+/**
+ * Resolve and memoize the orchestrion pieces. This is what actually loads
+ * the orchestrion modules. Returns `undefined` if the app never opted in.
+ * Callers gate this on span recording, so the modules load only when both
+ * opted in and tracing is enabled.
+ */
+export declare function resolveDiagnosticsChannelInjection(): DiagnosticsChannelInjection | undefined;
+//# sourceMappingURL=diagnosticsChannelInjection.d.ts.map

package/build/types-ts3.8/sdk/experimentalUseDiagnosticsChannelInjection.d.ts

@@ -0,0 +1,37 @@
+import { channelIntegrations } from '@sentry/server-utils/orchestrion';
+import { RegisterDiagnosticsChannelInjectionOptions } from '@sentry/server-utils/orchestrion/register';
+export declare function diagnosticsChannelInjectionIntegrations(): typeof channelIntegrations;
+/**
+ * EXPERIMENTAL: opt into diagnostics-channel-based auto-instrumentation.
+ *
+ * Call this BEFORE `Sentry.init()`:
+ *
+ * ```ts
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.experimentalUseDiagnosticsChannelInjection();
+ * Sentry.init({
+ *   dsn: '__DSN__',
+ *   // other settings...
+ * });
+ * ```
+ *
+ * When this has been called AND span recording is enabled, `Sentry.init()`
+ * uses the diagnostics-channel-injection-based integrations instead of the
+ * OpenTelemetry ones, and installs the module hooks that inject the channels
+ * (so libraries imported after `init()` publish the channel events).
+ *
+ * This is a standalone function rather than an `init()` option so that a
+ * bundler drops all of it (and its transitive deps) when this function isn't
+ * called. `init()` reads the loader registered below.
+ *
+ * An app that DOES call it gets the orchestrion code bundled as intended.
+ *
+ * In an unbundled (server-side runtime) app this eagerly loads only the small
+ * subscriber/channel modules; the heavy code-transform dependencies stay lazy
+ * inside `register()` and load only when injection actually runs.
+ *
+ * @experimental May change or be removed in any release.
+ */
+export declare function experimentalUseDiagnosticsChannelInjection(options?: RegisterDiagnosticsChannelInjectionOptions): void;
+//# sourceMappingURL=experimentalUseDiagnosticsChannelInjection.d.ts.map