@depup/sentry__server-utils 10.75.2-depup.0 → 11.1.0-depup.0

package/build/types/integrations/koa/koa-error-handler.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Key under which the koa instrumentation stashes the request's active span on
+ * the koa `ctx`. Koa emits its `error` event from `handleRequest`'s `.catch()`,
+ * *after* the middleware chain has unwound and no span is active — so we capture
+ * within this stashed span to keep the error linked to the request's trace.
+ */
+export declare const KOA_CONTEXT_SPAN = "__SENTRY_KOA_SPAN__";
+/** The subset of a koa `Application` the error handler needs (it extends `EventEmitter`). */
+export interface KoaApp {
+    on(event: 'error', listener: (error: unknown, context?: unknown) => void): unknown;
+    [key: string]: unknown;
+}
+/**
+ * Attach a Sentry error listener to a koa app's `error` event.
+ *
+ * Koa emits `'error'` for every request error that bubbles up unhandled, so a
+ * single `app.on('error')` listener captures the same errors a top-level
+ * try/catch middleware would — without depending on middleware order. The error
+ * is captured within the request's koa span (stashed on the koa `ctx` under
+ * {@link KOA_CONTEXT_SPAN}) so it keeps its trace linkage, since koa emits the
+ * event after the middleware spans have already ended.
+ *
+ * Idempotent — the app is marked so auto-registration (via the `callback`
+ * channel) and any explicit `setupKoaErrorHandler` call never stack up multiple
+ * listeners.
+ *
+ * @deprecated Internal. The error handler is registered automatically by the koa
+ * instrumentation; there is no need to call this directly. It is exported only
+ * so the deprecated `setupKoaErrorHandler` can delegate to it, and will be
+ * removed in a future major version.
+ */
+export declare function attachKoaErrorHandler(app: KoaApp): void;
+//# sourceMappingURL=koa-error-handler.d.ts.map

package/build/types/integrations/koa/koa-error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"koa-error-handler.d.ts","sourceRoot":"","sources":["../../../../src/integrations/koa/koa-error-handler.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,wBAAwB,CAAC;AAEtD,6FAA6F;AAC7F,MAAM,WAAW,MAAM;IACrB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC;IACnF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAwBvD"}

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

@@ -0,0 +1,9 @@
+/**
+ * Diagnostics-channel-based LangChain integration. Subscribes to the diagnostics_channels
+ * injected into `@langchain/core`'s `BaseChatModel` (to inject the Sentry callback handler) and into
+ * `@langchain/openai`'s embedding methods, so it requires the Sentry runtime hook or bundler plugin.
+ */
+export declare const langChainIntegration: (options?: import("../ai/core/utils").GenAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LangChain";
+};
+//# sourceMappingURL=langchain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.d.ts","sourceRoot":"","sources":["../../../src/integrations/langchain.ts"],"names":[],"mappings":"AAyHA;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;CAA2C,CAAC"}

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

@@ -0,0 +1,9 @@
+/**
+ * Diagnostics-channel-based LangGraph integration. Subscribes to the diagnostics_channels
+ * injected into `@langchain/langgraph`'s `StateGraph.compile` and `createReactAgent`, so it requires
+ * the Sentry runtime hook or bundler plugin.
+ */
+export declare const langGraphIntegration: (options?: import("../ai/core/utils").GenAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LangGraph";
+};
+//# sourceMappingURL=langgraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"langgraph.d.ts","sourceRoot":"","sources":["../../../src/integrations/langgraph.ts"],"names":[],"mappings":"AAiIA;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;CAA2C,CAAC"}

package/build/types/integrations/lru-memoizer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Diagnostics-channel-based lru-memoizer integration. Subscribes to
+ * `orchestrion:lru-memoizer:load` (injected into `lru-memoizer/lib/async.js`'s
+ * `memoizedFunction`). Creates no spans; only re-runs the memoized callback with the
+ * caller's scope. Requires the Sentry runtime hook or bundler plugin.
+ */
+export declare const lruMemoizerIntegration: () => import("@sentry/core").Integration & {
+    name: "LruMemoizer";
+};
+//# sourceMappingURL=lru-memoizer.d.ts.map

