@sentry/cloudflare 10.70.0 → 11.0.0-alpha.1

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

@@ -1,65 +0,0 @@
-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' | 'agent' | '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>;
-    /**
-     * Local class names detected as `agents` Agents. An Agent is configured as a Durable Object in
-     * wrangler, so this upgrades those entries from `durableObject` to `agent`.
-     */
-    agentClasses?: ReadonlySet<string>;
-    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

@@ -1,12 +0,0 @@
-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

@@ -1,43 +0,0 @@
-/**
- * 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/withSentry.d.ts

@@ -1,16 +0,0 @@
-import { env as cloudflareEnv } from 'cloudflare:workers';
-import { CloudflareOptions } from './client';
-import { WorkerEntrypointConstructor } from './instrumentations/instrumentWorkerEntrypoint';
-/**
- * Wrapper for Cloudflare handlers.
- *
- * Initializes the SDK and wraps the handler with Sentry instrumentation.
- *
- * Automatically instruments the `fetch` method of the handler.
- *
- * @param optionsCallback Function that returns the options for the SDK initialization.
- * @param handler {ExportedHandler} The handler to wrap.
- * @returns The wrapped handler.
- */
-export declare function withSentry<Env = typeof cloudflareEnv, QueueHandlerMessage = unknown, CfHostMetadata = unknown, T extends ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata> | WorkerEntrypointConstructor = ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata>>(optionsCallback: (env: Env) => CloudflareOptions | undefined, handler: T): T;
-//# sourceMappingURL=withSentry.d.ts.map

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

@@ -1,25 +0,0 @@
-import { WorkflowEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from './client';
-/**
- * Hashes a string to a UUID using SHA-1.
- */
-export declare function deterministicTraceIdFromInstanceId(instanceId: string): Promise<string>;
-/**
- * Instruments a Cloudflare Workflow class with Sentry.
- *
- * @example
- * ```typescript
- * const InstrumentedWorkflow = instrumentWorkflowWithSentry(
- *   (env) => ({ dsn: env.SENTRY_DSN }),
- *   MyWorkflowClass
- * );
- *
- * export default InstrumentedWorkflow;
- * ```
- *
- * @param optionsCallback - Function that returns Sentry options to initialize Sentry
- * @param WorkflowClass - The workflow class to instrument
- * @returns Instrumented workflow class with the same interface
- */
-export declare function instrumentWorkflowWithSentry<E, P, T extends WorkflowEntrypoint<E, P>, C extends new (ctx: ExecutionContext, env: E) => T>(optionsCallback: (env: E) => CloudflareOptions, WorkFlowClass: C): C;
-//# sourceMappingURL=workflows.d.ts.map

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

@@ -1,43 +0,0 @@
-import { DurableObjectStorage } from '@cloudflare/workers-types';
-import { CloudflareOptions } from './client';
-/** Extended DurableObjectState with originalStorage exposed by instrumentContext */
-export interface InstrumentedDurableObjectState extends DurableObjectState {
-    originalStorage?: DurableObjectStorage;
-}
-type MethodWrapperOptions = {
-    spanName?: string;
-    spanOp?: string;
-    options: CloudflareOptions;
-    context: ExecutionContext | InstrumentedDurableObjectState;
-    /**
-     * If true, starts a fresh trace instead of inheriting from a parent trace.
-     * Useful for scheduled/independent invocations like alarms.
-     *
-     * If true, it also stores the current span context and links to the previous invocation's span.
-     * Uses Durable Object storage to persist the link. The link is set asynchronously via `span.addLinks()`
-     * in a `waitUntil` to avoid blocking.
-     *
-     * @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;
-/**
- * Wraps a method with Sentry error tracking and optional tracing.
- * Supports starting new traces and linking to previous invocations via Durable Object storage.
- *
- * @param wrapperOptions - The options for the wrapper.
- * @param handler - The method to wrap.
- * @param callback - The callback to call.
- * @param noMark - Whether to mark the method as instrumented.
- * @returns The wrapped method.
- */
-export declare function wrapMethodWithSentry<T extends OriginalMethod>(wrapperOptions: MethodWrapperOptions, handler: T, callback?: (...args: Parameters<T>) => void, noMark?: true): T;
-export {};
-//# sourceMappingURL=wrapMethodWithSentry.d.ts.map