@sentry/cloudflare 10.66.0 → 10.68.0

package/build/types/utils/isBinding.d.ts

@@ -30,7 +30,7 @@
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 /**
  * Checks if a value is a JSRPC proxy (service binding).
  *
@@ -56,9 +56,22 @@ export declare function isQueue(item: unknown): item is Queue;
  * D1Database has `prepare`, `batch`, and `exec` methods.
  */
 export declare function isD1Database(item: unknown): item is D1Database;
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export declare function isAiBinding(item: unknown): item is Ai;
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.
  */
 export declare function isR2Bucket(item: unknown): item is R2Bucket;
+/**
+ * Duck-type check for RateLimit bindings.
+ * RateLimit only exposes a single `limit` method. Because that is a fairly
+ * common method name, this check is intentionally run after the more specific
+ * binding checks (Queue, R2, D1) in `instrumentEnv`, so those win when a binding
+ * also happens to expose `limit`.
+ */
+export declare function isRateLimit(item: unknown): item is RateLimit;
 //# sourceMappingURL=isBinding.d.ts.map

package/build/types/utils/isBinding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isBinding.d.ts","sourceRoot":"","sources":["../../../src/utils/isBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,sBAAsB,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAErG;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,OAAO,CAMtD;AAID;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,sBAAsB,CAEtF;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,KAAK,CAEpD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,UAAU,CAQ9D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,QAAQ,CAQ1D"}
+{"version":3,"file":"isBinding.d.ts","sourceRoot":"","sources":["../../../src/utils/isBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,sBAAsB,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAEpH;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,OAAO,CAMtD;AAID;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,sBAAsB,CAEtF;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,KAAK,CAEpD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,UAAU,CAQ9D;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,EAAE,CAQrD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,QAAQ,CAQ1D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,SAAS,CAE5D"}

package/build/types/vite/autoInstrument.d.ts

@@ -0,0 +1,21 @@
+import { type ProgramBody } from './transform';
+export declare function sentryCloudflareAutoInstrumentPlugin(): {
+    name: string;
+    configResolved(config: {
+        root: string;
+        logger?: {
+            warn(msg: string): void;
+        };
+    }): void;
+    transform(this: {
+        parse(code: string): ProgramBody;
+        warn?(msg: string): void;
+        environment?: {
+            name?: string;
+        };
+    }, code: string, id: string): {
+        code: string;
+        map: unknown;
+    } | undefined;
+};
+//# sourceMappingURL=autoInstrument.d.ts.map

package/build/types/vite/autoInstrument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoInstrument.d.ts","sourceRoot":"","sources":["../../../src/vite/autoInstrument.ts"],"names":[],"mappings":"AACA,OAAO,EAAwD,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAcrG,wBAAgB,oCAAoC;;2BAUzB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE;YAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAA;KAAE,GAAG,IAAI;oBAyB5E;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QAAC,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,WAAW,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,QAC/F,MAAM,MACR,MAAM,GACT;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS;EA6DhD"}

package/build/types/vite/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Options for {@link sentryCloudflareVitePlugin}.
+ */
+export interface SentryCloudflareVitePluginOptions {
+    /**
+     * Experimental options that may change or be removed without notice.
+     */
+    _experimental?: {
+        /**
+         * Enables build-time automatic instrumentation of supported dependencies
+         * (e.g. database clients like `mysql`) so the Sentry Cloudflare SDK can
+         * trace them without monkey-patching, which wouldn't work in workerd anyway.
+         *
+         * When enabled, the plugin injects `diagnostics_channel.tracingChannel`
+         * calls into the bundled packages and, next to each, a snippet that
+         * registers the matching Sentry channel-subscriber factory on the global
+         * marker, which the SDK picks up in `Sentry.withSentry()`. Both `vite build`
+         * and `vite dev` are instrumented.
+         *
+         * @default false
+         * @experimental May change or be removed in any release.
+         */
+        useDiagnosticsChannelInjection?: boolean;
+        /**
+         * Automatically wraps your Worker at build time so you don't have to edit
+         * your entry: the plugin reads your wrangler config, wraps the default
+         * export with `Sentry.withSentry()` (sourcing options from a co-located
+         * `instrument.*` file, falling back to env), and wraps any configured
+         * Durable Object class with `instrumentDurableObjectWithSentry`. Both
+         * `vite build` and `vite dev` are instrumented.
+         *
+         * @default false
+         * @experimental May change or be removed in any release.
+         */
+        autoInstrumentation?: boolean;
+    };
+}
+/**
+ * Sentry Vite plugin for Cloudflare Workers.
+ *
+ * Add this plugin to your Vite configuration to enable additional Sentry
+ * instrumentation for Cloudflare Workers built with Vite. Configure the Sentry
+ * SDK in your Worker as usual with `Sentry.withSentry()`.
+ *
+ * Currently, the only functionality is the experimental
+ * `_experimental.useDiagnosticsChannelInjection` option, which traces supported
+ * dependencies (such as database clients) without changing your application
+ * code. Without it, the plugin is a no-op.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { cloudflare } from '@cloudflare/vite-plugin';
+ * import { sentryCloudflareVitePlugin } from '@sentry/cloudflare/vite';
+ * import { defineConfig } from 'vite';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     cloudflare(),
+ *     sentryCloudflareVitePlugin({
+ *       _experimental: {
+ *         useDiagnosticsChannelInjection: true,
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function sentryCloudflareVitePlugin(options?: SentryCloudflareVitePluginOptions): ({
+    name: string;
+    configResolved(config: {
+        root: string;
+        logger?: {
+            warn(msg: string): void;
+        };
+    }): void;
+    transform(this: {
+        parse(code: string): import("./transform").ProgramBody;
+        warn?(msg: string): void;
+        environment?: {
+            name?: string;
+        };
+    }, code: string, id: string): {
+        code: string;
+        map: unknown;
+    } | undefined;
+} | import("vite").Plugin<any>)[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vite/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;OAEG;IACH,aAAa,CAAC,EAAE;QACd;;;;;;;;;;;;;WAaG;QACH,8BAA8B,CAAC,EAAE,OAAO,CAAC;QACzC;;;;;;;;;;WAUG;QACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,iCAAsC;;;;cAvDpC,CAAC;;;;;;YAoB7B,CAAA;mBAKf,CAAC;gBAAQ,CAAC;;;;;;kCAqCpB"}

package/build/types/vite/instrumentFile.d.ts

@@ -0,0 +1,22 @@
+export declare const ENV_FALLBACK_OPTIONS_FN = "() => undefined";
+/**
+ * Locate the conventional `instrument.server.*` module sitting next to the
+ * worker entry file. Returns its absolute path, or `undefined` when absent.
+ */
+export declare function resolveInstrumentFile(entryFilePath: string): string | undefined;
+/**
+ * Build the `optionsFn` reference and `import` statement for the instrument
+ * module whose **default export** is the options callback
+ * `(env) => CloudflareOptions`.
+ *
+ * The import is emitted relative to `entryFilePath` because it is injected into
+ * the entry file's source. The file extension is kept: extensionless specifiers
+ * only resolve for extensions in Vite's default `resolve.extensions` (which
+ * excludes `.cjs`), and keeping it makes our probe order authoritative when
+ * several `instrument.server.*` files coexist.
+ */
+export declare function buildOptionsImport(entryFilePath: string, instrumentFilePath: string): {
+    optionsFn: string;
+    importStmt: string;
+};
+//# sourceMappingURL=instrumentFile.d.ts.map

package/build/types/vite/instrumentFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentFile.d.ts","sourceRoot":"","sources":["../../../src/vite/instrumentFile.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AAWzD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO/E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,GACzB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAQ3C"}

package/build/types/vite/transform.d.ts

@@ -0,0 +1,60 @@
+import MagicString from 'magic-string';
+export interface BaseNode {
+    type: string;
+    start: number;
+    end: number;
+}
+export interface ProgramBody {
+    body: BaseNode[];
+}
+/**
+ * The kind of Sentry wrapper to apply to an exported class.
+ *
+ * `durableObject` and `workflow` are keyed by name from the wrangler config
+ * (`durable_objects.bindings`, `workflows`), since those class names are
+ * authoritative there. `workerEntrypoint` is different: a worker's own
+ * entrypoints aren't enumerated in its config, so they're detected structurally
+ * (a class extending `WorkerEntrypoint` from `cloudflare:workers`), with the
+ * config providing only a fallback for self-bound entrypoints whose base class
+ * lives in another module.
+ */
+export type ClassWrapperKind = 'durableObject' | 'workflow' | 'workerEntrypoint';
+export interface TransformContext {
+    /**
+     * Exported class name → the kind of Sentry wrapper to apply. Populated from
+     * the wrangler config, so the transform can wrap by name without resolving
+     * each class's base type.
+     */
+    classWrappers: Map<string, ClassWrapperKind>;
+    optionsFn: string;
+    /** Import statement prepended when `optionsFn` references a separate module. */
+    optionsImport?: string;
+}
+export interface TransformResult {
+    code: string;
+    map: ReturnType<MagicString['generateMap']>;
+    /**
+     * The configured class names that were actually wrapped. Lets the plugin warn
+     * about configured classes it could not find, instead of silently leaving
+     * them uninstrumented.
+     */
+    wrappedClasses: Set<string>;
+}
+/**
+ * Rewrite the worker entry source to wrap its default export with `withSentry`
+ * and any configured class export with its matching Sentry wrapper (see
+ * {@link TransformContext.classWrappers}, e.g. Durable Object classes with
+ * `instrumentDurableObjectWithSentry`).
+ *
+ * Handles both `export class MyDO {}` and the specifier form
+ * (`class MyDO {}` … `export { MyDO }` / `export { Foo as MyDO }`).
+ * Re-exports from other modules (`export { MyDO } from './do'`) cannot be
+ * wrapped here and are left alone — the plugin warns about them via
+ * {@link TransformResult.wrappedClasses}.
+ *
+ * Exported (rather than inlined into the plugin) so it can be unit-tested with a
+ * plain AST and no Vite context. Returns `undefined` when nothing was wrapped and
+ * there are no already-manually-wrapped classes to report.
+ */
+export declare function applyAutoInstrumentTransforms(code: string, ast: ProgramBody, ctx: TransformContext): TransformResult | undefined;
+//# sourceMappingURL=transform.d.ts.map

package/build/types/vite/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/vite/transform.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,cAAc,CAAC;AAOvC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,EAAE,CAAC;CAClB;AAuDD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,UAAU,GAAG,kBAAkB,CAAC;AAajF,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5C;;;;OAIG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,gBAAgB,GACpB,eAAe,GAAG,SAAS,CA6C7B"}

package/build/types/vite/workerEntrypoint.d.ts

@@ -0,0 +1,12 @@
+import type { ProgramBody } from './transform';
+/**
+ * Find top-level classes that (transitively, within this module) extend
+ * `WorkerEntrypoint` imported from `cloudflare:workers`. esbuild has already
+ * stripped TypeScript by transform time, so a superclass is a plain identifier
+ * (`extends WorkerEntrypoint`) or member access (`extends cf.WorkerEntrypoint`).
+ *
+ * Only same-file base chains are resolvable here; a base class imported from
+ * another module is invisible and relies on the config self-binding fallback.
+ */
+export declare function detectWorkerEntrypointClasses(ast: ProgramBody): Set<string>;
+//# sourceMappingURL=workerEntrypoint.d.ts.map

package/build/types/vite/workerEntrypoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerEntrypoint.d.ts","sourceRoot":"","sources":["../../../src/vite/workerEntrypoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,WAAW,EAAE,MAAM,aAAa,CAAC;AA0CzD;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CA8B3E"}

package/build/types/vite/wranglerConfig.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The slice of the wrangler configuration the auto-instrument plugin cares
+ * about. `main` is an absolute path (wrangler resolves it against the config
+ * file's directory).
+ */
+export interface WranglerConfig {
+    main?: string;
+    durableObjects: Array<{
+        name: string;
+        className: string;
+    }>;
+    workflows: Array<{
+        name: string;
+        className: string;
+    }>;
+    /**
+     * Named `WorkerEntrypoint` exports this worker binds to itself via a service
+     * binding (`services[]` whose `service` is this worker's own `name`). Only
+     * self-bindings appear here: a service binding's `entrypoint` otherwise names
+     * an export on a *different* worker, which this build can't wrap.
+     */
+    workerEntrypoints: string[];
+}
+/**
+ * Locate and resolve the wrangler configuration via wrangler's own
+ * `unstable_readConfig` — the API `@cloudflare/vite-plugin` uses.
+ *
+ * We only locate the file (probing `wrangler.json`, `.jsonc`, `.toml` inside
+ * `root` with wrangler's own precedence, since it discovers from `cwd` rather
+ * than an arbitrary root); wrangler then parses it, flattens the active
+ * environment (honoring `CLOUDFLARE_ENV`), and resolves `main` to an absolute
+ * path. Durable Object and Workflow bindings are the active environment's,
+ * matching what the deployed Worker actually binds.
+ *
+ * Returns `undefined` when no config file is found or it can't be read/parsed
+ * (the caller warns and disables auto-instrumentation rather than failing the
+ * whole build).
+ */
+export declare function resolveWranglerConfig(root: string, explicitPath?: string): {
+    config: WranglerConfig;
+    configDir: string;
+} | undefined;
+//# sourceMappingURL=wranglerConfig.d.ts.map

package/build/types/vite/wranglerConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wranglerConfig.d.ts","sourceRoot":"","sources":["../../../src/vite/wranglerConfig.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,SAAS,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtD;;;;;OAKG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,YAAY,CAAC,EAAE,MAAM,GACpB;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA2B3D"}

package/build/types/wrapMethodWithSentry.d.ts

@@ -20,6 +20,11 @@ type MethodWrapperOptions = {
      * @default false
      */
     startNewTrace?: boolean;
+    /**
+     * The trace origin identifying which instrumentation created the span, e.g. `auto.faas.cloudflare.durable_object`.
+     * Used both as the span's `sentry.origin` attribute and as the `mechanism.type` for captured exceptions.
+     */
+    origin: string;
 };
 export type UncheckedMethod = (...args: any[]) => any;
 type OriginalMethod = UncheckedMethod;

package/build/types/wrapMethodWithSentry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapMethodWithSentry.d.ts","sourceRoot":"","sources":["../../src/wrapMethodWithSentry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAgBtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAOlD,oFAAoF;AACpF,UAAU,8BAA+B,SAAQ,kBAAkB;IACjE,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAyBD,KAAK,oBAAoB,GAAG;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,gBAAgB,GAAG,8BAA8B,CAAC;IAC3D;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAGF,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AACtD,KAAK,cAAc,GAAG,eAAe,CAAC;AAEtC;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,cAAc,EAC3D,cAAc,EAAE,oBAAoB,EACpC,OAAO,EAAE,CAAC,EACV,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,EAC3C,MAAM,CAAC,EAAE,IAAI,GACZ,CAAC,CAuJH"}
+{"version":3,"file":"wrapMethodWithSentry.d.ts","sourceRoot":"","sources":["../../src/wrapMethodWithSentry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAgBtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAQlD,oFAAoF;AACpF,UAAU,8BAA+B,SAAQ,kBAAkB;IACjE,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAyBD,KAAK,oBAAoB,GAAG;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,gBAAgB,GAAG,8BAA8B,CAAC;IAC3D;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AACtD,KAAK,cAAc,GAAG,eAAe,CAAC;AAEtC;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,cAAc,EAC3D,cAAc,EAAE,oBAAoB,EACpC,OAAO,EAAE,CAAC,EACV,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,EAC3C,MAAM,CAAC,EAAE,IAAI,GACZ,CAAC,CA0JH"}

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

@@ -71,9 +71,9 @@ interface BaseCloudflareOptions {
      * When enabled, trace context (sentry-trace + baggage) is propagated across:
      * - `stub.fetch()` calls to Durable Objects (via HTTP headers)
      * - Service binding `fetch()` calls (via HTTP headers)
-     * - RPC method calls to Durable Objects (via trailing argument)
+     * - RPC method calls to Durable Objects and WorkerEntrypoints (via trailing argument)
      *
-     * When enabled on the **receiver side** (DurableObject), the SDK will also:
+     * When enabled on the **receiver side** (DurableObject or WorkerEntrypoint), the SDK will also:
      * - Extract and continue traces from incoming RPC calls
      * - Create spans for each RPC method invocation
      * - Capture errors thrown by RPC methods
@@ -100,9 +100,38 @@ interface BaseCloudflareOptions {
      *   }),
      *   MyDOBase,
      * );
+     *
+     * // WorkerEntrypoint side (receiver)
+     * export const MyEntrypoint = Sentry.withSentry(
+     *   env => ({ dsn: env.SENTRY_DSN, enableRpcTracePropagation: true }),
+     *   MyEntrypointBase,
+     * );
      * ```
      */
     enableRpcTracePropagation?: boolean;
+    /**
+     * Table names that should stay instrumented even though they match the reserved `cf_` prefix used
+     * by Durable Object frameworks (`agents`, `partyserver`, ...) for their internal SQLite tables.
+     *
+     * By default, `exec` queries against `cf_`-prefixed tables are treated as framework noise and no
+     * `db.query` span is created for them. If one of your own tables happens to use this prefix, add it
+     * here to opt it back into instrumentation. Entries are matched against each table name in the
+     * query summary — strings must match exactly, while regular expressions give you prefix/pattern
+     * matching.
+     *
+     * @default []
+     * @example
+     * ```ts
+     * export default Sentry.withSentry(
+     *   (env) => ({
+     *     dsn: env.SENTRY_DSN,
+     *     durableObjectSqlSpanAllowlist: ['cf_my_table', /^cf_reports_/],
+     *   }),
+     *   handler,
+     * );
+     * ```
+     */
+    durableObjectSqlSpanAllowlist?: Array<string | RegExp>;
     /**
      * @deprecated Use `enableRpcTracePropagation` instead. This option will be removed in a future major version.
      *

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

@@ -0,0 +1,38 @@
+import { env as cloudflareEnv } from 'cloudflare:workers';
+import { CloudflareOptions } from './client';
+/**
+ * Define the Sentry options for a Cloudflare Worker in a dedicated module.
+ *
+ * This is the recommended way to configure the SDK when using the Vite plugin's
+ * auto-instrumentation: place an `instrument.server.{ts,js,mjs}` file next to
+ * the worker entry whose **default export** is the result of this function. The
+ * plugin picks it up automatically and hands it to `withSentry`.
+ *
+ * Unlike Node's `Sentry.init(...)`, the options cannot be applied at module
+ * load time on Cloudflare: the DSN and other settings typically come from the
+ * per-request `env`, which only exists inside the handler. Pass a callback to
+ * read from `env`, or a static object when no `env` access is needed — either
+ * way you get full type-checking and autocomplete on {@link CloudflareOptions}.
+ *
+ * At runtime this is a thin pass-through; it only normalizes a static object
+ * into a callback so the plugin always imports a `(env) => options` function.
+ *
+ * @example
+ * ```ts
+ * // src/instrument.server.ts
+ * import { defineCloudflareOptions } from '@sentry/cloudflare';
+ *
+ * export default defineCloudflareOptions((env) => ({
+ *   dsn: env.SENTRY_DSN,
+ *   tracesSampleRate: 1.0,
+ * }));
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Static options — no `env` access needed
+ * export default defineCloudflareOptions({ tracesSampleRate: 1.0 });
+ * ```
+ */
+export declare function defineCloudflareOptions<Env = typeof cloudflareEnv>(optionsOrCallback: CloudflareOptions | ((env: Env) => CloudflareOptions | undefined)): (env: Env) => CloudflareOptions | undefined;
+//# sourceMappingURL=defineCloudflareOptions.d.ts.map

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

@@ -1,7 +1,8 @@
 export { Breadcrumb, BreadcrumbHint, PolymorphicRequest, RequestEventData, SdkInfo, Event, EventHint, ErrorEvent, Exception, FeatureFlagsIntegration, Session, SeverityLevel, Span, StackFrame, Stacktrace, Thread, User, Metric, ExclusiveEventHintOrCaptureContext, CaptureContext, } from '@sentry/core';
 export { CloudflareOptions } from './client';
-export { addEventProcessor, addBreadcrumb, addIntegration, captureException, captureEvent, captureMessage, captureFeedback, close, createTransport, lastEventId, flush, getClient, isInitialized, isEnabled, getCurrentScope, getGlobalScope, getIsolationScope, setCurrentClient, Scope, SDK_VERSION, setContext, setExtra, setExtras, setTag, setTags, setAttribute, setAttributes, setUser, setConversationId, getSpanStatusFromHttpCode, setHttpStatus, withScope, withIsolationScope, captureCheckIn, withMonitor, setMeasurement, getActiveSpan, getRootSpan, getTraceData, getTraceMetaTags, startSpan, startInactiveSpan, startSpanManual, startNewTrace, bindScopeToEmitter, suppressTracing, withActiveSpan, getSpanDescendants, continueTrace, functionToStringIntegration, inboundFiltersIntegration, instrumentOpenAiClient, instrumentGoogleGenAIClient, instrumentAnthropicAiClient, eventFiltersIntegration, linkedErrorsIntegration, requestDataIntegration, extraErrorDataIntegration, dedupeIntegration, rewriteFramesIntegration, captureConsoleIntegration, moduleMetadataIntegration, supabaseIntegration, instrumentSupabaseClient, instrumentPostgresJsSql, zodErrorsIntegration, consoleIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, trpcMiddleware, spanToJSON, spanToTraceHeader, spanToBaggageHeader, updateSpanName, wrapMcpServerWithSentry, consoleLoggingIntegration, createConsolaReporter, createLangChainCallbackHandler, instrumentLangChainEmbeddings, featureFlagsIntegration, growthbookIntegration, logger, metrics, withStreamedSpan, spanStreamingIntegration, instrumentLangGraph, instrumentCreateReactAgent, } from '@sentry/core';
+export { addEventProcessor, addBreadcrumb, addIntegration, captureException, captureEvent, captureMessage, captureFeedback, close, createTransport, lastEventId, flush, getClient, isInitialized, isEnabled, getCurrentScope, getGlobalScope, getIsolationScope, setCurrentClient, Scope, SDK_VERSION, setContext, setExtra, setExtras, setTag, setTags, setAttribute, setAttributes, setUser, setConversationId, getSpanStatusFromHttpCode, setHttpStatus, withScope, withIsolationScope, captureCheckIn, withMonitor, setMeasurement, getActiveSpan, getRootSpan, getTraceData, getTraceMetaTags, startSpan, startInactiveSpan, startSpanManual, startNewTrace, bindScopeToEmitter, suppressTracing, withActiveSpan, getSpanDescendants, continueTrace, functionToStringIntegration, inboundFiltersIntegration, instrumentOpenAiClient, instrumentGoogleGenAIClient, instrumentAnthropicAiClient, eventFiltersIntegration, linkedErrorsIntegration, requestDataIntegration, extraErrorDataIntegration, dedupeIntegration, rewriteFramesIntegration, captureConsoleIntegration, moduleMetadataIntegration, supabaseIntegration, instrumentSupabaseClient, instrumentPostgresJsSql, zodErrorsIntegration, consoleIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, trpcMiddleware, spanToJSON, spanToTraceHeader, spanToBaggageHeader, updateSpanName, wrapMcpServerWithSentry, consoleLoggingIntegration, createConsolaReporter, createLangChainCallbackHandler, instrumentLangChainEmbeddings, featureFlagsIntegration, growthbookIntegration, logger, metrics, withStreamedSpan, spanStreamingIntegration, instrumentStateGraph, instrumentLangGraph, instrumentCreateReactAgent, } from '@sentry/core';
 export { withSentry } from './withSentry';
+export { defineCloudflareOptions } from './defineCloudflareOptions';
 export { instrumentDurableObjectWithSentry } from './durableobject';
 export { sentryPagesPlugin } from './pages-plugin';
 export { wrapRequestHandler } from './request';

package/build/types-ts3.8/instrumentations/instrumentWorkerEntrypoint.d.ts

@@ -1,6 +1,6 @@
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
+import { WorkerEntrypoint } from 'cloudflare:workers';
 import { CloudflareOptions } from '../client';
-export type WorkerEntrypointConstructor<Env = typeof cloudflareEnv, Props = {}> = new (ctx: ExecutionContext, env: typeof cloudflareEnv) => InstanceType<typeof WorkerEntrypoint<Env, Props>>;
+export type WorkerEntrypointConstructor<Env = unknown, Props = {}> = new (ctx: ExecutionContext, env: any) => InstanceType<typeof WorkerEntrypoint<Env, Props>>;
 /**
  * Instruments a WorkerEntrypoint class to capture errors and performance data.
  *
@@ -38,5 +38,5 @@ export type WorkerEntrypointConstructor<Env = typeof cloudflareEnv, Props = {}>
  * );
  * ```
  */
-export declare function instrumentWorkerEntrypoint<T extends WorkerEntrypointConstructor>(optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined, WorkerEntrypointClass: T): T;
+export declare function instrumentWorkerEntrypoint<Env, Props, T extends InstanceType<typeof WorkerEntrypoint<Env, Props>>, C extends new (ctx: ExecutionContext, env: Env) => T>(optionsCallback: (env: Env) => CloudflareOptions | undefined, WorkerEntrypointClass: C): C;
 //# sourceMappingURL=instrumentWorkerEntrypoint.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentEnv.d.ts

@@ -8,6 +8,8 @@ import { CloudflareOptions } from '../../client';
  * - Service bindings / JSRPC proxies
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
+ * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation

package/build/types-ts3.8/instrumentations/worker/instrumentRateLimit.d.ts

@@ -0,0 +1,6 @@
+import { RateLimit } from '@cloudflare/workers-types';
+/**
+ * Wraps a Cloudflare rate limiter binding to create a span on each `limit()` call.
+ */
+export declare function instrumentRateLimit<T extends RateLimit>(rateLimit: T, bindingName: string): T;
+//# sourceMappingURL=instrumentRateLimit.d.ts.map

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

@@ -1,4 +1,4 @@
 export * from '../index';
-export { prismaIntegration } from '@sentry/node';
+export { prismaIntegration } from '@sentry/server-utils';
 export { vercelAIIntegration } from './integrations/tracing/vercelai';
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/nodejs_compat/integrations/tracing/vercelai.d.ts

@@ -1,16 +1,10 @@
-/**
- * This is a copy of the Vercel AI integration from the Cloudflare SDK (src/integrations/tracing/vercelai.ts).
- *
- * The only difference is that it includes tracing channel support
- * because the default Vercel AI integration needs `nodejs_als`, while this one uses `nodejs_compat`.
- */
-interface VercelAiOptions {
-    /**
-     * Enable or disable truncation of recorded input messages.
-     * Defaults to `true`.
-     */
-    enableTruncation?: boolean;
-}
+/*
+* This is a copy of the Vercel AI integration from the Cloudflare SDK (src/integrations/tracing/vercelai.ts).
+*
+* The only difference is that it includes tracing channel support
+* because the default Vercel AI integration needs `nodejs_als`, while this one uses `nodejs_compat`.
+*/
+import { VercelAiOptions } from '@sentry/server-utils';
 /**
  * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
  * This integration is not enabled by default, you need to manually add it.
@@ -40,5 +34,4 @@ interface VercelAiOptions {
 export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
     name: string;
 };
-export {};
 //# sourceMappingURL=vercelai.d.ts.map

package/build/types-ts3.8/utils/internalSqlQuery.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cloudflare frameworks that build on Durable Objects (`agents`, `partyserver`, ...) manage their
+ * own internal SQLite tables, all namespaced with a `cf_` prefix — e.g. `cf_agents_schedules`,
+ * `cf_agent_state`, `cf_ai_chat_stream_chunks`. Queries against them (schedule polling, chat-stream
+ * persistence, state bookkeeping) are framework implementation details that otherwise flood traces
+ * with dozens of zero-signal `db.query` spans per request. The exact set of tables even varies
+ * between framework versions, so we match the reserved prefix rather than an enumerated list.
+ *
+ * The `cf_` prefix is a reserved convention for framework-managed tables, so user tables should not
+ * use it. In case a user table does collide with the prefix, the `durableObjectSqlSpanAllowlist`
+ * option lets them opt those tables back into instrumentation.
+ *
+ * The check operates on the query summary produced by `getSqlQuerySummary` (`{operation} {table} ...`,
+ * the same value used as the span name), so table targets are already isolated from the rest of the
+ * query.
+ */
+export declare function targetsCloudflareInternalTable(querySummary: string | undefined, allowlist?: Array<string | RegExp>): boolean;
+//# sourceMappingURL=internalSqlQuery.d.ts.map

package/build/types-ts3.8/utils/isBinding.d.ts

@@ -30,7 +30,7 @@
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-import { D1Database, DurableObjectNamespace, Queue, R2Bucket } from '@cloudflare/workers-types';
+import { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 /**
  * Checks if a value is a JSRPC proxy (service binding).
  *
@@ -56,9 +56,22 @@ export declare function isQueue(item: unknown): item is Queue;
  * D1Database has `prepare`, `batch`, and `exec` methods.
  */
 export declare function isD1Database(item: unknown): item is D1Database;
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export declare function isAiBinding(item: unknown): item is Ai;
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.
  */
 export declare function isR2Bucket(item: unknown): item is R2Bucket;
+/**
+ * Duck-type check for RateLimit bindings.
+ * RateLimit only exposes a single `limit` method. Because that is a fairly
+ * common method name, this check is intentionally run after the more specific
+ * binding checks (Queue, R2, D1) in `instrumentEnv`, so those win when a binding
+ * also happens to expose `limit`.
+ */
+export declare function isRateLimit(item: unknown): item is RateLimit;
 //# sourceMappingURL=isBinding.d.ts.map

package/build/types-ts3.8/vite/autoInstrument.d.ts

@@ -0,0 +1,21 @@
+import { ProgramBody } from './transform';
+export declare function sentryCloudflareAutoInstrumentPlugin(): {
+    name: string;
+    configResolved(config: {
+        root: string;
+        logger?: {
+            warn(msg: string): void;
+        };
+    }): void;
+    transform(this: {
+        parse(code: string): ProgramBody;
+        warn?(msg: string): void;
+        environment?: {
+            name?: string;
+        };
+    }, code: string, id: string): {
+        code: string;
+        map: unknown;
+    } | undefined;
+};
+//# sourceMappingURL=autoInstrument.d.ts.map