@sentry/cloudflare 10.68.0 → 11.0.0-alpha.0

package/build/esm/prod/withSentry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withSentry.js","sources":["../../../src/withSentry.ts"],"sourcesContent":["import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';\nimport type { CloudflareOptions } from './client';\nimport { instrumentExportedHandlerEmail } from './instrumentations/worker/instrumentEmail';\nimport { instrumentExportedHandlerFetch } from './instrumentations/worker/instrumentFetch';\nimport { instrumentExportedHandlerQueue } from './instrumentations/worker/instrumentQueue';\nimport { instrumentExportedHandlerScheduled } from './instrumentations/worker/instrumentScheduled';\nimport { instrumentExportedHandlerTail } from './instrumentations/worker/instrumentTail';\nimport { isCloudflareClass } from './utils/isCloudflareClass';\nimport type { AnyExportedHandler, DefaultEnv, ResolveEnv } from './types';\nimport {\n  instrumentWorkerEntrypoint,\n  type WorkerEntrypointConstructor,\n} from './instrumentations/instrumentWorkerEntrypoint';\n\n/**\n * Wrapper for Cloudflare handlers.\n *\n * Initializes the SDK and wraps the handler with Sentry instrumentation.\n *\n * Automatically instruments the `fetch` method of the handler.\n *\n * @param optionsCallback Function that returns the options for the SDK initialization.\n * @param handler {ExportedHandler} The handler to wrap.\n * @returns The wrapped handler.\n */\nexport function withSentry<\n  Env = DefaultEnv,\n  QueueHandlerMessage = unknown,\n  CfHostMetadata = unknown,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  T extends AnyExportedHandler | WorkerEntrypointConstructor<any, any> =\n    | ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata>\n    | WorkerEntrypointConstructor<Env>,\n>(optionsCallback: (env: ResolveEnv<T, Env>) => CloudflareOptions | undefined, handler: T): T {\n  if (isCloudflareClass(handler, 'WorkerEntrypoint')) {\n    // oxlint-disable-next-line typescript/no-explicit-any\n    return instrumentWorkerEntrypoint(optionsCallback as any, handler);\n  }\n\n  setAsyncLocalStorageAsyncContextStrategy();\n\n  try {\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerFetch(handler, optionsCallback as any);\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerScheduled(handler, optionsCallback as any);\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerEmail(handler, optionsCallback as any);\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerQueue(handler, optionsCallback as any);\n    // oxlint-disable-next-line typescript/no-explicit-any\n    instrumentExportedHandlerTail(handler, optionsCallback as any);\n    // This is here because Miniflare sometimes cannot get instrumented\n  } catch {\n    // Do not console anything here, we don't want to spam the console with errors\n  }\n\n  return handler;\n}\n"],"names":[],"mappings":";;;;;;;;;AAyBO,SAAS,UAAA,CAQd,iBAA6E,OAAA,EAAe;AAC5F,EAAA,IAAI,iBAAA,CAAkB,OAAA,EAAS,kBAAkB,CAAA,EAAG;AAElD,IAAA,OAAO,0BAAA,CAA2B,iBAAwB,OAAO,CAAA;AAAA,EACnE;AAEA,EAAA,wCAAA,EAAyC;AAEzC,EAAA,IAAI;AAEF,IAAA,8BAAA,CAA+B,SAAS,eAAsB,CAAA;AAE9D,IAAA,kCAAA,CAAmC,SAAS,eAAsB,CAAA;AAElE,IAAA,8BAAA,CAA+B,SAAS,eAAsB,CAAA;AAE9D,IAAA,8BAAA,CAA+B,SAAS,eAAsB,CAAA;AAE9D,IAAA,6BAAA,CAA8B,SAAS,eAAsB,CAAA;AAAA,EAE/D,CAAA,CAAA,MAAQ;AAAA,EAER;AAEA,EAAA,OAAO,OAAA;AACT;;;;"}

package/build/esm/prod/workflows.js

