@sentry/node 10.57.0 → 10.59.0

package/build/types/sdk/experimentalUseDiagnosticsChannelInjection.d.ts

@@ -0,0 +1,34 @@
+/**
+ * EXPERIMENTAL: opt into diagnostics-channel-based auto-instrumentation.
+ *
+ * Call this BEFORE `Sentry.init()`:
+ *
+ * ```ts
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.experimentalUseDiagnosticsChannelInjection();
+ * Sentry.init({
+ *   dsn: '__DSN__',
+ *   // other settings...
+ * });
+ * ```
+ *
+ * When this has been called AND span recording is enabled, `Sentry.init()`
+ * uses the diagnostics-channel-injection-based integrations instead of the
+ * OpenTelemetry ones, and installs the module hooks that inject the channels
+ * (so libraries imported after `init()` publish the channel events).
+ *
+ * This is a standalone function rather than an `init()` option so that a
+ * bundler drops all of it (and its transitive deps) when this function isn't
+ * called. `init()` reads the loader registered below.
+ *
+ * An app that DOES call it gets the orchestrion code bundled as intended.
+ *
+ * In an unbundled (server-side runtime) app this eagerly loads only the small
+ * subscriber/channel modules; the heavy code-transform dependencies stay lazy
+ * inside `register()` and load only when injection actually runs.
+ *
+ * @experimental May change or be removed in any release.
+ */
+export declare function experimentalUseDiagnosticsChannelInjection(): void;
+//# sourceMappingURL=experimentalUseDiagnosticsChannelInjection.d.ts.map

package/build/types/sdk/experimentalUseDiagnosticsChannelInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experimentalUseDiagnosticsChannelInjection.d.ts","sourceRoot":"","sources":["../../../src/sdk/experimentalUseDiagnosticsChannelInjection.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0CAA0C,IAAI,IAAI,CASjE"}

package/build/types/sdk/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AASpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5C;;GAEG;AACH,wBAAgB,wCAAwC,IAAI,WAAW,EAAE,CAOxE;AAED,qDAAqD;AACrD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,EAAE,CAStE;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAElF;AA4BD;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAE5G"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AASpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAO5C;;GAEG;AACH,wBAAgB,wCAAwC,IAAI,WAAW,EAAE,CAOxE;AAED,qDAAqD;AACrD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,EAAE,CA2BtE;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAElF;AAkDD;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAE5G"}

package/build/types-ts3.8/index.d.ts

@@ -32,6 +32,7 @@ export { langGraphIntegration } from './integrations/tracing/langgraph';
 export { launchDarklyIntegration, buildLaunchDarklyFlagUsedHandler, openFeatureIntegration, OpenFeatureIntegrationHook, statsigIntegration, unleashIntegration, growthbookIntegration, } from './integrations/featureFlagShims';
 export { firebaseIntegration } from './integrations/tracing/firebase';
 export { init, getDefaultIntegrations, getDefaultIntegrationsWithoutPerformance, initWithoutDefaultIntegrations, } from './sdk';
+export { experimentalUseDiagnosticsChannelInjection } from './sdk/experimentalUseDiagnosticsChannelInjection';
 export { initOpenTelemetry, preloadOpenTelemetry } from './sdk/initOtel';
 export { getAutoPerformanceIntegrations } from './integrations/tracing';
 export { NodeOptions } from './types';

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

@@ -1,15 +1,11 @@
-import * as api from '@opentelemetry/api';
 import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FMember, FPMember, CreateHook, EndHook, FsInstrumentationConfig } from './types';
+import { FMember, FPMember, FsInstrumentationConfig, GenericFunction } from './types';
 export declare class FsInstrumentation extends InstrumentationBase<FsInstrumentationConfig> {
     constructor(config?: FsInstrumentationConfig);
-    init(): (InstrumentationNodeModuleDefinition | InstrumentationNodeModuleDefinition)[];
-    protected _patchSyncFunction<T extends (...args: any[]) => ReturnType<T>>(functionName: FMember, original: T): T;
-    protected _patchCallbackFunction<T extends (...args: any[]) => ReturnType<T>>(functionName: FMember, original: T): T;
-    protected _patchExistsCallbackFunction<T extends (...args: any[]) => ReturnType<T>>(functionName: 'exists', original: T): T;
-    protected _patchPromiseFunction<T extends (...args: any[]) => ReturnType<T>>(functionName: FPMember, original: T): T;
-    protected _runCreateHook(...args: Parameters<CreateHook>): ReturnType<CreateHook>;
-    protected _runEndHook(...args: Parameters<EndHook>): ReturnType<EndHook>;
-    protected _shouldTrace(context: api.Context): boolean;
+    init(): InstrumentationNodeModuleDefinition[];
+    protected _patchSyncFunction<T extends GenericFunction>(functionName: FMember, original: T): T;
+    protected _patchCallbackFunction<T extends GenericFunction>(functionName: FMember, original: T): T;
+    protected _patchExistsCallbackFunction<T extends GenericFunction>(functionName: 'exists', original: T): T;
+    protected _patchPromiseFunction<T extends GenericFunction>(functionName: FPMember, original: T): T;
 }
 //# sourceMappingURL=instrumentation.d.ts.map

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/dataloader/vendored/instrumentation.d.ts

@@ -1,10 +1,7 @@
 import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { DataloaderInstrumentationConfig } from './types';
-export declare class DataloaderInstrumentation extends InstrumentationBase<DataloaderInstrumentationConfig> {
-    constructor(config?: DataloaderInstrumentationConfig);
+export declare class DataloaderInstrumentation extends InstrumentationBase {
+    constructor(config?: {});
     protected init(): InstrumentationNodeModuleDefinition[];
-    private shouldCreateSpans;
-    private getSpanName;
     private _wrapBatchLoadFn;
     private _getPatchedConstructor;
     private _patchLoad;

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

@@ -1,10 +1,22 @@
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-export interface DataloaderInstrumentationConfig extends InstrumentationConfig {
-    /**
-     * Whether the instrumentation requires a parent span, if set to true
-     * and there is no parent span, no additional spans are created
-     * (default: true)
-     */
-    requireParentSpan?: boolean;
+import { SpanLink } from '@sentry/core';
+export type BatchLoadFn<K, V> = (keys: ReadonlyArray<K>) => PromiseLike<ArrayLike<V | Error>>;
+/** A `DataLoader` instance. */
+export interface DataLoader<K = unknown, V = unknown> {
+    _batchLoadFn: BatchLoadFn<K, V>;
+    _batch: {
+        spanLinks?: SpanLink[];
+    } | null;
+    load(key: K): Promise<V>;
+    loadMany(keys: ArrayLike<K>): Promise<Array<V | Error>>;
+    prime(key: K, value: V | Error): this;
+    clear(key: K): this;
+    clearAll(): this;
+    name: string | undefined;
+    [key: string]: any;
+}
+/** The `DataLoader` class/constructor. */
+export interface DataLoaderConstructor {
+    new <K, V>(batchLoadFn: BatchLoadFn<K, V>, options?: any): DataLoader<K, V>;
+    prototype: DataLoader<unknown, unknown>;
 }
 //# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/genericPool/vendored/generic-pool-types.d.ts

@@ -1,5 +1,5 @@
 export declare class Pool<T> {
     acquire(priority?: number): PromiseLike<T>;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 //# sourceMappingURL=generic-pool-types.d.ts.map

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

@@ -1,4 +1,5 @@
-import { InstrumentationBase, InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
 export declare class GenericPoolInstrumentation extends InstrumentationBase {
     private _isDisabled;
     constructor(config?: InstrumentationConfig);

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