@sentry/node 10.53.0 → 10.54.0

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

@@ -0,0 +1,131 @@
+/**
+ * The number of messages sent, received, or processed in the scope of the batching operation.
+ *
+ * @example 0
+ * @example 1
+ * @example 2
+ *
+ * @note Instrumentations **SHOULD NOT** set `messaging.batch.message_count` on spans that operate with a single message. When a messaging client library supports both batch and single-message API for the same operation, instrumentations **SHOULD** use `messaging.batch.message_count` for batching APIs and **SHOULD NOT** use it for single-message APIs.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_BATCH_MESSAGE_COUNT: "messaging.batch.message_count";
+/**
+ * The message destination name
+ *
+ * @example MyQueue
+ * @example MyTopic
+ *
+ * @note Destination name **SHOULD** uniquely identify a specific queue, topic or other entity within the broker. If
+ * the broker doesn't have such notion, the destination name **SHOULD** uniquely identify the broker.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_DESTINATION_NAME: "messaging.destination.name";
+/**
+ * The identifier of the partition messages are sent to or received from, unique within the `messaging.destination.name`.
+ *
+ * @example "1"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_DESTINATION_PARTITION_ID: "messaging.destination.partition.id";
+/**
+ * Message keys in Kafka are used for grouping alike messages to ensure they're processed on the same partition. They differ from `messaging.message.id` in that they're not unique. If the key is `null`, the attribute **MUST NOT** be set.
+ *
+ * @example "myKey"
+ *
+ * @note If the key type is not string, it's string representation has to be supplied for the attribute. If the key has no unambiguous, canonical string form, don't include its value.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_KAFKA_MESSAGE_KEY: "messaging.kafka.message.key";
+/**
+ * A boolean that is true if the message is a tombstone.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE: "messaging.kafka.message.tombstone";
+/**
+ * The offset of a record in the corresponding Kafka partition.
+ *
+ * @example 42
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_KAFKA_OFFSET: "messaging.kafka.offset";
+/**
+ * The system-specific name of the messaging operation.
+ *
+ * @example ack
+ * @example nack
+ * @example send
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_OPERATION_NAME: "messaging.operation.name";
+/**
+ * A string identifying the type of the messaging operation.
+ *
+ * @note If a custom value is used, it **MUST** be of low cardinality.
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_OPERATION_TYPE: "messaging.operation.type";
+/**
+ * The messaging system as identified by the client instrumentation.
+ *
+ * @note The actual messaging system may differ from the one known by the client. For example, when using Kafka client libraries to communicate with Azure Event Hubs, the `messaging.system` is set to `kafka` based on the instrumentation's best knowledge.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const ATTR_MESSAGING_SYSTEM: "messaging.system";
+/**
+ * Enum value "process" for attribute {@link ATTR_MESSAGING_OPERATION_TYPE}.
+ */
+export declare const MESSAGING_OPERATION_TYPE_VALUE_PROCESS: "process";
+/**
+ * Enum value "receive" for attribute {@link ATTR_MESSAGING_OPERATION_TYPE}.
+ */
+export declare const MESSAGING_OPERATION_TYPE_VALUE_RECEIVE: "receive";
+/**
+ * Enum value "send" for attribute {@link ATTR_MESSAGING_OPERATION_TYPE}.
+ */
+export declare const MESSAGING_OPERATION_TYPE_VALUE_SEND: "send";
+/**
+ * Enum value "kafka" for attribute {@link ATTR_MESSAGING_SYSTEM}.
+ */
+export declare const MESSAGING_SYSTEM_VALUE_KAFKA: "kafka";
+/**
+ * Number of messages that were delivered to the application.
+ *
+ * @note Records the number of messages pulled from the broker or number of messages dispatched to the application in push-based scenarios.
+ * The metric **SHOULD** be reported once per message delivery. For example, if receiving and processing operations are both instrumented for a single message delivery, this counter is incremented when the message is received and not reported when it is processed.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_MESSAGING_CLIENT_CONSUMED_MESSAGES: "messaging.client.consumed.messages";
+/**
+ * Duration of messaging operation initiated by a producer or consumer client.
+ *
+ * @note This metric **SHOULD NOT** be used to report processing duration - processing duration is reported in `messaging.process.duration` metric.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_MESSAGING_CLIENT_OPERATION_DURATION: "messaging.client.operation.duration";
+/**
+ * Number of messages producer attempted to send to the broker.
+ *
+ * @note This metric **MUST NOT** count messages that were created but haven't yet been sent.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_MESSAGING_CLIENT_SENT_MESSAGES: "messaging.client.sent.messages";
+/**
+ * Duration of processing operation.
+ *
+ * @note This metric **MUST** be reported for operations with `messaging.operation.type` that matches `process`.
+ *
+ * @experimental This metric is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export declare const METRIC_MESSAGING_PROCESS_DURATION: "messaging.process.duration";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,26 @@
+import { Span } from '@opentelemetry/api';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface KafkajsMessage {
+    key?: Buffer | string | null;
+    value: Buffer | string | null;
+    partition?: number;
+    headers?: Record<string, Buffer | string | (Buffer | string)[] | undefined>;
+    timestamp?: string;
+}
+export interface MessageInfo<T = KafkajsMessage> {
+    topic: string;
+    message: T;
+}
+export interface KafkaProducerCustomAttributeFunction<T = KafkajsMessage> {
+    (span: Span, info: MessageInfo<T>): void;
+}
+export interface KafkaConsumerCustomAttributeFunction<T = KafkajsMessage> {
+    (span: Span, info: MessageInfo<T>): void;
+}
+export interface KafkaJsInstrumentationConfig extends InstrumentationConfig {
+    /** hook for adding custom attributes before producer message is sent */
+    producerHook?: KafkaProducerCustomAttributeFunction;
+    /** hook for adding custom attributes before consumer message is processed */
+    consumerHook?: KafkaConsumerCustomAttributeFunction;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -1,4 +1,4 @@
-import { KnexInstrumentation } from '@opentelemetry/instrumentation-knex';
+import { KnexInstrumentation } from './vendored/instrumentation';
 export declare const instrumentKnex: ((options?: unknown) => KnexInstrumentation) & {
     id: string;
 };
