@sentry/cloudflare 10.70.0 → 11.0.0-alpha.1

package/build/esm/prod/opentelemetry/tracer.js

@@ -0,0 +1,47 @@
+import { trace } from '@opentelemetry/api';
+import { startInactiveSpan, startSpanManual } from '@sentry/core';
+
+function setupOpenTelemetryTracer() {
+  trace.setGlobalTracerProvider(new SentryCloudflareTraceProvider());
+}
+class SentryCloudflareTraceProvider {
+  constructor() {
+    this._tracers = /* @__PURE__ */ new Map();
+  }
+  getTracer(name, version, options) {
+    const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
+    if (!this._tracers.has(key)) {
+      this._tracers.set(key, new SentryCloudflareTracer());
+    }
+    return this._tracers.get(key);
+  }
+}
+class SentryCloudflareTracer {
+  startSpan(name, options) {
+    return startInactiveSpan({
+      ...options,
+      name,
+      attributes: {
+        ...options?.attributes,
+        "sentry.cloudflare_tracer": true
+      }
+    });
+  }
+  startActiveSpan(name, options, context, fn) {
+    const opts = typeof options === "object" && options !== null ? options : {};
+    const spanOpts = {
+      ...opts,
+      name,
+      attributes: {
+        ...opts.attributes,
+        "sentry.cloudflare_tracer": true
+      }
+    };
+    const callback = typeof options === "function" ? options : typeof context === "function" ? context : typeof fn === "function" ? fn : () => {
+    };
+    return startSpanManual(spanOpts, callback);
+  }
+}
+
+export { setupOpenTelemetryTracer };
+//# sourceMappingURL=tracer.js.map

