@sentry/node 10.53.0 → 10.54.0

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

@@ -0,0 +1,88 @@
+/**
+ * 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";
+/**
+ * Deprecated, use `db.namespace` instead.
+ *
+ * @example customers
+ * @example main
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.namespace`.
+ */
+export declare const ATTR_DB_NAME: "db.name";
+/**
+ * The database statement being executed.
+ *
+ * @example SELECT * FROM wuser_table
+ * @example SET mykey "WuValue"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.query.text`.
+ */
+export declare const ATTR_DB_STATEMENT: "db.statement";
+/**
+ * Deprecated, use `db.system.name` instead.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.system.name`.
+ */
+export declare const ATTR_DB_SYSTEM: "db.system";
+/**
+ * Deprecated, no replacement at this time.
+ *
+ * @example readonly_user
+ * @example reporting_user
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Removed, no replacement at this time.
+ */
+export declare const ATTR_DB_USER: "db.user";
+/**
+ * Deprecated, use `server.address` on client spans and `client.address` on server spans.
+ *
+ * @example example.com
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.address` on client spans and `client.address` on server spans.
+ */
+export declare const ATTR_NET_PEER_NAME: "net.peer.name";
+/**
+ * Deprecated, use `server.port` on client spans and `client.port` on server spans.
+ *
+ * @example 8080
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.port` on client spans and `client.port` on server spans.
+ */
+export declare const ATTR_NET_PEER_PORT: "net.peer.port";
+/**
+ * Enum value "mysql" for attribute {@link ATTR_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";
+/**
+ * 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/types.d.ts

@@ -0,0 +1,9 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface MySQLInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * If true, an attribute containing the query's parameters will be attached
+     * the spans generated to represent the query.
+     */
+    enhancedDatabaseReporting?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,25 @@
+import { Pool, Query, QueryOptions } from './mysql-types';
+export declare function getConfig(config: any): {
+    host: any;
+    port: any;
+    database: any;
+    user: any;
+};
+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.
+ *
+ * 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;
+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.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;
 };