package/build/types/integrations/lru-memoizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru-memoizer.d.ts","sourceRoot":"","sources":["../../../src/integrations/lru-memoizer.ts"],"names":[],"mappings":"AAiCA;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;CAA6C,CAAC"}

package/build/types/integrations/mastra.d.ts

@@ -0,0 +1,18 @@
+import type { MastraExporterOptions } from '../ai/mastra';
+export interface MastraOptions extends MastraExporterOptions {
+    /**
+     * Construct a Mastra observability pipeline when the app has not configured one. Defaults to
+     * `true`. Uses an `@mastra/observability` the app already has; the SDK never installs it.
+     */
+    bootstrapObservability?: boolean;
+}
+/**
+ * Hooks the `Mastra` constructor and registers a Sentry exporter via `registerExporter()`.
+ * Enabled by default. Disable with
+ * `defaultIntegrations: integrations => integrations.filter(i => i.name !== 'Mastra')`.
+ * Requires the runtime hook or bundler plugin, and `@mastra/core >= 1.63.2`.
+ */
+export declare const mastraIntegration: (options?: MastraOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Mastra";
+};
+//# sourceMappingURL=mastra.d.ts.map

package/build/types/integrations/mastra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mastra.d.ts","sourceRoot":"","sources":["../../../src/integrations/mastra.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAS1D,MAAM,WAAW,aAAc,SAAQ,qBAAqB;IAC1D;;;OAGG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AA8WD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;CAAwC,CAAC"}

package/build/types/integrations/mcp-server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Auto-instruments `@modelcontextprotocol/server` (v2) and `@modelcontextprotocol/sdk` (v1)
+ * `McpServer` instances, so users no longer have to wrap them with `wrapMcpServerWithSentry`
+ * by hand. Enabled by default. Requires the runtime hook or a bundler plugin (orchestrion) to
+ * inject the constructor channel.
+ */
+export declare const mcpServerIntegration: () => import("@sentry/core").Integration & {
+    name: string;
+};
+//# sourceMappingURL=mcp-server.d.ts.map

package/build/types/integrations/mcp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../src/integrations/mcp-server.ts"],"names":[],"mappings":"AA+CA;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;CAA2C,CAAC"}

package/build/types/integrations/mistral.d.ts

@@ -0,0 +1,7 @@
+/**
+ * An integration to instrument @mistralai/mistrailai.
+ */
+export declare const mistralAIIntegration: (options?: import("../ai/core/utils").GenAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Mistral";
+};
+//# sourceMappingURL=mistral.d.ts.map

package/build/types/integrations/mistral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mistral.d.ts","sourceRoot":"","sources":["../../../src/integrations/mistral.ts"],"names":[],"mappings":"AAuGA;;GAEG;AACH,eAAO,MAAM,oBAAoB;;CAA2C,CAAC"}

