@sentry/node 10.58.0 → 10.59.0

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

@@ -1,29 +1,24 @@
-import * as fs from 'fs';
-import * as api from '@opentelemetry/api';
 import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import * as fs from 'fs';
+export type GenericFunction = (...args: any[]) => unknown;
 export type FunctionPropertyNames<T> = Exclude<{
     [K in keyof T]: T[K] extends Function ? K : never;
 }[keyof T], undefined>;
-export type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
 export type FunctionPropertyNamesTwoLevels<T> = Exclude<{
     [K in keyof T]: {
         [L in keyof T[K]]: L extends string ? T[K][L] extends Function ? K extends string ? L extends string ? string : never : never : never : never;
     }[keyof T[K]];
 }[keyof T], undefined>;
-export type Member<F> = FunctionPropertyNames<F> | FunctionPropertyNamesTwoLevels<F>;
 export type FMember = FunctionPropertyNames<typeof fs> | FunctionPropertyNamesTwoLevels<typeof fs>;
 export type FPMember = FunctionPropertyNames<(typeof fs)['promises']> | FunctionPropertyNamesTwoLevels<(typeof fs)['promises']>;
-export type CreateHook = (functionName: FMember | FPMember, info: {
-    args: ArrayLike<unknown>;
-}) => boolean;
-export type EndHook = (functionName: FMember | FPMember, info: {
-    args: ArrayLike<unknown>;
-    span: api.Span;
-    error?: Error;
-}) => void;
 export interface FsInstrumentationConfig extends InstrumentationConfig {
-    createHook?: CreateHook;
-    endHook?: EndHook;
-    requireParentSpan?: boolean;
+    /**
+     * Setting this option to `true` will include any filepath arguments from your `fs` API calls as span attributes.
+     */
+    recordFilePaths?: boolean;
+    /**
+     * Setting this option to `true` will include the error messages of failed `fs` API calls as a span attribute.
+     */
+    recordErrorMessagesAsSpanAttributes?: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,5 +1,5 @@
-import { FunctionPropertyNames, FMember } from './types';
 import * as fs from 'fs';
+import { FMember, FunctionPropertyNames, GenericFunction } from './types';
 type FS = typeof fs;
 export declare function splitTwoLevels<FSObject>(functionName: FMember): [
     FunctionPropertyNames<FSObject> & string
@@ -8,7 +8,7 @@ export declare function splitTwoLevels<FSObject>(functionName: FMember): [
     string
 ];
 export declare function indexFs<FSObject extends FS | FS['promises']>(fs: FSObject, member: FMember): {
-    objectToPatch: any;
+    objectToPatch: Record<string, GenericFunction>;
     functionNameToPatch: string;
 };
 export {};

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

@@ -6,8 +6,4 @@ export declare enum ConnectTypes {
     MIDDLEWARE = "middleware",
     REQUEST_HANDLER = "request_handler"
 }
-export declare enum ConnectNames {
-    MIDDLEWARE = "middleware",
-    REQUEST_HANDLER = "request handler"
-}
 //# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -1,14 +1,14 @@
-import { Span } from '@opentelemetry/api';
 import { HandleFunction, NextFunction, Server, Use } from './internal-types';
-import { InstrumentationBase, InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-export declare const ANONYMOUS_NAME = "anonymous";
+import { Span } from '@sentry/core';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
 /** Connect instrumentation for OpenTelemetry */
 export declare class ConnectInstrumentation extends InstrumentationBase {
     constructor(config?: InstrumentationConfig);
     init(): InstrumentationNodeModuleDefinition[];
     private _patchApp;
     private _patchConstructor;
-    _patchNext(next: NextFunction, finishSpan: () => void): NextFunction;
+    _patchNext(next: NextFunction, span: Span, finishSpan: () => void): NextFunction;
     _startSpan(routeName: string, middleWare: HandleFunction): Span;
     _patchMiddleware(routeName: string, middleWare: HandleFunction): HandleFunction;
     _patchUse(original: Server['use']): Use;

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

@@ -2,10 +2,10 @@ import * as http from 'http';
 export type IncomingMessage = http.IncomingMessage & {
     originalUrl?: http.IncomingMessage['url'] | undefined;
 };
-export type NextFunction = (err?: any) => void;
+export type NextFunction = (err?: unknown) => void;
 export type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
 export type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
-export type ErrorHandleFunction = (err: any, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+export type ErrorHandleFunction = (err: unknown, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
 export type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
 export interface Server extends NodeJS.EventEmitter {
     (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;

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

@@ -5,8 +5,6 @@ export declare enum AttributeNames {
     FIELD_TYPE = "graphql.field.type",
     PARENT_NAME = "graphql.parent.name",
     OPERATION_TYPE = "graphql.operation.type",
-    OPERATION_NAME = "graphql.operation.name",
-    VARIABLES = "graphql.variables.",
-    ERROR_VALIDATION_NAME = "graphql.validation.error"
+    OPERATION_NAME = "graphql.operation.name"
 }
 //# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -9,7 +9,12 @@ export declare class GraphQLInstrumentation extends InstrumentationBase<GraphQLI
     private _addPatchingValidate;
     private _patchExecute;
     private _handleExecutionResult;
-    private _executeResponseHook;
+    /**
+     * Applies Sentry-specific span mutations based on the GraphQL execution result:
+     * - Marks the execute span as errored if the result contains errors (and no status was set yet)
+     * - Optionally renames the containing root span to include the GraphQL operation name(s)
+     */
+    private _updateSpanFromResult;
     private _patchParse;
     private _patchValidate;
     private _parse;

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

@@ -1,4 +1,4 @@
-import * as api from '@opentelemetry/api';
+import { Span } from '@sentry/core';
 import { DocumentNode, ExecutionArgs, ExecutionResult, GraphQLError, GraphQLFieldResolver, GraphQLSchema, GraphQLTypeResolver, Maybe, ParseOptions, PromiseOrValue, Source, TypeInfo, ValidationRule } from './graphql-types';
 import { OTEL_GRAPHQL_DATA_SYMBOL, OTEL_PATCHED_SYMBOL } from './symbols';
 export { Maybe } from './graphql-types';
@@ -37,11 +37,11 @@ export type validateType = (schema: GraphQLSchema, documentAST: DocumentNode, ru
     maxErrors?: number;
 }, typeInfo?: TypeInfo) => ReadonlyArray<GraphQLError>;
 export interface GraphQLField {
-    span: api.Span;
+    span: Span;
 }
 interface OtelGraphQLData {
     source?: any;
-    span: api.Span;
+    span: Span;
     fields: {
         [key: string]: GraphQLField;
     };

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

@@ -1,24 +1,5 @@
 import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import * as api from '@opentelemetry/api';
-export interface GraphQLInstrumentationExecutionResponseHook {
-    (span: api.Span, data: any): void;
-}
 export interface GraphQLInstrumentationConfig extends InstrumentationConfig {
-    /**
-     * When set to true it will not remove attributes values from schema source.
-     * By default all values that can be sensitive are removed and replaced
-     * with "*"
-     *
-     * @default false
-     */
-    allowValues?: boolean;
-    /**
-     * The maximum depth of fields/resolvers to instrument.
-     * When set to 0 it will not instrument fields and resolvers
-     *
-     * @default undefined
-     */
-    depth?: number;
     /**
      * Do not create spans for resolvers.
      *
@@ -37,35 +18,16 @@ export interface GraphQLInstrumentationConfig extends InstrumentationConfig {
      */
     ignoreTrivialResolveSpans?: boolean;
     /**
-     * Place all resolve spans under the same parent instead of producing a nested tree structure.
+     * If this is enabled, a `http.server` root span containing the execute span will automatically be renamed
+     * to include the operation name.
      *
      * @default false
      */
-    flatResolveSpans?: boolean;
-    /**
-     * Whether to merge list items into a single element.
-     *
-     * @example `users.*.name` instead of `users.0.name`, `users.1.name`
-     *
-     * @default false
-     */
-    mergeItems?: boolean;
-    /**
-     * Hook that allows adding custom span attributes based on the data
-     * returned from "execute" GraphQL action.
-     *
-     * @param data - A GraphQL `ExecutionResult` object. For the exact type definitions, see the following:
-     *  - {@linkcode https://github.com/graphql/graphql-js/blob/v14.7.0/src/execution/execute.js#L115 graphql@14}
-     *  - {@linkcode https://github.com/graphql/graphql-js/blob/15.x.x/src/execution/execute.d.ts#L31 graphql@15}
-     *  - {@linkcode https://github.com/graphql/graphql-js/blob/16.x.x/src/execution/execute.ts#L127 graphql@16}
-     *
-     * @default undefined
-     */
-    responseHook?: GraphQLInstrumentationExecutionResponseHook;
+    useOperationNameForRootSpan?: boolean;
 }
 type RequireSpecificKeys<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
 };
-export type GraphQLInstrumentationParsedConfig = RequireSpecificKeys<GraphQLInstrumentationConfig, 'mergeItems' | 'depth' | 'allowValues' | 'ignoreResolveSpans'>;
+export type GraphQLInstrumentationParsedConfig = RequireSpecificKeys<GraphQLInstrumentationConfig, 'ignoreResolveSpans'>;
 export {};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,17 +1,14 @@
 import { DocumentNode, GraphQLFieldResolver, GraphQLObjectType, Location, Maybe } from './graphql-types';
-import * as api from '@opentelemetry/api';
+import { Span } from '@sentry/core';
 import { ObjectWithGraphQLData, OtelPatched } from './internal-types';
 import { GraphQLInstrumentationParsedConfig } from './types';
 export declare const isPromise: (value: any) => value is Promise<unknown>;
-export declare function addInputVariableAttributes(span: api.Span, variableValues: {
-    [key: string]: any;
-}): void;
-export declare function addSpanSource(span: api.Span, loc?: Location, allowValues?: boolean, start?: number, end?: number): void;
-export declare function endSpan(span: api.Span, error?: Error): void;
+export declare function addSpanSource(span: Span, loc?: Location, start?: number, end?: number): void;
+export declare function endSpan(span: Span, error?: Error): void;
 export declare function getOperation(document: DocumentNode, operationName?: Maybe<string>): DefinitionNodeLike | undefined;
 type DefinitionNodeLike = DocumentNode['definitions'][number];
-export declare function getSourceFromLocation(loc?: Location, allowValues?: boolean, inputStart?: number, inputEnd?: number): string;
-export declare function wrapFields(type: Maybe<GraphQLObjectType & OtelPatched>, tracer: api.Tracer, getConfig: () => GraphQLInstrumentationParsedConfig): void;
-export declare function wrapFieldResolver<TSource = any, TContext = any, TArgs = any>(tracer: api.Tracer, getConfig: () => GraphQLInstrumentationParsedConfig, fieldResolver: Maybe<GraphQLFieldResolver<TSource, TContext, TArgs> & OtelPatched>, isDefaultResolver?: boolean): GraphQLFieldResolver<TSource, TContext & ObjectWithGraphQLData, TArgs> & OtelPatched;
+export declare function getSourceFromLocation(loc?: Location, inputStart?: number, inputEnd?: number): string;
+export declare function wrapFields(type: Maybe<GraphQLObjectType & OtelPatched>, getConfig: () => GraphQLInstrumentationParsedConfig): void;
+export declare function wrapFieldResolver<TSource = any, TContext = any, TArgs = any>(getConfig: () => GraphQLInstrumentationParsedConfig, fieldResolver: Maybe<GraphQLFieldResolver<TSource, TContext, TArgs> & OtelPatched>, isDefaultResolver?: boolean): GraphQLFieldResolver<TSource, TContext & ObjectWithGraphQLData, TArgs> & OtelPatched;
 export {};
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1,7 +1,7 @@
-import { InstrumentationBase, InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
 /** Hapi instrumentation for OpenTelemetry */
 export declare class HapiInstrumentation extends InstrumentationBase {
-    private _semconvStability;
     constructor(config?: InstrumentationConfig);
     protected init(): InstrumentationNodeModuleDefinition;
     /**

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

@@ -1,13 +1,12 @@
 import { Attributes } from '@opentelemetry/api';
 import * as Hapi from './hapi-types';
 import { HapiPluginObject, PatchableExtMethod, ServerExtDirectInput } from './internal-types';
-import { SemconvStability } from '@opentelemetry/instrumentation';
 export declare function getPluginName<T>(plugin: Hapi.Plugin<T>): string;
 export declare const isLifecycleExtType: (variableToCheck: unknown) => variableToCheck is Hapi.ServerRequestExtType;
 export declare const isLifecycleExtEventObj: (variableToCheck: unknown) => variableToCheck is Hapi.ServerExtEventsRequestObject;
 export declare const isDirectExtInput: (variableToCheck: unknown) => variableToCheck is ServerExtDirectInput;
 export declare const isPatchableExtMethod: (variableToCheck: PatchableExtMethod | PatchableExtMethod[]) => variableToCheck is PatchableExtMethod;
-export declare const getRouteMetadata: (route: Hapi.ServerRoute, semconvStability: SemconvStability, pluginName?: string) => {
+export declare const getRouteMetadata: (route: Hapi.ServerRoute, pluginName?: string) => {
     attributes: Attributes;
     name: string;
 };

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

@@ -1,14 +1,12 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
 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;
+export declare class KnexInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
     init(): InstrumentationNodeModuleDefinition;
-    private getRunnerNodeModuleFileInstrumentation;
-    private getClientNodeModuleFileInstrumentation;
-    private createQueryWrapper;
-    private storeContext;
-    ensureWrapped(obj: any, methodName: string, wrapper: (original: any) => any): void;
+    private _getRunnerNodeModuleFileInstrumentation;
+    private _getClientNodeModuleFileInstrumentation;
+    private _createQueryWrapper;
+    private _storeContext;
+    private _ensureWrapped;
 }
 //# sourceMappingURL=instrumentation.d.ts.map

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

@@ -35,4 +35,5 @@ export declare const ATTR_NET_PEER_PORT: "net.peer.port";
  */
 export declare const ATTR_NET_TRANSPORT: "net.transport";
 export declare const DB_SYSTEM_NAME_VALUE_SQLITE: "sqlite";
+export declare const DB_SYSTEM_NAME_VALUE_POSTGRESQL: "postgresql";
 //# sourceMappingURL=semconv.d.ts.map

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

@@ -1,9 +1,4 @@
-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;
@@ -11,5 +6,4 @@ export declare const extractDatabaseFromConnectionString: (connectionString?: st
 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/vendored/internal-types.d.ts

@@ -1,10 +1,10 @@
 interface DefaultState {
 }
-export type Next = () => Promise<any>;
+export type Next = () => Promise<unknown>;
 type ParameterizedContext<_StateT = DefaultState, ContextT = {}, _ResponseBodyT = unknown> = {
-    [key: string]: any;
+    [key: string]: unknown;
 } & ContextT;
-type Middleware<StateT = DefaultState, ContextT = {}, ResponseBodyT = any> = (context: ParameterizedContext<StateT, ContextT, ResponseBodyT>, next: Next) => any;
+type Middleware<StateT = DefaultState, ContextT = {}, ResponseBodyT = unknown> = (context: ParameterizedContext<StateT, ContextT, ResponseBodyT>, next: Next) => unknown;
 interface RouterParamContext<StateT = DefaultState, ContextT = {}> {
     params: Record<string, string>;
     router: Router<StateT, ContextT>;
@@ -13,7 +13,7 @@ interface RouterParamContext<StateT = DefaultState, ContextT = {}> {
 }
 interface Layer {
     path: string | RegExp;
-    stack: any[];
+    stack: KoaMiddleware[];
 }
 export interface Router<_StateT = DefaultState, _ContextT = {}> {
     stack: Layer[];

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

@@ -1,50 +1,13 @@
-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 {
+export interface KoaInstrumentationConfig 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/mongo/index.d.ts

@@ -2,10 +2,6 @@ import { MongoDBInstrumentation } from './vendored/instrumentation';
 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.
  *

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

@@ -1,79 +1,11 @@
 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;
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+/** mongodb instrumentation plugin */
+export declare class MongoDBInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
     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

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

@@ -1,35 +1,3 @@
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { Span } from '@opentelemetry/api';
-export interface MongoDBInstrumentationExecutionResponseHook {
-    (span: Span, responseInfo: MongoResponseHookInformation): void;
-}
-/**
- * Function that can be used to serialize db.statement tag
- * @param cmd - MongoDB command object
- *
- * @returns serialized string that will be used as the db.statement attribute.
- */
-export type DbStatementSerializer = (cmd: Record<string, unknown>) => string;
-export interface MongoDBInstrumentationConfig extends InstrumentationConfig {
-    /**
-     * If true, additional information about query parameters and
-     * results will be attached (as `attributes`) to spans representing
-     * database operations.
-     */
-    enhancedDatabaseReporting?: boolean;
-    /**
-     * Hook that allows adding custom span attributes based on the data
-     * returned from MongoDB actions.
-     *
-     * @default undefined
-     */
-    responseHook?: MongoDBInstrumentationExecutionResponseHook;
-    /**
-     * Custom serializer function for the db.statement tag
-     */
-    dbStatementSerializer?: DbStatementSerializer;
-}
-export type Func<T> = (...args: unknown[]) => T;
 export type MongoInternalCommand = {
     findandmodify: boolean;
     createIndexes: boolean;
@@ -42,23 +10,9 @@ export type MongoInternalCommand = {
     q?: Record<string, unknown>;
     u?: Record<string, unknown>;
 };
-export type ServerSession = {
-    id: any;
-    lastUse: number;
-    txnNumber: number;
-    isDirty: boolean;
-};
 export type CursorState = {
     cmd: MongoInternalCommand;
 } & Record<string, unknown>;
-export interface MongoResponseHookInformation {
-    data: CommandResult;
-}
-export type CommandResult = {
-    result?: unknown;
-    connection?: unknown;
-    message?: 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;
@@ -105,17 +59,4 @@ export type V4Connection = {
 export type V4ConnectionPool = {
     checkOut: (callback: (error: any, connection: any) => void) => void;
 };
-export type V4Connect = {
-    connect: Function;
-    connectPromise: (options: any) => Promise<any>;
-    connectCallback: (options: any, callback: any) => void;
-};
-export type V4Session = {
-    acquire: () => ServerSession;
-    release: (session: ServerSession) => void;
-};
-/**
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#replacer
- */
-export type Replacer = (key: string, value: unknown) => unknown;
 //# 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