@depup/sentry__node 10.47.0-depup.1 → 10.67.0-depup.0

package/build/types/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/integrations/tracing/kafka/vendored/kafkajs-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafkajs-types.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/kafka/vendored/kafkajs-types.ts"],"names":[],"mappings":"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"}

package/build/types/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/integrations/tracing/kafka/vendored/semconv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semconv.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/kafka/vendored/semconv.ts"],"names":[],"mappings":"AAgBA;;;;;;GAMG;AACH,eAAO,MAAM,uCAAuC,EAAG,oCAA6C,CAAC;AAErG;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC,EAAG,6BAAsC,CAAC;AAEvF;;;;GAIG;AACH,eAAO,MAAM,sCAAsC,EAAG,mCAA4C,CAAC;AAEnG;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,EAAG,wBAAiC,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,sCAAsC,EAAG,SAAkB,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,sCAAsC,EAAG,SAAkB,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,mCAAmC,EAAG,MAAe,CAAC;AAEnE;;GAEG;AACH,eAAO,MAAM,4BAA4B,EAAG,OAAgB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAG,QAAiB,CAAC"}

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

@@ -0,0 +1,29 @@
+import type { Span, SpanAttributes, SpanLink } from '@sentry/core';
+import type { 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/integrations/tracing/kafka/vendored/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/kafka/vendored/utils.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AASnE,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAe7D,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,YAAY,GAAG,SAAS,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,cAAc,CAAC;IAC3B,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMnG;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,GAAG,QAAQ,EAAE,GAAG,SAAS,CAwB5F;AAED,oGAAoG;AACpG,wBAAgB,iBAAiB,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,mBAAmB,GAAG,IAAI,CAwBjH;AAED,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CA4BvE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAyBvF"}

package/build/types/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/integrations/tracing/knex/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/knex/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAQjE,eAAO,MAAM,cAAc;;CAA4E,CAAC;AAkBxG;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;CAAsC,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { 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/integrations/tracing/knex/vendored/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/knex/vendored/instrumentation.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,mCAAmC,EAAa,MAAM,gCAAgC,CAAC;AA2CrH,qBAAa,mBAAoB,SAAQ,mBAAmB,CAAC,qBAAqB,CAAC;gBAC9D,MAAM,GAAE,qBAA0B;IAI9C,IAAI,IAAI,mCAAmC;IAclD,OAAO,CAAC,uCAAuC;IAe/C,OAAO,CAAC,uCAAuC;IAmB/C,OAAO,CAAC,mBAAmB;IAuD3B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,cAAc;CAMvB"}

package/build/types/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/integrations/tracing/knex/vendored/semconv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semconv.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/knex/vendored/semconv.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAG,cAAuB,CAAC;AAEzD,eAAO,MAAM,2BAA2B,EAAG,QAAiB,CAAC;AAE7D,eAAO,MAAM,+BAA+B,EAAG,YAAqB,CAAC"}

package/build/types/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/integrations/tracing/knex/vendored/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/knex/vendored/utils.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,YAAY,GAAI,QAAQ,GAAG,QAcvC,CAAC;AAOF,eAAO,MAAM,SAAS,GAAI,YAAY,MAAM,WAE3C,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,IAAI,MAAM,EAAE,YAAY,MAAM,EAAE,QAAQ,MAAM,WAQrE,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM,WAKzD,CAAC;AAEF,eAAO,MAAM,mCAAmC,GAAI,mBAAmB,MAAM,KAAG,MAAM,GAAG,SAQxF,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,mBAAmB,MAAM,KAAG,MAAM,GAAG,SAOpF,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,mBAAmB,MAAM,KAAG,MAAM,GAAG,SAQpF,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,SAAS,GAAG,KAAG,MAM/C,CAAC"}

package/build/types/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/integrations/tracing/koa/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/koa/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAKhE,UAAU,UAAU;IAClB;;OAEG;IACH,gBAAgB,CAAC,EAAE,KAAK,CAAC,YAAY,GAAG,QAAQ,CAAC,CAAC;CACnD;AAID,eAAO,MAAM,aAAa;;CAQzB,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,cAAc;;CAAqC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,eAAO,MAAM,oBAAoB,GAAI,KAAK;IAAE,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAA;CAAE,KAAG,IAgB3G,CAAC"}

package/build/types/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/integrations/tracing/koa/vendored/enums/AttributeNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeNames.d.ts","sourceRoot":"","sources":["../../../../../../../src/integrations/tracing/koa/vendored/enums/AttributeNames.ts"],"names":[],"mappings":"AASA,oBAAY,cAAc;IACxB,QAAQ,aAAa;IACrB,QAAQ,aAAa;CACtB"}

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

@@ -0,0 +1,32 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { type 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/integrations/tracing/koa/vendored/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/koa/vendored/instrumentation.ts"],"names":[],"mappings":"AAaA,OAAO,EAAa,mBAAmB,EAAE,mCAAmC,EAAE,MAAM,gCAAgC,CAAC;AAErH,OAAO,EAAgB,KAAK,wBAAwB,EAAE,MAAM,SAAS,CAAC;AA8BtE,4CAA4C;AAC5C,qBAAa,kBAAmB,SAAQ,mBAAmB,CAAC,wBAAwB,CAAC;gBACvE,MAAM,GAAE,wBAA6B;IAIjD,SAAS,CAAC,IAAI;IA8Bd;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAWvB;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;CAwDpB"}

package/build/types/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/integrations/tracing/koa/vendored/internal-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-types.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/koa/vendored/internal-types.ts"],"names":[],"mappings":"AAUA,UAAU,YAAY;CAAG;AAEzB,MAAM,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;AAE1C,KAAK,oBAAoB,CAAC,OAAO,GAAG,YAAY,EAAE,QAAQ,GAAG,EAAE,EAAE,cAAc,GAAG,OAAO,IAAI;IAC3F,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,GAAG,QAAQ,CAAC;AAEb,KAAK,UAAU,CAAC,MAAM,GAAG,YAAY,EAAE,QAAQ,GAAG,EAAE,EAAE,aAAa,GAAG,OAAO,IAAI,CAC/E,OAAO,EAAE,oBAAoB,CAAC,MAAM,EAAE,QAAQ,EAAE,aAAa,CAAC,EAC9D,IAAI,EAAE,IAAI,KACP,OAAO,CAAC;AAEb,UAAU,kBAAkB,CAAC,MAAM,GAAG,YAAY,EAAE,QAAQ,GAAG,EAAE;IAC/D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC3C,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,UAAU,KAAK;IACb,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,MAAM,CAAC,OAAO,GAAG,YAAY,EAAE,SAAS,GAAG,EAAE;IAC5D,KAAK,EAAE,KAAK,EAAE,CAAC;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,oBAAoB,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,YAAY,EAAE,UAAU,CAAC,GAAG;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,OAAO,MAAoC,CAAC;AAExE,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IACjD,CAAC,aAAa,CAAC,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC"}

package/build/types/integrations/tracing/koa/vendored/types.d.ts

@@ -0,0 +1,13 @@
+import type { 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/integrations/tracing/koa/vendored/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/koa/vendored/types.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAE5E,oBAAY,YAAY;IACtB,MAAM,WAAW;IACjB,UAAU,eAAe;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,qBAAqB;IACrE,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,YAAY,EAAE,CAAC;CACnC"}

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

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

package/build/types/integrations/tracing/koa/vendored/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/koa/vendored/utils.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,KAAK,wBAAwB,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAElE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,eAAO,MAAM,qBAAqB,GAChC,SAAS,UAAU,EACnB,OAAO,aAAa,EACpB,UAAU,OAAO,EACjB,YAAY,MAAM,GAAG,MAAM,KAC1B;IACD,UAAU,EAAE,UAAU,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CAqBd,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,YAAY,EAAE,SAAS,wBAAwB,KAAG,OAEtF,CAAC"}

package/build/types/integrations/tracing/langchain/index.d.ts

@@ -21,7 +21,7 @@ export declare const instrumentLangChain: ((options?: LangChainOptions | undefin
  *
  * Sentry.init({
  *   integrations: [Sentry.langChainIntegration()],
- *   sendDefaultPii: true, // Enable to record inputs/outputs
+ *   dataCollection: { genAI: { inputs: true, outputs: true } }, // Enable to record inputs/outputs
  * });
  *
  * // LangChain calls are automatically instrumented
@@ -52,18 +52,19 @@ export declare const instrumentLangChain: ((options?: LangChainOptions | undefin
  *
  * ## Options
  *
- * - `recordInputs`: Whether to record input messages/prompts (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ * - `recordInputs`: Whether to record input messages/prompts (default: follows `dataCollection.genAI.inputs`, or the deprecated `sendDefaultPii` option)
+ * - `recordOutputs`: Whether to record response text (default: follows `dataCollection.genAI.outputs`, or the deprecated `sendDefaultPii` option)
  *
  * ### Default Behavior
  *
  * By default, the integration will:
- * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
- * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
+ * - Record inputs and outputs based on `dataCollection.genAI` in your Sentry client options
+ *   (or the deprecated `sendDefaultPii` option, for backwards compatibility)
+ * - Integration-level `recordInputs`/`recordOutputs` options take precedence over global config
  *
  * @example
  * ```javascript
- * // Record inputs and outputs when sendDefaultPii is false
+ * // Always record inputs and outputs regardless of global dataCollection config
  * Sentry.init({
  *   integrations: [
  *     Sentry.langChainIntegration({
@@ -73,9 +74,9 @@ export declare const instrumentLangChain: ((options?: LangChainOptions | undefin
  *   ],
  * });
  *
- * // Never record inputs/outputs regardless of sendDefaultPii
+ * // Never record inputs/outputs regardless of global dataCollection config
  * Sentry.init({
- *   sendDefaultPii: true,
+ *   dataCollection: { genAI: { inputs: true, outputs: true } },
  *   integrations: [
  *     Sentry.langChainIntegration({
  *       recordInputs: false,
@@ -88,10 +89,13 @@ export declare const instrumentLangChain: ((options?: LangChainOptions | undefin
  * ## Supported Events
  *
  * The integration captures the following LangChain lifecycle events:
- * - LLM/Chat Model: start, end, error
- * - Chain: start, end, error
- * - Tool: start, end, error
+ * - LLM/Chat Model: start, end, error (via callbacks)
+ * - Chain: start, end, error (via callbacks)
+ * - Tool: start, end, error (via callbacks)
+ * - Embeddings: embedQuery, embedDocuments (via direct method wrapping)
  *
  */
-export declare const langChainIntegration: (options?: LangChainOptions | undefined) => import("@sentry/core").Integration;
+export declare const langChainIntegration: (options?: LangChainOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LangChain";
+};
 //# sourceMappingURL=index.d.ts.map

package/build/types/integrations/tracing/langchain/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langchain/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKpE,eAAO,MAAM,mBAAmB;;CAG/B,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AACH,eAAO,MAAM,oBAAoB,gFAA2C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langchain/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKpE,eAAO,MAAM,mBAAmB;;CAG/B,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4FG;AACH,eAAO,MAAM,oBAAoB;;CAA2C,CAAC"}

package/build/types/integrations/tracing/langchain/instrumentation.d.ts

@@ -15,7 +15,7 @@ export declare class SentryLangChainInstrumentation extends InstrumentationBase<
      */
     init(): InstrumentationModuleDefinition | InstrumentationModuleDefinition[];
     /**
-     * Core patch logic - patches chat model methods to inject Sentry callbacks
+     * Core patch logic - patches chat model and embedding methods
      * This is called when a LangChain provider package is loaded
      */
     private _patch;
@@ -24,6 +24,15 @@ export declare class SentryLangChainInstrumentation extends InstrumentationBase<
      * Finds a chat model class from the provider package exports and patches its prototype methods
      */
     private _patchRunnableMethods;
+    /**
+     * Patches embedding class methods (embedQuery, embedDocuments) to create Sentry spans.
+     *
+     * Unlike chat models which use LangChain's callback system, the Embeddings base class
+     * has no callback support. We wrap the methods directly on the prototype.
+     *
+     * Instruments any exported class whose prototype has both embedQuery and embedDocuments as functions.
+     */
+    private _patchEmbeddingsMethods;
 }
 export {};
 //# sourceMappingURL=instrumentation.d.ts.map

package/build/types/integrations/tracing/langchain/instrumentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langchain/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EAGrC,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAYrD,KAAK,+BAA+B,GAAG,qBAAqB,GAAG,gBAAgB,CAAC;AA0EhF;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,mBAAmB,CAAC,+BAA+B,CAAC;gBACnF,MAAM,GAAE,+BAAoC;IAI/D;;;;;;OAMG;IACI,IAAI,IAAI,+BAA+B,GAAG,+BAA+B,EAAE;IA0DlF;;;OAGG;IACH,OAAO,CAAC,MAAM;IAmBd;;;OAGG;IACH,OAAO,CAAC,qBAAqB;CA8C9B"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langchain/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EAErC,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAcrD,KAAK,+BAA+B,GAAG,qBAAqB,GAAG,gBAAgB,CAAC;AA4ChF;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,mBAAmB,CAAC,+BAA+B,CAAC;gBACnF,MAAM,GAAE,+BAAoC;IAI/D;;;;;;OAMG;IACI,IAAI,IAAI,+BAA+B,GAAG,+BAA+B,EAAE;IA0DlF;;;OAGG;IACH,OAAO,CAAC,MAAM;IAyBd;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IA+C7B;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;CAmBhC"}

package/build/types/integrations/tracing/langgraph/index.d.ts

@@ -21,18 +21,19 @@ export declare const instrumentLangGraph: ((options?: LangGraphOptions | undefin
  *
  * ## Options
  *
- * - `recordInputs`: Whether to record input messages (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ * - `recordInputs`: Whether to record prompt messages (default: follows `dataCollection.genAI.inputs`, or the deprecated `sendDefaultPii` option)
+ * - `recordOutputs`: Whether to record response text (default: follows `dataCollection.genAI.outputs`, or the deprecated `sendDefaultPii` option)
  *
  * ### Default Behavior
  *
  * By default, the integration will:
- * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
- * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
+ * - Record inputs and outputs based on `dataCollection.genAI` in your Sentry client options
+ *   (or the deprecated `sendDefaultPii` option, for backwards compatibility)
+ * - Integration-level `recordInputs`/`recordOutputs` options take precedence over global config
  *
  * @example
  * ```javascript
- * // Record inputs and outputs when sendDefaultPii is false
+ * // Always record inputs and outputs regardless of global dataCollection config
  * Sentry.init({
  *   integrations: [
  *     Sentry.langGraphIntegration({
@@ -42,9 +43,9 @@ export declare const instrumentLangGraph: ((options?: LangGraphOptions | undefin
  *   ],
  * });
  *
- * // Never record inputs/outputs regardless of sendDefaultPii
+ * // Never record inputs/outputs regardless of global dataCollection config
  * Sentry.init({
- *   sendDefaultPii: true,
+ *   dataCollection: { genAI: { inputs: true, outputs: true } },
  *   integrations: [
  *     Sentry.langGraphIntegration({
  *       recordInputs: false,
@@ -70,5 +71,7 @@ export declare const instrumentLangGraph: ((options?: LangGraphOptions | undefin
  * - Available tools configured in the graph
  *
  */
-export declare const langGraphIntegration: (options?: LangGraphOptions | undefined) => import("@sentry/core").Integration;
+export declare const langGraphIntegration: (options?: LangGraphOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LangGraph";
+};
 //# sourceMappingURL=index.d.ts.map

package/build/types/integrations/tracing/langgraph/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langgraph/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKpE,eAAO,MAAM,mBAAmB;;CAG/B,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,oBAAoB,gFAA2C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langgraph/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKpE,eAAO,MAAM,mBAAmB;;CAG/B,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,eAAO,MAAM,oBAAoB;;CAA2C,CAAC"}

package/build/types/integrations/tracing/langgraph/instrumentation.d.ts

@@ -9,7 +9,7 @@ export declare class SentryLangGraphInstrumentation extends InstrumentationBase<
     /**
      * Initializes the instrumentation by defining the modules to be patched.
      */
-    init(): InstrumentationModuleDefinition;
+    init(): InstrumentationModuleDefinition[];
     /**
      * Core patch logic applying instrumentation to the LangGraph module.
      */

package/build/types/integrations/tracing/langgraph/instrumentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langgraph/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EAGrC,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKrD,KAAK,+BAA+B,GAAG,qBAAqB,GAAG,gBAAgB,CAAC;AAUhF;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,mBAAmB,CAAC,+BAA+B,CAAC;gBACnF,MAAM,GAAE,+BAAoC;IAI/D;;OAEG;IACI,IAAI,IAAI,+BAA+B;IAwB9C;;OAEG;IACH,OAAO,CAAC,MAAM;CAWf"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/langgraph/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EAErC,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKpE,KAAK,+BAA+B,GAAG,qBAAqB,GAAG,gBAAgB,CAAC;AAWhF;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,mBAAmB,CAAC,+BAA+B,CAAC;gBACnF,MAAM,GAAE,+BAAoC;IAI/D;;OAEG;IACI,IAAI,IAAI,+BAA+B,EAAE;IAsDhD;;OAEG;IACH,OAAO,CAAC,MAAM;CA2Bf"}

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

@@ -1,4 +1,4 @@
-import { LruMemoizerInstrumentation } from '@opentelemetry/instrumentation-lru-memoizer';
+import { LruMemoizerInstrumentation } from './vendored/instrumentation';
 export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerInstrumentation) & {
     id: string;
 };
@@ -15,5 +15,7 @@ export declare const instrumentLruMemoizer: ((options?: unknown) => LruMemoizerI
  *  integrations: [Sentry.lruMemoizerIntegration()],
  * });
  */
-export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=lrumemoizer.d.ts.map
+export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration & {
+    name: "LruMemoizer";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/tracing/lrumemoizer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/lrumemoizer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAOxE,eAAO,MAAM,qBAAqB;;CAAmF,CAAC;AAWtH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB;;CAA6C,CAAC"}

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

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

package/build/types/integrations/tracing/lrumemoizer/vendored/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/lrumemoizer/vendored/instrumentation.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,mBAAmB,EAAE,mCAAmC,EAAE,MAAM,gCAAgC,CAAC;AAQ1G,qBAAa,0BAA2B,SAAQ,mBAAmB;;IAKjE,IAAI,IAAI,mCAAmC,EAAE;CAmC9C"}