package/build/esm/prod/opentelemetry/tracer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.js","sources":["../../../../src/opentelemetry/tracer.ts"],"sourcesContent":["import type { Context, Span, SpanOptions, Tracer, TracerProvider } from '@opentelemetry/api';\nimport { trace } from '@opentelemetry/api';\nimport { startInactiveSpan, startSpanManual } from '@sentry/core';\n\n/**\n * Set up a mock OTEL tracer to allow inter-op with OpenTelemetry emitted spans.\n * This is not perfect but handles easy/common use cases.\n */\nexport function setupOpenTelemetryTracer(): void {\n  trace.setGlobalTracerProvider(new SentryCloudflareTraceProvider());\n}\n\nclass SentryCloudflareTraceProvider implements TracerProvider {\n  private readonly _tracers: Map<string, Tracer> = new Map();\n\n  public getTracer(name: string, version?: string, options?: { schemaUrl?: string }): Tracer {\n    const key = `${name}@${version || ''}:${options?.schemaUrl || ''}`;\n    if (!this._tracers.has(key)) {\n      this._tracers.set(key, new SentryCloudflareTracer());\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return this._tracers.get(key)!;\n  }\n}\n\nclass SentryCloudflareTracer implements Tracer {\n  public startSpan(name: string, options?: SpanOptions): Span {\n    return startInactiveSpan({\n      ...options,\n      name,\n      attributes: {\n        ...options?.attributes,\n        'sentry.cloudflare_tracer': true,\n      },\n    });\n  }\n\n  /**\n   * NOTE: This does not handle `context` being passed in. It will always put spans on the current scope.\n   */\n  public startActiveSpan<F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;\n  public startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;\n  public startActiveSpan<F extends (span: Span) => unknown>(\n    name: string,\n    options: SpanOptions,\n    context: Context,\n    fn: F,\n  ): ReturnType<F>;\n  public startActiveSpan<F extends (span: Span) => unknown>(\n    name: string,\n    options: unknown,\n    context?: unknown,\n    fn?: F,\n  ): ReturnType<F> {\n    const opts = (typeof options === 'object' && options !== null ? options : {}) as SpanOptions;\n\n    const spanOpts = {\n      ...opts,\n      name,\n      attributes: {\n        ...opts.attributes,\n        'sentry.cloudflare_tracer': true,\n      },\n    };\n\n    const callback = (\n      typeof options === 'function'\n        ? options\n        : typeof context === 'function'\n          ? context\n          : typeof fn === 'function'\n            ? fn\n            : () => {}\n    ) as F;\n\n    // In OTEL the semantic matches `startSpanManual` because spans are not auto-ended\n    return startSpanManual(spanOpts, callback) as ReturnType<F>;\n  }\n}\n"],"names":[],"mappings":";;;AAQO,SAAS,wBAAA,GAAiC;AAC/C,EAAA,KAAA,CAAM,uBAAA,CAAwB,IAAI,6BAAA,EAA+B,CAAA;AACnE;AAEA,MAAM,6BAAA,CAAwD;AAAA,EAA9D,WAAA,GAAA;AACE,IAAA,IAAA,CAAiB,QAAA,uBAAoC,GAAA,EAAI;AAAA,EAAA;AAAA,EAElD,SAAA,CAAU,IAAA,EAAc,OAAA,EAAkB,OAAA,EAA0C;AACzF,IAAA,MAAM,GAAA,GAAM,GAAG,IAAI,CAAA,CAAA,EAAI,WAAW,EAAE,CAAA,CAAA,EAAI,OAAA,EAAS,SAAA,IAAa,EAAE,CAAA,CAAA;AAChE,IAAA,IAAI,CAAC,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA,EAAG;AAC3B,MAAA,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAA,EAAK,IAAI,wBAAwB,CAAA;AAAA,IACrD;AAGA,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA;AAAA,EAC9B;AACF;AAEA,MAAM,sBAAA,CAAyC;AAAA,EACtC,SAAA,CAAU,MAAc,OAAA,EAA6B;AAC1D,IAAA,OAAO,iBAAA,CAAkB;AAAA,MACvB,GAAG,OAAA;AAAA,MACH,IAAA;AAAA,MACA,UAAA,EAAY;AAAA,QACV,GAAG,OAAA,EAAS,UAAA;AAAA,QACZ,0BAAA,EAA4B;AAAA;AAC9B,KACD,CAAA;AAAA,EACH;AAAA,EAaO,eAAA,CACL,IAAA,EACA,OAAA,EACA,OAAA,EACA,EAAA,EACe;AACf,IAAA,MAAM,OAAQ,OAAO,OAAA,KAAY,YAAY,OAAA,KAAY,IAAA,GAAO,UAAU,EAAC;AAE3E,IAAA,MAAM,QAAA,GAAW;AAAA,MACf,GAAG,IAAA;AAAA,MACH,IAAA;AAAA,MACA,UAAA,EAAY;AAAA,QACV,GAAG,IAAA,CAAK,UAAA;AAAA,QACR,0BAAA,EAA4B;AAAA;AAC9B,KACF;AAEA,IAAA,MAAM,QAAA,GACJ,OAAO,OAAA,KAAY,UAAA,GACf,OAAA,GACA,OAAO,OAAA,KAAY,UAAA,GACjB,OAAA,GACA,OAAO,EAAA,KAAO,UAAA,GACZ,KACA,MAAM;AAAA,IAAC,CAAA;AAIjB,IAAA,OAAO,eAAA,CAAgB,UAAU,QAAQ,CAAA;AAAA,EAC3C;AACF;;;;"}

package/build/esm/prod/options.js

@@ -0,0 +1,31 @@
+import { envToBool, isObjectLike } from '@sentry/core';
+
+function isVersionMetadata(value) {
+  return isObjectLike(value) && "id" in value && typeof value.id === "string";
+}
+function getEnvVar(env, varName) {
+  return isObjectLike(env) && varName in env && typeof env[varName] === "string" ? env[varName] : void 0;
+}
+function getFinalOptions(userOptions = {}, env) {
+  if (typeof env !== "object" || env === null) {
+    return userOptions;
+  }
+  const release = "SENTRY_RELEASE" in env && typeof env.SENTRY_RELEASE === "string" ? env.SENTRY_RELEASE : "CF_VERSION_METADATA" in env && isVersionMetadata(env.CF_VERSION_METADATA) ? env.CF_VERSION_METADATA.id : void 0;
+  const tracesSampleRate = userOptions.tracesSampleRate ?? parseFloat(getEnvVar(env, "SENTRY_TRACES_SAMPLE_RATE") ?? "");
+  return {
+    release,
+    ...userOptions,
+    dsn: userOptions.dsn ?? getEnvVar(env, "SENTRY_DSN"),
+    environment: userOptions.environment ?? getEnvVar(env, "SENTRY_ENVIRONMENT"),
+    tracesSampleRate: isFinite(tracesSampleRate) ? tracesSampleRate : void 0,
+    debug: userOptions.debug ?? envToBool(getEnvVar(env, "SENTRY_DEBUG")),
+    tunnel: userOptions.tunnel ?? getEnvVar(env, "SENTRY_TUNNEL"),
+    traceLifecycle: userOptions.traceLifecycle ?? getTraceLifecycleFromEnv(getEnvVar(env, "SENTRY_TRACE_LIFECYCLE"))
+  };
+}
+function getTraceLifecycleFromEnv(envVar) {
+  return envVar === "stream" || envVar === "static" ? envVar : void 0;
+}
+
+export { getFinalOptions };
+//# sourceMappingURL=options.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sources":["../../../src/options.ts"],"sourcesContent":["import { isObjectLike, envToBool } from '@sentry/core';\nimport type { CloudflareOptions } from './client';\n\n/**\n * Cloudflare's version metadata binding structure.\n * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/version-metadata/\n */\ninterface CfVersionMetadata {\n  id: string;\n  tag?: string;\n  timestamp?: string;\n}\n\n/**\n * Checks if the value is a valid CF_VERSION_METADATA binding.\n */\nfunction isVersionMetadata(value: unknown): value is CfVersionMetadata {\n  return isObjectLike(value) && 'id' in value && typeof value.id === 'string';\n}\n\nfunction getEnvVar<T extends Record<string, unknown>>(env: unknown, varName: keyof T): string | undefined {\n  return isObjectLike(env) && varName in env && typeof (env as T)[varName] === 'string'\n    ? ((env as T)[varName] as string)\n    : undefined;\n}\n\n/**\n * Merges the options passed in from the user with the options we read from\n * the Cloudflare `env` environment variable object.\n *\n * Release is determined with the following priority (highest to lowest):\n * 1. User-provided release option\n * 2. SENTRY_RELEASE environment variable\n * 3. CF_VERSION_METADATA.id binding (if configured in the wrangler config)\n *\n * @param userOptions - The options passed in from the user.\n * @param env - The environment variables.\n *\n * @returns The final options.\n */\nexport function getFinalOptions(userOptions: CloudflareOptions = {}, env: unknown): CloudflareOptions {\n  if (typeof env !== 'object' || env === null) {\n    return userOptions;\n  }\n\n  // Priority: userOptions.release > SENTRY_RELEASE > CF_VERSION_METADATA.id\n  const release =\n    'SENTRY_RELEASE' in env && typeof env.SENTRY_RELEASE === 'string'\n      ? env.SENTRY_RELEASE\n      : 'CF_VERSION_METADATA' in env && isVersionMetadata(env.CF_VERSION_METADATA)\n        ? env.CF_VERSION_METADATA.id\n        : undefined;\n\n  const tracesSampleRate =\n    userOptions.tracesSampleRate ?? parseFloat(getEnvVar(env, 'SENTRY_TRACES_SAMPLE_RATE') ?? '');\n\n  // Spotlight precedence (mirrors node-core's getSpotlightConfig):\n  // - false or explicit string from options: use as-is\n  // - true: enable, but prefer a custom URL from the env var if set\n  // - undefined: defer entirely to the env var (bool or URL)\n  /*! rollup-include-development-only */\n  const spotlight = getSpotlightFromEnv(userOptions.spotlight, getEnvVar(env, 'SENTRY_SPOTLIGHT'));\n  /*! rollup-include-development-only-end */\n\n  return {\n    release,\n    ...userOptions,\n    dsn: userOptions.dsn ?? getEnvVar(env, 'SENTRY_DSN'),\n    environment: userOptions.environment ?? getEnvVar(env, 'SENTRY_ENVIRONMENT'),\n    tracesSampleRate: isFinite(tracesSampleRate) ? tracesSampleRate : undefined,\n    debug: userOptions.debug ?? envToBool(getEnvVar(env, 'SENTRY_DEBUG')),\n    tunnel: userOptions.tunnel ?? getEnvVar(env, 'SENTRY_TUNNEL'),\n    traceLifecycle: userOptions.traceLifecycle ?? getTraceLifecycleFromEnv(getEnvVar(env, 'SENTRY_TRACE_LIFECYCLE')),\n    /*! rollup-include-development-only */\n    spotlight,\n    /*! rollup-include-development-only-end */\n  };\n}\n\n/**\n * Resolve the spotlight option from a user-supplied value and an env binding string.\n * Mirrors node-core's `getSpotlightConfig` precedence:\n *   - `false` or explicit string from options → use as-is\n *   - `true` → enable, but prefer a custom URL from the env var if set\n *   - `undefined` → defer entirely to the env var (bool or URL)\n */\nfunction getSpotlightFromEnv(\n  optionsSpotlight: boolean | string | undefined,\n  envVar: string | undefined,\n): boolean | string | undefined {\n  if (optionsSpotlight === false) {\n    return false;\n  }\n  if (typeof optionsSpotlight === 'string') {\n    return optionsSpotlight;\n  }\n\n  // optionsSpotlight is true or undefined\n  const envBool = envToBool(envVar, { strict: true });\n  const envUrl = envBool === null && envVar ? envVar : undefined;\n\n  return optionsSpotlight === true\n    ? (envUrl ?? true) // true: use env URL if present, otherwise true\n    : (envBool ?? envUrl); // undefined: use env var (bool or URL)\n}\n\nfunction getTraceLifecycleFromEnv(envVar: string | undefined): 'static' | 'stream' | undefined {\n  return envVar === 'stream' || envVar === 'static' ? envVar : undefined;\n}\n"],"names":[],"mappings":";;AAgBA,SAAS,kBAAkB,KAAA,EAA4C;AACrE,EAAA,OAAO,aAAa,KAAK,CAAA,IAAK,QAAQ,KAAA,IAAS,OAAO,MAAM,EAAA,KAAO,QAAA;AACrE;AAEA,SAAS,SAAA,CAA6C,KAAc,OAAA,EAAsC;AACxG,EAAA,OAAO,YAAA,CAAa,GAAG,CAAA,IAAK,OAAA,IAAW,GAAA,IAAO,OAAQ,GAAA,CAAU,OAAO,CAAA,KAAM,QAAA,GACvE,GAAA,CAAU,OAAO,CAAA,GACnB,MAAA;AACN;AAgBO,SAAS,eAAA,CAAgB,WAAA,GAAiC,EAAC,EAAG,GAAA,EAAiC;AACpG,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,IAAA,EAAM;AAC3C,IAAA,OAAO,WAAA;AAAA,EACT;AAGA,EAAA,MAAM,UACJ,gBAAA,IAAoB,GAAA,IAAO,OAAO,GAAA,CAAI,mBAAmB,QAAA,GACrD,GAAA,CAAI,cAAA,GACJ,qBAAA,IAAyB,OAAO,iBAAA,CAAkB,GAAA,CAAI,mBAAmB,CAAA,GACvE,GAAA,CAAI,oBAAoB,EAAA,GACxB,MAAA;AAER,EAAA,MAAM,gBAAA,GACJ,YAAY,gBAAA,IAAoB,UAAA,CAAW,UAAU,GAAA,EAAK,2BAA2B,KAAK,EAAE,CAAA;AAM9F,EAAA,OAAO;AAAA,IACL,OAAA;AAAA,IACA,GAAG,WAAA;AAAA,IACH,GAAA,EAAK,WAAA,CAAY,GAAA,IAAO,SAAA,CAAU,KAAK,YAAY,CAAA;AAAA,IACnD,WAAA,EAAa,WAAA,CAAY,WAAA,IAAe,SAAA,CAAU,KAAK,oBAAoB,CAAA;AAAA,IAC3E,gBAAA,EAAkB,QAAA,CAAS,gBAAgB,CAAA,GAAI,gBAAA,GAAmB,MAAA;AAAA,IAClE,OAAO,WAAA,CAAY,KAAA,IAAS,UAAU,SAAA,CAAU,GAAA,EAAK,cAAc,CAAC,CAAA;AAAA,IACpE,MAAA,EAAQ,WAAA,CAAY,MAAA,IAAU,SAAA,CAAU,KAAK,eAAe,CAAA;AAAA,IAC5D,gBAAgB,WAAA,CAAY,cAAA,IAAkB,yBAAyB,SAAA,CAAU,GAAA,EAAK,wBAAwB,CAAC;AAAA,GAC/G;AACJ;AA6BA,SAAS,yBAAyB,MAAA,EAA6D;AAC7F,EAAA,OAAO,MAAA,KAAW,QAAA,IAAY,MAAA,KAAW,QAAA,GAAW,MAAA,GAAS,MAAA;AAC/D;;;;"}

package/build/esm/prod/package.json

@@ -0,0 +1 @@
+{"type":"module","version":"11.0.0-alpha.1","sideEffects":false}

package/build/esm/prod/pages-plugin.js

@@ -0,0 +1,22 @@
+import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';
+import { wrapRequestHandlerWithInit } from './request.js';
+import { init } from './sdk.js';
+
+function sentryPagesPlugin(handlerOrOptions) {
+  setAsyncLocalStorageAsyncContextStrategy();
+  return (context) => {
+    if (context.request.method === "OPTIONS" || context.request.method === "HEAD") {
+      return context.next();
+    }
+    const options = typeof handlerOrOptions === "function" ? handlerOrOptions(context) : handlerOrOptions;
+    const executionContext = { ...context, props: {} };
+    return wrapRequestHandlerWithInit(
+      { options, request: context.request, context: executionContext },
+      () => context.next(),
+      init
+    );
+  };
+}
+
+export { sentryPagesPlugin };
+//# sourceMappingURL=pages-plugin.js.map

package/build/esm/prod/pages-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages-plugin.js","sources":["../../../src/pages-plugin.ts"],"sourcesContent":["import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';\nimport type { CloudflareOptions } from './client';\nimport type { ExecutionContextCompat } from './executionContext';\nimport { wrapRequestHandlerWithInit } from './request';\nimport { init } from './sdk';\n\n/**\n * Plugin middleware for Cloudflare Pages.\n *\n * Initializes the SDK and wraps cloudflare pages requests with SDK instrumentation.\n *\n * @example Simple usage\n *\n * ```javascript\n * // functions/_middleware.js\n * import * as Sentry from '@sentry/cloudflare';\n *\n * export const onRequest = Sentry.sentryPagesPlugin({\n *   dsn: process.env.SENTRY_DSN,\n *   tracesSampleRate: 1.0,\n * });\n * ```\n *\n * @example Usage with handler function to access context for environmental variables\n *\n * ```javascript\n * import * as Sentry from '@sentry/cloudflare';\n *\n * const const onRequest = Sentry.sentryPagesPlugin((context) => ({\n *   dsn: context.env.SENTRY_DSN,\n *   tracesSampleRate: 1.0,\n * })\n * ```\n *\n * @param handlerOrOptions Configuration options or a function that returns configuration options.\n * @returns A plugin function that can be used in Cloudflare Pages.\n */\nexport function sentryPagesPlugin<\n  // oxlint-disable-next-line typescript/no-explicit-any\n  Env = any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Params extends string = any,\n  Data extends Record<string, unknown> = Record<string, unknown>,\n  // Although it is not ideal to use `any` here, it makes usage more flexible for different setups.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  PluginParams = any,\n>(\n  handlerOrOptions:\n    | CloudflareOptions\n    | ((context: EventPluginContext<Env, Params, Data, PluginParams>) => CloudflareOptions),\n): PagesPluginFunction<Env, Params, Data, PluginParams> {\n  setAsyncLocalStorageAsyncContextStrategy();\n  return context => {\n    if (context.request.method === 'OPTIONS' || context.request.method === 'HEAD') {\n      return context.next();\n    }\n\n    const options = typeof handlerOrOptions === 'function' ? handlerOrOptions(context) : handlerOrOptions;\n    // A Pages `EventPluginContext` is not a Workers `ExecutionContext`, but `wrapRequestHandler` only\n    // uses `waitUntil` and a `'storage' in context` check, both of which this satisfies.\n    const executionContext = { ...context, props: {} } as unknown as ExecutionContextCompat;\n    return wrapRequestHandlerWithInit(\n      { options, request: context.request, context: executionContext },\n      () => context.next(),\n      init,\n    );\n  };\n}\n"],"names":[],"mappings":";;;;AAqCO,SAAS,kBAUd,gBAAA,EAGsD;AACtD,EAAA,wCAAA,EAAyC;AACzC,EAAA,OAAO,CAAA,OAAA,KAAW;AAChB,IAAA,IAAI,QAAQ,OAAA,CAAQ,MAAA,KAAW,aAAa,OAAA,CAAQ,OAAA,CAAQ,WAAW,MAAA,EAAQ;AAC7E,MAAA,OAAO,QAAQ,IAAA,EAAK;AAAA,IACtB;AAEA,IAAA,MAAM,UAAU,OAAO,gBAAA,KAAqB,UAAA,GAAa,gBAAA,CAAiB,OAAO,CAAA,GAAI,gBAAA;AAGrF,IAAA,MAAM,mBAAmB,EAAE,GAAG,OAAA,EAAS,KAAA,EAAO,EAAC,EAAE;AACjD,IAAA,OAAO,0BAAA;AAAA,MACL,EAAE,OAAA,EAAS,OAAA,EAAS,OAAA,CAAQ,OAAA,EAAS,SAAS,gBAAA,EAAiB;AAAA,MAC/D,MAAM,QAAQ,IAAA,EAAK;AAAA,MACnB;AAAA,KACF;AAAA,EACF,CAAA;AACF;;;;"}

package/build/esm/prod/request.js

@@ -0,0 +1,129 @@
+import { parseStringToURLObject, getHttpSpanDetailsFromUrlObject, httpHeadersToSpanAttributes, winterCGHeadersToDict, SEMANTIC_ATTRIBUTE_SENTRY_OP, captureException, continueTrace, startSpanManual, setHttpStatus } from '@sentry/core';
+import { captureIncomingRequestBody } from './integrations/httpServer.js';
+import { initBaseSdk } from './baseSdk.js';
+import { getOriginalWaitUntil, flushAndDispose } from './flush.js';
+import { addCloudResourceContext, addRequest, addCultureContext } from './scope-utils.js';
+import { withInvocationIsolationScope } from './utils/invocationScope.js';
+import { classifyResponseStreaming } from './utils/streaming.js';
+
+function getRequestErrorMechanismType(context) {
+  return context && "storage" in context ? "auto.faas.cloudflare.durable_object" : "auto.http.cloudflare";
+}
+function wrapRequestHandler(wrapperOptions, handler) {
+  return wrapRequestHandlerWithInit(wrapperOptions, handler, initBaseSdk);
+}
+function wrapRequestHandlerWithInit(wrapperOptions, handler, initSdk) {
+  return withInvocationIsolationScope(async (isolationScope) => {
+    const { options, request, captureErrors = true } = wrapperOptions;
+    const context = wrapperOptions.context;
+    const waitUntil = context ? getOriginalWaitUntil(context).bind(context) : void 0;
+    const errorMechanismType = getRequestErrorMechanismType(context);
+    const client = initSdk({ ...options, ctx: context });
+    isolationScope.setClient(client);
+    const urlObject = parseStringToURLObject(request.url);
+    const [name, attributes] = getHttpSpanDetailsFromUrlObject(
+      urlObject,
+      "server",
+      "auto.http.cloudflare",
+      request,
+      void 0,
+      client
+    );
+    const contentLength = request.headers.get("content-length");
+    if (contentLength) {
+      attributes["http.request.body.size"] = parseInt(contentLength, 10);
+    }
+    const userAgentHeader = request.headers.get("user-agent");
+    if (userAgentHeader) {
+      attributes["user_agent.original"] = userAgentHeader;
+    }
+    if (client) {
+      Object.assign(
+        attributes,
+        httpHeadersToSpanAttributes(winterCGHeadersToDict(request.headers), client.getDataCollectionOptions())
+      );
+    }
+    attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] = "http.server";
+    addCloudResourceContext(isolationScope);
+    addRequest(isolationScope, request);
+    if (request.cf) {
+      addCultureContext(isolationScope, request.cf);
+      if (typeof request.cf.httpProtocol === "string") {
+        attributes["network.protocol.name"] = request.cf.httpProtocol;
+      }
+    }
+    if (request.method === "OPTIONS" || request.method === "HEAD") {
+      try {
+        return await handler();
+      } catch (e) {
+        if (captureErrors) {
+          captureException(e, { mechanism: { handled: false, type: errorMechanismType } });
+        }
+        throw e;
+      } finally {
+        waitUntil?.(flushAndDispose(client));
+      }
+    }
+    if (client) {
+      await captureIncomingRequestBody(client, request);
+    }
+    return continueTrace(
+      { sentryTrace: request.headers.get("sentry-trace") || "", baggage: request.headers.get("baggage") },
+      () => {
+        return startSpanManual({ name, attributes }, async (span) => {
+          let res;
+          try {
+            res = await handler();
+            setHttpStatus(span, res.status);
+          } catch (e) {
+            span.end();
+            if (captureErrors) {
+              captureException(e, { mechanism: { handled: false, type: errorMechanismType } });
+            }
+            waitUntil?.(flushAndDispose(client));
+            throw e;
+          }
+          const classification = classifyResponseStreaming(res);
+          if (classification.isStreaming && res.body) {
+            try {
+              let ended = false;
+              const endSpanOnce = () => {
+                if (ended) return;
+                ended = true;
+                span.end();
+                waitUntil?.(flushAndDispose(client));
+              };
+              const transform = new TransformStream({
+                flush() {
+                  endSpanOnce();
+                },
+                cancel() {
+                  endSpanOnce();
+                }
+              });
+              return new Response(res.body.pipeThrough(transform), {
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers
+              });
+            } catch {
+              span.end();
+              waitUntil?.(flushAndDispose(client));
+              return res;
+            }
+          }
+          span.end();
+          if (res.status === 101) {
+            waitUntil?.(client?.flush(2e3));
+          } else {
+            waitUntil?.(flushAndDispose(client));
+          }
+          return res;
+        });
+      }
+    );
+  });
+}
+
+export { wrapRequestHandler, wrapRequestHandlerWithInit };
+//# sourceMappingURL=request.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sources":["../../../src/request.ts"],"sourcesContent":["import type { CfProperties, IncomingRequestCfProperties } from '@cloudflare/workers-types';\nimport {\n  captureException,\n  continueTrace,\n  getHttpSpanDetailsFromUrlObject,\n  httpHeadersToSpanAttributes,\n  parseStringToURLObject,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  setHttpStatus,\n  startSpanManual,\n  winterCGHeadersToDict,\n} from '@sentry/core';\nimport { captureIncomingRequestBody } from './integrations/httpServer';\nimport { initBaseSdk } from './baseSdk';\nimport type { CloudflareClient, CloudflareOptions } from './client';\nimport type { ExecutionContextCompat } from './executionContext';\nimport { flushAndDispose, getOriginalWaitUntil } from './flush';\nimport { addCloudResourceContext, addCultureContext, addRequest } from './scope-utils';\nimport { withInvocationIsolationScope } from './utils/invocationScope';\nimport { classifyResponseStreaming } from './utils/streaming';\n\nfunction getRequestErrorMechanismType(context: ExecutionContextCompat | undefined): string {\n  // Durable Object fetch handlers use DO state as context (see instrumentDurableObjectWithSentry)\n  return context && 'storage' in context ? 'auto.faas.cloudflare.durable_object' : 'auto.http.cloudflare';\n}\n\ninterface RequestHandlerWrapperOptions {\n  options: CloudflareOptions;\n  request: Request<unknown, IncomingRequestCfProperties<unknown> | CfProperties<unknown>>;\n  context: ExecutionContextCompat | undefined;\n  /**\n   * If true, errors will be captured, rethrown and sent to Sentry.\n   * Otherwise, errors are rethrown but not captured.\n   *\n   * You most likely don't want to set this to `false`, if you use `wrapRequestHandler` directly.\n   * This is primarily meant as an escape hatch for higher-level SDKs relying on additional error\n   * capturing mechanisms where this wrapper captures errors too early or too generally.\n   *\n   * @default true\n   */\n  captureErrors?: boolean;\n}\n\ntype InitSdk = (options: CloudflareOptions) => CloudflareClient | undefined;\n\n/**\n * Wraps a cloudflare request handler in Sentry instrumentation.\n *\n * The client is set up with the default integrations that work without the `nodejs_compat`\n * compatibility flag, so that this also works on runtimes that cannot enable it (e.g. Shopify\n * Oxygen). On a runtime that has `nodejs_compat`, pass `defaultIntegrations:\n * getDefaultIntegrations(options)` in `options` to get the full set instead.\n */\nexport function wrapRequestHandler(\n  wrapperOptions: RequestHandlerWrapperOptions,\n  handler: (...args: unknown[]) => Response | Promise<Response>,\n): Promise<Response> {\n  return wrapRequestHandlerWithInit(wrapperOptions, handler, initBaseSdk);\n}\n\n/**\n * Same as {@link wrapRequestHandler}, but with the SDK initialization injected.\n *\n * Wrappers that are only reachable from the main entry point — where `nodejs_compat` is a\n * requirement anyway — pass `init` from `sdk.ts` to get the full default integrations.\n *\n * @internal\n */\nexport function wrapRequestHandlerWithInit(\n  wrapperOptions: RequestHandlerWrapperOptions,\n  handler: (...args: unknown[]) => Response | Promise<Response>,\n  initSdk: InitSdk,\n): Promise<Response> {\n  return withInvocationIsolationScope(async isolationScope => {\n    const { options, request, captureErrors = true } = wrapperOptions;\n    const context = wrapperOptions.context;\n\n    // Use getOriginalWaitUntil to get the un-instrumented waitUntil function.\n    // This is crucial to avoid deadlock: the flush lock mechanism wraps waitUntil\n    // to track pending tasks. If we use the instrumented version for flushAndDispose,\n    // it acquires the lock, then flushAndDispose tries to wait for the same lock,\n    // creating a deadlock.\n    const waitUntil = context ? getOriginalWaitUntil(context).bind(context) : undefined;\n    const errorMechanismType = getRequestErrorMechanismType(context);\n\n    const client = initSdk({ ...options, ctx: context });\n    isolationScope.setClient(client);\n\n    const urlObject = parseStringToURLObject(request.url);\n    const [name, attributes] = getHttpSpanDetailsFromUrlObject(\n      urlObject,\n      'server',\n      'auto.http.cloudflare',\n      request,\n      undefined,\n      client,\n    );\n\n    const contentLength = request.headers.get('content-length');\n    if (contentLength) {\n      attributes['http.request.body.size'] = parseInt(contentLength, 10);\n    }\n\n    const userAgentHeader = request.headers.get('user-agent');\n    if (userAgentHeader) {\n      attributes['user_agent.original'] = userAgentHeader;\n    }\n\n    if (client) {\n      Object.assign(\n        attributes,\n        httpHeadersToSpanAttributes(winterCGHeadersToDict(request.headers), client.getDataCollectionOptions()),\n      );\n    }\n\n    attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] = 'http.server';\n\n    addCloudResourceContext(isolationScope);\n    addRequest(isolationScope, request);\n    if (request.cf) {\n      addCultureContext(isolationScope, request.cf);\n\n      if (typeof request.cf.httpProtocol === 'string') {\n        attributes['network.protocol.name'] = request.cf.httpProtocol;\n      }\n    }\n\n    // Do not capture spans for OPTIONS and HEAD requests\n    if (request.method === 'OPTIONS' || request.method === 'HEAD') {\n      try {\n        return await handler();\n      } catch (e) {\n        if (captureErrors) {\n          captureException(e, { mechanism: { handled: false, type: errorMechanismType } });\n        }\n        throw e;\n      } finally {\n        waitUntil?.(flushAndDispose(client));\n      }\n    }\n\n    if (client) {\n      await captureIncomingRequestBody(client, request);\n    }\n\n    return continueTrace(\n      { sentryTrace: request.headers.get('sentry-trace') || '', baggage: request.headers.get('baggage') },\n      () => {\n        // Note: This span will not have a duration unless I/O happens in the handler. This is\n        // because of how the cloudflare workers runtime works.\n        // See: https://developers.cloudflare.com/workers/runtime-apis/performance/\n\n        // Use startSpanManual to control when span ends (needed for streaming responses)\n        return startSpanManual({ name, attributes }, async span => {\n          let res: Response;\n\n          try {\n            res = await handler();\n            setHttpStatus(span, res.status);\n\n            // After the handler runs, the span name might have been updated by nested instrumentation\n            // (e.g., Remix parameterizing routes). The span should already have the correct name\n            // from that instrumentation, so we don't need to do anything here.\n          } catch (e) {\n            span.end();\n            if (captureErrors) {\n              captureException(e, { mechanism: { handled: false, type: errorMechanismType } });\n            }\n            waitUntil?.(flushAndDispose(client));\n            throw e;\n          }\n\n          // Classify response to detect actual streaming\n          const classification = classifyResponseStreaming(res);\n\n          if (classification.isStreaming && res.body) {\n            try {\n              let ended = false;\n\n              const endSpanOnce = (): void => {\n                if (ended) return;\n\n                ended = true;\n                span.end();\n                waitUntil?.(flushAndDispose(client));\n              };\n\n              const transform = new TransformStream({\n                flush() {\n                  // Source stream completed normally.\n                  endSpanOnce();\n                },\n                cancel() {\n                  // Client disconnected (or downstream cancelled). The `cancel`\n                  // is being called while the response is still considered\n                  // active, so this is a safe place to end the span.\n                  endSpanOnce();\n                },\n              });\n\n              return new Response(res.body.pipeThrough(transform), {\n                status: res.status,\n                statusText: res.statusText,\n                headers: res.headers,\n              });\n            } catch {\n              span.end();\n              waitUntil?.(flushAndDispose(client));\n              return res;\n            }\n          }\n\n          // Non-streaming response - end span immediately and return original\n          span.end();\n\n          // Don't dispose for protocol upgrades (101 Switching Protocols) - the connection stays alive.\n          // This includes WebSocket upgrades where webSocketMessage/webSocketClose handlers\n          // will still be called and may need the client to capture errors.\n          if (res.status === 101) {\n            waitUntil?.(client?.flush(2000));\n          } else {\n            waitUntil?.(flushAndDispose(client));\n          }\n          return res;\n        });\n      },\n    );\n  });\n}\n"],"names":[],"mappings":"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"}

package/build/esm/prod/scope-utils.js

@@ -0,0 +1,18 @@
+import { winterCGRequestToRequestData } from '@sentry/core';
+
+function addCloudResourceContext(scope) {
+  scope.setContext("cloud_resource", {
+    "cloud.provider": "cloudflare"
+  });
+}
+function addCultureContext(scope, cf) {
+  scope.setContext("culture", {
+    timezone: cf.timezone
+  });
+}
+function addRequest(scope, request) {
+  scope.setSDKProcessingMetadata({ normalizedRequest: winterCGRequestToRequestData(request) });
+}
+
+export { addCloudResourceContext, addCultureContext, addRequest };
+//# sourceMappingURL=scope-utils.js.map

package/build/esm/prod/scope-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-utils.js","sources":["../../../src/scope-utils.ts"],"sourcesContent":["import type { CfProperties, IncomingRequestCfProperties } from '@cloudflare/workers-types';\nimport type { Scope } from '@sentry/core';\nimport { winterCGRequestToRequestData } from '@sentry/core';\n\n/**\n * Set cloud resource context on scope.\n */\nexport function addCloudResourceContext(scope: Scope): void {\n  scope.setContext('cloud_resource', {\n    'cloud.provider': 'cloudflare',\n  });\n}\n\n/**\n * Set culture context on scope\n */\nexport function addCultureContext(scope: Scope, cf: IncomingRequestCfProperties | CfProperties): void {\n  scope.setContext('culture', {\n    timezone: cf.timezone,\n  });\n}\n\n/**\n * Set request data on scope\n */\nexport function addRequest(scope: Scope, request: Request): void {\n  scope.setSDKProcessingMetadata({ normalizedRequest: winterCGRequestToRequestData(request) });\n}\n"],"names":[],"mappings":";;AAOO,SAAS,wBAAwB,KAAA,EAAoB;AAC1D,EAAA,KAAA,CAAM,WAAW,gBAAA,EAAkB;AAAA,IACjC,gBAAA,EAAkB;AAAA,GACnB,CAAA;AACH;AAKO,SAAS,iBAAA,CAAkB,OAAc,EAAA,EAAsD;AACpG,EAAA,KAAA,CAAM,WAAW,SAAA,EAAW;AAAA,IAC1B,UAAU,EAAA,CAAG;AAAA,GACd,CAAA;AACH;AAKO,SAAS,UAAA,CAAW,OAAc,OAAA,EAAwB;AAC/D,EAAA,KAAA,CAAM,yBAAyB,EAAE,iBAAA,EAAmB,4BAAA,CAA6B,OAAO,GAAG,CAAA;AAC7F;;;;"}

package/build/esm/prod/sdk.js

@@ -0,0 +1,16 @@
+import { vercelAIIntegration } from './integrations/tracing/vercelai.js';
+import { getBaseDefaultIntegrations, initWithDefaultIntegrations } from './baseSdk.js';
+
+function getDefaultIntegrations(options) {
+  return [
+    ...getBaseDefaultIntegrations(options),
+    // Subscribes to the `ai` SDK's native `node:diagnostics_channel` telemetry channel.
+    vercelAIIntegration()
+  ];
+}
+function init(options) {
+  return initWithDefaultIntegrations(options, getDefaultIntegrations);
+}
+
+export { getDefaultIntegrations, init };
+//# sourceMappingURL=sdk.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.js","sources":["../../../src/sdk.ts"],"sourcesContent":["import type { Integration } from '@sentry/core';\nimport { vercelAIIntegration } from './integrations/tracing/vercelai';\nimport { getBaseDefaultIntegrations, initWithDefaultIntegrations } from './baseSdk';\nimport type { CloudflareClient, CloudflareOptions } from './client';\n\n/**\n * Get the default integrations for the Cloudflare SDK.\n *\n * This is the full set and requires the `nodejs_compat` compatibility flag. Runtimes that cannot\n * enable it (e.g. Shopify Oxygen) go through `wrapRequestHandler`, which only sets up\n * `getBaseDefaultIntegrations`.\n */\nexport function getDefaultIntegrations(options: CloudflareOptions): Integration[] {\n  return [\n    ...getBaseDefaultIntegrations(options),\n    // Subscribes to the `ai` SDK's native `node:diagnostics_channel` telemetry channel.\n    vercelAIIntegration(),\n  ];\n}\n\n/**\n * Initializes the cloudflare SDK.\n */\nexport function init(options: CloudflareOptions): CloudflareClient | undefined {\n  return initWithDefaultIntegrations(options, getDefaultIntegrations);\n}\n"],"names":[],"mappings":";;;AAYO,SAAS,uBAAuB,OAAA,EAA2C;AAChF,EAAA,OAAO;AAAA,IACL,GAAG,2BAA2B,OAAO,CAAA;AAAA;AAAA,IAErC,mBAAA;AAAoB,GACtB;AACF;AAKO,SAAS,KAAK,OAAA,EAA0D;AAC7E,EAAA,OAAO,2BAAA,CAA4B,SAAS,sBAAsB,CAAA;AACpE;;;;"}

package/build/esm/prod/transport.js

@@ -0,0 +1,72 @@
+import { createTransport, suppressTracing, SENTRY_BUFFER_FULL_ERROR } from '@sentry/core';
+
+const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
+class IsolatedPromiseBuffer {
+  constructor(_bufferSize = DEFAULT_TRANSPORT_BUFFER_SIZE) {
+    this.$ = [];
+    this._taskProducers = [];
+    this._bufferSize = _bufferSize;
+  }
+  /**
+   * @inheritdoc
+   */
+  add(taskProducer) {
+    if (this._taskProducers.length >= this._bufferSize) {
+      return Promise.reject(SENTRY_BUFFER_FULL_ERROR);
+    }
+    this._taskProducers.push(taskProducer);
+    return Promise.resolve({});
+  }
+  /**
+   * @inheritdoc
+   */
+  drain(timeout) {
+    const oldTaskProducers = [...this._taskProducers];
+    this._taskProducers = [];
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (timeout && timeout > 0) {
+          resolve(false);
+        }
+      }, timeout);
+      Promise.all(
+        oldTaskProducers.map(
+          (taskProducer) => taskProducer().then(null, () => {
+          })
+        )
+      ).then(() => {
+        clearTimeout(timer);
+        resolve(true);
+      });
+    });
+  }
+}
+function makeCloudflareTransport(options) {
+  function makeRequest(request) {
+    const requestOptions = {
+      body: request.body,
+      method: "POST",
+      headers: options.headers,
+      ...options.fetchOptions
+    };
+    return suppressTracing(() => {
+      return (options.fetch ?? fetch)(options.url, requestOptions).then(async (response) => {
+        try {
+          await response.text();
+        } catch {
+        }
+        return {
+          statusCode: response.status,
+          headers: {
+            "x-sentry-rate-limits": response.headers.get("X-Sentry-Rate-Limits"),
+            "retry-after": response.headers.get("Retry-After")
+          }
+        };
+      });
+    });
+  }
+  return createTransport(options, makeRequest, new IsolatedPromiseBuffer(options.bufferSize));
+}
+
+export { IsolatedPromiseBuffer, makeCloudflareTransport };
+//# sourceMappingURL=transport.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sources":["../../../src/transport.ts"],"sourcesContent":["import type { BaseTransportOptions, Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/core';\nimport { createTransport, SENTRY_BUFFER_FULL_ERROR, suppressTracing } from '@sentry/core';\n\nexport interface CloudflareTransportOptions extends BaseTransportOptions {\n  /** Custom fetch function to use. This allows usage of things like Workers VPC */\n  fetch?: typeof fetch;\n  /** Fetch API init parameters. */\n  fetchOptions?: RequestInit;\n}\n\nconst DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * This is a modified promise buffer that collects tasks until drain is called.\n * We need this in the edge runtime because edge function invocations may not share I/O objects, like fetch requests\n * and responses, and the normal PromiseBuffer inherently buffers stuff inbetween incoming requests.\n *\n * A limitation we need to be aware of is that DEFAULT_TRANSPORT_BUFFER_SIZE is the maximum amount of payloads the\n * SDK can send for a given edge function invocation.\n */\nexport class IsolatedPromiseBuffer {\n  // We just have this field because the promise buffer interface requires it.\n  // If we ever remove it from the interface we should also remove it here.\n  public $: Array<PromiseLike<TransportMakeRequestResponse>>;\n\n  private _taskProducers: (() => PromiseLike<TransportMakeRequestResponse>)[];\n\n  private readonly _bufferSize: number;\n\n  public constructor(_bufferSize = DEFAULT_TRANSPORT_BUFFER_SIZE) {\n    this.$ = [];\n    this._taskProducers = [];\n    this._bufferSize = _bufferSize;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  public add(taskProducer: () => PromiseLike<TransportMakeRequestResponse>): PromiseLike<TransportMakeRequestResponse> {\n    if (this._taskProducers.length >= this._bufferSize) {\n      return Promise.reject(SENTRY_BUFFER_FULL_ERROR);\n    }\n\n    this._taskProducers.push(taskProducer);\n    return Promise.resolve({});\n  }\n\n  /**\n   * @inheritdoc\n   */\n  public drain(timeout?: number): PromiseLike<boolean> {\n    const oldTaskProducers = [...this._taskProducers];\n    this._taskProducers = [];\n\n    return new Promise(resolve => {\n      const timer = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // This cannot reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      Promise.all(\n        oldTaskProducers.map(taskProducer =>\n          taskProducer().then(null, () => {\n            // catch all failed requests\n          }),\n        ),\n      ).then(() => {\n        // resolve to true if all fetch requests settled\n        clearTimeout(timer);\n        resolve(true);\n      });\n    });\n  }\n}\n\n/**\n * Creates a Transport that uses the native fetch API to send events to Sentry.\n */\nexport function makeCloudflareTransport(options: CloudflareTransportOptions): Transport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    const requestOptions: RequestInit = {\n      body: request.body as BodyInit,\n      method: 'POST',\n      headers: options.headers,\n      ...options.fetchOptions,\n    };\n\n    return suppressTracing(() => {\n      return (options.fetch ?? fetch)(options.url, requestOptions).then(async response => {\n        // Consume the response body to satisfy Cloudflare Workers' fetch requirements.\n        // The runtime requires all fetch response bodies to be read or explicitly canceled\n        // to prevent connection stalls and potential deadlocks. We read the body as text\n        // even though we don't use the content, as Sentry's response information is in the headers.\n        // See: https://github.com/getsentry/sentry-javascript/issues/18534\n        try {\n          await response.text();\n        } catch {\n          // no-op\n        }\n\n        return {\n          statusCode: response.status,\n          headers: {\n            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n            'retry-after': response.headers.get('Retry-After'),\n          },\n        };\n      });\n    });\n  }\n\n  return createTransport(options, makeRequest, new IsolatedPromiseBuffer(options.bufferSize));\n}\n"],"names":[],"mappings":";;AAUA,MAAM,6BAAA,GAAgC,EAAA;AAU/B,MAAM,qBAAA,CAAsB;AAAA,EAS1B,WAAA,CAAY,cAAc,6BAAA,EAA+B;AAC9D,IAAA,IAAA,CAAK,IAAI,EAAC;AACV,IAAA,IAAA,CAAK,iBAAiB,EAAC;AACvB,IAAA,IAAA,CAAK,WAAA,GAAc,WAAA;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA,EAKO,IAAI,YAAA,EAA0G;AACnH,IAAA,IAAI,IAAA,CAAK,cAAA,CAAe,MAAA,IAAU,IAAA,CAAK,WAAA,EAAa;AAClD,MAAA,OAAO,OAAA,CAAQ,OAAO,wBAAwB,CAAA;AAAA,IAChD;AAEA,IAAA,IAAA,CAAK,cAAA,CAAe,KAAK,YAAY,CAAA;AACrC,IAAA,OAAO,OAAA,CAAQ,OAAA,CAAQ,EAAE,CAAA;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKO,MAAM,OAAA,EAAwC;AACnD,IAAA,MAAM,gBAAA,GAAmB,CAAC,GAAG,IAAA,CAAK,cAAc,CAAA;AAChD,IAAA,IAAA,CAAK,iBAAiB,EAAC;AAEvB,IAAA,OAAO,IAAI,QAAQ,CAAA,OAAA,KAAW;AAC5B,MAAA,MAAM,KAAA,GAAQ,WAAW,MAAM;AAC7B,QAAA,IAAI,OAAA,IAAW,UAAU,CAAA,EAAG;AAC1B,UAAA,OAAA,CAAQ,KAAK,CAAA;AAAA,QACf;AAAA,MACF,GAAG,OAAO,CAAA;AAIV,MAAA,OAAA,CAAQ,GAAA;AAAA,QACN,gBAAA,CAAiB,GAAA;AAAA,UAAI,CAAA,YAAA,KACnB,YAAA,EAAa,CAAE,IAAA,CAAK,MAAM,MAAM;AAAA,UAEhC,CAAC;AAAA;AACH,OACF,CAAE,KAAK,MAAM;AAEX,QAAA,YAAA,CAAa,KAAK,CAAA;AAClB,QAAA,OAAA,CAAQ,IAAI,CAAA;AAAA,MACd,CAAC,CAAA;AAAA,IACH,CAAC,CAAA;AAAA,EACH;AACF;AAKO,SAAS,wBAAwB,OAAA,EAAgD;AACtF,EAAA,SAAS,YAAY,OAAA,EAAsE;AACzF,IAAA,MAAM,cAAA,GAA8B;AAAA,MAClC,MAAM,OAAA,CAAQ,IAAA;AAAA,MACd,MAAA,EAAQ,MAAA;AAAA,MACR,SAAS,OAAA,CAAQ,OAAA;AAAA,MACjB,GAAG,OAAA,CAAQ;AAAA,KACb;AAEA,IAAA,OAAO,gBAAgB,MAAM;AAC3B,MAAA,OAAA,CAAQ,OAAA,CAAQ,SAAS,KAAA,EAAO,OAAA,CAAQ,KAAK,cAAc,CAAA,CAAE,IAAA,CAAK,OAAM,QAAA,KAAY;AAMlF,QAAA,IAAI;AACF,UAAA,MAAM,SAAS,IAAA,EAAK;AAAA,QACtB,CAAA,CAAA,MAAQ;AAAA,QAER;AAEA,QAAA,OAAO;AAAA,UACL,YAAY,QAAA,CAAS,MAAA;AAAA,UACrB,OAAA,EAAS;AAAA,YACP,sBAAA,EAAwB,QAAA,CAAS,OAAA,CAAQ,GAAA,CAAI,sBAAsB,CAAA;AAAA,YACnE,aAAA,EAAe,QAAA,CAAS,OAAA,CAAQ,GAAA,CAAI,aAAa;AAAA;AACnD,SACF;AAAA,MACF,CAAC,CAAA;AAAA,IACH,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,OAAO,gBAAgB,OAAA,EAAS,WAAA,EAAa,IAAI,qBAAA,CAAsB,OAAA,CAAQ,UAAU,CAAC,CAAA;AAC5F;;;;"}

