@sentry/cloudflare 10.66.0 → 10.68.0

package/build/types-ts3.8/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-ts3.8/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-ts3.8/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-ts3.8/vite/workerEntrypoint.d.ts

@@ -0,0 +1,12 @@
+import { 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-ts3.8/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-ts3.8/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/cloudflare",
-  "version": "10.66.0",
+  "version": "10.68.0",
   "description": "Official Sentry SDK for Cloudflare Workers and Pages",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/cloudflare",
@@ -46,6 +46,16 @@
         "types": "./build/types/nodejs_compat/index.d.ts",
         "default": "./build/cjs/nodejs_compat/index.js"
       }
+    },
+    "./vite": {
+      "import": {
+        "types": "./build/types/vite/index.d.ts",
+        "default": "./build/esm/vite/index.js"
+      },
+      "require": {
+        "types": "./build/types/vite/index.d.ts",
+        "default": "./build/cjs/vite/index.js"
+      }
     }
   },
   "typesVersions": {
@@ -60,16 +70,20 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@sentry/core": "10.66.0",
-    "@sentry/node": "10.66.0",
-    "@sentry/server-utils": "10.66.0"
+    "@sentry/core": "10.68.0",
+    "@sentry/server-utils": "10.68.0",
+    "magic-string": "~0.30.21"
   },
   "peerDependencies": {
-    "@cloudflare/workers-types": "^4.x || ^5.x"
+    "@cloudflare/workers-types": "^4.x || ^5.x",
+    "wrangler": "^4.x"
   },
   "peerDependenciesMeta": {
     "@cloudflare/workers-types": {
       "optional": true
+    },
+    "wrangler": {
+      "optional": true
     }
   },
   "devDependencies": {