@@ -0,0 +1,136 @@
+import { CODE_FUNCTION_NAME, SENTRY_OP } from '@sentry/conventions/attributes';
+import { GENERAL_FUNCTION_SPAN_OP } from '@sentry/conventions/op';
+import { withIsolationScope, withScope, getCurrentScope, startSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, captureException, flush } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';
+import { getOriginalWaitUntil, flushAndDispose } from './flush.js';
+import { instrumentEnv } from './instrumentations/worker/instrumentEnv.js';
+import { addCloudResourceContext } from './scope-utils.js';
+import { init } from './sdk.js';
+import { instrumentContext } from './utils/instrumentContext.js';
+
+const UUID_REGEX = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i;
+async function deterministicTraceIdFromInstanceId(instanceId) {
+  const buf = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(instanceId));
+  return Array.from(new Uint8Array(buf)).slice(0, 16).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function propagationContextFromInstanceId(instanceId) {
+  const traceId = UUID_REGEX.test(instanceId) ? instanceId.replace(/-/g, "") : await deterministicTraceIdFromInstanceId(instanceId);
+  const sampleRand = parseInt(traceId.slice(-4), 16) / 65535;
+  return {
+    traceId,
+    sampleRand
+  };
+}
+class WrappedWorkflowStep {
+  constructor(_instanceId, _options, _step, _waitUntil) {
+    this._instanceId = _instanceId;
+    this._options = _options;
+    this._step = _step;
+    this._waitUntil = _waitUntil;
+  }
+  async do(name, configOrCallback, callbackOrRollback, maybeRollback) {
+    const scopeForStep = getCurrentScope();
+    const hasConfig = typeof configOrCallback !== "function";
+    const config = hasConfig ? configOrCallback : void 0;
+    const userCallback = hasConfig ? callbackOrRollback : configOrCallback;
+    const rollbackOptions = hasConfig ? maybeRollback : callbackOrRollback;
+    const instrumentedCallback = async (...args) => {
+      const stepContext = args[0];
+      const attempt = stepContext?.attempt;
+      const retryLimit = stepContext?.config?.retries?.limit;
+      const hasStepContext = typeof attempt === "number" && typeof retryLimit === "number";
+      const isFinalAttempt = !hasStepContext || attempt > retryLimit;
+      return startSpan(
+        {
+          name,
+          scope: scopeForStep,
+          attributes: {
+            [SENTRY_OP]: GENERAL_FUNCTION_SPAN_OP,
+            [CODE_FUNCTION_NAME]: name,
+            "workflow.step.name": name,
+            "cloudflare.workflow.timeout": config?.timeout,
+            "cloudflare.workflow.retries.backoff": config?.retries?.backoff,
+            // In workers-types v5, `delay` may be a `WorkflowDelayFunction`, which isn't a valid span attribute value.
+            "cloudflare.workflow.retries.delay": typeof config?.retries?.delay === "function" ? void 0 : config?.retries?.delay,
+            "cloudflare.workflow.retries.limit": config?.retries?.limit,
+            "cloudflare.workflow.attempt": attempt,
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.faas.cloudflare.workflow",
+            [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "task"
+          }
+        },
+        async (span) => {
+          try {
+            const result = await userCallback(...args);
+            span.setStatus({ code: 1 });
+            return result;
+          } catch (error) {
+            if (isFinalAttempt) {
+              captureException(error, { mechanism: { handled: true, type: "auto.faas.cloudflare.workflow" } });
+            }
+            throw error;
+          } finally {
+            this._waitUntil(flush(2e3));
+          }
+        }
+      );
+    };
+    if (config) {
+      return rollbackOptions ? this._step.do(name, config, instrumentedCallback, rollbackOptions) : this._step.do(name, config, instrumentedCallback);
+    }
+    return rollbackOptions ? this._step.do(name, instrumentedCallback, rollbackOptions) : this._step.do(name, instrumentedCallback);
+  }
+  async sleep(name, duration) {
+    return this._step.sleep(name, duration);
+  }
+  async sleepUntil(name, timestamp) {
+    return this._step.sleepUntil(name, timestamp);
+  }
+  async waitForEvent(name, options) {
+    return this._step.waitForEvent(name, options);
+  }
+}
+function instrumentWorkflowWithSentry(optionsCallback, WorkFlowClass) {
+  return new Proxy(WorkFlowClass, {
+    // oxlint-disable-next-line typescript/no-explicit-any
+    construct(target, args, newTarget) {
+      const [ctx, env] = args;
+      const context = instrumentContext(ctx);
+      const options = optionsCallback(env);
+      args[0] = context;
+      args[1] = instrumentEnv(env, options);
+      const instance = Reflect.construct(target, args, newTarget);
+      return new Proxy(instance, {
+        get(obj, prop, receiver) {
+          if (prop === "run") {
+            return async function(event, step) {
+              setAsyncLocalStorageAsyncContextStrategy();
+              return withIsolationScope(async (isolationScope) => {
+                const waitUntil = getOriginalWaitUntil(context).bind(context);
+                const client = init({ ...options, ctx: context, enableDedupe: false });
+                isolationScope.setClient(client);
+                addCloudResourceContext(isolationScope);
+                return withScope(async (scope) => {
+                  const propagationContext = await propagationContextFromInstanceId(event.instanceId);
+                  scope.setPropagationContext(propagationContext);
+                  try {
+                    return await obj.run.call(
+                      obj,
+                      event,
+                      new WrappedWorkflowStep(event.instanceId, options, step, waitUntil)
+                    );
+                  } finally {
+                    waitUntil(flushAndDispose(client));
+                  }
+                });
+              });
+            };
+          }
+          return Reflect.get(obj, prop, receiver);
+        }
+      });
+    }
+  });
+}
+
+export { deterministicTraceIdFromInstanceId, instrumentWorkflowWithSentry };
+//# sourceMappingURL=workflows.js.map

package/build/esm/prod/workflows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.js","sources":["../../../src/workflows.ts"],"sourcesContent":["import { CODE_FUNCTION_NAME, SENTRY_OP } from '@sentry/conventions/attributes';\nimport { GENERAL_FUNCTION_SPAN_OP } from '@sentry/conventions/op';\nimport type { PropagationContext } from '@sentry/core';\nimport {\n  captureException,\n  flush,\n  getCurrentScope,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  startSpan,\n  withIsolationScope,\n  withScope,\n} from '@sentry/core';\nimport type {\n  WorkflowDelayDuration,\n  WorkflowEntrypoint,\n  WorkflowEvent,\n  WorkflowSleepDuration,\n  WorkflowStep,\n  WorkflowStepConfig,\n  WorkflowStepContext,\n  WorkflowStepEvent,\n  WorkflowStepRollbackOptions,\n  WorkflowTimeoutDuration,\n} from 'cloudflare:workers';\nimport { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';\nimport type { CloudflareOptions } from './client';\nimport { flushAndDispose, getOriginalWaitUntil } from './flush';\nimport { instrumentEnv } from './instrumentations/worker/instrumentEnv';\nimport { addCloudResourceContext } from './scope-utils';\nimport { init } from './sdk';\nimport { instrumentContext } from './utils/instrumentContext';\nimport type { DefaultEnv, ResolveEnv } from './types';\n\nconst UUID_REGEX = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i;\n\n/**\n * Hashes a string to a UUID using SHA-1.\n */\nexport async function deterministicTraceIdFromInstanceId(instanceId: string): Promise<string> {\n  const buf = await crypto.subtle.digest('SHA-1', new TextEncoder().encode(instanceId));\n  return (\n    Array.from(new Uint8Array(buf))\n      // We only need the first 16 bytes for the 32 characters\n      .slice(0, 16)\n      .map(b => b.toString(16).padStart(2, '0'))\n      .join('')\n  );\n}\n\nasync function propagationContextFromInstanceId(instanceId: string): Promise<PropagationContext> {\n  const traceId = UUID_REGEX.test(instanceId)\n    ? instanceId.replace(/-/g, '')\n    : await deterministicTraceIdFromInstanceId(instanceId);\n\n  // Derive sampleRand from last 4 characters of the random UUID\n  //\n  // We cannot store any state between workflow steps, so we derive the\n  // sampleRand from the traceId itself. This ensures that the sampling is\n  // consistent across all steps in the same workflow instance.\n  const sampleRand = parseInt(traceId.slice(-4), 16) / 0xffff;\n\n  return {\n    traceId,\n    sampleRand,\n  };\n}\n\nclass WrappedWorkflowStep implements WorkflowStep {\n  public constructor(\n    private _instanceId: string,\n    private _options: CloudflareOptions,\n    private _step: WorkflowStep,\n    private _waitUntil: ExecutionContext['waitUntil'],\n  ) {}\n\n  public async do<T extends Rpc.Serializable<T>>(\n    name: string,\n    callback: (ctx: WorkflowStepContext) => Promise<T>,\n    rollbackOptions?: WorkflowStepRollbackOptions<T>,\n  ): Promise<T>;\n  public async do<T extends Rpc.Serializable<T>, const C extends WorkflowStepConfig>(\n    name: string,\n    config: C,\n    callback: (\n      ctx: WorkflowStepContext<C['retries'] extends { delay: infer D } ? D : WorkflowDelayDuration | number>,\n    ) => Promise<T>,\n    rollbackOptions?: WorkflowStepRollbackOptions<T>,\n  ): Promise<T>;\n  public async do<T extends Rpc.Serializable<T>>(\n    name: string,\n    configOrCallback: WorkflowStepConfig | ((ctx: WorkflowStepContext) => Promise<T>),\n    callbackOrRollback?: ((ctx: WorkflowStepContext) => Promise<T>) | WorkflowStepRollbackOptions<T>,\n    maybeRollback?: WorkflowStepRollbackOptions<T>,\n  ): Promise<T> {\n    // Capture the current scope, so parent span (e.g., a startSpan surrounding step.do) is preserved\n    const scopeForStep = getCurrentScope();\n\n    const hasConfig = typeof configOrCallback !== 'function';\n    const config = hasConfig ? configOrCallback : undefined;\n    const userCallback = (hasConfig ? callbackOrRollback : configOrCallback) as (\n      ctx: WorkflowStepContext,\n    ) => Promise<T>;\n    const rollbackOptions = (hasConfig ? maybeRollback : callbackOrRollback) as\n      | WorkflowStepRollbackOptions<T>\n      | undefined;\n\n    const instrumentedCallback = async (...args: unknown[]): Promise<T> => {\n      // Feature detection: Cloudflare Workflows (April 2026+) pass a step context\n      // with `attempt` and `config.retries.limit`. When available, we only capture\n      // errors on the final attempt to avoid duplicates during retries.\n      const stepContext = args[0] as { attempt?: number; config?: { retries?: { limit?: number } } } | undefined;\n      const attempt = stepContext?.attempt;\n      const retryLimit = stepContext?.config?.retries?.limit;\n      const hasStepContext = typeof attempt === 'number' && typeof retryLimit === 'number';\n\n      // Only capture error on final attempt (attempt > retryLimit means no more retries left)\n      // or when step context is unavailable (legacy behavior - capture all errors)\n      const isFinalAttempt = !hasStepContext || attempt > retryLimit;\n\n      return startSpan(\n        {\n          name,\n          scope: scopeForStep,\n          attributes: {\n            [SENTRY_OP]: GENERAL_FUNCTION_SPAN_OP,\n            [CODE_FUNCTION_NAME]: name,\n            'workflow.step.name': name,\n            'cloudflare.workflow.timeout': config?.timeout,\n            'cloudflare.workflow.retries.backoff': config?.retries?.backoff,\n            // In workers-types v5, `delay` may be a `WorkflowDelayFunction`, which isn't a valid span attribute value.\n            'cloudflare.workflow.retries.delay':\n              typeof config?.retries?.delay === 'function' ? undefined : config?.retries?.delay,\n            'cloudflare.workflow.retries.limit': config?.retries?.limit,\n            'cloudflare.workflow.attempt': attempt,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.faas.cloudflare.workflow',\n            [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'task',\n          },\n        },\n        async span => {\n          try {\n            const result = await (userCallback as (...args: unknown[]) => Promise<T>)(...args);\n            span.setStatus({ code: 1 });\n            return result;\n          } catch (error) {\n            if (isFinalAttempt) {\n              captureException(error, { mechanism: { handled: true, type: 'auto.faas.cloudflare.workflow' } });\n            }\n            throw error;\n          } finally {\n            this._waitUntil(flush(2000));\n          }\n        },\n      );\n    };\n\n    if (config) {\n      return rollbackOptions\n        ? this._step.do(name, config, instrumentedCallback, rollbackOptions)\n        : this._step.do(name, config, instrumentedCallback);\n    }\n\n    return rollbackOptions\n      ? this._step.do(name, instrumentedCallback, rollbackOptions)\n      : this._step.do(name, instrumentedCallback);\n  }\n\n  public async sleep(name: string, duration: WorkflowSleepDuration): Promise<void> {\n    return this._step.sleep(name, duration);\n  }\n\n  public async sleepUntil(name: string, timestamp: Date | number): Promise<void> {\n    return this._step.sleepUntil(name, timestamp);\n  }\n\n  public async waitForEvent<T extends Rpc.Serializable<T>>(\n    name: string,\n    options: { type: string; timeout?: WorkflowTimeoutDuration | number },\n  ): Promise<WorkflowStepEvent<T>> {\n    return this._step.waitForEvent<T>(name, options);\n  }\n}\n\n/**\n * Instruments a Cloudflare Workflow class with Sentry.\n *\n * @example\n * ```typescript\n * const InstrumentedWorkflow = instrumentWorkflowWithSentry(\n *   (env) => ({ dsn: env.SENTRY_DSN }),\n *   MyWorkflowClass\n * );\n *\n * export default InstrumentedWorkflow;\n * ```\n *\n * @param optionsCallback - Function that returns Sentry options to initialize Sentry\n * @param WorkflowClass - The workflow class to instrument\n * @returns Instrumented workflow class with the same interface\n */\nexport function instrumentWorkflowWithSentry<\n  E = DefaultEnv, // Environment type\n  P = unknown, // Payload type\n  // oxlint-disable-next-line typescript/no-explicit-any\n  T extends WorkflowEntrypoint<any, any> = WorkflowEntrypoint<E, P>, // WorkflowEntrypoint type\n  // The constraint must not route through `T`: workers-types defaults `WorkflowEntrypoint`'s\n  // `Env` to `unknown` (unlike `WorkerEntrypoint`/`DurableObject`, which default to\n  // `Cloudflare.Env`), so a bare subclass would be rejected in a `wrangler types` project.\n  // The callback env is resolved from the inferred constructor via `ResolveEnv` instead.\n  // oxlint-disable-next-line typescript/no-explicit-any\n  C extends new (ctx: ExecutionContext, env: any) => WorkflowEntrypoint<any, any> = new (\n    ctx: ExecutionContext,\n    // oxlint-disable-next-line typescript/no-explicit-any\n    env: any,\n  ) => T, // Constructor type of the WorkflowEntrypoint class\n>(optionsCallback: (env: ResolveEnv<C, E>) => CloudflareOptions, WorkFlowClass: C): C {\n  return new Proxy(WorkFlowClass, {\n    // oxlint-disable-next-line typescript/no-explicit-any\n    construct(target: C, args: [ctx: ExecutionContext, env: any], newTarget) {\n      const [ctx, env] = args;\n      const context = instrumentContext(ctx);\n      const options = optionsCallback(env);\n      args[0] = context;\n      args[1] = instrumentEnv(env as Record<string, unknown>, options) as E;\n      const instance = Reflect.construct(target, args, newTarget) as T;\n      return new Proxy(instance, {\n        get(obj, prop, receiver) {\n          if (prop === 'run') {\n            return async function (event: WorkflowEvent<P>, step: WorkflowStep): Promise<unknown> {\n              setAsyncLocalStorageAsyncContextStrategy();\n\n              return withIsolationScope(async isolationScope => {\n                const waitUntil = getOriginalWaitUntil(context).bind(context);\n                const client = init({ ...options, ctx: context, enableDedupe: false });\n                isolationScope.setClient(client);\n\n                addCloudResourceContext(isolationScope);\n\n                return withScope(async scope => {\n                  const propagationContext = await propagationContextFromInstanceId(event.instanceId);\n                  scope.setPropagationContext(propagationContext);\n\n                  try {\n                    return await obj.run.call(\n                      obj,\n                      event,\n                      new WrappedWorkflowStep(event.instanceId, options, step, waitUntil),\n                    );\n                  } finally {\n                    waitUntil(flushAndDispose(client));\n                  }\n                });\n              });\n            };\n          }\n          return Reflect.get(obj, prop, receiver);\n        },\n      });\n    },\n  });\n}\n"],"names":[],"mappings":"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"}

package/build/esm/prod/wrapMethodWithSentry.js

@@ -0,0 +1,132 @@
+import { isThenable, SEMANTIC_ATTRIBUTE_SENTRY_OP, continueTrace, startNewTrace, captureException, startSpan, isObjectLike, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { getOriginalWaitUntil, flushAndDispose } from './flush.js';
+import { ensureInstrumented } from './instrument.js';
+import { init } from './sdk.js';
+import { withInvocationIsolationScope } from './utils/invocationScope.js';
+import { extractRpcMeta } from './utils/rpcMeta.js';
+import { getStoredSpanContext, buildSpanLinks, storeSpanContext } from './utils/traceLinks.js';
+
+function resolveOriginalStorage(context, thisArg) {
+  if (isObjectLike(thisArg) && "ctx" in thisArg) {
+    const doCtx = thisArg.ctx;
+    if (doCtx?.originalStorage) {
+      return doCtx.originalStorage;
+    }
+  }
+  if (context && "originalStorage" in context && context.originalStorage) {
+    return context.originalStorage;
+  }
+  return void 0;
+}
+function wrapMethodWithSentry(wrapperOptions, handler, callback, noMark) {
+  return ensureInstrumented(
+    handler,
+    (original) => new Proxy(original, {
+      apply(target, thisArg, rawArgs) {
+        const { startNewTrace: startNewTrace$1, origin } = wrapperOptions;
+        let args = rawArgs;
+        let rpcMeta;
+        if (wrapperOptions.spanOp === "rpc") {
+          const extracted = extractRpcMeta(rawArgs);
+          args = extracted.args;
+          rpcMeta = extracted.rpcMeta;
+        }
+        const wrappedFunction = (scope) => {
+          const context = wrapperOptions.context;
+          const waitUntil = context ? getOriginalWaitUntil(context)?.bind(context) : void 0;
+          const storage = resolveOriginalStorage(context, thisArg);
+          let scopeClient = scope.getClient();
+          if (startNewTrace$1 || !scopeClient?.getTransport()) {
+            const client = init({
+              ...wrapperOptions.options,
+              ctx: context
+            });
+            scope.setClient(client);
+            scopeClient = client;
+          }
+          const clientToDispose = scopeClient;
+          const methodName = wrapperOptions.spanName || "unknown";
+          const teardown = async () => {
+            if (startNewTrace$1 && storage) {
+              storeSpanContext(storage, methodName);
+            }
+            await flushAndDispose(clientToDispose);
+          };
+          const onFulfilled = (res) => {
+            waitUntil?.(teardown());
+            return res;
+          };
+          const onRejected = (e) => {
+            captureException(e, {
+              mechanism: {
+                type: origin,
+                handled: false
+              }
+            });
+            waitUntil?.(teardown());
+            throw e;
+          };
+          if (!wrapperOptions.spanName) {
+            try {
+              if (callback) {
+                callback(...args);
+              }
+              const result = Reflect.apply(target, thisArg, args);
+              if (isThenable(result)) {
+                return result.then(onFulfilled, onRejected);
+              } else {
+                return onFulfilled(result);
+              }
+            } catch (e) {
+              return onRejected(e);
+            }
+          }
+          const attributes = wrapperOptions.spanOp ? {
+            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: wrapperOptions.spanOp,
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: origin
+          } : {};
+          const executeSpan = () => {
+            return startSpan({ name: methodName, attributes }, (span) => {
+              if (startNewTrace$1 && storage) {
+                const storedContext = getStoredSpanContext(storage, methodName);
+                if (storedContext) {
+                  span.addLinks(buildSpanLinks(storedContext));
+                  const sampledFlag = storedContext.sampled ? "1" : "0";
+                  span.setAttribute(
+                    "sentry.previous_trace",
+                    `${storedContext.traceId}-${storedContext.spanId}-${sampledFlag}`
+                  );
+                }
+              }
+              try {
+                const result = Reflect.apply(target, thisArg, args);
+                if (isThenable(result)) {
+                  return result.then(onFulfilled, onRejected);
+                } else {
+                  return onFulfilled(result);
+                }
+              } catch (e) {
+                return onRejected(e);
+              }
+            });
+          };
+          if (rpcMeta) {
+            return continueTrace(
+              { sentryTrace: rpcMeta["sentry-trace"] || "", baggage: rpcMeta.baggage || "" },
+              executeSpan
+            );
+          }
+          if (startNewTrace$1) {
+            return startNewTrace(() => executeSpan());
+          }
+          return executeSpan();
+        };
+        return withInvocationIsolationScope(wrappedFunction);
+      }
+    }),
+    noMark
+  );
+}
+
+export { wrapMethodWithSentry };
+//# sourceMappingURL=wrapMethodWithSentry.js.map

package/build/esm/prod/wrapMethodWithSentry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapMethodWithSentry.js","sources":["../../../src/wrapMethodWithSentry.ts"],"sourcesContent":["import type { DurableObjectStorage } from '@cloudflare/workers-types';\nimport type { SerializedTraceData } from '@sentry/core';\nimport {\n  isObjectLike,\n  captureException,\n  continueTrace,\n  isThenable,\n  type Scope,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  startNewTrace as startNewTraceCore,\n  startSpan,\n} from '@sentry/core';\nimport type { CloudflareOptions } from './client';\nimport type { ExecutionContextCompat } from './executionContext';\nimport { flushAndDispose, getOriginalWaitUntil } from './flush';\nimport { ensureInstrumented } from './instrument';\nimport { init } from './sdk';\nimport { withInvocationIsolationScope } from './utils/invocationScope';\nimport { extractRpcMeta } from './utils/rpcMeta';\nimport { buildSpanLinks, getStoredSpanContext, storeSpanContext } from './utils/traceLinks';\n\n/** Extended DurableObjectState with originalStorage exposed by instrumentContext */\nexport interface InstrumentedDurableObjectState extends DurableObjectState {\n  originalStorage?: DurableObjectStorage;\n}\n\n/**\n * Resolves uninstrumented DO storage for the current invocation.\n * Prefer `thisArg.ctx` (the live Durable Object instance) over the context captured at\n * construction time to avoid cross-DO I/O errors in the same isolate.\n */\nfunction resolveOriginalStorage(\n  context: ExecutionContext | InstrumentedDurableObjectState | undefined,\n  thisArg: unknown,\n): DurableObjectStorage | undefined {\n  if (isObjectLike(thisArg) && 'ctx' in thisArg) {\n    const doCtx = (thisArg as { ctx: InstrumentedDurableObjectState }).ctx;\n    if (doCtx?.originalStorage) {\n      return doCtx.originalStorage;\n    }\n  }\n\n  if (context && 'originalStorage' in context && context.originalStorage) {\n    return context.originalStorage;\n  }\n\n  return undefined;\n}\n\ntype MethodWrapperOptions = {\n  spanName?: string;\n  spanOp?: string;\n  options: CloudflareOptions;\n  context: ExecutionContext | InstrumentedDurableObjectState;\n  /**\n   * If true, starts a fresh trace instead of inheriting from a parent trace.\n   * Useful for scheduled/independent invocations like alarms.\n   *\n   * If true, it also stores the current span context and links to the previous invocation's span.\n   * Uses Durable Object storage to persist the link. The link is set asynchronously via `span.addLinks()`\n   * in a `waitUntil` to avoid blocking.\n   *\n   * @default false\n   */\n  startNewTrace?: boolean;\n  /**\n   * The trace origin identifying which instrumentation created the span, e.g. `auto.faas.cloudflare.durable_object`.\n   * Used both as the span's `sentry.origin` attribute and as the `mechanism.type` for captured exceptions.\n   */\n  origin: string;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type UncheckedMethod = (...args: any[]) => any;\ntype OriginalMethod = UncheckedMethod;\n\n/**\n * Wraps a method with Sentry error tracking and optional tracing.\n * Supports starting new traces and linking to previous invocations via Durable Object storage.\n *\n * @param wrapperOptions - The options for the wrapper.\n * @param handler - The method to wrap.\n * @param callback - The callback to call.\n * @param noMark - Whether to mark the method as instrumented.\n * @returns The wrapped method.\n */\nexport function wrapMethodWithSentry<T extends OriginalMethod>(\n  wrapperOptions: MethodWrapperOptions,\n  handler: T,\n  callback?: (...args: Parameters<T>) => void,\n  noMark?: true,\n): T {\n  return ensureInstrumented(\n    handler,\n    original =>\n      new Proxy(original, {\n        apply(target, thisArg, rawArgs: Parameters<T>) {\n          const { startNewTrace, origin } = wrapperOptions;\n\n          // For RPC methods, extract Sentry trace context from the trailing argument.\n          // The caller side (instrumentDurableObjectStub / JSRPC proxy) appends it;\n          // we strip it here so the user's method never sees it.\n          let args = rawArgs;\n          let rpcMeta: SerializedTraceData | undefined;\n\n          if (wrapperOptions.spanOp === 'rpc') {\n            const extracted = extractRpcMeta(rawArgs);\n            args = extracted.args;\n            rpcMeta = extracted.rpcMeta;\n          }\n\n          const wrappedFunction = (scope: Scope): unknown | Promise<unknown> => {\n            // In certain situations, the passed context can become undefined.\n            // For example, for Astro while prerendering pages at build time.\n            // see: https://github.com/getsentry/sentry-javascript/issues/13217\n            const context: typeof wrapperOptions.context | undefined = wrapperOptions.context;\n\n            // see: https://github.com/getsentry/sentry-javascript/issues/22328\n            const waitUntil = context\n              ? getOriginalWaitUntil(context as ExecutionContextCompat)?.bind(context)\n              : undefined;\n            const storage = resolveOriginalStorage(context, thisArg);\n\n            let scopeClient = scope.getClient();\n            // Check if client exists AND is still usable (transport not disposed)\n            // This handles the case where a previous handler disposed the client\n            // but the scope still holds a reference to it (e.g., alarm handlers in Durable Objects)\n            // For startNewTrace, always create a fresh client\n            if (startNewTrace || !scopeClient?.getTransport()) {\n              const client = init({\n                ...wrapperOptions.options,\n                ctx: context as unknown as ExecutionContext | undefined,\n              });\n              scope.setClient(client);\n              scopeClient = client;\n            }\n\n            const clientToDispose = scopeClient;\n            const methodName = wrapperOptions.spanName || 'unknown';\n\n            const teardown = async (): Promise<void> => {\n              if (startNewTrace && storage) {\n                storeSpanContext(storage, methodName);\n              }\n              await flushAndDispose(clientToDispose);\n            };\n\n            const onFulfilled = (res: unknown) => {\n              waitUntil?.(teardown());\n              return res;\n            };\n\n            const onRejected = (e: unknown) => {\n              captureException(e, {\n                mechanism: {\n                  type: origin,\n                  handled: false,\n                },\n              });\n              waitUntil?.(teardown());\n              throw e;\n            };\n\n            if (!wrapperOptions.spanName) {\n              try {\n                if (callback) {\n                  callback(...args);\n                }\n\n                const result = Reflect.apply(target, thisArg, args);\n\n                if (isThenable(result)) {\n                  return result.then(onFulfilled, onRejected);\n                } else {\n                  return onFulfilled(result);\n                }\n              } catch (e) {\n                return onRejected(e);\n              }\n            }\n\n            const attributes = wrapperOptions.spanOp\n              ? {\n                  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: wrapperOptions.spanOp,\n                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: origin,\n                }\n              : {};\n\n            const executeSpan = (): unknown => {\n              return startSpan({ name: methodName, attributes }, span => {\n                if (startNewTrace && storage) {\n                  const storedContext = getStoredSpanContext(storage, methodName);\n\n                  if (storedContext) {\n                    span.addLinks(buildSpanLinks(storedContext));\n                    // TODO: Remove this once EAP can store span links. We currently only set this attribute so that we\n                    // can obtain the previous trace information from the EAP store. Long-term, EAP will handle\n                    // span links and then we should remove this again. Also throwing in a TODO(v11), to remind us\n                    // to check this at v11 time :)\n                    const sampledFlag = storedContext.sampled ? '1' : '0';\n                    span.setAttribute(\n                      'sentry.previous_trace',\n                      `${storedContext.traceId}-${storedContext.spanId}-${sampledFlag}`,\n                    );\n                  }\n                }\n\n                try {\n                  const result = Reflect.apply(target, thisArg, args);\n\n                  if (isThenable(result)) {\n                    return result.then(onFulfilled, onRejected);\n                  } else {\n                    return onFulfilled(result);\n                  }\n                } catch (e) {\n                  return onRejected(e);\n                }\n              });\n            };\n\n            if (rpcMeta) {\n              return continueTrace(\n                { sentryTrace: rpcMeta['sentry-trace'] || '', baggage: rpcMeta.baggage || '' },\n                executeSpan,\n              );\n            }\n\n            if (startNewTrace) {\n              return startNewTraceCore(() => executeSpan());\n            }\n\n            return executeSpan();\n          };\n\n          return withInvocationIsolationScope(wrappedFunction);\n        },\n      }),\n    noMark,\n  );\n}\n"],"names":["startNewTrace","startNewTraceCore"],"mappings":"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"}

package/build/types/baseSdk.d.ts

@@ -0,0 +1,28 @@
+import type { Integration } from '@sentry/core';
+import type { CloudflareOptions } from './client';
+import { CloudflareClient } from './client';
+/**
+ * Get the default integrations that run on any Workers-compatible runtime, i.e. without the
+ * `nodejs_compat` compatibility flag.
+ *
+ * `getDefaultIntegrations` in `sdk.ts` extends this set with the integrations that do depend on
+ * Node.js APIs. Keeping the two apart is what allows `wrapRequestHandler` to stay usable on runtimes
+ * that cannot enable `nodejs_compat`, such as Shopify Oxygen.
+ */
+export declare function getBaseDefaultIntegrations(options: CloudflareOptions): Integration[];
+/**
+ * Initializes the Cloudflare SDK with the passed default integrations.
+ *
+ * The default integrations are injected rather than imported so that this module stays free of
+ * Node.js-only code. `request.ts` — which backs both `wrapRequestHandler` and the
+ * `@sentry/cloudflare/request` entry point, and therefore has to work on runtimes without the
+ * `nodejs_compat` compatibility flag — creates its client from here instead of from `sdk.ts`.
+ */
+export declare function initWithDefaultIntegrations(options: CloudflareOptions, getDefaultIntegrationsImpl: (options: CloudflareOptions) => Integration[]): CloudflareClient | undefined;
+/**
+ * Initializes the Cloudflare SDK with only the default integrations from
+ * {@link getBaseDefaultIntegrations}, i.e. those that work without the `nodejs_compat`
+ * compatibility flag.
+ */
+export declare function initBaseSdk(options: CloudflareOptions): CloudflareClient | undefined;
+//# sourceMappingURL=baseSdk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"baseSdk.d.ts","sourceRoot":"","sources":["../../src/baseSdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAchD,OAAO,KAAK,EAA2B,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AA0B5C;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iBAAiB,GAAG,WAAW,EAAE,CAqBpF;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,iBAAiB,EAC1B,0BAA0B,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,WAAW,EAAE,GACxE,gBAAgB,GAAG,SAAS,CAmD9B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CAEpF"}

package/build/types/client.d.ts

@@ -41,6 +41,8 @@ export declare class CloudflareClient extends ServerRuntimeClient {
      * After calling dispose(), the client should not be used anymore.
      */
     dispose(): void;
+    /** @inheritDoc */
+    protected _setupIntegrations(): void;
     /**
      * Resets the span completion promise and resolve function.
      */
@@ -54,15 +56,15 @@ interface BaseCloudflareOptions {
      */
     enableDedupe?: boolean;
     /**
-     * The Cloudflare SDK is not OpenTelemetry native, however, we set up some OpenTelemetry compatibility
-     * via a custom trace provider.
-     * This ensures that any spans emitted via `@opentelemetry/api` will be captured by Sentry.
-     * HOWEVER, big caveat: This does not handle custom context handling, it will always work off the current scope.
-     * This should be good enough for many, but not all integrations.
+     * The Cloudflare SDK is not OpenTelemetry native. By default (`true`) it does not set up a tracer
+     * provider; spans are emitted via the SDK's own instrumentation and scopes are isolated with
+     * AsyncLocalStorage.
      *
-     * If you want to opt-out of setting up the OpenTelemetry compatibility tracer, set this to `true`.
+     * Set this to `false` to opt into the OpenTelemetry compatibility tracer, which captures spans
+     * emitted via `@opentelemetry/api`. Big caveat: it does not handle custom context, always working
+     * off the current scope. This is good enough for many, but not all, integrations.
      *
-     * @default false
+     * @default true
      */
     skipOpenTelemetrySetup?: boolean;
     /**
@@ -78,34 +80,20 @@ interface BaseCloudflareOptions {
      * - Create spans for each RPC method invocation
      * - Capture errors thrown by RPC methods
      *
-     * **Important:** This option should be enabled on **both sides** for full trace propagation.
+     * **Important:** This option is enabled by default. Set it to `false` to opt out, e.g. if you
+     * do not want trace context to leave your Worker via RPC calls.
      *
-     * @default false
+     * @default true
      * @example
      * ```ts
-     * // Worker side (caller)
+     * // Opt out of RPC trace propagation
      * export default Sentry.withSentry(
      *   (env) => ({
      *     dsn: env.SENTRY_DSN,
-     *     enableRpcTracePropagation: true,
+     *     enableRpcTracePropagation: false,
      *   }),
      *   handler,
      * );
-     *
-     * // Durable Object side (receiver)
-     * export const MyDO = Sentry.instrumentDurableObjectWithSentry(
-     *   (env) => ({
-     *     dsn: env.SENTRY_DSN,
-     *     enableRpcTracePropagation: true,
-     *   }),
-     *   MyDOBase,
-     * );
-     *
-     * // WorkerEntrypoint side (receiver)
-     * export const MyEntrypoint = Sentry.withSentry(
-     *   env => ({ dsn: env.SENTRY_DSN, enableRpcTracePropagation: true }),
-     *   MyEntrypointBase,
-     * );
      * ```
      */
     enableRpcTracePropagation?: boolean;
@@ -133,18 +121,40 @@ interface BaseCloudflareOptions {
      */
     durableObjectSqlSpanAllowlist?: Array<string | RegExp>;
     /**
-     * @deprecated Use `enableRpcTracePropagation` instead. This option will be removed in a future major version.
+     * KV keys that should stay instrumented even though they match a reserved prefix used by Durable
+     * Object frameworks (`agents`, `partyserver`, ...) for their internal storage entries.
+     *
+     * By default, KV reads/writes (`get`, `put`, `delete`, `list`) of `cf_`- or `__ps_`-prefixed keys
+     * are treated as framework noise and no `durable_object_storage_*` span is created for them,
+     * mirroring how `cf_`-prefixed SQL tables are handled (see {@link durableObjectSqlSpanAllowlist}).
+     * If one of your own keys happens to use such a prefix, add it here to opt it back into
+     * instrumentation. Strings must match exactly, while regular expressions give you prefix/pattern
+     * matching.
      *
-     * Enable instrumentation of prototype methods for DurableObjects.
+     * @default []
+     * @example
+     * ```ts
+     * export default Sentry.withSentry(
+     *   (env) => ({
+     *     dsn: env.SENTRY_DSN,
+     *     durableObjectStorageSpanAllowlist: ['cf_my_key', /^cf_reports_/],
+     *   }),
+     *   handler,
+     * );
+     * ```
+     */
+    durableObjectStorageSpanAllowlist?: Array<string | RegExp>;
+    /**
+     * If you use Spotlight by Sentry during development, use
+     * this option to forward captured Sentry events to Spotlight.
      *
-     * When `true`, the SDK will wrap all methods on the DurableObject prototype chain
-     * to automatically create spans and capture errors for RPC method calls.
+     * Either set it to true, or provide a specific Spotlight Sidecar URL.
      *
-     * When an array of strings is provided, only the specified method names will be instrumented.
+     * More details: https://spotlightjs.com/
      *
-     * @default false
+     * IMPORTANT: Only set this option to `true` while developing, not in production!
      */
-    instrumentPrototypeMethods?: boolean | string[];
+    spotlight?: boolean | string;
 }
 /**
  * Configuration options for the Sentry Cloudflare SDK

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAA8B,MAAM,cAAc,CAAC;AACvF,OAAO,EAA2B,mBAAmB,EAAiB,MAAM,cAAc,CAAC;AAE3F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,mBAAmB;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0C;IACrE,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,sBAAsB,CAA6B;IAE3D,OAAO,CAAC,qBAAqB,CAA6B;IAC1D,OAAO,CAAC,mBAAmB,CAA6B;IAExD;;;OAGG;gBACgB,OAAO,EAAE,uBAAuB;IAqDnD;;;;;;;;OAQG;IACU,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA2BtD;;;;;;;;OAQG;IACa,OAAO,IAAI,IAAI;IAkB/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;CAKpC;AAED,UAAU,qBAAqB;IAC7B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;;;;OAUG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAEpC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,6BAA6B,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IAEvD;;;;;;;;;;;OAWG;IACH,0BAA0B,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;CACjD;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAAC,0BAA0B,CAAC,EAAE,qBAAqB;IACnG,GAAG,CAAC,EAAE,sBAAsB,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAwB,SAAQ,aAAa,CAAC,0BAA0B,CAAC,EAAE,qBAAqB;IAC/G,SAAS,CAAC,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;CAC9C"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAA8B,MAAM,cAAc,CAAC;AACvF,OAAO,EAIL,mBAAmB,EAEpB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,mBAAmB;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0C;IACrE,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,sBAAsB,CAA6B;IAE3D,OAAO,CAAC,qBAAqB,CAA6B;IAC1D,OAAO,CAAC,mBAAmB,CAA6B;IAExD;;;OAGG;IACH,YAAmB,OAAO,EAAE,uBAAuB,EAmDlD;IAED;;;;;;;;OAQG;IACU,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAyBrD;IAED;;;;;;;;OAQG;IACa,OAAO,IAAI,IAAI,CAgB9B;IAED,kBAAkB;IAClB,UAAmB,kBAAkB,IAAI,IAAI,CAO5C;IAED;;OAEG;IACH,OAAO,CAAC,2BAA2B;CAKpC;AAED,UAAU,qBAAqB;IAC7B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;;;;OAUG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAEpC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,6BAA6B,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iCAAiC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IAE3D;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAAC,0BAA0B,CAAC,EAAE,qBAAqB;IACnG,GAAG,CAAC,EAAE,sBAAsB,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAwB,SAAQ,aAAa,CAAC,0BAA0B,CAAC,EAAE,qBAAqB;IAC/G,SAAS,CAAC,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;CAC9C"}

package/build/types/defineCloudflareOptions.d.ts

@@ -1,5 +1,5 @@
-import type { env as cloudflareEnv } from 'cloudflare:workers';
 import type { CloudflareOptions } from './client';
+import type { DefaultEnv } from './types';
 /**
  * Define the Sentry options for a Cloudflare Worker in a dedicated module.
  *
@@ -34,5 +34,5 @@ import type { CloudflareOptions } from './client';
  * export default defineCloudflareOptions({ tracesSampleRate: 1.0 });
  * ```
  */
-export declare function defineCloudflareOptions<Env = typeof cloudflareEnv>(optionsOrCallback: CloudflareOptions | ((env: Env) => CloudflareOptions | undefined)): (env: Env) => CloudflareOptions | undefined;
+export declare function defineCloudflareOptions<Env = DefaultEnv>(optionsOrCallback: CloudflareOptions | ((env: Env) => CloudflareOptions | undefined)): (env: Env) => CloudflareOptions | undefined;
 //# sourceMappingURL=defineCloudflareOptions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"defineCloudflareOptions.d.ts","sourceRoot":"","sources":["../../src/defineCloudflareOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,GAAG,OAAO,aAAa,EAChE,iBAAiB,EAAE,iBAAiB,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,iBAAiB,GAAG,SAAS,CAAC,GACnF,CAAC,GAAG,EAAE,GAAG,KAAK,iBAAiB,GAAG,SAAS,CAM7C"}
+{"version":3,"file":"defineCloudflareOptions.d.ts","sourceRoot":"","sources":["../../src/defineCloudflareOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,GAAG,UAAU,EACtD,iBAAiB,EAAE,iBAAiB,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,iBAAiB,GAAG,SAAS,CAAC,GACnF,CAAC,GAAG,EAAE,GAAG,KAAK,iBAAiB,GAAG,SAAS,CAM7C"}

package/build/types/durableobject.d.ts

@@ -1,5 +1,54 @@
 import type { DurableObject } from 'cloudflare:workers';
 import type { CloudflareOptions } from './client';
+import type { DefaultEnv, ResolveEnv } from './types';
+/**
+ * The instrumented context passed between the shared construction helpers.
+ *
+ * This is intentionally `any` rather than `ReturnType<typeof instrumentContext<DurableObjectState>>`.
+ * A concrete `DurableObjectState` here forces `tsc` to structurally relate its `storage: SqlStorage`
+ * graph against the `ExecutionContext | InstrumentedDurableObjectState` parameter of
+ * `wrapMethodWithSentry`, while the RPC-branded `DurableObject` from `cloudflare:workers` is also in
+ * scope. That union comparison explodes (1296×1296) and hangs the type build. The original inline
+ * implementation avoided this only incidentally, because `ctx` reached it as `any` through the Proxy
+ * `construct` trap. Keeping the shared context `any` preserves that behavior.
+ */
+type InstrumentedDurableObjectContext = any;
+/**
+ * Constructs a Durable Object instance and instruments its built-in handler methods
+ * (`fetch`, `alarm`, `webSocketMessage`, `webSocketClose`, `webSocketError`).
+ *
+ * This is the shared construction path used by both {@link instrumentDurableObjectWithSentry}
+ * and {@link instrumentAgentWithSentry}. It intentionally does NOT apply the RPC prototype-method
+ * instrumentation — callers apply that last via {@link finalizeWithRpcInstrumentation}, after any
+ * additional per-instance instrumentation has been layered onto the returned object.
+ *
+ * @internal
+ */
+export declare function constructInstrumentedDurableObject<E, T extends DurableObject<E>>(target: new (state: DurableObjectState, env: E) => T, ctx: DurableObjectState, env: E, newTarget: NewableFunction, optionsCallback: (env: E) => CloudflareOptions): {
+    obj: T;
+    options: CloudflareOptions;
+    context: InstrumentedDurableObjectContext;
+    frameworkManagedMethods: ReadonlySet<string>;
+};
+/**
+ * Adds trace propagation to a constructed Durable Object's RPC methods.
+ *
+ * RPC methods are wrapped on the prototype because Cloudflare dispatches them with the Durable
+ * Object instance as the receiver. This preserves native private-field access and keeps the methods
+ * visible to Cloudflare's RPC dispatcher. Built-in handlers, Agent handlers, and methods managed by
+ * another framework are left untouched.
+ *
+ * Call this after all per-instance instrumentation has been applied. If RPC trace propagation is
+ * disabled, the object is returned unchanged.
+ *
+ * @param obj The constructed Durable Object instance.
+ * @param options The resolved SDK options for this instance.
+ * @param context The instrumented execution context for this instance.
+ * @param excludedMethods Method names owned by another framework and therefore not safe to wrap.
+ * @returns The same Durable Object instance, with eligible prototype methods instrumented.
+ * @internal
+ */
+export declare function finalizeWithRpcInstrumentation<T extends object>(obj: T, options: CloudflareOptions, context: InstrumentedDurableObjectContext, excludedMethods?: ReadonlySet<string>): T;
 /**
  * Instruments a Durable Object class to capture errors and performance data.
  *
@@ -10,7 +59,8 @@ import type { CloudflareOptions } from './client';
  * - webSocketClose
  * - webSocketError
  *
- * To instrument RPC methods (prototype methods), enable the `enableRpcTracePropagation` option.
+ * RPC methods (prototype methods) are instrumented by default. Set `enableRpcTracePropagation`
+ * to `false` to opt out.
  *
  * @param optionsCallback Function that returns the options for the SDK initialization.
  * @param DurableObjectClass The Durable Object class to instrument.
@@ -33,5 +83,46 @@ import type { CloudflareOptions } from './client';
  * );
  * ```
  */
-export declare function instrumentDurableObjectWithSentry<E, T extends DurableObject<E>, C extends new (state: DurableObjectState, env: E) => T>(optionsCallback: (env: E) => CloudflareOptions, DurableObjectClass: C): C;
+export declare function instrumentDurableObjectWithSentry<Env = DefaultEnv, T extends DurableObject<any> = DurableObject<Env>, C extends new (state: DurableObjectState, env: any) => T = new (state: DurableObjectState, env: any) => T>(optionsCallback: (env: ResolveEnv<C, Env>) => CloudflareOptions, DurableObjectClass: C): C;
+/**
+ * Instruments a Cloudflare [`agents`](https://www.npmjs.com/package/agents) Agent class with Sentry.
+ *
+ * An `Agent` is a Durable Object under the hood, so this applies the same instrumentation as
+ * {@link instrumentDurableObjectWithSentry} (request transactions, `alarm`, WebSocket handlers, RPC
+ * trace propagation, SQL spans) and additionally captures Agent-specific telemetry via
+ * `instrumentCloudflareAgent`:
+ *
+ * - **Callable RPC spans** — a span (op `rpc`) for each `@callable()` method invoked over WebSocket.
+ * - **Breadcrumbs** — for every Agent observability event (`rpc`, `state:update`, `connect`,
+ *   `disconnect`, `schedule:*`, `queue:*`, `workflow:*`, `email:*`, `mcp:*`, ...).
+ *
+ * Cloudflare Workers cannot auto-instrument, so the Agent class must be wrapped manually.
+ *
+ * @param optionsCallback Function that returns the options for the SDK initialization.
+ * @param AgentClass The Agent class to instrument.
+ * @returns The instrumented Agent class.
+ *
+ * @example
+ * ```ts
+ * import { Agent, callable, routeAgentRequest } from 'agents';
+ * import * as Sentry from '@sentry/cloudflare';
+ *
+ * class MyAgentBase extends Agent<Env> {
+ *   @callable()
+ *   async greet(name: string): Promise<string> {
+ *     return `Hello, ${name}!`;
+ *   }
+ * }
+ *
+ * export const MyAgent = Sentry.instrumentAgentWithSentry(
+ *   env => ({
+ *     dsn: env.SENTRY_DSN,
+ *     tracesSampleRate: 1.0,
+ *   }),
+ *   MyAgentBase,
+ * );
+ * ```
+ */
+export declare function instrumentAgentWithSentry<Env = DefaultEnv, T extends DurableObject<any> = DurableObject<Env>, C extends new (state: DurableObjectState, env: any) => T = new (state: DurableObjectState, env: any) => T>(optionsCallback: (env: ResolveEnv<C, Env>) => CloudflareOptions, AgentClass: C): C;
+export {};
 //# sourceMappingURL=durableobject.d.ts.map