@sentry/node 10.61.0 → 10.63.0

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

@@ -1,6 +1,8 @@
-import { Instrumentation, InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { Integration } from '@sentry/core';
 import { FastifyMinimal, FastifyReply, FastifyRequest } from './types';
 import { FastifyInstrumentationV3 } from './v3/instrumentation';
+import { instrumentFastify } from '@sentry/server-utils';
+export { instrumentFastify };
 /**
  * Options for the Fastify integration.
  *
@@ -74,9 +76,6 @@ interface FastifyHandlerOptions {
 export declare const instrumentFastifyV3: ((options?: unknown) => FastifyInstrumentationV3) & {
     id: string;
 };
-export declare const instrumentFastify: ((options?: unknown) => Instrumentation<InstrumentationConfig>) & {
-    id: string;
-};
 /**
  * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
  *
@@ -93,7 +92,9 @@ export declare const instrumentFastify: ((options?: unknown) => Instrumentation<
  * })
  * ```
  */
-export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => import("@sentry/core").Integration;
+export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => Integration & {
+    name: string;
+};
 /**
  * Add an Fastify error handler to capture errors to Sentry.
  *
@@ -115,5 +116,4 @@ export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOp
  * ```
  */
 export declare function setupFastifyErrorHandler(fastify: FastifyMinimal, options?: Partial<FastifyHandlerOptions>): void;
-export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -2,5 +2,7 @@ import { FirebaseInstrumentation } from './otel';
 export declare const instrumentFirebase: ((options?: unknown) => FirebaseInstrumentation) & {
     id: string;
 };
-export declare const firebaseIntegration: () => import("@sentry/core").Integration;
+export declare const firebaseIntegration: () => import("@sentry/core").Integration & {
+    name: "Firebase";
+};
 //# sourceMappingURL=firebase.d.ts.map

package/build/types-ts3.8/integrations/tracing/firebase/otel/firebaseInstrumentation.d.ts

@@ -1,15 +1,10 @@
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseInstrumentationConfig } from './types';
+import { InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
 /**
  * Instrumentation for Firebase services, specifically Firestore.
  */
-export declare class FirebaseInstrumentation extends InstrumentationBase<FirebaseInstrumentationConfig> {
-    constructor(config?: FirebaseInstrumentationConfig);
-    /**
-     * sets config
-     * @param config
-     */
-    setConfig(config?: FirebaseInstrumentationConfig): void;
+export declare class FirebaseInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
     /**
      *
      * @protected

package/build/types-ts3.8/integrations/tracing/firebase/otel/patches/firestore.d.ts

@@ -1,20 +1,17 @@
-import { Tracer } from '@opentelemetry/api';
 import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseInstrumentationConfig, FirestoreSettings } from '../types';
+import { FirestoreSettings } from '../types';
 type ShimmerWrap = (target: any, name: string, wrapper: (...args: any[]) => any) => void;
 type ShimmerUnwrap = (target: any, name: string) => void;
 /**
  *
- * @param tracer - Opentelemetry Tracer
  * @param firestoreSupportedVersions - supported version of firebase/firestore
  * @param wrap - reference to native instrumentation wrap function
  * @param unwrap - reference to native instrumentation wrap function
  */
-export declare function patchFirestore(tracer: Tracer, firestoreSupportedVersions: string[], wrap: ShimmerWrap, unwrap: ShimmerUnwrap, config: FirebaseInstrumentationConfig): InstrumentationNodeModuleDefinition;
+export declare function patchFirestore(firestoreSupportedVersions: string[], wrap: ShimmerWrap, unwrap: ShimmerUnwrap): InstrumentationNodeModuleDefinition;
 /**
  * Gets the server address and port attributes from the Firestore settings.
  * It's best effort to extract the address and port from the settings, especially for IPv6.
- * @param span - The span to set attributes on.
  * @param settings - The Firestore settings containing host information.
  */
 export declare function getPortAndAddress(settings: FirestoreSettings): {

package/build/types-ts3.8/integrations/tracing/firebase/otel/patches/functions.d.ts

@@ -1,23 +1,18 @@
-import { Tracer } from '@opentelemetry/api';
 import { InstrumentationBase } from '@opentelemetry/instrumentation';
 import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseFunctions, FirebaseInstrumentationConfig, OverloadedParameters } from '../types';
+import { FirebaseFunctions, OverloadedParameters } from '../types';
 /**
  * Patches Firebase Functions v2 to add OpenTelemetry instrumentation
- * @param tracer - Opentelemetry Tracer
  * @param functionsSupportedVersions - supported versions of firebase-functions
  * @param wrap - reference to native instrumentation wrap function
  * @param unwrap - reference to native instrumentation unwrap function
- * @param config - Firebase instrumentation config
  */
-export declare function patchFunctions(tracer: Tracer, functionsSupportedVersions: string[], wrap: InstrumentationBase['_wrap'], unwrap: InstrumentationBase['_unwrap'], config: FirebaseInstrumentationConfig): InstrumentationNodeModuleDefinition;
+export declare function patchFunctions(functionsSupportedVersions: string[], wrap: InstrumentationBase['_wrap'], unwrap: InstrumentationBase['_unwrap']): InstrumentationNodeModuleDefinition;
 /**
  * Patches Cloud Functions for Firebase (v2) to add OpenTelemetry instrumentation
  *
- * @param tracer - Opentelemetry Tracer
- * @param functionsConfig - Firebase instrumentation config
  * @param triggerType - Type of trigger
  * @returns A function that patches the function
  */
-export declare function patchV2Functions<T extends FirebaseFunctions = FirebaseFunctions>(tracer: Tracer, functionsConfig: FirebaseInstrumentationConfig['functions'], triggerType: string): (original: T) => (...args: OverloadedParameters<T>) => ReturnType<T>;
+export declare function patchV2Functions<T extends FirebaseFunctions = FirebaseFunctions>(triggerType: string): (original: T) => (...args: OverloadedParameters<T>) => ReturnType<T>;
 //# sourceMappingURL=functions.d.ts.map

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

@@ -1,5 +1,3 @@
-import { Span } from '@opentelemetry/api';
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
 export interface FirebaseOptions {
     [key: string]: any;
     apiKey?: string;
@@ -70,24 +68,6 @@ export interface FirestoreSettings {
     experimentalAutoDetectLongPolling?: boolean;
     useFetchStreams?: boolean;
 }
-/**
- * Firebase Auto Instrumentation
- */
-export interface FirebaseInstrumentationConfig extends InstrumentationConfig {
-    firestoreSpanCreationHook?: FirestoreSpanCreationHook;
-    functions?: FunctionsConfig;
-}
-export interface FunctionsConfig {
-    requestHook?: RequestHook;
-    responseHook?: ResponseHook;
-    errorHook?: ErrorHook;
-}
-export type RequestHook = (span: Span) => void;
-export type ResponseHook = (span: Span, error?: unknown) => void;
-export type ErrorHook = (span: Span, error?: unknown) => Promise<void> | void;
-export interface FirestoreSpanCreationHook {
-    (span: Span): void;
-}
 export type GetDocsType<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = (query: CollectionReference<AppModelType, DbModelType>) => Promise<QuerySnapshot<AppModelType, DbModelType>>;
 export type SetDocType<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = ((reference: DocumentReference<AppModelType, DbModelType>, data: WithFieldValue<AppModelType>) => Promise<void>) & ((reference: DocumentReference<AppModelType, DbModelType>, data: PartialWithFieldValue<AppModelType>, options: SetOptions) => Promise<void>);
 export type AddDocType<AppModelType, DbModelType extends DocumentData> = (reference: CollectionReference<AppModelType, DbModelType>, data: WithFieldValue<AppModelType>) => Promise<DocumentReference<AppModelType, DbModelType>>;

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

@@ -16,5 +16,7 @@ export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolI
  * });
  * ```
  */
-export declare const genericPoolIntegration: () => import("@sentry/core").Integration;
+export declare const genericPoolIntegration: () => import("@sentry/core").Integration & {
+    name: "GenericPool";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -56,5 +56,7 @@ export declare const instrumentGoogleGenAI: ((options?: GoogleGenAIOptions | und
  * ```
  *
  */
-export declare const googleGenAIIntegration: (options?: GoogleGenAIOptions | undefined) => import("@sentry/core").Integration;
+export declare const googleGenAIIntegration: (options?: GoogleGenAIOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Google_GenAI";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -43,6 +43,8 @@ export declare const instrumentGraphql: ((options: GraphqlOptions) => GraphQLIns
  *  integrations: [Sentry.graphqlIntegration()],
  * });
  */