package/build/types/integrations/mongodb/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Diagnostics-channel-based mongodb integration.
+ *
+ * Reproduces the vendored `@opentelemetry/instrumentation-mongodb` span shape
+ * (legacy db/net semantic conventions, `mongodb.<op>` names, scrubbed
+ * `db.statement`) via the `orchestrion:mongodb:*` diagnostics_channels
+ * injected by Sentry's code transform.
+ */
+export declare const mongoIntegration: () => import("@sentry/core").Integration & {
+    name: "Mongo";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/mongodb/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/mongodb/index.ts"],"names":[],"mappings":"AAyKA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;CAAuC,CAAC"}

package/build/types/integrations/mongodb/mongodb-span.d.ts

@@ -0,0 +1,65 @@
+import type { Span, SpanAttributes } from '@sentry/core';
+/**
+ * The db/collection namespace mongodb (v4+) passes to `Connection.command`
+ */
+export interface MongodbNamespace {
+    db: string;
+    collection?: string;
+}
+interface V4Command {
+    documents?: unknown[];
+    cursors?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Replaces every leaf value in the command object with '?', keeping keys
+ * and Mongo operators. hides PII and improves grouping. Reproduced from
+ * the OTel instrumentation.
+ */
+export declare function serializeDbStatement(commandObj: Record<string, unknown>): string;
+/**
+ * Build span attributes for a mongodb v4+ command from the connection
+ * context, namespace and command.
+ */
+export declare function getV4SpanAttributes(connectionCtx: {
+    address?: string;
+} | undefined, ns: MongodbNamespace, command: V4Command | undefined, operation: string | undefined, origin: string): SpanAttributes;
+/**
+ * Shared attribute builder used by both the v3 topology path and the v4+
+ * connection path.
+ */
+export declare function getSpanAttributes(dbName: string | undefined, dbCollection: string | undefined, host: string | undefined, port: string | undefined, commandObj: Record<string, unknown> | undefined, operation: string | undefined, origin: string): SpanAttributes;
+/** The v3 driver topology, from which host/port are read (mongodb 3.x). */
+export interface MongoV3Topology {
+    s?: {
+        options?: {
+            host?: string;
+            port?: number;
+        };
+        host?: string;
+        port?: number;
+    };
+    description?: {
+        address?: string;
+    };
+}
+/**
+ * Determine the operation name for a mongodb v3 `command` from the command
+ * document, mirroring the vendored instrumentation. Returns `undefined` for
+ * commands it doesn't classify (e.g. `endSessions`).
+ */
+export declare function getV3CommandOperation(command: Record<string, unknown>): string | undefined;
+/**
+ * Build span attributes for a mongodb v3 operation from the topology,
+ * namespace string and command.
+ */
+export declare function getV3SpanAttributes(ns: string, topology: MongoV3Topology | undefined, command: Record<string, unknown> | undefined, operation: string | undefined, origin: string): SpanAttributes;
+/**
+ * Start a mongodb client span on the stable conventions.
+ *
+ * The `db` op is set explicitly rather than relying on `inferDbSpanData`,
+ * to support platforms that lack it (ie, Deno).
+ */
+export declare function startMongoSpan(attributes: SpanAttributes): Span;
+export {};
+//# sourceMappingURL=mongodb-span.d.ts.map

package/build/types/integrations/mongodb/mongodb-span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb-span.d.ts","sourceRoot":"","sources":["../../../../src/integrations/mongodb/mongodb-span.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAczD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,SAAS;IACjB,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAEhF;AAmCD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,EAC/C,EAAE,EAAE,gBAAgB,EACpB,OAAO,EAAE,SAAS,GAAG,SAAS,EAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,GACb,cAAc,CAqBhB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC/C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,GACb,cAAc,CA2BhB;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC9B,CAAC,CAAC,EAAE;QACF,OAAO,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACF,WAAW,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS,CAa1F;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC5C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,GACb,cAAc,CAyBhB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI,CAoB/D"}

package/build/types/integrations/mongoose/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Diagnostics-channel-based mongoose integration.
+ *
+ * Reproduces the vendored `@opentelemetry/instrumentation-mongoose` span
+ * shape (legacy db/net semantic conventions, `mongoose.<Model>.<op>` names,
+ * build-time span parenting) via the `orchestrion:mongoose:*`
+ * diagnostics_channels injected into mongoose `< 9.7` by Sentry's
+ * code transform. For mongoose `>= 9.7` it also drives the native
+ * diagnostics_channel subscription, so this single integration covers every
+ * supported version once it replaces the OTel one.
+ */
+export declare const mongooseIntegration: () => import("@sentry/core").Integration & {
+    name: "Mongoose";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/mongoose/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/mongoose/index.ts"],"names":[],"mappings":"AAsLA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;CAA0C,CAAC"}

package/build/types/integrations/mongoose/mongoose-dc-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose-dc-subscriber.d.ts","sourceRoot":"","sources":["../../../../src/integrations/mongoose/mongoose-dc-subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AA4B/D,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAC1D,eAAO,MAAM,6BAA6B,uBAAuB,CAAC;AAClE,eAAO,MAAM,8BAA8B,wBAAwB,CAAC;AACpE,eAAO,MAAM,qCAAqC,8BAA8B,CAAC;AACjF,eAAO,MAAM,oCAAoC,6BAA6B,CAAC;AAC/E,eAAO,MAAM,+BAA+B,yBAAyB,CAAC;AAStE;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,uFAAuF;IACvF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;;;;GAMG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAIrG;;;;;;;;;;GAUG;AACH,wBAAgB,mCAAmC,CAAC,cAAc,EAAE,6BAA6B,GAAG,IAAI,CAkBvG"}

package/build/types/integrations/mongoose/mongoose-legacy-span.d.ts

@@ -0,0 +1,30 @@
+import type { Span } from '@sentry/core';
+/** The subset of mongoose's `Collection` that the legacy span shape reads. */
+export interface MongooseLegacyCollection {
+    name?: string;
+    conn?: {
+        name?: string;
+        user?: string;
+        host?: string;
+        port?: number;
+    };
+}
+export interface StartMongooseLegacySpanOptions {
+    collection: MongooseLegacyCollection | undefined;
+    modelName: string | undefined;
+    operation: string;
+    origin: string;
+    parentSpan?: Span;
+}
+/**
+ * Start a mongoose client span reproducing the vendored
+ * `@opentelemetry/instrumentation-mongoose` span shape, on the stable
+ * conventions. `db.system.name` deliberately deviates from what the OTel
+ * instrumentation emitted: mongoose is an ODM, the database system is mongodb.
+ *
+ * Shared by the vendored OTel/IITM instrumentation (`@sentry/node`) and the
+ * orchestrion channel subscriber so the two emit an identical span shape,
+ * differing only by `origin`.
+ */
+export declare function startMongooseLegacySpan({ collection, modelName, operation, origin, parentSpan, }: StartMongooseLegacySpanOptions): Span;
+//# sourceMappingURL=mongoose-legacy-span.d.ts.map

package/build/types/integrations/mongoose/mongoose-legacy-span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose-legacy-span.d.ts","sourceRoot":"","sources":["../../../../src/integrations/mongoose/mongoose-legacy-span.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,cAAc,CAAC;AAKzD,8EAA8E;AAC9E,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACvE;AAED,MAAM,WAAW,8BAA8B;IAC7C,UAAU,EAAE,wBAAwB,GAAG,SAAS,CAAC;IACjD,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,IAAI,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,UAAU,EACV,SAAS,EACT,SAAS,EACT,MAAM,EACN,UAAU,GACX,EAAE,8BAA8B,GAAG,IAAI,CAgCvC"}

package/build/types/integrations/mysql.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Diagnostics-channel-based mysql integration.
+ *
+ * Subscribes to the `orchestrion:mysql:query` diagnostics_channel that
+ * Sentry's code transform injects into `mysql/lib/Connection.js`'s
+ * `Connection.prototype.query`. Requires the Sentry runtime hook or
+ * bundler plugin to be active.
+ */
+export declare const mysqlIntegration: () => import("@sentry/core").Integration & {
+    name: "Mysql";
+};
+//# sourceMappingURL=mysql.d.ts.map

package/build/types/integrations/mysql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../../src/integrations/mysql.ts"],"names":[],"mappings":"AAsLA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;CAAuC,CAAC"}

package/build/types/integrations/mysql2/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Diagnostics-channel-based mysql2 integration.
+ *
+ * Adds Sentry tracing instrumentation for the
+ * [mysql2](https://www.npmjs.com/package/mysql2) library via diagnostics-channel
+ * injection. See {@link instrumentMysql2} for how the two mysql2 version ranges
+ * are covered.
+ *
+ * Known limitation vs. older OTel integration it replaced: the callback-less
+ * streaming form (`connection.query(sql).on('result', ...)`) is not traced.
+ * See the `mysql2` transform config for why. The callback and promise forms
+ * (the common case) are fully instrumented.
+ */
+export declare const mysql2Integration: () => import("@sentry/core").Integration & {
+    name: "Mysql2";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/mysql2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/mysql2/index.ts"],"names":[],"mappings":"AAsKA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB;;CAAwC,CAAC"}

package/build/types/integrations/mysql2/mysql2-dc-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql2-dc-subscriber.d.ts","sourceRoot":"","sources":["../../../../src/integrations/mysql2/mysql2-dc-subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAmB/D,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AACtD,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAC1D,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAC1D,eAAO,MAAM,8BAA8B,wBAAwB,CAAC;AAQpE;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oFAAoF;IACpF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;;;;GAMG;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEnG;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAAC,cAAc,EAAE,2BAA2B,GAAG,IAAI,CAKnG"}

package/build/types/integrations/openai-compatible.d.ts

@@ -0,0 +1,32 @@
+import type { Integration } from '@sentry/core';
+import type { OpenAiOptions } from '../ai/openai/types';
+/**
+ * Describes an OpenAI-compatible provider whose SDK mirrors the openai wire format (Groq, Together, ...),
+ * so the span building, streaming and response parsing can all be reused from `ai/openai`.
+ */
+export interface OpenAiCompatibleProvider {
+    /** Integration name; also the key used to skip double-wrapping when another provider drives the SDK. */
+    integrationName: string;
+    /** Value reported on `gen_ai.provider.name`. */
+    providerName: string;
+    /** Span origin, `auto.ai.<provider>`. */
+    origin: string;
+    /** The instrumented `module.name`s (from the orchestrion config's `getModuleNames`). */
+    moduleNames: string[];
+    /** The fully-qualified orchestrion channels this provider publishes to. */
+    channels: {
+        chat: string;
+        embeddings: string;
+    };
+}
+/**
+ * Builds a diagnostics-channel integration for an OpenAI-compatible provider SDK. It subscribes to the
+ * `orchestrion:<module>:{chat,embeddings}` channels injected into the SDK's `create` methods, so it
+ * requires the Sentry runtime hook or bundler plugin. Everything below the channel — request/response
+ * attributes and streaming — is shared with the openai integration; only the provider name and origin
+ * differ.
+ */
+export declare function createOpenAiCompatibleIntegration<T extends OpenAiCompatibleProvider>(provider: T): (options?: OpenAiOptions) => Integration & {
+    name: T['integrationName'];
+};
+//# sourceMappingURL=openai-compatible.d.ts.map

package/build/types/integrations/openai-compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compatible.d.ts","sourceRoot":"","sources":["../../../src/integrations/openai-compatible.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAA2C,MAAM,cAAc,CAAC;AAYzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAKxD;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,wGAAwG;IACxG,eAAe,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,wFAAwF;IACxF,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CAChD;AAYD;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,wBAAwB,EAClF,QAAQ,EAAE,CAAC,GACV,CAAC,OAAO,CAAC,EAAE,aAAa,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,CAAC,CAAC,iBAAiB,CAAC,CAAA;CAAE,CA8B3E"}

package/build/types/integrations/openai.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Diagnostics-channel-based OpenAI integration. Subscribes to the `orchestrion:openai:*`
+ * diagnostics_channels injected into `openai`'s `create` methods (chat completions, responses, embeddings,
+ * conversations), so it requires the Sentry runtime hook or bundler plugin.
+ */
+export declare const openAIIntegration: (options?: import("../ai/core/utils").GenAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "OpenAI";
+};
+//# sourceMappingURL=openai.d.ts.map

package/build/types/integrations/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/integrations/openai.ts"],"names":[],"mappings":"AAmIA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;CAAwC,CAAC"}

package/build/types/integrations/postgres-js.d.ts

@@ -0,0 +1,27 @@
+import type { Span } from '@sentry/core';
+import { type PostgresConnectionContext } from './postgresjs';
+export interface PostgresJsIntegrationOptions {
+    /**
+     * Only create spans when there's already an active parent span. Defaults to
+     * `true`, matching the OTel `postgresJsIntegration`.
+     */
+    requireParentSpan?: boolean;
+    /**
+     * Hook to modify the query span before the query runs. Receives the span, the
+     * sanitized SQL, and (when resolvable) the connection context.
+     */
+    requestHook?: (span: Span, sanitizedSqlQuery: string, postgresConnectionContext?: PostgresConnectionContext) => void;
+}
+/**
+ * Diagnostics-channel-based postgres.js (`postgres` v3.x) integration.
+ *
+ * Subscribes to the `orchestrion:postgres:handle` / `:connection` / `:execute` /
+ * `:connect` diagnostics channels injected into postgres.js' `Query.prototype.handle`
+ * and `Connection`/`execute`/`connect` (in `src/*` and `cjs/src/*`) and creates db
+ * spans matching the OTel `postgresJsIntegration`. Requires the Sentry runtime
+ * hook or bundler plugin.
+ */
+export declare const postgresJsIntegration: (options?: PostgresJsIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+    name: "PostgresJs";
+};
+//# sourceMappingURL=postgres-js.d.ts.map

package/build/types/integrations/postgres-js.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-js.d.ts","sourceRoot":"","sources":["../../../src/integrations/postgres-js.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAiB,IAAI,EAAE,MAAM,cAAc,CAAC;AAYxD,OAAO,EAKL,KAAK,yBAAyB,EAC/B,MAAM,cAAc,CAAC;AAiCtB,MAAM,WAAW,4BAA4B;IAC3C;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,yBAAyB,CAAC,EAAE,yBAAyB,KAAK,IAAI,CAAC;CACtH;AAoRD;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;CAA4C,CAAC"}

package/build/types/integrations/postgres.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Diagnostics-channel-based `pg` (node-postgres) integration.
+ *
+ * Subscribes to the `orchestrion:pg:query`/`:connect` and
+ * `orchestrion:pg-pool:connect` diagnostics_channels that Sentry's code
+ * transform injects into `pg`'s `Client.prototype.query`/`connect`
+ * and `pg-pool`'s `Pool.prototype.connect`. Requires the Sentry runtime
+ * hook or bundler plugin to be active.
+ */
+export declare const postgresIntegration: (options?: {
+    ignoreConnectSpans?: boolean;
+} | undefined) => import("@sentry/core").Integration & {
+    name: "Postgres";
+};
+//# sourceMappingURL=postgres.d.ts.map

package/build/types/integrations/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../src/integrations/postgres.ts"],"names":[],"mappings":"AAgSA;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;yBAjN+B,OAAO;;;CAiNI,CAAC"}

package/build/types/integrations/postgresjs.d.ts

@@ -0,0 +1,75 @@
+import { type Span, type SpanAttributes } from '@sentry/core';
+export type PostgresConnectionContext = {
+    ATTR_DB_NAMESPACE?: string;
+    ATTR_SERVER_ADDRESS?: string;
+    ATTR_SERVER_PORT?: string;
+};
+interface PostgresJsSqlInstrumentationOptions {
+    /**
+     * Whether to require a parent span for the instrumentation.
+     * If set to true, the instrumentation will only create spans if there is a parent span
+     * available in the current scope.
+     * @default true
+     */
+    requireParentSpan?: boolean;
+    /**
+     * Hook to modify the span before it is started.
+     * This can be used to set additional attributes or modify the span in any way.
+     */
+    requestHook?: (span: Span, sanitizedSqlQuery: string, postgresConnectionContext?: PostgresConnectionContext) => void;
+}
+/**
+ * Instruments a postgres.js `sql` instance with Sentry tracing.
+ *
+ * This is a portable instrumentation function that works in any environment
+ * (Node.js, Cloudflare Workers, etc.) without depending on OpenTelemetry.
+ *
+ * @example
+ * ```javascript
+ * import postgres from 'postgres';
+ * import * as Sentry from '@sentry/cloudflare'; // or '@sentry/deno'
+ *
+ * const sql = Sentry.instrumentPostgresJsSql(
+ *   postgres({ host: 'localhost', database: 'mydb' })
+ * );
+ *
+ * // All queries now create Sentry spans
+ * await sql`SELECT * FROM users WHERE id = ${userId}`;
+ * ```
+ */
+export declare function instrumentPostgresJsSql<T>(sql: T, options?: PostgresJsSqlInstrumentationOptions): T;
+/**
+ * Reconstructs the full SQL query from template strings with PostgreSQL placeholders.
+ *
+ * For sql`SELECT * FROM users WHERE id = ${123} AND name = ${'foo'}`:
+ *   strings = ["SELECT * FROM users WHERE id = ", " AND name = ", ""]
+ *   returns: "SELECT * FROM users WHERE id = $1 AND name = $2"
+ *
+ * @internal Exported for testing only
+ */
+export declare function _reconstructQuery(strings: string[] | undefined): string | undefined;
+/**
+ * Returns connection context attributes.
+ *
+ * @internal Exported for the diagnostics-channel integration.
+ */
+export declare function _getConnectionAttributes(connectionContext: PostgresConnectionContext): SpanAttributes;
+/**
+ * Extracts the DB operation name from a SQL query, preferring the server-reported `command`.
+ *
+ * @internal Exported for the diagnostics-channel integration.
+ */
+export declare function _getOperationName(sanitizedQuery: string | undefined, command?: string): string | undefined;
+/**
+ * Builds a {@link PostgresConnectionContext} from postgres.js' parsed options
+ * (which store `host`/`port` as arrays). Defaults to 'localhost'/5432.
+ *
+ * @internal Exported for the diagnostics-channel integration.
+ */
+export declare function _buildConnectionContext(options: {
+    host?: string[];
+    port?: number[];
+    database?: string;
+}): PostgresConnectionContext;
+export {};
+//# sourceMappingURL=postgresjs.d.ts.map

package/build/types/integrations/postgresjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgresjs.d.ts","sourceRoot":"","sources":["../../../src/integrations/postgresjs.ts"],"names":[],"mappings":"AAKA,OAAO,EAML,KAAK,IAAI,EACT,KAAK,cAAc,EAGpB,MAAM,cAAc,CAAC;AAkBtB,MAAM,MAAM,yBAAyB,GAAG;IACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,UAAU,mCAAmC;IAC3C;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,yBAAyB,CAAC,EAAE,yBAAyB,KAAK,IAAI,CAAC;CACtH;AAYD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,mCAAmC,GAAG,CAAC,CAOnG;AAqQD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CASnF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,iBAAiB,EAAE,yBAAyB,GAAG,cAAc,CAkBrG;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO1G;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,yBAAyB,CAQ5B"}

package/build/types/integrations/prisma/global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../../../../src/integrations/prisma/global.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAoC,aAAa,EAAE,MAAM,SAAS,CAAC;AAe/E,wBAAgB,sBAAsB,IAAI,aAAa,GAAG,SAAS,CAUlE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAKlE;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C"}

package/build/types/integrations/prisma/index.d.ts

@@ -0,0 +1,43 @@
+export interface PrismaInstrumentationConfig {
+    /**
+     * Span types that should not be traced. Matched against the full span name (e.g. `prisma:client:operation`),
+     * either exactly (string) or by pattern (RegExp).
+     */
+    ignoreSpanTypes?: (string | RegExp)[];
+}
+export interface PrismaOptions {
+    /**
+     * Configuration for the Prisma tracing helper.
+     */
+    instrumentationConfig?: PrismaInstrumentationConfig;
+}
+/**
+ * Sets up the global Prisma tracing helper that Prisma looks up on `globalThis` to emit tracing data.
+ *
+ * Prisma reads `globalThis.PRISMA_INSTRUMENTATION` (and its versioned variant) to find a "TracingHelper"
+ * which it uses internally to create spans, so it can produce tracing data without depending on
+ * OpenTelemetry. The helper we install here mints spans through Sentry's span APIs. A single helper
+ * serves both Prisma v5 (which calls `createEngineSpan`) and v6/v7 (which call `dispatchEngineSpans`),
+ * so it doesn't blow up on version mismatches.
+ */
+export declare function instrumentPrisma(options?: PrismaOptions): void;
+/**
+ * Adds Sentry tracing instrumentation for the [prisma](https://www.npmjs.com/package/prisma) library.
+ * For more information, see the [`prismaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma/).
+ *
+ * NOTE: This integration works out of the box with Prisma v6, v7 and v8. Prisma v8 ("Prisma Next")
+ * has no tracing surface of its own, so its ORM calls are instrumented through Sentry's runtime hook
+ * or bundler plugin, like the other channel-based integrations.
+ * On Prisma versions prior to v6, add `previewFeatures = ["tracing"]` to the client generator block of your Prisma schema:
+ *
+ *    ```
+ *    generator client {
+ *      provider = "prisma-client-js"
+ *      previewFeatures = ["tracing"]
+ *    }
+ *    ```
+ */
+export declare const prismaIntegration: (options?: PrismaOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Prisma";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/prisma/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/prisma/index.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,2BAA2B;IAC1C;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,qBAAqB,CAAC,EAAE,2BAA2B,CAAC;CACrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAM9D;AAiBD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB;;CAAwC,CAAC"}

package/build/types/integrations/prisma/orchestrion.d.ts

@@ -0,0 +1,10 @@
+interface PrismaV8InstrumentationOptions {
+    ignoreSpanTypes: (string | RegExp)[];
+}
+/**
+ * Opens a `prisma:client:operation` span per ORM call, kept active while the terminal runs so the `pg`
+ * query spans nest under it like the `db_query` spans did on v5–v7.
+ */
+export declare function instrumentPrismaV8(options: PrismaV8InstrumentationOptions): void;
+export {};
+//# sourceMappingURL=orchestrion.d.ts.map

package/build/types/integrations/prisma/orchestrion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrion.d.ts","sourceRoot":"","sources":["../../../../src/integrations/prisma/orchestrion.ts"],"names":[],"mappings":"AA4CA,UAAU,8BAA8B;IACtC,eAAe,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CACtC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,8BAA8B,GAAG,IAAI,CAmBhF"}

package/build/types/integrations/prisma/tracing-helper.d.ts

@@ -0,0 +1,48 @@
+import type { Span } from '@sentry/core';
+import type { EngineSpan, ExtendedSpanOptions, SpanCallback, TracingHelper } from './types';
+type Options = {
+    ignoreSpanTypes: (string | RegExp)[];
+};
+type V5EngineSpanEvent = {
+    span: boolean;
+    spans: V5EngineSpan[];
+};
+type V5EngineSpanKind = 'client' | 'internal';
+type V5EngineSpan = {
+    span: boolean;
+    name: string;
+    trace_id: string;
+    span_id: string;
+    parent_span_id: string;
+    start_time: [number, number];
+    end_time: [number, number];
+    attributes?: Record<string, string>;
+    links?: {
+        trace_id: string;
+        span_id: string;
+    }[];
+    kind: V5EngineSpanKind;
+};
+/**
+ * This satisifes the TracingHelper interface for Prisma v5 and v6/v7.
+ */
+export declare class ActiveTracingHelper implements TracingHelper {
+    private ignoreSpanTypes;
+    constructor({ ignoreSpanTypes }: Options);
+    isEnabled(): boolean;
+    getTraceParent(span?: Span): string;
+    dispatchEngineSpans(spans: EngineSpan[]): void;
+    /**
+     * Prisma v5 broke the tracing helper interface with the v6 major, replacing `createEngineSpan` with
+     * `dispatchEngineSpans`. We implement the v6/v7 interface (`dispatchEngineSpans`) but also keep this
+     * v5-only method so the same helper doesn't blow up in Prisma 5 users' faces, minting v5 engine spans
+     * through Sentry's span APIs instead of crashing.
+     */
+    createEngineSpan(engineSpanEvent: V5EngineSpanEvent): void;
+    getActiveContext(): Span | undefined;
+    runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
+}
+/** Whether `spanName` matches one of the configured `ignoreSpanTypes` patterns. */
+export declare function shouldIgnoreSpan(spanName: string, ignoreSpanTypes: (string | RegExp)[]): boolean;
+export {};
+//# sourceMappingURL=tracing-helper.d.ts.map