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

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

@@ -21,7 +21,7 @@ export declare const instrumentLangChain: ((options?: LangChainOptions | undefin
  *
  * Sentry.init({
  *   integrations: [Sentry.langChainIntegration()],
- *   sendDefaultPii: true, // Enable to record inputs/outputs
+ *   dataCollection: { genAI: { inputs: true, outputs: true } }, // Enable to record inputs/outputs
  * });
  *
  * // LangChain calls are automatically instrumented
@@ -52,18 +52,19 @@ export declare const instrumentLangChain: ((options?: LangChainOptions | undefin
  *
  * ## Options
  *
- * - `recordInputs`: Whether to record input messages/prompts (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.langChainIntegration({
@@ -73,9 +74,9 @@ export declare const instrumentLangChain: ((options?: LangChainOptions | undefin
  *   ],
  * });
  *
- * // 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.langChainIntegration({
  *       recordInputs: false,
@@ -94,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

@@ -21,18 +21,19 @@ export declare const instrumentLangGraph: ((options?: LangGraphOptions | undefin
  *
  * ## Options
  *
- * - `recordInputs`: Whether to record input messages (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ * - `recordInputs`: Whether to record prompt messages (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.langGraphIntegration({
@@ -42,9 +43,9 @@ export declare const instrumentLangGraph: ((options?: LangGraphOptions | undefin
  *   ],
  * });
  *
- * // 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.langGraphIntegration({
  *       recordInputs: false,
@@ -70,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/langgraph/instrumentation.d.ts

@@ -9,7 +9,7 @@ export declare class SentryLangGraphInstrumentation extends InstrumentationBase<
     /**
      * Initializes the instrumentation by defining the modules to be patched.
      */
-    init(): InstrumentationModuleDefinition;
+    init(): InstrumentationModuleDefinition[];
     /**
      * Core patch logic applying instrumentation to the LangGraph module.
      */

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

@@ -1,4 +1,4 @@
-import { LruMemoizerInstrumentation } from '@opentelemetry/instrumentation-lru-memoizer';
+import { LruMemoizerInstrumentation } from './vendored/instrumentation';
 export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerInstrumentation) & {
     id: string;
 };
@@ -15,5 +15,7 @@ export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerI
  *  integrations: [Sentry.lruMemoizerIntegration()],
  * });
  */
-export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=lrumemoizer.d.ts.map
+export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration & {
+    name: "LruMemoizer";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare class LruMemoizerInstrumentation extends InstrumentationBase {
+    constructor();
+    init(): InstrumentationNodeModuleDefinition[];
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

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

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

@@ -0,0 +1,11 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+/** mongodb instrumentation plugin */
+export declare class MongoDBInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
+    init(): InstrumentationNodeModuleDefinition[];
+    private _getV3ConnectionPatches;
+    private _getV4ConnectionPoolPatches;
+    private _getV4ConnectionPatches;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,62 @@
+export type MongoInternalCommand = {
+    findandmodify: boolean;
+    createIndexes: boolean;
+    count: boolean;
+    aggregate: boolean;
+    ismaster: boolean;
+    indexes?: unknown[];
+    query?: Record<string, unknown>;
+    limit?: number;
+    q?: Record<string, unknown>;
+    u?: Record<string, unknown>;
+};
+export type CursorState = {
+    cmd: MongoInternalCommand;
+} & Record<string, unknown>;
+export type WireProtocolInternal = {
+    insert: (server: MongoInternalTopology, ns: string, ops: unknown[], options: unknown | Function, callback?: Function) => unknown;
+    update: (server: MongoInternalTopology, ns: string, ops: unknown[], options: unknown | Function, callback?: Function) => unknown;
+    remove: (server: MongoInternalTopology, ns: string, ops: unknown[], options: unknown | Function, callback?: Function) => unknown;
+    killCursors: (server: MongoInternalTopology, ns: string, cursorState: CursorState, callback: Function) => unknown;
+    getMore: (server: MongoInternalTopology, ns: string, cursorState: CursorState, batchSize: number, options: unknown | Function, callback?: Function) => unknown;
+    query: (server: MongoInternalTopology, ns: string, cmd: MongoInternalCommand, cursorState: CursorState, options: unknown | Function, callback?: Function) => unknown;
+    command: (server: MongoInternalTopology, ns: string, cmd: MongoInternalCommand, options: unknown | Function, callback?: Function) => unknown;
+};
+export type MongoInternalTopology = {
+    s?: {
+        options?: {
+            host?: string;
+            port?: number;
+            servername?: string;
+        };
+        host?: string;
+        port?: number;
+    };
+    description?: {
+        address?: string;
+    };
+};
+export declare enum MongodbCommandType {
+    CREATE_INDEXES = "createIndexes",
+    FIND_AND_MODIFY = "findAndModify",
+    IS_MASTER = "isMaster",
+    COUNT = "count",
+    AGGREGATE = "aggregate",
+    UNKNOWN = "unknown"
+}
+export type Document = {
+    [key: string]: any;
+};
+export interface MongodbNamespace {
+    db: string;
+    collection?: string;
+}
+export type V4Connection = {
+    command: Function;
+    commandPromise(ns: MongodbNamespace, cmd: Document, options: undefined | unknown, responseType: undefined | unknown): Promise<any>;
+    commandCallback(ns: MongodbNamespace, cmd: Document, options: undefined | unknown, callback: any): void;
+};
+export type V4ConnectionPool = {
+    checkOut: (callback: (error: any, connection: any) => void) => void;
+};
+//# sourceMappingURL=internal-types.d.ts.map

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

@@ -0,0 +1,15 @@
+import { CursorState, MongodbNamespace, MongoInternalCommand, MongoInternalTopology, V4Connection, V4ConnectionPool, WireProtocolInternal } from './internal-types';
+/** Creates spans for v3 common operations (insert/update/remove). */
+export declare function getV3PatchOperation(operationName: 'insert' | 'update' | 'remove'): (original: WireProtocolInternal[typeof operationName]) => (this: unknown, server: MongoInternalTopology, ns: string, ops: unknown[], options: unknown | Function, callback?: Function) => any;
+/** Creates spans for the v3 command operation. */
+export declare function getV3PatchCommand(): (original: WireProtocolInternal["command"]) => (this: unknown, server: MongoInternalTopology, ns: string, cmd: MongoInternalCommand, options: unknown | Function, callback?: Function) => any;
+/** Creates spans for the v4 (<6.4) callback-style command operation. */
+export declare function getV4PatchCommandCallback(): (original: V4Connection["commandCallback"]) => (this: any, ns: MongodbNamespace, cmd: any, options: undefined | unknown, callback: any) => any;
+/** Creates spans for the v4 (>=6.4) promise-style command operation. */
+export declare function getV4PatchCommandPromise(): (original: V4Connection["commandPromise"]) => (this: any, ...args: Parameters<V4Connection["commandPromise"]>) => any;
+/** Creates spans for the v3 find operation. */
+export declare function getV3PatchFind(): (original: WireProtocolInternal["query"]) => (this: unknown, server: MongoInternalTopology, ns: string, cmd: MongoInternalCommand, cursorState: CursorState, options: unknown | Function, callback?: Function) => any;
+/** Creates spans for the v3 getMore (cursor) operation. */
+export declare function getV3PatchCursor(): (original: WireProtocolInternal["getMore"]) => (this: unknown, server: MongoInternalTopology, ns: string, cursorState: CursorState, batchSize: number, options: unknown | Function, callback?: Function) => any;
+export declare function getV4ConnectionPoolCheckOut(): (original: V4ConnectionPool["checkOut"]) => (this: unknown, callback: (error: any, connection: any) => void) => any;
+//# sourceMappingURL=patches.d.ts.map

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

@@ -0,0 +1,15 @@
+import { Span, SpanAttributes } from '@sentry/core';
+import { getV3CommandOperation, startMongoSpan } from '@sentry/server-utils';
+export { getV3CommandOperation, startMongoSpan };
+/** Determine a span's attributes from the v4 connection context (OTel origin). */
+export declare function getV4SpanAttributes(connectionCtx: any, ns: any, command?: any, operation?: string): SpanAttributes;
+/** Determine a span's attributes from the v3 topology (OTel origin). */
+export declare function getV3SpanAttributes(ns: string, topology: any, command?: any, operation?: string): SpanAttributes;
+/**
+ * Wraps the result handler so it ends the span (with error status on failure) and runs the
+ * original callback re-activated under the parent span — mongodb loses the async context when
+ * it invokes the callback on a later tick.
+ */
+export declare function patchEnd(span: Span | undefined, resultHandler: Function): Function;
+export declare function shouldSkipInstrumentation(): boolean;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,4 +1,4 @@
-import { MongooseInstrumentation } from '@opentelemetry/instrumentation-mongoose';
+import { MongooseInstrumentation } from './vendored/mongoose';
 export declare const instrumentMongoose: ((options?: unknown) => MongooseInstrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentMongoose: ((options?: unknown) => MongooseInstrum
  * });
  * ```
  */
-export declare const mongooseIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=mongoose.d.ts.map
+export declare const mongooseIntegration: () => import("@sentry/core").Integration & {
+    name: "Mongoose";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,33 @@
+export interface Collection {
+    name: string;
+    conn: Connection;
+    [key: string]: any;
+}
+export interface Connection {
+    name: string;
+    host: string;
+    port: number;
+    user?: string;
+    [key: string]: any;
+}
+export declare const Model: {
+    prototype: any;
+    collection: Collection;
+    modelName: string;
+    aggregate: Function;
+    insertMany: Function;
+    bulkWrite: Function;
+    [key: string]: any;
+};
+export declare const Query: {
+    prototype: any;
+    [key: string]: any;
+};
+export declare const Aggregate: {
+    prototype: any;
+    [key: string]: any;
+};
+export interface MongooseError extends Error {
+    code?: number;
+}
+//# sourceMappingURL=mongoose-types.d.ts.map

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

@@ -0,0 +1,18 @@
+import { InstrumentationConfig, InstrumentationBase, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+export declare const _STORED_PARENT_SPAN: unique symbol;
+export declare const _ALREADY_INSTRUMENTED: unique symbol;
+export declare class MongooseInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
+    protected init(): InstrumentationModuleDefinition;
+    private patch;
+    private unpatch;
+    private patchAggregateExec;
+    private patchQueryExec;
+    private patchOnModelMethods;
+    private _patchDocumentUpdateMethods;
+    private patchModelStatic;
+    private patchModelAggregate;
+    private patchAndCaptureSpanContext;
+    private _handleResponse;
+}
+//# sourceMappingURL=mongoose.d.ts.map

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

@@ -0,0 +1,4 @@
+import { Span } from '@sentry/core';
+export declare function handlePromiseResponse(execResponse: any, span: Span): any;
+export declare function handleCallbackResponse(callback: Function, exec: Function, originalThis: any, span: Span, args: IArguments): any;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,4 +1,4 @@
-import { MySQLInstrumentation } from '@opentelemetry/instrumentation-mysql';
+import { MySQLInstrumentation } from './vendored/instrumentation';
 export declare const instrumentMysql: ((options?: unknown) => MySQLInstrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentMysql: ((options?: unknown) => MySQLInstrumentati
  * });
  * ```
  */
-export declare const mysqlIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=mysql.d.ts.map
+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

@@ -0,0 +1,14 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare class MySQLInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition[];
+    private _patchCreateConnection;
+    private _patchCreatePool;
+    private _patchCreatePoolCluster;
+    private _patchGetConnection;
+    private _getConnectionCallbackPatchFn;
+    private _patchQuery;
+    private _patchCallbackQuery;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,78 @@
+export interface MysqlError extends Error {
+    code: string;
+    errno: number;
+    fatal: boolean;
+    sql?: string;
+    sqlState?: string;
+    sqlMessage?: string;
+    [key: string]: unknown;
+}
+export interface ConnectionConfig {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    [key: string]: unknown;
+}
+export interface PoolConfig extends ConnectionConfig {
+    connectionConfig?: ConnectionConfig;
+    [key: string]: unknown;
+}
+export interface QueryOptions {
+    sql: string;
+    values?: unknown;
+    [key: string]: unknown;
+}
+export interface FieldInfo {
+    catalog: string;
+    db: string;
+    table: string;
+    orgTable: string;
+    name: string;
+    orgName: string;
+    charsetNr: number;
+    length: number;
+    type: number;
+    [key: string]: unknown;
+}
+export type queryCallback = (err: MysqlError | null, results?: unknown, fields?: FieldInfo[]) => void;
+export interface Query {
+    sql: string;
+    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?: unknown, callback?: queryCallback): Query;
+};
+export interface Connection {
+    config: ConnectionConfig;
+    query: QueryFunction;
+    [key: string]: unknown;
+}
+export interface PoolConnection extends Connection {
+    release(): void;
+    [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: unknown[]) => void): this;
+    [key: string]: unknown;
+}
+export interface PoolCluster {
+    getConnection(callback: (err: MysqlError, connection: PoolConnection) => void): void;
+    getConnection(pattern: string, callback: (err: MysqlError, connection: PoolConnection) => void): void;
+    getConnection(pattern: string, selector: string, callback: (err: MysqlError, connection: PoolConnection) => void): void;
+    add(config: PoolConfig): void;
+    add(id: string, config: PoolConfig): void;
+    [key: string]: unknown;
+}
+export declare function createConnection(connectionUri: string | ConnectionConfig): Connection;
+export declare function createPool(config: string | PoolConfig): Pool;
+export declare function createPoolCluster(config?: PoolConfig): PoolCluster;
+//# sourceMappingURL=mysql-types.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * Deprecated, use `server.address`, `server.port` attributes instead.
+ *
+ * @example "Server=(localdb)\\v11.0;Integrated Security=true;"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.address` and `server.port`.
+ */
+export declare const ATTR_DB_CONNECTION_STRING: "db.connection_string";
+/**
+ * Enum value "mysql" for attribute `db.system`.
+ *
+ * MySQL
+ *
+ * @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";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,22 @@
+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;
+/**
+ * The span name SHOULD be set to a low cardinality value
+ * representing the statement executed on the database.
+ *
+ * TODO: revisit span name based on https://github.com/open-telemetry/semantic-conventions/blob/v1.33.0/docs/database/database-spans.md#name
+ *
+ * @returns SQL statement without variable arguments or SQL verb
+ */
+export declare function getSpanName(query: string | Query | QueryOptions): string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,4 +1,4 @@
-import { MySQL2Instrumentation } from '@opentelemetry/instrumentation-mysql2';
+import { MySQL2Instrumentation } from './vendored/instrumentation';
 export declare const instrumentMysql2: ((options?: unknown) => MySQL2Instrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentMysql2: ((options?: unknown) => MySQL2Instrumenta
  * });
  * ```
  */
-export declare const mysql2Integration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=mysql2.d.ts.map
+export declare const mysql2Integration: () => import("@sentry/core").Integration & {
+    name: "Mysql2";
+};
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,39 @@
+export interface Connection {
+    config: ConnectionConfig;
+    query: (...args: any[]) => Query;
+    execute: (...args: any[]) => Query;
+    [key: string]: any;
+}
+export interface ConnectionConfig {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    connectionConfig?: ConnectionConfig;
+    [key: string]: any;
+}
+export interface Query {
+    sql: string;
+    onResult?: (...args: any[]) => any;
+    once(event: string, callback: (...args: any[]) => void): Query;
+    [key: string]: any;
+}
+export interface QueryOptions {
+    sql: string;
+    values?: any | any[] | {
+        [param: string]: any;
+    };
+    [key: string]: any;
+}
+export interface QueryError extends Error {
+    code?: string;
+    errno?: number;
+    sqlState?: string;
+    sqlMessage?: string;
+    [key: string]: any;
+}
+export interface FieldPacket {
+    [key: string]: any;
+}
+export type FormatFunction = (sql: string, values?: any[], stringifyObjects?: boolean, timeZone?: string) => string;
+//# sourceMappingURL=mysql2-types.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare const ATTR_DB_CONNECTION_STRING: "db.connection_string";
+export declare const DB_SYSTEM_VALUE_MYSQL: "mysql";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,25 @@
+import { SpanAttributes } from '@sentry/core';
+import { FormatFunction } from './mysql2-types';
+interface QueryOptions {
+    sql: string;
+    values?: any | any[] | {
+        [param: string]: any;
+    };
+}
+interface Query {
+    sql: string;
+}
+interface Config {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    connectionConfig?: Config;
+}
+export declare function getConnectionAttributes(config: Config): SpanAttributes;
+export declare function getQueryText(query: string | Query | QueryOptions, format?: FormatFunction, values?: any[]): string;
+export declare function getSpanName(query: string | Query | QueryOptions): string;
+export declare const once: (fn: Function) => (...args: unknown[]) => any;
+export declare function getConnectionPrototypeToInstrument(connection: any): any;
+export {};
+//# sourceMappingURL=utils.d.ts.map