-export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration;
+export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Graphql";
+};
 export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -19,7 +19,9 @@ export declare const instrumentHapi: ((options?: unknown) => HapiInstrumentation
  * })
  * ```
  */
-export declare const hapiIntegration: () => import("@sentry/core").Integration;
+export declare const hapiIntegration: () => import("@sentry/core").Integration & {
+    name: "Hapi";
+};
 export declare const hapiErrorPlugin: {
     name: string;
     version: string;

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

@@ -22,7 +22,9 @@ export declare const instrumentHono: ((options?: unknown) => HonoInstrumentation
  * })
  * ```
  */
-export declare const honoIntegration: () => import("@sentry/core").Integration;
+export declare const honoIntegration: () => import("@sentry/core").Integration & {
+    name: "Hono";
+};
 interface HonoHandlerOptions {
     /**
      * Callback method deciding whether error should be captured and sent to Sentry

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

@@ -15,5 +15,7 @@ export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumenta
  *  integrations: [Sentry.kafkaIntegration()],
  * });
  */
-export declare const kafkaIntegration: () => import("@sentry/core").Integration;
+export declare const kafkaIntegration: () => import("@sentry/core").Integration & {
+    name: "Kafka";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -16,5 +16,7 @@ export declare const instrumentKnex: ((options?: unknown) => KnexInstrumentation
  * });
  * ```
  */
-export declare const knexIntegration: () => import("@sentry/core").Integration;
+export declare const knexIntegration: () => import("@sentry/core").Integration & {
+    name: "Knex";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -40,7 +40,9 @@ export declare const instrumentKoa: ((options: KoaOptions | undefined) => KoaIns
  * })
  * ```
  */
-export declare const koaIntegration: (options?: KoaOptions | undefined) => import("@sentry/core").Integration;
+export declare const koaIntegration: (options?: KoaOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Koa";
+};
 /**
  * Add an Koa error handler to capture errors to Sentry.
  *

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

@@ -95,5 +95,7 @@ export declare const instrumentLangChain: ((options?: LangChainOptions | undefin
  * - Embeddings: embedQuery, embedDocuments (via direct method wrapping)
  *
  */
-export declare const langChainIntegration: (options?: LangChainOptions | undefined) => import("@sentry/core").Integration;
+export declare const langChainIntegration: (options?: LangChainOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LangChain";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -71,5 +71,7 @@ export declare const instrumentLangGraph: ((options?: LangGraphOptions | undefin
  * - Available tools configured in the graph
  *
  */
-export declare const langGraphIntegration: (options?: LangGraphOptions | undefined) => import("@sentry/core").Integration;
+export declare const langGraphIntegration: (options?: LangGraphOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LangGraph";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -15,5 +15,7 @@ export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerI
  *  integrations: [Sentry.lruMemoizerIntegration()],
  * });
  */
-export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration;
+export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration & {
+    name: "LruMemoizer";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -16,5 +16,7 @@ export declare const instrumentMongo: ((options?: unknown) => MongoDBInstrumenta
  * });
  * ```
  */
-export declare const mongoIntegration: () => import("@sentry/core").Integration;
+export declare const mongoIntegration: () => import("@sentry/core").Integration & {
+    name: "Mongo";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -16,5 +16,7 @@ export declare const instrumentMongoose: ((options?: unknown) => MongooseInstrum
  * });
  * ```
  */
-export declare const mongooseIntegration: () => import("@sentry/core").Integration;
+export declare const mongooseIntegration: () => import("@sentry/core").Integration & {
+    name: "Mongoose";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -16,5 +16,7 @@ export declare const instrumentMysql: ((options?: unknown) => MySQLInstrumentati
  * });
  * ```
  */
-export declare const mysqlIntegration: () => import("@sentry/core").Integration;
+export declare const mysqlIntegration: () => import("@sentry/core").Integration & {
+    name: "Mysql";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,28 +1,14 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
 import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { MySQLInstrumentationConfig } from './types';
-export declare class MySQLInstrumentation extends InstrumentationBase<MySQLInstrumentationConfig> {
-    private _netSemconvStability;
-    private _dbSemconvStability;
-    private _connectionsUsageOld;
-    constructor(config?: MySQLInstrumentationConfig);
-    private _setSemconvStabilityFromEnv;
-    protected _updateMetricInstruments(): void;
-    /**
-     * Convenience function for updating the `db.client.connections.usage` metric.
-     * The name "count" comes from the eventually replacement for this metric per
-     * https://opentelemetry.io/docs/specs/semconv/non-normative/db-migration/#database-client-connection-count
-     */
-    private _connCountAdd;
+export declare class MySQLInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
     protected init(): InstrumentationNodeModuleDefinition[];
     private _patchCreateConnection;
     private _patchCreatePool;
-    private _patchPoolEnd;
     private _patchCreatePoolCluster;
-    private _patchAdd;
     private _patchGetConnection;
     private _getConnectionCallbackPatchFn;
     private _patchQuery;
     private _patchCallbackQuery;
-    private _setPoolCallbacks;
 }
 //# sourceMappingURL=instrumentation.d.ts.map

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

@@ -5,7 +5,7 @@ export interface MysqlError extends Error {
     sql?: string;
     sqlState?: string;
     sqlMessage?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface ConnectionConfig {
     host?: string;
@@ -13,16 +13,16 @@ export interface ConnectionConfig {
     database?: string;
     user?: string;
     password?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface PoolConfig extends ConnectionConfig {
     connectionConfig?: ConnectionConfig;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface QueryOptions {
     sql: string;
-    values?: any;
-    [key: string]: any;
+    values?: unknown;
+    [key: string]: unknown;
 }
 export interface FieldInfo {
     catalog: string;
@@ -34,35 +34,35 @@ export interface FieldInfo {
     charsetNr: number;
     length: number;
     type: number;
-    [key: string]: any;
+    [key: string]: unknown;
 }
-export type queryCallback = (err: MysqlError | null, results?: any, fields?: FieldInfo[]) => void;
+export type queryCallback = (err: MysqlError | null, results?: unknown, fields?: FieldInfo[]) => void;
 export interface Query {
     sql: string;
-    values?: any;
-    on(event: string, listener: (...args: any[]) => void): this;
-    [key: string]: any;
+    values?: unknown;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    [key: string]: unknown;
 }
 export type QueryFunction = {
     (query: string | QueryOptions, callback?: queryCallback): Query;
-    (query: string | QueryOptions, values?: any, callback?: queryCallback): Query;
+    (query: string | QueryOptions, values?: unknown, callback?: queryCallback): Query;
 };
 export interface Connection {
     config: ConnectionConfig;
     query: QueryFunction;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface PoolConnection extends Connection {
     release(): void;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface Pool {
     config: PoolConfig;
     query: QueryFunction;
     getConnection(callback: (err: MysqlError, connection: PoolConnection) => void): void;
     end(callback?: (err?: MysqlError) => void): void;
-    on(event: string, listener: (...args: any[]) => void): this;
-    [key: string]: any;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    [key: string]: unknown;
 }
 export interface PoolCluster {
     getConnection(callback: (err: MysqlError, connection: PoolConnection) => void): void;
@@ -70,7 +70,7 @@ export interface PoolCluster {
     getConnection(pattern: string, selector: string, callback: (err: MysqlError, connection: PoolConnection) => void): void;
     add(config: PoolConfig): void;
     add(id: string, config: PoolConfig): void;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export declare function createConnection(connectionUri: string | ConnectionConfig): Connection;
 export declare function createPool(config: string | PoolConfig): Pool;

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

@@ -77,12 +77,4 @@ export declare const ATTR_NET_PEER_PORT: "net.peer.port";
  * @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_MYSQL: "mysql";
-/**
- * Deprecated, use `db.client.connection.count` instead.
- *
- * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
- *
- * @deprecated Replaced by `db.client.connection.count`.
- */
-export declare const METRIC_DB_CLIENT_CONNECTIONS_USAGE: "db.client.connections.usage";
 //# sourceMappingURL=semconv.d.ts.map

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

@@ -1,16 +1,15 @@
-import { Pool, Query, QueryOptions } from './mysql-types';
-export declare function getConfig(config: any): {
-    host: any;
-    port: any;
-    database: any;
-    user: any;
+import { ConnectionConfig, PoolConfig, Query, QueryOptions } from './mysql-types';
+export declare function getConfig(config: ConnectionConfig | PoolConfig | undefined): {
+    host: string | undefined;
+    port: number | undefined;
+    database: string | undefined;
+    user: string | undefined;
 };
 export declare function getJDBCString(host: string | undefined, port: number | undefined, database: string | undefined): string;
 /**
  * @returns the database query being executed.
  */
 export declare function getDbQueryText(query: string | Query | QueryOptions): string;
-export declare function getDbValues(query: string | Query | QueryOptions, values?: any[]): string;
 /**
  * The span name SHOULD be set to a low cardinality value
  * representing the statement executed on the database.
@@ -20,6 +19,4 @@ export declare function getDbValues(query: string | Query | QueryOptions, values
  * @returns SQL statement without variable arguments or SQL verb
  */
 export declare function getSpanName(query: string | Query | QueryOptions): string;
-export declare function arrayStringifyHelper(arr: Array<unknown> | undefined): string;
-export declare function getPoolNameOld(pool: Pool): string;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -16,5 +16,7 @@ export declare const instrumentMysql2: ((options?: unknown) => MySQL2Instrumenta
  * });
  * ```
  */
-export declare const mysql2Integration: () => import("@sentry/core").Integration;
+export declare const mysql2Integration: () => import("@sentry/core").Integration & {
+    name: "Mysql2";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -56,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/index.d.ts

@@ -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=index.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/prisma/index.d.ts

@@ -17,26 +17,8 @@ export declare const instrumentPrisma: ((options?: PrismaOptions | undefined) =>
  * 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:
+ * NOTE: This integration works out of the box with Prisma v6, and v7.
+ * On Prisma versions prior to v6, add `previewFeatures = ["tracing"]` to the client generator block of your Prisma schema:
  *
  *    ```
  *    generator client {
@@ -45,6 +27,8 @@ export declare const instrumentPrisma: ((options?: PrismaOptions | undefined) =>
  *    }
  *    ```
  */
-export declare const prismaIntegration: (options?: PrismaOptions | undefined) => import("@sentry/core").Integration;
+export declare const prismaIntegration: (options?: PrismaOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Prisma";
+};
 export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,18 +1,16 @@
-import { Context, TracerProvider } from '@opentelemetry/api';
+import { Span } from '@sentry/core';
 import { EngineSpan, ExtendedSpanOptions, SpanCallback, TracingHelper } from './types';
 type Options = {
-    tracerProvider: TracerProvider;
     ignoreSpanTypes: (string | RegExp)[];
 };
 export declare class ActiveTracingHelper implements TracingHelper {
-    private tracerProvider;
     private ignoreSpanTypes;
-    constructor({ tracerProvider, ignoreSpanTypes }: Options);
+    constructor({ ignoreSpanTypes }: Options);
     isEnabled(): boolean;
-    getTraceParent(context?: Context | undefined): string;
+    getTraceParent(span?: Span): string;
     dispatchEngineSpans(spans: EngineSpan[]): void;
-    getActiveContext(): Context | undefined;
-    runInChildSpan<R>(options: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
+    getActiveContext(): Span | undefined;
+    runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
 }
 export {};
 //# sourceMappingURL=active-tracing-helper.d.ts.map

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

@@ -1,13 +1,11 @@
-import { TracerProvider } from '@opentelemetry/api';
-import { InstrumentationBase, InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
 export interface PrismaInstrumentationConfig {
     ignoreSpanTypes?: (string | RegExp)[];
 }
 type Config = PrismaInstrumentationConfig & InstrumentationConfig;
 export declare class PrismaInstrumentation extends InstrumentationBase {
-    private tracerProvider;
     constructor(config?: Config);
-    setTracerProvider(tracerProvider: TracerProvider): void;
     init(): InstrumentationNodeModuleDefinition[];
     enable(): void;
     disable(): void;

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

@@ -1,13 +1,12 @@
-import { Context, Span, SpanOptions } from '@opentelemetry/api';
-export type SpanCallback<R> = (span?: Span, context?: Context) => R;
+import { SpanOptions } from '@opentelemetry/api';
+import { Span } from '@sentry/core';
+export type SpanCallback<R> = (span?: Span, parentSpan?: Span) => R;
 export interface ExtendedSpanOptions extends SpanOptions {
     /** The name of the span */
     name: string;
     internal?: boolean;
     /** Whether it propagates context (?=true) */
     active?: boolean;
-    /** The context to append the span to */
-    context?: Context;
 }
 export type EngineSpanId = string;
 export type HrTime = [
@@ -25,28 +24,11 @@ export type EngineSpan = {
     attributes?: Record<string, unknown>;
     links?: EngineSpanId[];
 };
-export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'query';
-export interface EngineTraceEvent {
-    spanId: EngineSpanId;
-    target?: string;
-    level: LogLevel;
-    timestamp: HrTime;
-    attributes: Record<string, unknown> & {
-        message?: string;
-        query?: string;
-        duration_ms?: number;
-        params?: string;
-    };
-}
-export interface EngineTrace {
-    spans: EngineSpan[];
-    events: EngineTraceEvent[];
-}
 export interface TracingHelper {
     isEnabled(): boolean;
-    getTraceParent(context?: Context): string;
+    getTraceParent(span?: Span): string;
     dispatchEngineSpans(spans: EngineSpan[]): void;
-    getActiveContext(): Context | undefined;
+    getActiveContext(): Span | undefined;
     runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
 }
 export interface PrismaInstrumentationGlobalValue {