package/build/esm/prod/utils/instrumentContext.js

@@ -0,0 +1,61 @@
+import { instrumentDurableObjectStorage } from '../instrumentations/instrumentDurableObjectStorage.js';
+
+function instrumentContext(ctx) {
+  if (!ctx) return ctx;
+  const overrides = /* @__PURE__ */ new Map();
+  const contextPrototype = Object.getPrototypeOf(ctx);
+  const prototypeMethodNames = Object.getOwnPropertyNames(contextPrototype);
+  const ownPropertyNames = Object.getOwnPropertyNames(ctx);
+  const instrumented = /* @__PURE__ */ new Set(["constructor"]);
+  const descriptors = {};
+  for (const methodName of [...ownPropertyNames, ...prototypeMethodNames]) {
+    if (instrumented.has(methodName) || typeof ctx[methodName] !== "function") {
+      continue;
+    }
+    instrumented.add(methodName);
+    descriptors[methodName] = makeOverridableDescriptor(overrides, ctx, methodName);
+  }
+  if ("storage" in ctx && ctx.storage) {
+    const originalStorage = ctx.storage;
+    const waitUntil = "waitUntil" in ctx && typeof ctx.waitUntil === "function" ? ctx.waitUntil.bind(ctx) : void 0;
+    let instrumentedStorage;
+    descriptors.storage = {
+      configurable: true,
+      enumerable: true,
+      get: () => {
+        if (!instrumentedStorage) {
+          instrumentedStorage = instrumentDurableObjectStorage(originalStorage, waitUntil);
+        }
+        return instrumentedStorage;
+      }
+    };
+    descriptors.originalStorage = {
+      configurable: true,
+      enumerable: false,
+      get: () => originalStorage
+    };
+  }
+  return Object.create(ctx, descriptors);
+}
+function makeOverridableDescriptor(store, ctx, method) {
+  return {
+    configurable: true,
+    enumerable: true,
+    set: (newValue) => {
+      if (typeof newValue == "function") {
+        store.set(method, newValue);
+        return;
+      }
+      Reflect.set(ctx, method, newValue);
+    },
+    get: () => {
+      if (store.has(method)) return store.get(method);
+      const methodFunction = Reflect.get(ctx, method);
+      if (typeof methodFunction !== "function") return methodFunction;
+      return methodFunction.bind(ctx);
+    }
+  };
+}
+
+export { instrumentContext };
+//# sourceMappingURL=instrumentContext.js.map

