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

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

@@ -0,0 +1,6 @@
+export declare enum AttributeNames {
+    HAPI_TYPE = "hapi.type",
+    PLUGIN_NAME = "hapi.plugin.name",
+    EXT_TYPE = "server.ext.type"
+}
+//# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -0,0 +1,70 @@
+export type ServerOptions = Record<string, any>;
+export declare function server(options?: ServerOptions): Server;
+export declare function Server(options?: ServerOptions): Server;
+export type ServerRequestExtType = 'onPreAuth' | 'onCredentials' | 'onPostAuth' | 'onPreHandler' | 'onPostHandler' | 'onPreResponse' | 'onRequest';
+export declare namespace Lifecycle {
+    type Method = (request: any, h: any, err?: Error) => ReturnValue;
+    type ReturnValue = any;
+    type FailAction = 'error' | 'log' | 'ignore' | Method;
+}
+export interface ServerRoute<T = any> {
+    path: string;
+    method: string;
+    handler?: Lifecycle.Method | T;
+    options?: ((server: Server) => ServerRouteOptions) | ServerRouteOptions;
+    [key: string]: any;
+}
+interface ServerRouteOptions {
+    handler?: Lifecycle.Method | any;
+    [key: string]: any;
+}
+export interface Server {
+    route: (...args: any[]) => any;
+    ext: (...args: any[]) => any;
+    register: (...args: any[]) => any;
+    [key: string]: any;
+}
+export interface Plugin<T, _V = void> {
+    register: (server: Server, options: T) => void | Promise<void>;
+    name?: string;
+    pkg?: {
+        name: string;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface PluginNameVersion {
+    name: string;
+    [key: string]: any;
+}
+export interface PluginPackage {
+    pkg: {
+        name: string;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface ServerRegisterPluginObject<T> {
+    plugin: Plugin<T, void> | {
+        plugin: Plugin<T, void>;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface ServerRegisterOptions {
+    [key: string]: any;
+}
+export interface ServerExtEventsObject {
+    type: string;
+    [key: string]: any;
+}
+export interface ServerExtEventsRequestObject {
+    type: ServerRequestExtType;
+    method: Lifecycle.Method;
+    [key: string]: any;
+}
+export interface ServerExtOptions {
+    [key: string]: any;
+}
+export {};
+//# sourceMappingURL=hapi-types.d.ts.map

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

@@ -0,0 +1,72 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+/** Hapi instrumentation for OpenTelemetry */
+export declare class HapiInstrumentation extends InstrumentationBase {
+    constructor(config?: InstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition;
+    /**
+     * Patches the Hapi.server and Hapi.Server functions in order to instrument
+     * the server.route, server.ext, and server.register functions via calls to the
+     * @function _getServerRoutePatch, @function _getServerExtPatch, and
+     * @function _getServerRegisterPatch functions
+     * @param original - the original Hapi Server creation function
+     */
+    private _getServerPatch;
+    /**
+     * Patches the plugin register function used by the Hapi Server. This function
+     * goes through each plugin that is being registered and adds instrumentation
+     * via a call to the @function _wrapRegisterHandler function.
+     * @param {RegisterFunction<T>} original - the original register function which
+     * registers each plugin on the server
+     */
+    private _getServerRegisterPatch;
+    /**
+     * Patches the Server.ext function which adds extension methods to the specified
+     * point along the request lifecycle. This function accepts the full range of
+     * accepted input into the standard Hapi `server.ext` function. For each extension,
+     * it adds instrumentation to the handler via a call to the @function _wrapExtMethods
+     * function.
+     * @param original - the original ext function which adds the extension method to the server
+     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
+     * for adding this server extension. Else, signifies that the extension was added directly
+     */
+    private _getServerExtPatch;
+    /**
+     * Patches the Server.route function. This function accepts either one or an array
+     * of Hapi.ServerRoute objects and adds instrumentation on each route via a call to
+     * the @function _wrapRouteHandler function.
+     * @param {HapiServerRouteInputMethod} original - the original route function which adds
+     * the route to the server
+     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
+     * for adding this server route. Else, signifies that the route was added directly
+     */
+    private _getServerRoutePatch;
+    /**
+     * Wraps newly registered plugins to add instrumentation to the plugin's clone of
+     * the original server. Specifically, wraps the server.route and server.ext functions
+     * via calls to @function _getServerRoutePatch and @function _getServerExtPatch
+     * @param {Hapi.Plugin<T>} plugin - the new plugin which is being instrumented
+     */
+    private _wrapRegisterHandler;
+    /**
+     * Wraps request extension methods to add instrumentation to each new extension handler.
+     * Patches each individual extension in order to create the
+     * span and propagate context. It does not create spans when there is no parent span.
+     * @param {PatchableExtMethod | PatchableExtMethod[]} method - the request extension
+     * handler which is being instrumented
+     * @param {Hapi.ServerRequestExtType} extPoint - the point in the Hapi request lifecycle
+     * which this extension targets
+     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
+     * for adding this server route. Else, signifies that the route was added directly
+     */
+    private _wrapExtMethods;
+    /**
+     * Patches each individual route handler method in order to create the
+     * span and propagate context. It does not create spans when there is no parent span.
+     * @param {PatchableServerRoute} route - the route handler which is being instrumented
+     * @param {string} [pluginName] - if present, represents the name of the plugin responsible
+     * for adding this server route. Else, signifies that the route was added directly
+     */
+    private _wrapRouteHandler;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,32 @@
+import * as Hapi from './hapi-types';
+export declare const HapiComponentName = "@hapi/hapi";
+/**
+ * This symbol is used to mark a Hapi route handler or server extension handler as
+ * already patched, since its possible to use these handlers multiple times
+ * i.e. when allowing multiple versions of one plugin, or when registering a plugin
+ * multiple times on different servers.
+ */
+export declare const handlerPatched: unique symbol;
+export type HapiServerRouteInputMethod = (route: HapiServerRouteInput) => void;
+export type HapiServerRouteInput = PatchableServerRoute | PatchableServerRoute[];
+export type PatchableServerRoute = Hapi.ServerRoute<any> & {
+    [handlerPatched]?: boolean;
+};
+export type HapiPluginObject<T> = Hapi.ServerRegisterPluginObject<T>;
+export type HapiPluginInput<T> = HapiPluginObject<T> | Array<HapiPluginObject<T>>;
+export type RegisterFunction<T> = (plugin: HapiPluginInput<T>, options?: Hapi.ServerRegisterOptions) => Promise<void>;
+export type PatchableExtMethod = Hapi.Lifecycle.Method & {
+    [handlerPatched]?: boolean;
+};
+export type ServerExtDirectInput = [
+    Hapi.ServerRequestExtType,
+    Hapi.Lifecycle.Method,
+    (Hapi.ServerExtOptions | undefined)?
+];
+export declare const HapiLayerType: {
+    ROUTER: string;
+    PLUGIN: string;
+    EXT: string;
+};
+export declare const HapiLifecycleMethodNames: Set<string>;
+//# sourceMappingURL=internal-types.d.ts.map

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

@@ -0,0 +1,18 @@
+import { Attributes } from '@opentelemetry/api';
+import * as Hapi from './hapi-types';
+import { HapiPluginObject, PatchableExtMethod, ServerExtDirectInput } from './internal-types';
+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, pluginName?: string) => {
+    attributes: Attributes;
+    name: string;
+};
+export declare const getExtMetadata: (extPoint: Hapi.ServerRequestExtType, pluginName?: string, methodName?: string) => {
+    attributes: Attributes;
+    name: string;
+};
+export declare const getPluginFromInput: <T>(pluginObj: HapiPluginObject<T>) => Hapi.Plugin<T, void>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -10,6 +10,9 @@ export declare const instrumentHono: ((options?: unknown) => HonoInstrumentation
  *
  * For more information, see the [hono documentation](https://docs.sentry.io/platforms/javascript/guides/hono/).
  *
+ * @deprecated Use the `@sentry/hono` package instead. The `sentry()` middleware from `@sentry/hono/node` handles
+ * tracing and error capturing automatically without needing this integration or `setupHonoErrorHandler`.
+ *
  * @example
  * ```javascript
  * const Sentry = require('@sentry/node');
@@ -19,7 +22,9 @@ export declare const instrumentHono: ((options?: unknown) => HonoInstrumentation
  * })
  * ```
  */
-export declare const honoIntegration: () => import("@sentry/core").Integration;
+export declare const honoIntegration: () => import("@sentry/core").Integration & {
+    name: "Hono";
+};
 interface HonoHandlerOptions {
     /**
      * Callback method deciding whether error should be captured and sent to Sentry
@@ -33,6 +38,9 @@ interface HonoHandlerOptions {
  * @param app The Hono instances
  * @param options Configuration options for the handler
  *
+ * @deprecated Use the `@sentry/hono` package instead. The `sentry()` middleware from `@sentry/hono/node` handles
+ * error capturing automatically without needing this function or `honoIntegration`.
+ *
  * @example
  * ```javascript
  * const Sentry = require('@sentry/node');

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

@@ -1,4 +1,4 @@
-import { KafkaJsInstrumentation } from '@opentelemetry/instrumentation-kafkajs';
+import { KafkaJsInstrumentation } from './vendored/instrumentation';
 export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumentation) & {
     id: string;
 };
@@ -15,5 +15,7 @@ export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumenta
  *  integrations: [Sentry.kafkaIntegration()],
  * });
  */
-export declare const kafkaIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=kafka.d.ts.map
+export declare const kafkaIntegration: () => import("@sentry/core").Integration & {
+    name: "Kafka";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,15 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare class KafkaJsInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition;
+    private _getConsumerPatch;
+    private _getProducerPatch;
+    private _getConsumerRunPatch;
+    private _getConsumerEachMessagePatch;
+    private _getConsumerEachBatchPatch;
+    private _getProducerTransactionPatch;
+    private _getSendBatchPatch;
+    private _getSendPatch;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,79 @@
+type Sender = {
+    send(record: any): Promise<any>;
+    sendBatch(batch: any): Promise<any>;
+};
+export type Producer = Sender & {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isIdempotent(): boolean;
+    transaction(): Promise<Transaction>;
+    [key: string]: any;
+};
+export type Transaction = Sender & {
+    sendOffsets(offsets: any): Promise<void>;
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+    isActive(): boolean;
+};
+export type Consumer = {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    subscribe(subscription: any): Promise<void>;
+    run(config?: any): Promise<void>;
+    [key: string]: any;
+};
+export declare class Kafka {
+    consumer(config: any): Consumer;
+    producer(config?: any): Producer;
+    [key: string]: any;
+}
+export interface Message {
+    key?: Buffer | string | null;
+    value: Buffer | string | null;
+    partition?: number;
+    headers?: Record<string, Buffer | string | (Buffer | string)[] | undefined>;
+    timestamp?: string;
+}
+export type KafkaMessage = {
+    [key: string]: any;
+} & Message;
+export type RecordMetadata = {
+    topicName: string;
+    partition: number;
+    errorCode: number;
+    offset?: string;
+    timestamp?: string;
+    baseOffset?: string;
+    logAppendTime?: string;
+    logStartOffset?: string;
+};
+export interface EachMessagePayload {
+    topic: string;
+    partition: number;
+    message: KafkaMessage;
+    heartbeat(): Promise<void>;
+    pause(): () => void;
+}
+export interface EachBatchPayload {
+    batch: any;
+    resolveOffset(offset: string): void;
+    heartbeat(): Promise<void>;
+    pause(): () => void;
+    commitOffsetsIfNecessary(offsets?: any): Promise<void>;
+    uncommittedOffsets(): any;
+    isRunning(): boolean;
+    isStale(): boolean;
+}
+export type EachMessageHandler = (payload: EachMessagePayload) => Promise<void>;
+export type EachBatchHandler = (payload: EachBatchPayload) => Promise<void>;
+export type ConsumerRunConfig = {
+    autoCommit?: boolean;
+    autoCommitInterval?: number | null;
+    autoCommitThreshold?: number | null;
+    eachBatchAutoResolve?: boolean;
+    partitionsConsumedConcurrently?: number;
+    eachBatch?: EachBatchHandler;
+    eachMessage?: EachMessageHandler;
+};
+export {};
+//# sourceMappingURL=kafkajs-types.d.ts.map

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

@@ -0,0 +1,54 @@
+/**
+ * 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";
+/**
+ * Enum value "process" for attribute `messaging.operation.type`.
+ */
+export declare const MESSAGING_OPERATION_TYPE_VALUE_PROCESS: "process";
+/**
+ * Enum value "receive" for attribute `messaging.operation.type`.
+ */
+export declare const MESSAGING_OPERATION_TYPE_VALUE_RECEIVE: "receive";
+/**
+ * Enum value "send" for attribute `messaging.operation.type`.
+ */
+export declare const MESSAGING_OPERATION_TYPE_VALUE_SEND: "send";
+/**
+ * Enum value "kafka" for attribute `messaging.system`.
+ */
+export declare const MESSAGING_SYSTEM_VALUE_KAFKA: "kafka";
+/**
+ * Enum value "_OTHER" for attribute `error.type`. A fallback error value to be used when
+ * the instrumentation doesn't define a custom value.
+ */
+export declare const ERROR_TYPE_VALUE_OTHER: "_OTHER";
+//# sourceMappingURL=semconv.d.ts.map

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

@@ -0,0 +1,29 @@
+import { Span, SpanAttributes, SpanLink } from '@sentry/core';
+import { KafkaMessage, Message } from './kafkajs-types';
+export interface ConsumerSpanOptions {
+    topic: string;
+    message: KafkaMessage | undefined;
+    operationType: string;
+    attributes: SpanAttributes;
+    links?: SpanLink[];
+}
+/**
+ * Reads a header value off a kafkajs message as a string. kafkajs delivers headers as `Buffer`s (or
+ * arrays of them), so we normalize to a string before handing them to Sentry's trace helpers.
+ */
+export declare function getHeaderAsString(headers: KafkaMessage['headers'], key: string): string | undefined;
+/**
+ * Builds a span link to the producer span carried in the message headers, mirroring the upstream
+ * behavior of linking each batch-processed message to its originating producer span.
+ */
+export declare function getLinksFromHeaders(headers: KafkaMessage['headers']): SpanLink[] | undefined;
+/** Starts an inactive consumer (process/receive) span carrying the kafkajs messaging attributes. */
+export declare function startConsumerSpan({ topic, message, operationType, links, attributes }: ConsumerSpanOptions): Span;
+/** Starts an inactive producer span and propagates its trace into the message headers. */
+export declare function startProducerSpan(topic: string, message: Message): Span;
+/**
+ * Resolves once `sendPromise` settles, ending all `spans` and, on failure, marking them with the
+ * error status and `error.type` before re-throwing.
+ */
+export declare function endSpansOnPromise<T>(spans: Span[], sendPromise: Promise<T>): Promise<T>;
+//# sourceMappingURL=utils.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;
 };
@@ -16,5 +16,7 @@ export declare const instrumentKnex: ((options?: unknown) => KnexInstrumentation
  * });
  * ```
  */
-export declare const knexIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=knex.d.ts.map
+export declare const knexIntegration: () => import("@sentry/core").Integration & {
+    name: "Knex";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,12 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare class KnexInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
+    init(): InstrumentationNodeModuleDefinition;
+    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

@@ -0,0 +1,7 @@
+/**
+ * @deprecated Replaced by `db.collection.name`.
+ */
+export declare const ATTR_DB_SQL_TABLE: "db.sql.table";
+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

@@ -0,0 +1,9 @@
+export declare const getFormatter: (runner: any) => any;
+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;
+//# 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
@@ -40,7 +40,9 @@ export declare const instrumentKoa: ((options: KoaOptions | undefined) => KoaIns
  * })
  * ```
  */
-export declare const koaIntegration: (options?: KoaOptions | undefined) => import("@sentry/core").Integration;
+export declare const koaIntegration: (options?: KoaOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Koa";
+};
 /**
  * Add an Koa error handler to capture errors to Sentry.
  *
@@ -67,4 +69,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<unknown>;
+type ParameterizedContext<_StateT = DefaultState, ContextT = {}, _ResponseBodyT = unknown> = {
+    [key: string]: unknown;
+} & ContextT;
+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>;
+    _matchedRoute: string | RegExp | undefined;
+    _matchedRouteName: string | undefined;
+}
+interface Layer {
+    path: string | RegExp;
+    stack: KoaMiddleware[];
+}
+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,13 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export declare enum KoaLayerType {
+    ROUTER = "router",
+    MIDDLEWARE = "middleware"
+}
+/**
+ * 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 extends InstrumentationConfig {
+    /** Ignore specific layers based on their type */
+    ignoreLayersType?: KoaLayerType[];
+}
+//# 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