@@ -17,4 +17,4 @@ export declare const instrumentMysql2: ((options?: unknown) => MySQL2Instrumenta
  * ```
  */
 export declare const mysql2Integration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=mysql2.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,12 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { MySQL2InstrumentationConfig } from './types';
+export declare class MySQL2Instrumentation extends InstrumentationBase<MySQL2InstrumentationConfig> {
+    private _netSemconvStability;
+    private _dbSemconvStability;
+    constructor(config?: MySQL2InstrumentationConfig);
+    private _setSemconvStabilityFromEnv;
+    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,9 @@
+export declare const ATTR_DB_CONNECTION_STRING: "db.connection_string";
+export declare const ATTR_DB_NAME: "db.name";
+export declare const ATTR_DB_STATEMENT: "db.statement";
+export declare const ATTR_DB_SYSTEM: "db.system";
+export declare const ATTR_DB_USER: "db.user";
+export declare const ATTR_NET_PEER_NAME: "net.peer.name";
+export declare const ATTR_NET_PEER_PORT: "net.peer.port";
+export declare const DB_SYSTEM_VALUE_MYSQL: "mysql";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,18 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { Span } from '@opentelemetry/api';
+export interface MySQL2ResponseHookInformation {
+    queryResults: any;
+}
+export interface MySQL2InstrumentationExecutionResponseHook {
+    (span: Span, responseHookInfo: MySQL2ResponseHookInformation): void;
+}
+export interface MySQL2InstrumentationQueryMaskingHook {
+    (query: string): string;
+}
+export interface MySQL2InstrumentationConfig extends InstrumentationConfig {
+    maskStatement?: boolean;
+    maskStatementHook?: MySQL2InstrumentationQueryMaskingHook;
+    responseHook?: MySQL2InstrumentationExecutionResponseHook;
+    addSqlCommenterCommentToQueries?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,27 @@
+import { Attributes } from '@opentelemetry/api';
+import { FormatFunction } from './mysql2-types';
+import { MySQL2InstrumentationQueryMaskingHook } from './types';
+import { SemconvStability } from '@opentelemetry/instrumentation';
+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, dbSemconvStability: SemconvStability, netSemconvStability: SemconvStability): Attributes;
+export declare function getQueryText(query: string | Query | QueryOptions, format?: FormatFunction, values?: any[], maskStatement?: boolean, maskStatementHook?: MySQL2InstrumentationQueryMaskingHook): 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

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;
 }
@@ -21,4 +21,4 @@ export declare const instrumentPostgres: ((options: PostgresIntegrationOptions |
  */
 export declare const postgresIntegration: (options?: PostgresIntegrationOptions | undefined) => import("@sentry/core").Integration;
 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,7 @@
+export declare enum AttributeNames {
+    PG_VALUES = "db.postgresql.values",
+    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,20 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { PgInstrumentationConfig } from './types';
+export declare class PgInstrumentation extends InstrumentationBase<PgInstrumentationConfig> {
+    private _operationDuration;
+    private _connectionsCount;
+    private _connectionPendingRequests;
+    private _connectionsCounter;
+    private _semconvStability;
+    constructor(config?: PgInstrumentationConfig);
+    _updateMetricInstruments(): void;
+    protected init(): InstrumentationNodeModuleDefinition[];
+    private _patchPgClient;
+    private _unpatchPgClient;
+    private _getClientConnectPatch;
+    private recordOperationDuration;
+    private _getClientQueryPatch;
+    private _setPoolConnectEventListeners;
+    private _getPoolConnectPatch;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,35 @@
+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 declare const EVENT_LISTENERS_SET: unique symbol;
+export interface PgPoolExtended extends PgPool {
+    options: PgPoolOptionsParams;
+    [EVENT_LISTENERS_SET]?: boolean;
+}
+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,112 @@
+/**
+ * The name of the connection pool; unique within the instrumented application. In case the connection pool implementation doesn't provide a name, instrumentation **SHOULD** use a combination of parameters that would make the name unique, for example, combining attributes `server.address`, `server.port`, and `db.namespace`, formatted as `server.address:server.port/db.namespace`. Instrumentations that generate connection pool name following different patterns **SHOULD** document it.
+ *
+ * @example myDataSource
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_DB_CLIENT_CONNECTION_POOL_NAME: "db.client.connection.pool.name";
+/**
+ * The state of a connection in the pool
+ *
+ * @example idle
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_DB_CLIENT_CONNECTION_STATE: "db.client.connection.state";
+/**
+ * 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";
+/**
+ * Deprecated, use `db.namespace` instead.
+ *
+ * @example customers
+ * @example main
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.namespace`.
+ */
+export declare const ATTR_DB_NAME: "db.name";
+/**
+ * The database statement being executed.
+ *
+ * @example SELECT * FROM wuser_table
+ * @example SET mykey "WuValue"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.query.text`.
+ */
+export declare const ATTR_DB_STATEMENT: "db.statement";
+/**
+ * Deprecated, use `db.system.name` instead.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `db.system.name`.
+ */
+export declare const ATTR_DB_SYSTEM: "db.system";
+/**
+ * Deprecated, no replacement at this time.
+ *
+ * @example readonly_user
+ * @example reporting_user
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Removed, no replacement at this time.
+ */
+export declare const ATTR_DB_USER: "db.user";
+/**
+ * Deprecated, use `server.address` on client spans and `client.address` on server spans.
+ *
+ * @example example.com
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.address` on client spans and `client.address` on server spans.
+ */
+export declare const ATTR_NET_PEER_NAME: "net.peer.name";
+/**
+ * Deprecated, use `server.port` on client spans and `client.port` on server spans.
+ *
+ * @example 8080
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.port` on client spans and `client.port` on server spans.
+ */
+export declare const ATTR_NET_PEER_PORT: "net.peer.port";
+/**
+ * Enum value "idle" for attribute {@link ATTR_DB_CLIENT_CONNECTION_STATE}.
+ */
+export declare const DB_CLIENT_CONNECTION_STATE_VALUE_IDLE: "idle";
+/**
+ * Enum value "used" for attribute {@link ATTR_DB_CLIENT_CONNECTION_STATE}.
+ */
+export declare const DB_CLIENT_CONNECTION_STATE_VALUE_USED: "used";
+/**
+ * Enum value "postgresql" for attribute {@link ATTR_DB_SYSTEM}.
+ */
+export declare const DB_SYSTEM_VALUE_POSTGRESQL: "postgresql";
+/**
+ * The number of connections that are currently in state described by the `state` attribute
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_DB_CLIENT_CONNECTION_COUNT: "db.client.connection.count";
+/**
+ * The number of current pending requests for an open connection
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_DB_CLIENT_CONNECTION_PENDING_REQUESTS: "db.client.connection.pending_requests";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,65 @@
+import { QueryResult, QueryArrayResult } from './pg-types';
+import * as api from '@opentelemetry/api';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface PgResponseHookInformation {
+    data: QueryResult | QueryArrayResult;
+}
+export interface PgInstrumentationExecutionResponseHook {
+    (span: api.Span, responseInfo: PgResponseHookInformation): void;
+}
+export interface PgRequestHookInformation {
+    query: {
+        text: string;
+        name?: string;
+        values?: unknown[];
+    };
+    connection: {
+        database?: string;
+        host?: string;
+        port?: number;
+        user?: string;
+    };
+}
+export interface PgInstrumentationExecutionRequestHook {
+    (span: api.Span, queryInfo: PgRequestHookInformation): void;
+}
+export interface PgInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * If true, an attribute containing the query's parameters will be attached
+     * the spans generated to represent the query.
+     */
+    enhancedDatabaseReporting?: boolean;
+    /**
+     * Hook that allows adding custom span attributes or updating the
+     * span's name based on the data about the query to execute.
+     *
+     * @default undefined
+     */
+    requestHook?: PgInstrumentationExecutionRequestHook;
+    /**
+     * Hook that allows adding custom span attributes based on the data
+     * returned from "query" Pg actions.
+     *
+     * @default undefined
+     */
+    responseHook?: PgInstrumentationExecutionResponseHook;
+    /**
+     * If true, requires a parent span to create new spans.
+     *
+     * @default false
+     */
+    requireParentSpan?: boolean;
+    /**
+     * If true, queries are modified to also include a comment with
+     * the tracing context, following the {@link https://github.com/open-telemetry/opentelemetry-sqlcommenter sqlcommenter} format
+     */
+    addSqlCommenterCommentToQueries?: boolean;
+    /**
+     * If true, `pg.connect` and `pg-pool.connect` spans will not be created.
+     * Query spans and pool metrics 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,69 @@
+import { Span, Tracer, UpDownCounter, Attributes } from '@opentelemetry/api';
+import { PgClientExtended, PostgresCallback, PgPoolCallback, PgPoolExtended, PgParsedConnectionParams, PgPoolOptionsParams } from './internal-types';
+import { PgInstrumentationConfig } from './types';
+import { QueryResult, QueryArrayResult } from './pg-types';
+import { SemconvStability } from '@opentelemetry/instrumentation';
+/**
+ * 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, semconvStability: SemconvStability): Attributes;
+export declare function getSemanticAttributesFromPoolConnection(params: PgPoolOptionsParams, semconvStability: SemconvStability): Attributes;
+export declare function shouldSkipInstrumentation(instrumentationConfig: PgInstrumentationConfig): boolean;
+export declare function handleConfigQuery(this: PgClientExtended, tracer: Tracer, instrumentationConfig: PgInstrumentationConfig, semconvStability: SemconvStability, queryConfig?: {
+    text: string;
+    values?: unknown;
+    name?: unknown;
+}): Span;
+export declare function handleExecutionResult(config: PgInstrumentationConfig, span: Span, pgResult: QueryResult | QueryArrayResult | unknown): void;
+export declare function patchCallback(instrumentationConfig: PgInstrumentationConfig, span: Span, cb: PostgresCallback, attributes: Attributes, recordDuration: {
+    (): void;
+}): PostgresCallback;
+export declare function getPoolName(pool: PgPoolOptionsParams): string;
+export interface poolConnectionsCounter {
+    used: number;
+    idle: number;
+    pending: number;
+}
+export declare function updateCounter(poolName: string, pool: PgPoolExtended, connectionCount: UpDownCounter, connectionPendingRequests: UpDownCounter, latestCounter: poolConnectionsCounter): poolConnectionsCounter;
+export declare function patchCallbackPGPool(span: Span, cb: PgPoolCallback): PgPoolCallback;
+export declare function patchClientConnectCallback(span: Span, cb: Function): Function;
+/**
+ * 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;
+};
+/**
+ * Generates a sanitized message for the error.
+ * Only includes the error type and PostgreSQL error code, omitting any sensitive details.
+ */
+export declare function sanitizedErrorMessage(error: unknown): string;
+//# sourceMappingURL=utils.d.ts.map