package/build/esm/prod/utils/instrumentContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentContext.js","sources":["../../../../src/utils/instrumentContext.ts"],"sourcesContent":["import { type DurableObjectState, type DurableObjectStorage, type ExecutionContext } from '@cloudflare/workers-types';\nimport { instrumentDurableObjectStorage } from '../instrumentations/instrumentDurableObjectStorage';\n\ntype ContextType = ExecutionContext | DurableObjectState;\ntype OverridesStore<T extends ContextType> = Map<keyof T, (...args: unknown[]) => unknown>;\n\n/**\n * Instruments an execution context or DurableObjectState with Sentry tracing.\n *\n * Creates a copy of the context that:\n * - Allows overriding of methods (e.g., waitUntil)\n * - For DurableObjectState: instruments storage operations (get, put, delete, list, etc.)\n *   to create Sentry spans automatically\n *\n * @param ctx - The execution context or DurableObjectState to instrument\n * @returns An instrumented copy of the context\n */\nexport function instrumentContext<T extends ContextType>(ctx: T): T {\n  if (!ctx) return ctx;\n\n  const overrides: OverridesStore<T> = new Map();\n  const contextPrototype = Object.getPrototypeOf(ctx);\n  const prototypeMethodNames = Object.getOwnPropertyNames(contextPrototype) as unknown as (keyof T)[];\n  const ownPropertyNames = Object.getOwnPropertyNames(ctx) as unknown as (keyof T)[];\n  const instrumented = new Set<unknown>(['constructor']);\n  const descriptors: PropertyDescriptorMap = {};\n\n  for (const methodName of [...ownPropertyNames, ...prototypeMethodNames]) {\n    if (instrumented.has(methodName) || typeof ctx[methodName] !== 'function') {\n      continue;\n    }\n\n    instrumented.add(methodName);\n    descriptors[methodName as string] = makeOverridableDescriptor(overrides, ctx, methodName);\n  }\n\n  // Check if this is a DurableObjectState context with a storage property\n  // If so, wrap the storage with instrumentation\n  if ('storage' in ctx && ctx.storage) {\n    const originalStorage = ctx.storage;\n    const waitUntil = 'waitUntil' in ctx && typeof ctx.waitUntil === 'function' ? ctx.waitUntil.bind(ctx) : undefined;\n    let instrumentedStorage: DurableObjectStorage | undefined;\n    descriptors.storage = {\n      configurable: true,\n      enumerable: true,\n      get: () => {\n        if (!instrumentedStorage) {\n          instrumentedStorage = instrumentDurableObjectStorage(originalStorage, waitUntil);\n        }\n        return instrumentedStorage;\n      },\n    };\n    // Expose the original uninstrumented storage for internal Sentry operations\n    // This avoids creating spans for internal storage operations\n    descriptors.originalStorage = {\n      configurable: true,\n      enumerable: false,\n      get: () => originalStorage,\n    };\n  }\n\n  return Object.create(ctx, descriptors);\n}\n\n/**\n * Creates a property descriptor that allows overriding of a method on the given context object.\n *\n * This descriptor supports property overriding with functions only. It delegates method calls to\n * the provided store if an override exists or to the original method on the context otherwise.\n *\n * @param {OverridesStore<ContextType>} store - The storage for overridden methods specific to the context type.\n * @param {ContextType} ctx - The context object that contains the method to be overridden.\n * @param {keyof ContextType} method - The method on the context object to create the overridable descriptor for.\n * @return {PropertyDescriptor} A property descriptor enabling the overriding of the specified method.\n */\nfunction makeOverridableDescriptor<T extends ContextType>(\n  store: OverridesStore<T>,\n  ctx: T,\n  method: keyof T,\n): PropertyDescriptor {\n  return {\n    configurable: true,\n    enumerable: true,\n    set: newValue => {\n      if (typeof newValue == 'function') {\n        store.set(method, newValue);\n        return;\n      }\n      Reflect.set(ctx, method, newValue);\n    },\n\n    get: () => {\n      if (store.has(method)) return store.get(method);\n      const methodFunction = Reflect.get(ctx, method);\n      if (typeof methodFunction !== 'function') return methodFunction;\n      // We should do bind() to make sure that the method is bound to the context object - otherwise it will not work\n      return methodFunction.bind(ctx);\n    },\n  };\n}\n"],"names":[],"mappings":";;AAiBO,SAAS,kBAAyC,GAAA,EAAW;AAClE,EAAA,IAAI,CAAC,KAAK,OAAO,GAAA;AAEjB,EAAA,MAAM,SAAA,uBAAmC,GAAA,EAAI;AAC7C,EAAA,MAAM,gBAAA,GAAmB,MAAA,CAAO,cAAA,CAAe,GAAG,CAAA;AAClD,EAAA,MAAM,oBAAA,GAAuB,MAAA,CAAO,mBAAA,CAAoB,gBAAgB,CAAA;AACxE,EAAA,MAAM,gBAAA,GAAmB,MAAA,CAAO,mBAAA,CAAoB,GAAG,CAAA;AACvD,EAAA,MAAM,YAAA,mBAAe,IAAI,GAAA,CAAa,CAAC,aAAa,CAAC,CAAA;AACrD,EAAA,MAAM,cAAqC,EAAC;AAE5C,EAAA,KAAA,MAAW,cAAc,CAAC,GAAG,gBAAA,EAAkB,GAAG,oBAAoB,CAAA,EAAG;AACvE,IAAA,IAAI,YAAA,CAAa,IAAI,UAAU,CAAA,IAAK,OAAO,GAAA,CAAI,UAAU,MAAM,UAAA,EAAY;AACzE,MAAA;AAAA,IACF;AAEA,IAAA,YAAA,CAAa,IAAI,UAAU,CAAA;AAC3B,IAAA,WAAA,CAAY,UAAoB,CAAA,GAAI,yBAAA,CAA0B,SAAA,EAAW,KAAK,UAAU,CAAA;AAAA,EAC1F;AAIA,EAAA,IAAI,SAAA,IAAa,GAAA,IAAO,GAAA,CAAI,OAAA,EAAS;AACnC,IAAA,MAAM,kBAAkB,GAAA,CAAI,OAAA;AAC5B,IAAA,MAAM,SAAA,GAAY,WAAA,IAAe,GAAA,IAAO,OAAO,GAAA,CAAI,SAAA,KAAc,UAAA,GAAa,GAAA,CAAI,SAAA,CAAU,IAAA,CAAK,GAAG,CAAA,GAAI,MAAA;AACxG,IAAA,IAAI,mBAAA;AACJ,IAAA,WAAA,CAAY,OAAA,GAAU;AAAA,MACpB,YAAA,EAAc,IAAA;AAAA,MACd,UAAA,EAAY,IAAA;AAAA,MACZ,KAAK,MAAM;AACT,QAAA,IAAI,CAAC,mBAAA,EAAqB;AACxB,UAAA,mBAAA,GAAsB,8BAAA,CAA+B,iBAAiB,SAAS,CAAA;AAAA,QACjF;AACA,QAAA,OAAO,mBAAA;AAAA,MACT;AAAA,KACF;AAGA,IAAA,WAAA,CAAY,eAAA,GAAkB;AAAA,MAC5B,YAAA,EAAc,IAAA;AAAA,MACd,UAAA,EAAY,KAAA;AAAA,MACZ,KAAK,MAAM;AAAA,KACb;AAAA,EACF;AAEA,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,GAAA,EAAK,WAAW,CAAA;AACvC;AAaA,SAAS,yBAAA,CACP,KAAA,EACA,GAAA,EACA,MAAA,EACoB;AACpB,EAAA,OAAO;AAAA,IACL,YAAA,EAAc,IAAA;AAAA,IACd,UAAA,EAAY,IAAA;AAAA,IACZ,KAAK,CAAA,QAAA,KAAY;AACf,MAAA,IAAI,OAAO,YAAY,UAAA,EAAY;AACjC,QAAA,KAAA,CAAM,GAAA,CAAI,QAAQ,QAAQ,CAAA;AAC1B,QAAA;AAAA,MACF;AACA,MAAA,OAAA,CAAQ,GAAA,CAAI,GAAA,EAAK,MAAA,EAAQ,QAAQ,CAAA;AAAA,IACnC,CAAA;AAAA,IAEA,KAAK,MAAM;AACT,MAAA,IAAI,MAAM,GAAA,CAAI,MAAM,GAAG,OAAO,KAAA,CAAM,IAAI,MAAM,CAAA;AAC9C,MAAA,MAAM,cAAA,GAAiB,OAAA,CAAQ,GAAA,CAAI,GAAA,EAAK,MAAM,CAAA;AAC9C,MAAA,IAAI,OAAO,cAAA,KAAmB,UAAA,EAAY,OAAO,cAAA;AAEjD,MAAA,OAAO,cAAA,CAAe,KAAK,GAAG,CAAA;AAAA,IAChC;AAAA,GACF;AACF;;;;"}

package/build/esm/prod/utils/internalSqlQuery.js

@@ -0,0 +1,23 @@
+import { stringMatchesSomePattern } from '@sentry/core';
+
+function targetsCloudflareInternalTable(querySummary, allowlist, queryText) {
+  if (!querySummary) {
+    return false;
+  }
+  const indexedTable = queryText ? CREATE_INDEX_TABLE_RE.exec(queryText)?.groups?.["table"] : void 0;
+  if (indexedTable) {
+    return isCloudflareInternalTable(indexedTable, allowlist);
+  }
+  const [, ...tables] = querySummary.split(" ");
+  return tables.some((table) => isCloudflareInternalTable(table, allowlist));
+}
+const CREATE_INDEX_TABLE_RE = /^\s*CREATE\s+(?:UNIQUE\s+)?INDEX(?:\s+IF\s+(?:NOT\s+)?EXISTS)?\s+[^\s(,;)]+\s+ON\s+(?<table>[^\s(,;)]+)/i;
+function isCloudflareInternalTable(table, allowlist) {
+  if (!table.toLowerCase().startsWith("cf_")) {
+    return false;
+  }
+  return !allowlist?.length || !stringMatchesSomePattern(table, allowlist, true);
+}
+
+export { targetsCloudflareInternalTable };
+//# sourceMappingURL=internalSqlQuery.js.map

package/build/esm/prod/utils/internalSqlQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalSqlQuery.js","sources":["../../../../src/utils/internalSqlQuery.ts"],"sourcesContent":["import { stringMatchesSomePattern } from '@sentry/core';\n\n/**\n * Cloudflare frameworks that build on Durable Objects (`agents`, `partyserver`, ...) manage their\n * own internal SQLite tables, all namespaced with a `cf_` prefix — e.g. `cf_agents_schedules`,\n * `cf_agent_state`, `cf_ai_chat_stream_chunks`. Queries against them (schedule polling, chat-stream\n * persistence, state bookkeeping) are framework implementation details that otherwise flood traces\n * with dozens of zero-signal `db.query` spans per request. The exact set of tables even varies\n * between framework versions, so we match the reserved prefix rather than an enumerated list.\n *\n * The `cf_` prefix is a reserved convention for framework-managed tables, so user tables should not\n * use it. In case a user table does collide with the prefix, the `durableObjectSqlSpanAllowlist`\n * option lets them opt those tables back into instrumentation.\n *\n * The check operates on the query summary produced by `getSqlQuerySummary` (`{operation} {table} ...`,\n * the same value used as the span name), so table targets are already isolated from the rest of the\n * query. The one exception is `CREATE INDEX`: its summary carries the index name, not the indexed\n * table (upstream OTel convention), so the `cf_` target only appears in the ON clause of the full\n * statement, which `queryText` is needed for.\n */\nexport function targetsCloudflareInternalTable(\n  querySummary: string | undefined,\n  allowlist?: Array<string | RegExp>,\n  queryText?: string,\n): boolean {\n  if (!querySummary) {\n    return false;\n  }\n\n  const indexedTable = queryText ? CREATE_INDEX_TABLE_RE.exec(queryText)?.groups?.['table'] : undefined;\n  if (indexedTable) {\n    return isCloudflareInternalTable(indexedTable, allowlist);\n  }\n\n  const [, ...tables] = querySummary.split(' ');\n\n  return tables.some(table => isCloudflareInternalTable(table, allowlist));\n}\n\n// `CREATE [UNIQUE] INDEX [IF NOT EXISTS] <name> ON <table>` — the IF EXISTS shape mirrors DDL_RE\n// in @sentry/core.\nconst CREATE_INDEX_TABLE_RE =\n  /^\\s*CREATE\\s+(?:UNIQUE\\s+)?INDEX(?:\\s+IF\\s+(?:NOT\\s+)?EXISTS)?\\s+[^\\s(,;)]+\\s+ON\\s+(?<table>[^\\s(,;)]+)/i;\n\nfunction isCloudflareInternalTable(table: string, allowlist?: Array<string | RegExp>): boolean {\n  if (!table.toLowerCase().startsWith('cf_')) {\n    return false;\n  }\n\n  // A table on the allowlist is treated as a user table and stays instrumented, even though it\n  // matches the reserved prefix.\n  return !allowlist?.length || !stringMatchesSomePattern(table, allowlist, true);\n}\n"],"names":[],"mappings":";;AAoBO,SAAS,8BAAA,CACd,YAAA,EACA,SAAA,EACA,SAAA,EACS;AACT,EAAA,IAAI,CAAC,YAAA,EAAc;AACjB,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,YAAA,GAAe,YAAY,qBAAA,CAAsB,IAAA,CAAK,SAAS,CAAA,EAAG,MAAA,GAAS,OAAO,CAAA,GAAI,MAAA;AAC5F,EAAA,IAAI,YAAA,EAAc;AAChB,IAAA,OAAO,yBAAA,CAA0B,cAAc,SAAS,CAAA;AAAA,EAC1D;AAEA,EAAA,MAAM,GAAG,GAAG,MAAM,CAAA,GAAI,YAAA,CAAa,MAAM,GAAG,CAAA;AAE5C,EAAA,OAAO,OAAO,IAAA,CAAK,CAAA,KAAA,KAAS,yBAAA,CAA0B,KAAA,EAAO,SAAS,CAAC,CAAA;AACzE;AAIA,MAAM,qBAAA,GACJ,0GAAA;AAEF,SAAS,yBAAA,CAA0B,OAAe,SAAA,EAA6C;AAC7F,EAAA,IAAI,CAAC,KAAA,CAAM,WAAA,EAAY,CAAE,UAAA,CAAW,KAAK,CAAA,EAAG;AAC1C,IAAA,OAAO,KAAA;AAAA,EACT;AAIA,EAAA,OAAO,CAAC,SAAA,EAAW,MAAA,IAAU,CAAC,wBAAA,CAAyB,KAAA,EAAO,WAAW,IAAI,CAAA;AAC/E;;;;"}

package/build/esm/prod/utils/internalStorageKey.js

@@ -0,0 +1,41 @@
+import { stringMatchesSomePattern } from '@sentry/core';
+
+function targetsCloudflareInternalKey(key, allowlist) {
+  if (!key) {
+    return false;
+  }
+  const isFrameworkKey = key.startsWith("cf_") || key.startsWith("cf:") || key.startsWith("__ps_") || key.startsWith("/");
+  if (!isFrameworkKey) {
+    return false;
+  }
+  return !allowlist?.length || !stringMatchesSomePattern(key, allowlist, true);
+}
+function getStorageKeys(methodName, args) {
+  const [first] = args;
+  if (methodName === "get" || methodName === "delete") {
+    if (typeof first === "string") {
+      return [first];
+    }
+    if (Array.isArray(first)) {
+      return first.filter((k) => typeof k === "string");
+    }
+    return void 0;
+  }
+  if (methodName === "put") {
+    if (typeof first === "string") {
+      return [first];
+    }
+    if (first && typeof first === "object" && !Array.isArray(first)) {
+      return Object.keys(first);
+    }
+    return void 0;
+  }
+  if (methodName === "list") {
+    const prefix = first && typeof first === "object" ? first.prefix : void 0;
+    return typeof prefix === "string" ? [prefix] : void 0;
+  }
+  return void 0;
+}
+
+export { getStorageKeys, targetsCloudflareInternalKey };
+//# sourceMappingURL=internalStorageKey.js.map

package/build/esm/prod/utils/internalStorageKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalStorageKey.js","sources":["../../../../src/utils/internalStorageKey.ts"],"sourcesContent":["import { stringMatchesSomePattern } from '@sentry/core';\n\n/**\n * Cloudflare frameworks that build on Durable Objects (`agents`, `partyserver`, ...) also manage\n * their own internal KV entries alongside their internal SQLite tables, namespaced with a reserved\n * prefix — e.g. `cf_agents_state`, `cf_agents_mcp_servers`, `__ps_name`. Reads/writes of these\n * (message persistence, MCP connection bookkeeping, name hydration) are framework implementation\n * details that otherwise flood traces with dozens of zero-signal `durable_object_storage_*` spans\n * per request, so we match the reserved prefixes rather than an enumerated list. This mirrors the\n * `cf_` convention used for internal SQL tables (see `targetsCloudflareInternalTable`).\n *\n * The prefixes are a reserved convention for framework-managed entries, so user keys should not use\n * them. In case a user key does collide, the `durableObjectStorageSpanAllowlist` option lets them\n * opt those keys back into instrumentation.\n */\nexport function targetsCloudflareInternalKey(key: string | undefined, allowlist?: Array<string | RegExp>): boolean {\n  if (!key) {\n    return false;\n  }\n\n  // Framework-managed KV namespaces:\n  // - `cf_`   — agents / ai-chat internal state (mirrors the internal SQL table convention)\n  // - `cf:`   — agents chat-recovery entries (`cf:chat-recovery:*`, `cf:chat:*`); the same reserved\n  //   `cf` namespace, but colon-separated instead of underscore-separated\n  // - `__ps_` — partyserver internals (e.g. `__ps_name`)\n  // - `/`     — MCP OAuth client state (`/<clientName>/<serverId>/{token,client_info,state,...}`),\n  //   read on every MCP tool call. User keys on an Agent rarely use a leading slash; if one does,\n  //   the allowlist opts it back in.\n  const isFrameworkKey =\n    key.startsWith('cf_') || key.startsWith('cf:') || key.startsWith('__ps_') || key.startsWith('/');\n  if (!isFrameworkKey) {\n    return false;\n  }\n\n  // A key on the allowlist is treated as a user key and stays instrumented, even though it matches\n  // a reserved prefix.\n  return !allowlist?.length || !stringMatchesSomePattern(key, allowlist, true);\n}\n\n/**\n * Extracts the KV keys a Durable Object storage call targets, so the caller can decide whether the\n * operation only touches framework-internal entries. Returns `undefined` when the keys can't be\n * determined from the arguments (e.g. `list()` without a prefix), in which case the call is treated\n * as user work and stays instrumented.\n */\nexport function getStorageKeys(methodName: string, args: unknown[]): string[] | undefined {\n  const [first] = args;\n\n  if (methodName === 'get' || methodName === 'delete') {\n    // get(key) / get(keys[]) / delete(key) / delete(keys[])\n    if (typeof first === 'string') {\n      return [first];\n    }\n    if (Array.isArray(first)) {\n      return first.filter((k): k is string => typeof k === 'string');\n    }\n    return undefined;\n  }\n\n  if (methodName === 'put') {\n    // put(key, value) or put({ key: value, ... })\n    if (typeof first === 'string') {\n      return [first];\n    }\n    if (first && typeof first === 'object' && !Array.isArray(first)) {\n      return Object.keys(first);\n    }\n    return undefined;\n  }\n\n  if (methodName === 'list') {\n    // list({ prefix })\n    const prefix = first && typeof first === 'object' ? (first as { prefix?: unknown }).prefix : undefined;\n    return typeof prefix === 'string' ? [prefix] : undefined;\n  }\n\n  return undefined;\n}\n"],"names":[],"mappings":";;AAeO,SAAS,4BAAA,CAA6B,KAAyB,SAAA,EAA6C;AACjH,EAAA,IAAI,CAAC,GAAA,EAAK;AACR,IAAA,OAAO,KAAA;AAAA,EACT;AAUA,EAAA,MAAM,cAAA,GACJ,GAAA,CAAI,UAAA,CAAW,KAAK,KAAK,GAAA,CAAI,UAAA,CAAW,KAAK,CAAA,IAAK,IAAI,UAAA,CAAW,OAAO,CAAA,IAAK,GAAA,CAAI,WAAW,GAAG,CAAA;AACjG,EAAA,IAAI,CAAC,cAAA,EAAgB;AACnB,IAAA,OAAO,KAAA;AAAA,EACT;AAIA,EAAA,OAAO,CAAC,SAAA,EAAW,MAAA,IAAU,CAAC,wBAAA,CAAyB,GAAA,EAAK,WAAW,IAAI,CAAA;AAC7E;AAQO,SAAS,cAAA,CAAe,YAAoB,IAAA,EAAuC;AACxF,EAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,EAAA,IAAI,UAAA,KAAe,KAAA,IAAS,UAAA,KAAe,QAAA,EAAU;AAEnD,IAAA,IAAI,OAAO,UAAU,QAAA,EAAU;AAC7B,MAAA,OAAO,CAAC,KAAK,CAAA;AAAA,IACf;AACA,IAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxB,MAAA,OAAO,MAAM,MAAA,CAAO,CAAC,CAAA,KAAmB,OAAO,MAAM,QAAQ,CAAA;AAAA,IAC/D;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,IAAI,eAAe,KAAA,EAAO;AAExB,IAAA,IAAI,OAAO,UAAU,QAAA,EAAU;AAC7B,MAAA,OAAO,CAAC,KAAK,CAAA;AAAA,IACf;AACA,IAAA,IAAI,KAAA,IAAS,OAAO,KAAA,KAAU,QAAA,IAAY,CAAC,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AAC/D,MAAA,OAAO,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,IAC1B;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,IAAI,eAAe,MAAA,EAAQ;AAEzB,IAAA,MAAM,SAAS,KAAA,IAAS,OAAO,KAAA,KAAU,QAAA,GAAY,MAA+B,MAAA,GAAS,MAAA;AAC7F,IAAA,OAAO,OAAO,MAAA,KAAW,QAAA,GAAW,CAAC,MAAM,CAAA,GAAI,MAAA;AAAA,EACjD;AAEA,EAAA,OAAO,MAAA;AACT;;;;"}

package/build/esm/prod/utils/invocationScope.js

@@ -0,0 +1,10 @@
+import { getIsolationScope, getDefaultIsolationScope, withIsolationScope } from '@sentry/core';
+
+function withInvocationIsolationScope(callback) {
+  const isolationScope = getIsolationScope();
+  const newIsolationScope = isolationScope === getDefaultIsolationScope() ? isolationScope.clone() : isolationScope;
+  return withIsolationScope(newIsolationScope, () => callback(newIsolationScope));
+}
+
+export { withInvocationIsolationScope };
+//# sourceMappingURL=invocationScope.js.map

package/build/esm/prod/utils/invocationScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocationScope.js","sources":["../../../../src/utils/invocationScope.ts"],"sourcesContent":["import { getDefaultIsolationScope, getIsolationScope, type Scope, withIsolationScope } from '@sentry/core';\n\n/**\n * Runs `callback` on the isolation scope for the current invocation.\n *\n * An instrumented handler is either the entry point of an invocation or reentrant — reached from\n * another instrumented handler already serving the same invocation (a Durable Object method calling\n * its own `fetch`, an RPC method reaching a sibling method). Only the entry point may fork:\n *\n * - Forking at the entry point is mandatory. `setUser`/`setTag` write to the isolation scope, and a\n *   Durable Object's isolation scope outlives the invocation that touched it, so without a fork one\n *   invocation's user and tags reappear on the next invocation's events in the same isolate.\n *   Forking clones, so request data set by an enclosing wrapper is still inherited.\n * - Forking again when reentrant would be wrong. Everything below the entry point is one logical\n *   unit of work: a nested call must see what the caller set and be able to add to it, the way it\n *   would if the SDK were not wrapping it at all.\n *\n * The AsyncLocalStorage strategy hands the default isolation scope back whenever no invocation is in\n * flight, and a forked one while inside `withIsolationScope`. Reference-comparing against the default\n * is therefore enough to tell the two cases apart. The stack fallback does not fork, so it reports the\n * default scope even inside an invocation; there the fork degrades to a no-op, which the stack strategy\n * tolerates. This matches the approach used by `patchEventHandler` in Nuxt.\n */\nexport function withInvocationIsolationScope<T>(callback: (scope: Scope) => T): T {\n  const isolationScope = getIsolationScope();\n\n  const newIsolationScope = isolationScope === getDefaultIsolationScope() ? isolationScope.clone() : isolationScope;\n\n  return withIsolationScope(newIsolationScope, () => callback(newIsolationScope));\n}\n"],"names":[],"mappings":";;AAuBO,SAAS,6BAAgC,QAAA,EAAkC;AAChF,EAAA,MAAM,iBAAiB,iBAAA,EAAkB;AAEzC,EAAA,MAAM,oBAAoB,cAAA,KAAmB,wBAAA,EAAyB,GAAI,cAAA,CAAe,OAAM,GAAI,cAAA;AAEnG,EAAA,OAAO,kBAAA,CAAmB,iBAAA,EAAmB,MAAM,QAAA,CAAS,iBAAiB,CAAC,CAAA;AAChF;;;;"}