@@ -17,4 +17,4 @@ export declare const instrumentKnex: ((options?: unknown) => KnexInstrumentation
  * ```
  */
 export declare const knexIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=knex.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare const MODULE_NAME = "knex";
+export declare const SUPPORTED_VERSIONS: string[];
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1,14 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { KnexInstrumentationConfig } from './types';
+export declare class KnexInstrumentation extends InstrumentationBase<KnexInstrumentationConfig> {
+    private _semconvStability;
+    constructor(config?: KnexInstrumentationConfig);
+    setConfig(config?: KnexInstrumentationConfig): void;
+    init(): InstrumentationNodeModuleDefinition;
+    private getRunnerNodeModuleFileInstrumentation;
+    private getClientNodeModuleFileInstrumentation;
+    private createQueryWrapper;
+    private storeContext;
+    ensureWrapped(obj: any, methodName: string, wrapper: (original: any) => any): void;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * @deprecated Replaced by `db.namespace`.
+ */
+export declare const ATTR_DB_NAME: "db.name";
+/**
+ * @deprecated Replaced by `db.operation.name`.
+ */
+export declare const ATTR_DB_OPERATION: "db.operation";
+/**
+ * @deprecated Replaced by `db.collection.name`.
+ */
+export declare const ATTR_DB_SQL_TABLE: "db.sql.table";
+/**
+ * @deprecated Replaced by `db.query.text`.
+ */
+export declare const ATTR_DB_STATEMENT: "db.statement";
+/**
+ * @deprecated Replaced by `db.system.name`.
+ */
+export declare const ATTR_DB_SYSTEM: "db.system";
+/**
+ * @deprecated Removed, no replacement at this time.
+ */
+export declare const ATTR_DB_USER: "db.user";
+/**
+ * @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 Replaced by `server.port` on client spans and `client.port` on server spans.
+ */
+export declare const ATTR_NET_PEER_PORT: "net.peer.port";
+/**
+ * @deprecated Replaced by `network.transport`.
+ */
+export declare const ATTR_NET_TRANSPORT: "net.transport";
+export declare const DB_SYSTEM_NAME_VALUE_SQLITE: "sqlite";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,8 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface KnexInstrumentationConfig extends InstrumentationConfig {
+    /** max query length in db.statement attribute ".." is added to the end when query is truncated  */
+    maxQueryLength?: number;
+    /** only create spans if part of an existing trace */
+    requireParentSpan?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,15 @@
+import { Exception } from '@opentelemetry/api';
+type KnexError = Error & {
+    code?: string;
+};
+export declare const getFormatter: (runner: any) => any;
+export declare function otelExceptionFromKnexError(err: KnexError, message: string): Exception;
+export declare const mapSystem: (knexSystem: string) => string;
+export declare const getName: (db: string, operation?: string, table?: string) => string;
+export declare const limitLength: (str: string, maxLength: number) => string;
+export declare const extractDatabaseFromConnectionString: (connectionString?: string) => string | undefined;
+export declare const extractHostFromConnectionString: (connectionString?: string) => string | undefined;
+export declare const extractPortFromConnectionString: (connectionString?: string) => number | undefined;
+export declare const extractTableName: (builder: any) => string;
+export {};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,4 +1,4 @@
-import { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';
+import { KoaInstrumentation } from './vendored/instrumentation';
 interface KoaOptions {
     /**
      * Ignore layers of specified types
@@ -67,4 +67,4 @@ export declare const setupKoaErrorHandler: (app: {
     use: (arg0: (ctx: any, next: any) => Promise<void>) => void;
 }) => void;
 export {};
-//# sourceMappingURL=koa.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare enum AttributeNames {
+    KOA_TYPE = "koa.type",
+    KOA_NAME = "koa.name"
+}
+//# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -0,0 +1,32 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { KoaInstrumentationConfig } from './types';
+/** Koa instrumentation for OpenTelemetry */
+export declare class KoaInstrumentation extends InstrumentationBase<KoaInstrumentationConfig> {
+    constructor(config?: KoaInstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition;
+    /**
+     * Patches the Koa.use function in order to instrument each original
+     * middleware layer which is introduced
+     * @param {KoaMiddleware} middleware - the original middleware function
+     */
+    private _getKoaUsePatch;
+    /**
+     * Patches the dispatch function used by @koa/router. This function
+     * goes through each routed middleware and adds instrumentation via a call
+     * to the @function _patchLayer function.
+     * @param {KoaMiddleware} dispatchLayer - the original dispatch function which dispatches
+     * routed middleware
+     */
+    private _patchRouterDispatch;
+    /**
+     * Patches each individual @param middlewareLayer function in order to create the
+     * span and propagate context. It does not create spans when there is no parent span.
+     * @param {KoaMiddleware} middlewareLayer - the original middleware function.
+     * @param {boolean} isRouter - tracks whether the original middleware function
+     * was dispatched by the router originally
+     * @param {string?} layerPath - if present, provides additional data from the
+     * router about the routed path which the middleware is attached to
+     */
+    private _patchLayer;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,34 @@
+interface DefaultState {
+}
+export type Next = () => Promise<any>;
+type ParameterizedContext<_StateT = DefaultState, ContextT = {}, _ResponseBodyT = unknown> = {
+    [key: string]: any;
+} & ContextT;
+type Middleware<StateT = DefaultState, ContextT = {}, ResponseBodyT = any> = (context: ParameterizedContext<StateT, ContextT, ResponseBodyT>, next: Next) => any;
+interface RouterParamContext<StateT = DefaultState, ContextT = {}> {
+    params: Record<string, string>;
+    router: Router<StateT, ContextT>;
+    _matchedRoute: string | RegExp | undefined;
+    _matchedRouteName: string | undefined;
+}
+interface Layer {
+    path: string | RegExp;
+    stack: any[];
+}
+export interface Router<_StateT = DefaultState, _ContextT = {}> {
+    stack: Layer[];
+}
+export type KoaContext = ParameterizedContext<DefaultState, RouterParamContext>;
+export type KoaMiddleware = Middleware<DefaultState, KoaContext> & {
+    router?: Router;
+};
+/**
+ * This symbol is used to mark a Koa layer as being already instrumented
+ * since its possible to use a given layer multiple times (ex: middlewares)
+ */
+export declare const kLayerPatched: unique symbol;
+export type KoaPatchedMiddleware = KoaMiddleware & {
+    [kLayerPatched]?: boolean;
+};
+export {};
+//# sourceMappingURL=internal-types.d.ts.map

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

@@ -0,0 +1,50 @@
+import { Span } from '@opentelemetry/api';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export declare enum KoaLayerType {
+    ROUTER = "router",
+    MIDDLEWARE = "middleware"
+}
+/**
+ * Information about the current Koa middleware layer
+ * The middleware layer type is any by default.
+ * One can install koa types packages `@types/koa` and `@types/koa__router`
+ * with compatible versions to the koa version used in the project
+ * to get more specific types for the middleware layer property.
+ *
+ * Example use in a custom attribute function:
+ * ```ts
+ * import type { Middleware, ParameterizedContext, DefaultState } from 'koa';
+ * import type { RouterParamContext } from '@koa/router';
+ *
+ * type KoaContext = ParameterizedContext<DefaultState, RouterParamContext>;
+ * type KoaMiddleware = Middleware<DefaultState, KoaContext>;
+ *
+ * const koaConfig: KoaInstrumentationConfig<KoaContext, KoaMiddleware> = {
+ *  requestHook: (span: Span, info: KoaRequestInfo<KoaContext, KoaMiddleware>) => {
+ *   // custom typescript code that can access the typed into.middlewareLayer and info.context
+ * }
+ *
+ */
+export type KoaRequestInfo<KoaContextType = any, KoaMiddlewareType = any> = {
+    context: KoaContextType;
+    middlewareLayer: KoaMiddlewareType;
+    layerType: KoaLayerType;
+};
+/**
+ * Function that can be used to add custom attributes to the current span
+ * @param span - The Express middleware layer span.
+ * @param context - The current KoaContext.
+ */
+export interface KoaRequestCustomAttributeFunction<KoaContextType = any, KoaMiddlewareType = any> {
+    (span: Span, info: KoaRequestInfo<KoaContextType, KoaMiddlewareType>): void;
+}
+/**
+ * Options available for the Koa Instrumentation (see [documentation](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-Instrumentation-koa#koa-Instrumentation-options))
+ */
+export interface KoaInstrumentationConfig<KoaContextType = any, KoaMiddlewareType = any> extends InstrumentationConfig {
+    /** Ignore specific layers based on their type */
+    ignoreLayersType?: KoaLayerType[];
+    /** Function for adding custom attributes to each middleware layer span */
+    requestHook?: KoaRequestCustomAttributeFunction<KoaContextType, KoaMiddlewareType>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,15 @@
+import { KoaLayerType, KoaInstrumentationConfig } from './types';
+import { KoaContext, KoaMiddleware } from './internal-types';
+import { Attributes } from '@opentelemetry/api';
+export declare const getMiddlewareMetadata: (context: KoaContext, layer: KoaMiddleware, isRouter: boolean, layerPath?: string | RegExp) => {
+    attributes: Attributes;
+    name: string;
+};
+/**
+ * Check whether the given request is ignored by configuration
+ * @param [list] List of ignore patterns
+ * @param [onException] callback for doing something when an exception has
+ *     occurred
+ */
+export declare const isLayerIgnored: (type: KoaLayerType, config?: KoaInstrumentationConfig) => boolean;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,19 +1,19 @@
-import { LruMemoizerInstrumentation } from '@opentelemetry/instrumentation-lru-memoizer';
-export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for the [lru-memoizer](https://www.npmjs.com/package/lru-memoizer) library.
- *
- * For more information, see the [`lruMemoizerIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/lrumemoizer/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *  integrations: [Sentry.lruMemoizerIntegration()],
- * });
- */
-export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=lrumemoizer.d.ts.map
+import { LruMemoizerInstrumentation } from './vendored/instrumentation';
+export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [lru-memoizer](https://www.npmjs.com/package/lru-memoizer) library.
+ *
+ * For more information, see the [`lruMemoizerIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/lrumemoizer/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.lruMemoizerIntegration()],
+ * });
+ */
+export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,4 +1,4 @@
-import { MongoDBInstrumentation } from '@opentelemetry/instrumentation-mongodb';
+import { MongoDBInstrumentation } from './vendored/instrumentation';
 export declare const instrumentMongo: ((options?: unknown) => MongoDBInstrumentation) & {
     id: string;
 };
@@ -21,4 +21,4 @@ export declare function _defaultDbStatementSerializer(commandObj: Record<string,
  * ```
  */
 export declare const mongoIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=mongo.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,79 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { MongoDBInstrumentationConfig } from './types';
+/** mongodb instrumentation plugin for OpenTelemetry */
+export declare class MongoDBInstrumentation extends InstrumentationBase<MongoDBInstrumentationConfig> {
+    private _netSemconvStability;
+    private _dbSemconvStability;
+    private _connectionsUsage;
+    private _poolName;
+    constructor(config?: MongoDBInstrumentationConfig);
+    private _setSemconvStabilityFromEnv;
+    setConfig(config?: MongoDBInstrumentationConfig): void;
+    _updateMetricInstruments(): void;
+    /**
+     * Convenience function for updating the `db.client.connections.usage` metric.
+     * The name "count" comes from the eventual replacement for this metric per
+     * https://opentelemetry.io/docs/specs/semconv/non-normative/db-migration/#database-client-connection-count
+     */
+    private _connCountAdd;
+    init(): InstrumentationNodeModuleDefinition[];
+    private _getV3ConnectionPatches;
+    private _getV4SessionsPatches;
+    private _getV4AcquireCommand;
+    private _getV4ReleaseCommand;
+    private _getV4ConnectionPoolPatches;
+    private _getV4ConnectPatches;
+    private _getV4ConnectionPoolCheckOut;
+    private _getV4ConnectCommand;
+    private _getV4ConnectionPatches;
+    /** Creates spans for common operations */
+    private _getV3PatchOperation;
+    /** Creates spans for command operation */
+    private _getV3PatchCommand;
+    /** Creates spans for command operation */
+    private _getV4PatchCommandCallback;
+    private _getV4PatchCommandPromise;
+    /** Creates spans for find operation */
+    private _getV3PatchFind;
+    /** Creates spans for find operation */
+    private _getV3PatchCursor;
+    /**
+     * Get the mongodb command type from the object.
+     * @param command Internal mongodb command object
+     */
+    private static _getCommandType;
+    /**
+     * Determine a span's attributes by fetching related metadata from the context
+     * @param connectionCtx mongodb internal connection context
+     * @param ns mongodb namespace
+     * @param command mongodb internal representation of a command
+     */
+    private _getV4SpanAttributes;
+    /**
+     * Determine a span's attributes by fetching related metadata from the context
+     * @param ns mongodb namespace
+     * @param topology mongodb internal representation of the network topology
+     * @param command mongodb internal representation of a command
+     */
+    private _getV3SpanAttributes;
+    private _getSpanAttributes;
+    private _spanNameFromAttrs;
+    private _getDefaultDbStatementReplacer;
+    private _defaultDbStatementSerializer;
+    /**
+     * Triggers the response hook in case it is defined.
+     * @param span The span to add the results to.
+     * @param result The command result
+     */
+    private _handleExecutionResult;
+    /**
+     * Ends a created span.
+     * @param span The created span to end.
+     * @param resultHandler A callback function.
+     * @param connectionId: The connection ID of the Command response.
+     */
+    private _patchEnd;
+    private setPoolName;
+    private _checkSkipInstrumentation;
+}
+//# sourceMappingURL=instrumentation.d.ts.map