@sentry/cloudflare 10.70.0 → 11.0.0-alpha.1

package/README.md

@@ -167,16 +167,12 @@ Sentry.captureEvent({
 
 ## Cloudflare D1 Instrumentation
 
-You can use the `instrumentD1WithSentry` method to instrument [Cloudflare D1](https://developers.cloudflare.com/d1/),
-Cloudflare's serverless SQL database with Sentry.
+`withSentry()` automatically instruments all [Cloudflare D1](https://developers.cloudflare.com/d1/) bindings on `env`,
+Cloudflare's serverless SQL database. Just use the binding as usual:
 
 ```javascript
-import * as Sentry from '@sentry/cloudflare';
-
 // env.DB is the D1 DB binding configured in your `wrangler.toml`
-const db = Sentry.instrumentD1WithSentry(env.DB);
-// Now you can use the database as usual
-await db.prepare('SELECT * FROM table WHERE id = ?').bind(1).run();
+await env.DB.prepare('SELECT * FROM table WHERE id = ?').bind(1).run();
 ```
 
 ## Cron Monitoring (Cloudflare Workers)

package/build/cjs/{sdk.js → dev/baseSdk.js}

@@ -3,9 +3,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const core = require('@sentry/core');
 const client = require('./client.js');
 const flush = require('./flush.js');
-const httpServer = require('./integrations/httpServer.js');
 const fetch = require('./integrations/fetch.js');
-const hono = require('./integrations/hono.js');
+const httpServer = require('./integrations/httpServer.js');
 const spotlight = require('./integrations/spotlight.js');
 const tracer = require('./opentelemetry/tracer.js');
 const transport = require('./transport.js');
@@ -15,23 +14,18 @@ function getRegisteredChannelIntegrations() {
   const registered = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.integrations;
   return registered ? [...registered.values()].map((factory) => factory()) : [];
 }
-function getDefaultIntegrations(options) {
-  const cookiesEnabled = options.sendDefaultPii || options.dataCollection?.cookies != null;
+function getBaseDefaultIntegrations(options) {
   return [
     // The Dedupe integration should not be used in workflows because we want to
     // capture all step failures, even if they are the same error.
     ...options.enableDedupe === false ? [] : [core.dedupeIntegration()],
-    // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
-    // eslint-disable-next-line typescript/no-deprecated
-    core.inboundFiltersIntegration(),
+    core.eventFiltersIntegration(),
     core.functionToStringIntegration(),
     core.conversationIdIntegration(),
     core.linkedErrorsIntegration(),
     fetch.fetchIntegration(),
-    // eslint-disable-next-line typescript/no-deprecated
-    hono.honoIntegration(),
     httpServer.httpServerIntegration(),
-    core.requestDataIntegration(cookiesEnabled ? void 0 : { include: { cookies: false } }),
+    core.requestDataIntegration(),
     core.consoleIntegration(),
     // The orchestrion diagnostics-channel subscribers (mysql, pg, …). The
     // `@sentry/cloudflare/vite` plugin injects the channels at build time and,
@@ -42,9 +36,9 @@ function getDefaultIntegrations(options) {
     ...getRegisteredChannelIntegrations()
   ];
 }
-function init(options) {
+function initWithDefaultIntegrations(options, getDefaultIntegrationsImpl) {
   if (options.defaultIntegrations === void 0) {
-    options.defaultIntegrations = getDefaultIntegrations(options);
+    options.defaultIntegrations = getDefaultIntegrationsImpl(options);
   }
   const flushLock = options.ctx ? flush.makeFlushLock(options.ctx) : void 0;
   delete options.ctx;
@@ -53,8 +47,12 @@ function init(options) {
     stackParser: core.stackParserFromStackParserOptions(options.stackParser || stacktrace.defaultStackParser),
     integrations: core.getIntegrationsToSetup(options),
     transport: options.transport || transport.makeCloudflareTransport,
+    // Like most Node-based SDKs, Cloudflare defaults to running without a Sentry OpenTelemetry tracer
+    // provider. Scope isolation is handled by the entrypoint wrappers' AsyncLocalStorage strategy.
+    enableOpenTelemetrySetup: options.enableOpenTelemetrySetup ?? false,
     flushLock
   };
+  /*! rollup-include-development-only */
   if (options.spotlight && !clientOptions.integrations.some(({ name }) => name === spotlight.INTEGRATION_NAME)) {
     clientOptions.integrations.push(
       spotlight.spotlightIntegration({
@@ -62,12 +60,24 @@ function init(options) {
       })
     );
   }
-  if (!options.skipOpenTelemetrySetup) {
+  /*! rollup-include-development-only-end */
+  if (clientOptions.enableOpenTelemetrySetup) {
     tracer.setupOpenTelemetryTracer();
   }
-  return core.initAndBind(client.CloudflareClient, clientOptions);
+  const client$1 = core.initAndBind(client.CloudflareClient, clientOptions);
+  client$1.on("orchestrion.module-injected", (moduleName) => {
+    const factory = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.integrations?.get(moduleName);
+    if (factory) {
+      client$1.addIntegration(factory());
+    }
+  });
+  return client$1;
+}
+function initBaseSdk(options) {
+  return initWithDefaultIntegrations(options, getBaseDefaultIntegrations);
 }
 
-exports.getDefaultIntegrations = getDefaultIntegrations;
-exports.init = init;
-//# sourceMappingURL=sdk.js.map
+exports.getBaseDefaultIntegrations = getBaseDefaultIntegrations;
+exports.initBaseSdk = initBaseSdk;
+exports.initWithDefaultIntegrations = initWithDefaultIntegrations;
+//# sourceMappingURL=baseSdk.js.map

package/build/cjs/dev/baseSdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseSdk.js","sources":["../../../src/baseSdk.ts"],"sourcesContent":["import type { Integration } from '@sentry/core';\nimport {\n  consoleIntegration,\n  conversationIdIntegration,\n  dedupeIntegration,\n  eventFiltersIntegration,\n  functionToStringIntegration,\n  getIntegrationsToSetup,\n  GLOBAL_OBJ,\n  initAndBind,\n  linkedErrorsIntegration,\n  requestDataIntegration,\n  stackParserFromStackParserOptions,\n} from '@sentry/core';\nimport type { CloudflareClientOptions, CloudflareOptions } from './client';\nimport { CloudflareClient } from './client';\nimport { makeFlushLock } from './flush';\nimport { fetchIntegration } from './integrations/fetch';\nimport { httpServerIntegration } from './integrations/httpServer';\nimport { INTEGRATION_NAME as SPOTLIGHT_INTEGRATION_NAME, spotlightIntegration } from './integrations/spotlight';\nimport { setupOpenTelemetryTracer } from './opentelemetry/tracer';\nimport { makeCloudflareTransport } from './transport';\nimport { defaultStackParser } from './vendor/stacktrace';\n\n/**\n * Instantiate the channel-subscriber factories the `@sentry/cloudflare/vite`\n * plugin registered on the global marker. The plugin splices a small snippet\n * into each instrumented module that `.set`s its factory here (keyed by module\n * name), so the marker holds one factory per package actually bundled.\n *\n * The marker is read directly instead of importing the factories, so a worker\n * built without the plugin — where the channels never fire — ships none of this\n * code.\n * TODO(v11): Use `@sentry/server-utils/orchestrion` once we move to `nodejs_compat` by default.\n */\nfunction getRegisteredChannelIntegrations(): Integration[] {\n  const registered = GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.integrations;\n\n  return registered ? [...registered.values()].map(factory => factory()) : [];\n}\n\n/**\n * Get the default integrations that run on any Workers-compatible runtime, i.e. without the\n * `nodejs_compat` compatibility flag.\n *\n * `getDefaultIntegrations` in `sdk.ts` extends this set with the integrations that do depend on\n * Node.js APIs. Keeping the two apart is what allows `wrapRequestHandler` to stay usable on runtimes\n * that cannot enable `nodejs_compat`, such as Shopify Oxygen.\n */\nexport function getBaseDefaultIntegrations(options: CloudflareOptions): Integration[] {\n  return [\n    // The Dedupe integration should not be used in workflows because we want to\n    // capture all step failures, even if they are the same error.\n    ...(options.enableDedupe === false ? [] : [dedupeIntegration()]),\n    eventFiltersIntegration(),\n    functionToStringIntegration(),\n    conversationIdIntegration(),\n    linkedErrorsIntegration(),\n    fetchIntegration(),\n    httpServerIntegration(),\n    requestDataIntegration(),\n    consoleIntegration(),\n    // The orchestrion diagnostics-channel subscribers (mysql, pg, …). The\n    // `@sentry/cloudflare/vite` plugin injects the channels at build time and,\n    // next to each, a snippet that registers the matching subscriber factory on\n    // the global marker. Read from there instead of importing them so bundles\n    // built without the plugin — where the channels would never fire — don't\n    // ship the code.\n    ...getRegisteredChannelIntegrations(),\n  ];\n}\n\n/**\n * Initializes the Cloudflare SDK with the passed default integrations.\n *\n * The default integrations are injected rather than imported so that this module stays free of\n * Node.js-only code. `request.ts` — which backs both `wrapRequestHandler` and the\n * `@sentry/cloudflare/request` entry point, and therefore has to work on runtimes without the\n * `nodejs_compat` compatibility flag — creates its client from here instead of from `sdk.ts`.\n */\nexport function initWithDefaultIntegrations(\n  options: CloudflareOptions,\n  getDefaultIntegrationsImpl: (options: CloudflareOptions) => Integration[],\n): CloudflareClient | undefined {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = getDefaultIntegrationsImpl(options);\n  }\n\n  const flushLock = options.ctx ? makeFlushLock(options.ctx) : undefined;\n  delete options.ctx;\n\n  const clientOptions: CloudflareClientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || makeCloudflareTransport,\n    // Like most Node-based SDKs, Cloudflare defaults to running without a Sentry OpenTelemetry tracer\n    // provider. Scope isolation is handled by the entrypoint wrappers' AsyncLocalStorage strategy.\n    enableOpenTelemetrySetup: options.enableOpenTelemetrySetup ?? false,\n    flushLock,\n  };\n\n  /*! rollup-include-development-only */\n  if (options.spotlight && !clientOptions.integrations.some(({ name }) => name === SPOTLIGHT_INTEGRATION_NAME)) {\n    clientOptions.integrations.push(\n      spotlightIntegration({\n        sidecarUrl: typeof options.spotlight === 'string' ? options.spotlight : undefined,\n      }),\n    );\n  }\n  /*! rollup-include-development-only-end */\n\n  // Opt-in only: when `enableOpenTelemetrySetup` is `true`, set up a custom trace provider so spans\n  // emitted via `@opentelemetry/api` are captured by Sentry. See the option's docs for the caveats.\n  if (clientOptions.enableOpenTelemetrySetup) {\n    setupOpenTelemetryTracer();\n  }\n\n  const client = initAndBind(CloudflareClient, clientOptions) as CloudflareClient;\n\n  // An instrumented module that first evaluates AFTER this init (e.g. a driver\n  // lazily required on first use) stores its subscriber factory on the global\n  // marker too late for the default-integrations snapshot above. Its injected\n  // snippet emits this event right after storing the factory, so install the\n  // integration on the live client here. `addIntegration` dedupes by\n  // integration name, so already-installed integrations are no-ops.\n  client.on('orchestrion.module-injected', moduleName => {\n    const factory = GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.integrations?.get(moduleName);\n    if (factory) {\n      client.addIntegration(factory());\n    }\n  });\n\n  return client;\n}\n\n/**\n * Initializes the Cloudflare SDK with only the default integrations from\n * {@link getBaseDefaultIntegrations}, i.e. those that work without the `nodejs_compat`\n * compatibility flag.\n */\nexport function initBaseSdk(options: CloudflareOptions): CloudflareClient | undefined {\n  return initWithDefaultIntegrations(options, getBaseDefaultIntegrations);\n}\n"],"names":["GLOBAL_OBJ","dedupeIntegration","eventFiltersIntegration","functionToStringIntegration","conversationIdIntegration","linkedErrorsIntegration","fetchIntegration","httpServerIntegration","requestDataIntegration","consoleIntegration","makeFlushLock","stackParserFromStackParserOptions","defaultStackParser","getIntegrationsToSetup","makeCloudflareTransport","SPOTLIGHT_INTEGRATION_NAME","spotlightIntegration","setupOpenTelemetryTracer","client","initAndBind","CloudflareClient"],"mappings":";;;;;;;;;;;;AAmCA,SAAS,gCAAA,GAAkD;AACzD,EAAA,MAAM,UAAA,GAAaA,gBAAW,sBAAA,EAAwB,YAAA;AAEtD,EAAA,OAAO,UAAA,GAAa,CAAC,GAAG,UAAA,CAAW,MAAA,EAAQ,CAAA,CAAE,GAAA,CAAI,CAAA,OAAA,KAAW,OAAA,EAAS,CAAA,GAAI,EAAC;AAC5E;AAUO,SAAS,2BAA2B,OAAA,EAA2C;AACpF,EAAA,OAAO;AAAA;AAAA;AAAA,IAGL,GAAI,QAAQ,YAAA,KAAiB,KAAA,GAAQ,EAAC,GAAI,CAACC,wBAAmB,CAAA;AAAA,IAC9DC,4BAAA,EAAwB;AAAA,IACxBC,gCAAA,EAA4B;AAAA,IAC5BC,8BAAA,EAA0B;AAAA,IAC1BC,4BAAA,EAAwB;AAAA,IACxBC,sBAAA,EAAiB;AAAA,IACjBC,gCAAA,EAAsB;AAAA,IACtBC,2BAAA,EAAuB;AAAA,IACvBC,uBAAA,EAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOnB,GAAG,gCAAA;AAAiC,GACtC;AACF;AAUO,SAAS,2BAAA,CACd,SACA,0BAAA,EAC8B;AAC9B,EAAA,IAAI,OAAA,CAAQ,wBAAwB,MAAA,EAAW;AAC7C,IAAA,OAAA,CAAQ,mBAAA,GAAsB,2BAA2B,OAAO,CAAA;AAAA,EAClE;AAEA,EAAA,MAAM,YAAY,OAAA,CAAQ,GAAA,GAAMC,mBAAA,CAAc,OAAA,CAAQ,GAAG,CAAA,GAAI,MAAA;AAC7D,EAAA,OAAO,OAAA,CAAQ,GAAA;AAEf,EAAA,MAAM,aAAA,GAAyC;AAAA,IAC7C,GAAG,OAAA;AAAA,IACH,WAAA,EAAaC,sCAAA,CAAkC,OAAA,CAAQ,WAAA,IAAeC,6BAAkB,CAAA;AAAA,IACxF,YAAA,EAAcC,4BAAuB,OAAO,CAAA;AAAA,IAC5C,SAAA,EAAW,QAAQ,SAAA,IAAaC,iCAAA;AAAA;AAAA;AAAA,IAGhC,wBAAA,EAA0B,QAAQ,wBAAA,IAA4B,KAAA;AAAA,IAC9D;AAAA,GACF;AAAA;AAGA,EAAA,IAAI,OAAA,CAAQ,SAAA,IAAa,CAAC,aAAA,CAAc,YAAA,CAAa,IAAA,CAAK,CAAC,EAAE,IAAA,EAAK,KAAM,IAAA,KAASC,0BAA0B,CAAA,EAAG;AAC5G,IAAA,aAAA,CAAc,YAAA,CAAa,IAAA;AAAA,MACzBC,8BAAA,CAAqB;AAAA,QACnB,YAAY,OAAO,OAAA,CAAQ,SAAA,KAAc,QAAA,GAAW,QAAQ,SAAA,GAAY;AAAA,OACzE;AAAA,KACH;AAAA,EACF;AAAA;AAKA,EAAA,IAAI,cAAc,wBAAA,EAA0B;AAC1C,IAAAC,+BAAA,EAAyB;AAAA,EAC3B;AAEA,EAAA,MAAMC,QAAA,GAASC,gBAAA,CAAYC,uBAAA,EAAkB,aAAa,CAAA;AAQ1D,EAAAF,QAAA,CAAO,EAAA,CAAG,+BAA+B,CAAA,UAAA,KAAc;AACrD,IAAA,MAAM,OAAA,GAAUlB,eAAA,CAAW,sBAAA,EAAwB,YAAA,EAAc,IAAI,UAAU,CAAA;AAC/E,IAAA,IAAI,OAAA,EAAS;AACX,MAAAkB,QAAA,CAAO,cAAA,CAAe,SAAS,CAAA;AAAA,IACjC;AAAA,EACF,CAAC,CAAA;AAED,EAAA,OAAOA,QAAA;AACT;AAOO,SAAS,YAAY,OAAA,EAA0D;AACpF,EAAA,OAAO,2BAAA,CAA4B,SAAS,0BAA0B,CAAA;AACxE;;;;;;"}

package/build/cjs/dev/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sources":["../../../src/client.ts"],"sourcesContent":["import type { ClientOptions, Options, ServerRuntimeClientOptions } from '@sentry/core';\nimport {\n  _INTERNAL_clearAiProviderSkips,\n  applySdkMetadata,\n  debug,\n  ServerRuntimeClient,\n  spanIsSampled,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { ExecutionContextCompat } from './executionContext';\nimport type { makeFlushLock } from './flush';\nimport type { CloudflareTransportOptions } from './transport';\n\n/**\n * The Sentry Cloudflare SDK Client.\n *\n * @see CloudflareClientOptions for documentation on configuration options.\n * @see ServerRuntimeClient for usage documentation.\n */\nexport class CloudflareClient extends ServerRuntimeClient {\n  private readonly _flushLock: ReturnType<typeof makeFlushLock> | void;\n  private _pendingSpans: Set<string> = new Set();\n  private _spanCompletionPromise: Promise<void> | null = null;\n  private _resolveSpanCompletion: (() => void) | null = null;\n\n  private _unsubscribeSpanStart: (() => void) | null = null;\n  private _unsubscribeSpanEnd: (() => void) | null = null;\n\n  /**\n   * Creates a new Cloudflare SDK instance.\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: CloudflareClientOptions) {\n    applySdkMetadata(options, 'cloudflare');\n    options._metadata = options._metadata || {};\n    const { flushLock, ...serverOptions } = options;\n\n    const clientOptions: ServerRuntimeClientOptions = {\n      ...serverOptions,\n      platform: 'javascript',\n      // TODO: Grab version information\n      runtime: { name: 'cloudflare' },\n      // TODO: Add server name\n      _flushInterval: 0,\n    };\n\n    super(clientOptions);\n    this._flushLock = flushLock;\n\n    // Track span lifecycle to know when to flush\n    this._unsubscribeSpanStart = this.on('spanStart', span => {\n      const spanId = span.spanContext().spanId;\n      DEBUG_BUILD && debug.log('[CloudflareClient] Span started:', spanId);\n\n      // Negatively sampled spans never emit spanEnd,\n      // so tracking them would cause _pendingSpans to grow unboundedly.\n      // We should fix the inconsistent behavior for NonRecordingSpans in the future but\n      // for now, we just ignore them.\n      if (!spanIsSampled(span)) {\n        return;\n      }\n\n      this._pendingSpans.add(spanId);\n\n      if (!this._spanCompletionPromise) {\n        this._spanCompletionPromise = new Promise(resolve => {\n          this._resolveSpanCompletion = resolve;\n        });\n      }\n    });\n\n    this._unsubscribeSpanEnd = this.on('spanEnd', span => {\n      const spanId = span.spanContext().spanId;\n      DEBUG_BUILD && debug.log('[CloudflareClient] Span ended:', spanId);\n      this._pendingSpans.delete(spanId);\n\n      // If no more pending spans, resolve the completion promise\n      if (this._pendingSpans.size === 0 && this._resolveSpanCompletion) {\n        DEBUG_BUILD && debug.log('[CloudflareClient] All spans completed, resolving promise');\n        this._resolveSpanCompletion();\n        this._resetSpanCompletionPromise();\n      }\n    });\n  }\n\n  /**\n   * Flushes pending operations and ensures all data is processed.\n   * If a timeout is provided, the operation will be completed within the specified time limit.\n   *\n   * It will wait for all pending spans to complete before flushing.\n   *\n   * @param {number} [timeout] - Optional timeout in milliseconds to force the completion of the flush operation.\n   * @return {Promise<boolean>} A promise that resolves to a boolean indicating whether the flush operation was successful.\n   */\n  public async flush(timeout?: number): Promise<boolean> {\n    if (this._flushLock) {\n      await this._flushLock.finalize();\n    }\n\n    if (this._pendingSpans.size > 0 && this._spanCompletionPromise) {\n      DEBUG_BUILD &&\n        debug.log('[CloudflareClient] Waiting for', this._pendingSpans.size, 'pending spans to complete...');\n\n      const timeoutMs = timeout ?? 5000;\n      const spanCompletionRace = Promise.race([\n        this._spanCompletionPromise,\n        new Promise(resolve =>\n          setTimeout(() => {\n            DEBUG_BUILD &&\n              debug.log('[CloudflareClient] Span completion timeout after', timeoutMs, 'ms, flushing anyway');\n            resolve(undefined);\n          }, timeoutMs),\n        ),\n      ]);\n\n      await spanCompletionRace;\n    }\n\n    return super.flush(timeout);\n  }\n\n  /**\n   * Disposes of the client and releases all resources.\n   *\n   * This method clears all Cloudflare-specific state in addition to the base client cleanup.\n   * It unsubscribes from span lifecycle events and clears pending span tracking.\n   *\n   * Call this method after flushing to allow the client to be garbage collected.\n   * After calling dispose(), the client should not be used anymore.\n   */\n  public override dispose(): void {\n    DEBUG_BUILD && debug.log('[CloudflareClient] Disposing client...');\n\n    super.dispose();\n\n    if (this._unsubscribeSpanStart) {\n      this._unsubscribeSpanStart();\n      this._unsubscribeSpanStart = null;\n    }\n    if (this._unsubscribeSpanEnd) {\n      this._unsubscribeSpanEnd();\n      this._unsubscribeSpanEnd = null;\n    }\n\n    this._resetSpanCompletionPromise();\n    (this as unknown as { _flushLock: ReturnType<typeof makeFlushLock> | void })._flushLock = undefined;\n  }\n\n  /** @inheritDoc */\n  protected override _setupIntegrations(): void {\n    // Clear AI provider skip registrations before setting up integrations.\n    // The registry is module-global and Cloudflare calls `init()` per request, so without this a\n    // single `ai` SDK call would suppress direct `env.AI.run` spans for the rest of the isolate's\n    // life. Mirrors the same reset in the Node client.\n    _INTERNAL_clearAiProviderSkips();\n    super._setupIntegrations();\n  }\n\n  /**\n   * Resets the span completion promise and resolve function.\n   */\n  private _resetSpanCompletionPromise(): void {\n    this._pendingSpans.clear();\n    this._spanCompletionPromise = null;\n    this._resolveSpanCompletion = null;\n  }\n}\n\ninterface BaseCloudflareOptions {\n  /**\n   * @ignore Used internally to disable the deDupeIntegration for workflows.\n   * @hidden Used internally to disable the deDupeIntegration for workflows.\n   * @default true\n   */\n  enableDedupe?: boolean;\n\n  /**\n   * The Cloudflare SDK is not OpenTelemetry native. By default (`false`) it does not set up a tracer\n   * provider; spans are emitted via the SDK's own instrumentation and scopes are isolated with\n   * AsyncLocalStorage.\n   *\n   * Set this to `true` to opt into the OpenTelemetry compatibility tracer, which captures spans\n   * emitted via `@opentelemetry/api`. Big caveat: it does not handle custom context, always working\n   * off the current scope. This is good enough for many, but not all, integrations.\n   *\n   * @default false\n   */\n  enableOpenTelemetrySetup?: boolean;\n\n  /**\n   * Enable trace propagation for RPC calls between Workers, Durable Objects, and Service Bindings.\n   *\n   * When enabled, trace context (sentry-trace + baggage) is propagated across:\n   * - `stub.fetch()` calls to Durable Objects (via HTTP headers)\n   * - Service binding `fetch()` calls (via HTTP headers)\n   * - RPC method calls to Durable Objects and WorkerEntrypoints (via trailing argument)\n   *\n   * When enabled on the **receiver side** (DurableObject or WorkerEntrypoint), the SDK will also:\n   * - Extract and continue traces from incoming RPC calls\n   * - Create spans for each RPC method invocation\n   * - Capture errors thrown by RPC methods\n   *\n   * **Important:** This option is enabled by default. Set it to `false` to opt out, e.g. if you\n   * do not want trace context to leave your Worker via RPC calls.\n   *\n   * @default true\n   * @example\n   * ```ts\n   * // Opt out of RPC trace propagation\n   * export default Sentry.withSentry(\n   *   (env) => ({\n   *     dsn: env.SENTRY_DSN,\n   *     enableRpcTracePropagation: false,\n   *   }),\n   *   handler,\n   * );\n   * ```\n   */\n  enableRpcTracePropagation?: boolean;\n\n  /**\n   * Table names that should stay instrumented even though they match the reserved `cf_` prefix used\n   * by Durable Object frameworks (`agents`, `partyserver`, ...) for their internal SQLite tables.\n   *\n   * By default, `exec` queries against `cf_`-prefixed tables are treated as framework noise and no\n   * `db.query` span is created for them. If one of your own tables happens to use this prefix, add it\n   * here to opt it back into instrumentation. Entries are matched against each table name in the\n   * query summary — strings must match exactly, while regular expressions give you prefix/pattern\n   * matching.\n   *\n   * @default []\n   * @example\n   * ```ts\n   * export default Sentry.withSentry(\n   *   (env) => ({\n   *     dsn: env.SENTRY_DSN,\n   *     durableObjectSqlSpanAllowlist: ['cf_my_table', /^cf_reports_/],\n   *   }),\n   *   handler,\n   * );\n   * ```\n   */\n  durableObjectSqlSpanAllowlist?: Array<string | RegExp>;\n\n  /**\n   * KV keys that should stay instrumented even though they match a reserved prefix used by Durable\n   * Object frameworks (`agents`, `partyserver`, ...) for their internal storage entries.\n   *\n   * By default, KV reads/writes (`get`, `put`, `delete`, `list`) of `cf_`- or `__ps_`-prefixed keys\n   * are treated as framework noise and no `durable_object_storage_*` span is created for them,\n   * mirroring how `cf_`-prefixed SQL tables are handled (see {@link durableObjectSqlSpanAllowlist}).\n   * If one of your own keys happens to use such a prefix, add it here to opt it back into\n   * instrumentation. Strings must match exactly, while regular expressions give you prefix/pattern\n   * matching.\n   *\n   * @default []\n   * @example\n   * ```ts\n   * export default Sentry.withSentry(\n   *   (env) => ({\n   *     dsn: env.SENTRY_DSN,\n   *     durableObjectStorageSpanAllowlist: ['cf_my_key', /^cf_reports_/],\n   *   }),\n   *   handler,\n   * );\n   * ```\n   */\n  durableObjectStorageSpanAllowlist?: Array<string | RegExp>;\n\n  /**\n   * If you use Spotlight by Sentry during development, use\n   * this option to forward captured Sentry events to Spotlight.\n   *\n   * Either set it to true, or provide a specific Spotlight Sidecar URL.\n   *\n   * More details: https://spotlightjs.com/\n   *\n   * IMPORTANT: Only set this option to `true` while developing, not in production!\n   */\n  spotlight?: boolean | string;\n}\n\n/**\n * Configuration options for the Sentry Cloudflare SDK\n *\n * @see @sentry/core Options for more information.\n */\nexport interface CloudflareOptions extends Options<CloudflareTransportOptions>, BaseCloudflareOptions {\n  ctx?: ExecutionContextCompat;\n}\n\n/**\n * Configuration options for the Sentry Cloudflare SDK Client class\n *\n * @see CloudflareClient for more information.\n */\nexport interface CloudflareClientOptions extends ClientOptions<CloudflareTransportOptions>, BaseCloudflareOptions {\n  flushLock?: ReturnType<typeof makeFlushLock>;\n}\n"],"names":["ServerRuntimeClient","applySdkMetadata","DEBUG_BUILD","debug","spanIsSampled","_INTERNAL_clearAiProviderSkips"],"mappings":"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"}

package/build/cjs/dev/debug-build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-build.js","sources":["../../../src/debug-build.ts"],"sourcesContent":["declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n"],"names":[],"mappings":";;AAOO,MAAM,WAAA,IAAc,OAAA,gBAAA,KAAA,WAAA,IAAA,gBAAA;;;;"}

package/build/cjs/dev/defineCloudflareOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineCloudflareOptions.js","sources":["../../../src/defineCloudflareOptions.ts"],"sourcesContent":["import type { CloudflareOptions } from './client';\nimport type { DefaultEnv } from './types';\n\n/**\n * Define the Sentry options for a Cloudflare Worker in a dedicated module.\n *\n * This is the recommended way to configure the SDK when using the Vite plugin's\n * auto-instrumentation: place an `instrument.server.{ts,js,mjs}` file next to\n * the worker entry whose **default export** is the result of this function. The\n * plugin picks it up automatically and hands it to `withSentry`.\n *\n * Unlike Node's `Sentry.init(...)`, the options cannot be applied at module\n * load time on Cloudflare: the DSN and other settings typically come from the\n * per-request `env`, which only exists inside the handler. Pass a callback to\n * read from `env`, or a static object when no `env` access is needed — either\n * way you get full type-checking and autocomplete on {@link CloudflareOptions}.\n *\n * At runtime this is a thin pass-through; it only normalizes a static object\n * into a callback so the plugin always imports a `(env) => options` function.\n *\n * @example\n * ```ts\n * // src/instrument.server.ts\n * import { defineCloudflareOptions } from '@sentry/cloudflare';\n *\n * export default defineCloudflareOptions((env) => ({\n *   dsn: env.SENTRY_DSN,\n *   tracesSampleRate: 1.0,\n * }));\n * ```\n *\n * @example\n * ```ts\n * // Static options — no `env` access needed\n * export default defineCloudflareOptions({ tracesSampleRate: 1.0 });\n * ```\n */\nexport function defineCloudflareOptions<Env = DefaultEnv>(\n  optionsOrCallback: CloudflareOptions | ((env: Env) => CloudflareOptions | undefined),\n): (env: Env) => CloudflareOptions | undefined {\n  if (typeof optionsOrCallback === 'function') {\n    return optionsOrCallback;\n  }\n\n  return () => optionsOrCallback;\n}\n"],"names":[],"mappings":";;AAqCO,SAAS,wBACd,iBAAA,EAC6C;AAC7C,EAAA,IAAI,OAAO,sBAAsB,UAAA,EAAY;AAC3C,IAAA,OAAO,iBAAA;AAAA,EACT;AAEA,EAAA,OAAO,MAAM,iBAAA;AACf;;;;"}

package/build/cjs/{durableobject.js → dev/durableobject.js}

@@ -1,19 +1,19 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const core = require('@sentry/core');
-const async = require('./async.js');
+const noDiagnosticChannels = require('@sentry/server-utils/no-diagnostic-channels');
 const instrument = require('./instrument.js');
 const instrumentEnv = require('./instrumentations/worker/instrumentEnv.js');
 const options = require('./options.js');
 const request = require('./request.js');
+const sdk = require('./sdk.js');
 const instrumentContext = require('./utils/instrumentContext.js');
 const rpcMeta = require('./utils/rpcMeta.js');
-const rpcOptions = require('./utils/rpcOptions.js');
 const index = require('./instrumentations/agents/index.js');
 const wrapMethodWithSentry = require('./wrapMethodWithSentry.js');
 
 function constructInstrumentedDurableObject(target, ctx, env, newTarget, optionsCallback) {
-  async.setAsyncLocalStorageAsyncContextStrategy();
+  noDiagnosticChannels.setAsyncLocalStorageAsyncContextStrategy();
   const options$1 = options.getFinalOptions(optionsCallback(env), env);
   const context = instrumentContext.instrumentContext(ctx);
   const instrumentedEnv = instrumentEnv.instrumentEnv(env, options$1);
@@ -67,9 +67,13 @@ function instrumentDurableObjectHandlers(obj, options, context) {
       obj.fetch.bind(obj),
       (original) => new Proxy(original, {
         apply(target, thisArg, args) {
-          return request.wrapRequestHandler({ options, request: args[0], context }, () => {
-            return Reflect.apply(target, thisArg, args);
-          });
+          return request.wrapRequestHandlerWithInit(
+            { options, request: args[0], context },
+            () => {
+              return Reflect.apply(target, thisArg, args);
+            },
+            sdk.init
+          );
         }
       })
     );
@@ -124,21 +128,15 @@ const RESERVED_RPC_METHOD_NAMES = /* @__PURE__ */ new Set([
 ]);
 const rpcInstanceStates = /* @__PURE__ */ new WeakMap();
 function finalizeWithRpcInstrumentation(obj, options, context, excludedMethods) {
-  const rpcPropagation = rpcOptions.getEffectiveRpcPropagation(options);
-  if (!rpcPropagation) {
+  if (options.enableRpcTracePropagation === false) {
     return obj;
   }
-  const allowedMethods = Array.isArray(options.instrumentPrototypeMethods) ? (
-    // eslint-disable-next-line typescript/no-deprecated
-    new Set(options.instrumentPrototypeMethods)
-  ) : void 0;
-  const alwaysTrace = options.enableRpcTracePropagation === void 0;
-  rpcInstanceStates.set(obj, { options, context, alwaysTrace });
-  instrumentPrototypeRpcMethods(obj, excludedMethods, allowedMethods);
+  rpcInstanceStates.set(obj, { options, context });
+  instrumentPrototypeRpcMethods(obj, excludedMethods);
   return obj;
 }
-function getRpcMethodDescriptor(obj, prototype, methodName, excludedMethods, allowedMethods) {
-  if (RESERVED_RPC_METHOD_NAMES.has(methodName) || Object.prototype.hasOwnProperty.call(obj, methodName) || excludedMethods?.has(methodName) || allowedMethods && !allowedMethods.has(methodName)) {
+function getRpcMethodDescriptor(obj, prototype, methodName, excludedMethods) {
+  if (RESERVED_RPC_METHOD_NAMES.has(methodName) || Object.prototype.hasOwnProperty.call(obj, methodName) || excludedMethods?.has(methodName)) {
     return void 0;
   }
   const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
@@ -147,11 +145,11 @@ function getRpcMethodDescriptor(obj, prototype, methodName, excludedMethods, all
   }
   return descriptor;
 }
-function instrumentPrototypeRpcMethods(obj, excludedMethods, allowedMethods) {
+function instrumentPrototypeRpcMethods(obj, excludedMethods) {
   let prototype = Object.getPrototypeOf(obj);
   while (prototype && prototype !== Object.prototype) {
     for (const methodName of Object.getOwnPropertyNames(prototype)) {
-      const descriptor = getRpcMethodDescriptor(obj, prototype, methodName, excludedMethods, allowedMethods);
+      const descriptor = getRpcMethodDescriptor(obj, prototype, methodName, excludedMethods);
       if (!descriptor) {
         continue;
       }
@@ -167,8 +165,11 @@ function instrumentPrototypeRpcMethods(obj, excludedMethods, allowedMethods) {
 }
 function createRpcPrototypeWrapper(methodName, originalMethod) {
   const wrapper = function(...args) {
+    if (!rpcMeta.hasRpcMeta(args)) {
+      return Reflect.apply(originalMethod, this, args);
+    }
     const state = core.isObjectLike(this) ? rpcInstanceStates.get(this) : void 0;
-    if (!state || !state.alwaysTrace && !rpcMeta.hasRpcMeta(args)) {
+    if (!state) {
       return Reflect.apply(originalMethod, this, args);
     }
     const tracedMethods = state.tracedMethods ?? (state.tracedMethods = /* @__PURE__ */ new Map());

package/build/cjs/dev/durableobject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durableobject.js","sources":["../../../src/durableobject.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/unbound-method */\nimport { captureException, isObjectLike } from '@sentry/core';\nimport type { DurableObject } from 'cloudflare:workers';\nimport { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';\nimport type { CloudflareOptions } from './client';\nimport { ensureInstrumented, getInstrumented, markAsInstrumented } from './instrument';\nimport { instrumentEnv } from './instrumentations/worker/instrumentEnv';\nimport { getFinalOptions } from './options';\nimport { wrapRequestHandlerWithInit } from './request';\nimport { init } from './sdk';\nimport { instrumentContext } from './utils/instrumentContext';\nimport { hasRpcMeta } from './utils/rpcMeta';\nimport { instrumentCloudflareAgent } from './instrumentations/agents';\nimport type { DefaultEnv, ResolveEnv } from './types';\nimport { type UncheckedMethod, wrapMethodWithSentry } from './wrapMethodWithSentry';\n\n/**\n * The instrumented context passed between the shared construction helpers.\n *\n * This is intentionally `any` rather than `ReturnType<typeof instrumentContext<DurableObjectState>>`.\n * A concrete `DurableObjectState` here forces `tsc` to structurally relate its `storage: SqlStorage`\n * graph against the `ExecutionContext | InstrumentedDurableObjectState` parameter of\n * `wrapMethodWithSentry`, while the RPC-branded `DurableObject` from `cloudflare:workers` is also in\n * scope. That union comparison explodes (1296×1296) and hangs the type build. The original inline\n * implementation avoided this only incidentally, because `ctx` reached it as `any` through the Proxy\n * `construct` trap. Keeping the shared context `any` preserves that behavior.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype InstrumentedDurableObjectContext = any;\n\n/**\n * Constructs a Durable Object instance and instruments its built-in handler methods\n * (`fetch`, `alarm`, `webSocketMessage`, `webSocketClose`, `webSocketError`).\n *\n * This is the shared construction path used by both {@link instrumentDurableObjectWithSentry}\n * and {@link instrumentAgentWithSentry}. It intentionally does NOT apply the RPC prototype-method\n * instrumentation — callers apply that last via {@link finalizeWithRpcInstrumentation}, after any\n * additional per-instance instrumentation has been layered onto the returned object.\n *\n * @internal\n */\nexport function constructInstrumentedDurableObject<E, T extends DurableObject<E>>(\n  target: new (state: DurableObjectState, env: E) => T,\n  ctx: DurableObjectState,\n  env: E,\n  newTarget: NewableFunction,\n  optionsCallback: (env: E) => CloudflareOptions,\n): {\n  obj: T;\n  options: CloudflareOptions;\n  context: InstrumentedDurableObjectContext;\n  frameworkManagedMethods: ReadonlySet<string>;\n} {\n  setAsyncLocalStorageAsyncContextStrategy();\n  const options = getFinalOptions(optionsCallback(env), env);\n  // See InstrumentedDurableObjectContext — `ctx` is widened to `any` so the concrete\n  // `DurableObjectState` type never enters the checker's relation graph in this module.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const context = instrumentContext(ctx as any);\n  const instrumentedEnv = instrumentEnv(env as Record<string, unknown>, options);\n\n  const prototype = (newTarget as unknown as { prototype?: object }).prototype ?? target.prototype;\n  const cachedFrameworkManagedMethods = frameworkManagedMethodsCache.get(prototype);\n  const methodsBeforeConstruction = cachedFrameworkManagedMethods ? undefined : resolvePrototypeMethods(prototype);\n\n  // Pass `newTarget` so that subclasses of the instrumented class (e.g. the wrapper classes\n  // created by wrangler's local dev tooling or `@cloudflare/vitest-pool-workers`) keep their\n  // own prototype — otherwise subclass methods disappear and `instanceof` checks break.\n  const obj = Reflect.construct(target, [context, instrumentedEnv], newTarget) as T;\n\n  const frameworkManagedMethods = resolveFrameworkManagedMethods(\n    prototype,\n    obj,\n    methodsBeforeConstruction,\n    cachedFrameworkManagedMethods,\n  );\n\n  instrumentDurableObjectHandlers(obj, options, context);\n\n  return { obj, options, context, frameworkManagedMethods };\n}\n\nconst frameworkManagedMethodsCache = new WeakMap<object, ReadonlySet<string>>();\n\n/**\n * Collects the methods visible from a prototype, using normal property lookup precedence.\n * Methods inherited from `Object.prototype` are excluded because they cannot be Durable Object RPC methods.\n */\nfunction resolvePrototypeMethods(prototype: object | null): Map<string, unknown> {\n  const methods = new Map<string, unknown>();\n\n  for (let current = prototype; current && current !== Object.prototype; current = Object.getPrototypeOf(current)) {\n    for (const name of Object.getOwnPropertyNames(current)) {\n      // The first occurrence wins, mirroring what a property lookup on the instance would find\n      if (name === 'constructor' || methods.has(name)) {\n        continue;\n      }\n\n      const descriptor = Object.getOwnPropertyDescriptor(current, name);\n\n      if (descriptor && typeof descriptor.value === 'function') {\n        methods.set(name, descriptor.value);\n      }\n    }\n  }\n\n  return methods;\n}\n\n/**\n * Finds methods that a framework replaced while constructing the first instance.\n *\n * Some frameworks register methods by function identity, so replacing one of their wrappers would\n * break dispatch. The result is cached because frameworks commonly install their wrappers only\n * once; later constructions would no longer reveal which methods they manage.\n */\nfunction resolveFrameworkManagedMethods(\n  prototype: object,\n  obj: object,\n  methodsBeforeConstruction: Map<string, unknown> | undefined,\n  cached: ReadonlySet<string> | undefined,\n): ReadonlySet<string> {\n  if (cached) {\n    return cached;\n  }\n\n  const methodsAfterConstruction = resolvePrototypeMethods(Object.getPrototypeOf(obj) as object);\n  const managed = new Set<string>();\n\n  for (const [name, method] of methodsAfterConstruction) {\n    const before = methodsBeforeConstruction?.get(name);\n\n    if (before && before !== method) {\n      managed.add(name);\n    }\n  }\n\n  frameworkManagedMethodsCache.set(prototype, managed);\n\n  return managed;\n}\n\n/**\n * Instruments the built-in Durable Object handler methods on a constructed instance.\n *\n * These are the methods that are available on a Durable Object\n * ref: https://developers.cloudflare.com/durable-objects/api/base/\n * - obj.alarm\n * - obj.fetch\n * - obj.webSocketError\n * - obj.webSocketClose\n * - obj.webSocketMessage\n *\n * Any other public methods on the Durable Object instance are RPC calls.\n */\nfunction instrumentDurableObjectHandlers<E, T extends DurableObject<E>>(\n  obj: T,\n  options: CloudflareOptions,\n  context: InstrumentedDurableObjectContext,\n): void {\n  // Bind each built-in handler to this instance before wrapping.\n  // See https://github.com/getsentry/sentry-javascript/issues/22328\n  if (obj.fetch && typeof obj.fetch === 'function') {\n    obj.fetch = ensureInstrumented(\n      obj.fetch.bind(obj),\n      original =>\n        new Proxy(original, {\n          apply(target, thisArg, args) {\n            return wrapRequestHandlerWithInit(\n              { options, request: args[0], context },\n              () => {\n                return Reflect.apply(target, thisArg, args);\n              },\n              init,\n            );\n          },\n        }),\n    );\n  }\n\n  if (obj.alarm && typeof obj.alarm === 'function') {\n    // Alarms are independent invocations, so we start a new trace and link to the previous alarm\n    obj.alarm = wrapMethodWithSentry(\n      {\n        options,\n        context,\n        spanName: 'alarm',\n        spanOp: 'function',\n        startNewTrace: true,\n        origin: 'auto.faas.cloudflare.durable_object',\n      },\n      obj.alarm.bind(obj),\n    );\n  }\n\n  if (obj.webSocketMessage && typeof obj.webSocketMessage === 'function') {\n    obj.webSocketMessage = wrapMethodWithSentry(\n      { options, context, spanName: 'webSocketMessage', origin: 'auto.faas.cloudflare.durable_object' },\n      obj.webSocketMessage.bind(obj),\n    );\n  }\n\n  if (obj.webSocketClose && typeof obj.webSocketClose === 'function') {\n    obj.webSocketClose = wrapMethodWithSentry(\n      { options, context, spanName: 'webSocketClose', origin: 'auto.faas.cloudflare.durable_object' },\n      obj.webSocketClose.bind(obj),\n    );\n  }\n\n  if (obj.webSocketError && typeof obj.webSocketError === 'function') {\n    obj.webSocketError = wrapMethodWithSentry(\n      { options, context, spanName: 'webSocketError', origin: 'auto.faas.cloudflare.durable_object' },\n      obj.webSocketError.bind(obj),\n      (_, error) =>\n        captureException(error, {\n          mechanism: {\n            type: 'auto.faas.cloudflare.durable_object_websocket',\n            handled: false,\n          },\n        }),\n    );\n  }\n}\n\ntype RpcInstanceState = {\n  options: CloudflareOptions;\n  context: InstrumentedDurableObjectContext;\n  /** Per-instance cache of the traced method wrappers, keyed by method name. Created on first use. */\n  tracedMethods?: Map<string, UncheckedMethod>;\n};\n\n/**\n * Method names the runtime never dispatches over RPC, so wrapping them buys no tracing.\n *\n * Mirrors `isReservedName` in workerd (`src/workerd/api/worker-rpc.c++`): the runtime rejects these\n * before any property lookup happens. `fetch`, `alarm` and the `webSocket*` handlers are also\n * instrumented per-instance as own properties, and `constructor` is on every prototype.\n */\nconst RESERVED_RPC_METHOD_NAMES: ReadonlySet<string> = new Set([\n  'constructor',\n  'fetch',\n  'connect',\n  'alarm',\n  'webSocketMessage',\n  'webSocketClose',\n  'webSocketError',\n  'dup',\n]);\n\n// Prototype wrappers are shared by all instances, while SDK options and traced method caches are not.\nconst rpcInstanceStates = new WeakMap<object, RpcInstanceState>();\n\n/**\n * Adds trace propagation to a constructed Durable Object's RPC methods.\n *\n * RPC methods are wrapped on the prototype because Cloudflare dispatches them with the Durable\n * Object instance as the receiver. This preserves native private-field access and keeps the methods\n * visible to Cloudflare's RPC dispatcher. Built-in handlers, Agent handlers, and methods managed by\n * another framework are left untouched.\n *\n * Call this after all per-instance instrumentation has been applied. If RPC trace propagation is\n * disabled, the object is returned unchanged.\n *\n * @param obj The constructed Durable Object instance.\n * @param options The resolved SDK options for this instance.\n * @param context The instrumented execution context for this instance.\n * @param excludedMethods Method names owned by another framework and therefore not safe to wrap.\n * @returns The same Durable Object instance, with eligible prototype methods instrumented.\n * @internal\n */\nexport function finalizeWithRpcInstrumentation<T extends object>(\n  obj: T,\n  options: CloudflareOptions,\n  context: InstrumentedDurableObjectContext,\n  excludedMethods?: ReadonlySet<string>,\n): T {\n  // Skip RPC instrumentation only when explicitly opted out (enabled by default)\n  if (options.enableRpcTracePropagation === false) {\n    return obj;\n  }\n\n  rpcInstanceStates.set(obj, { options, context });\n\n  instrumentPrototypeRpcMethods(obj, excludedMethods);\n\n  return obj;\n}\n\n/**\n * Returns a prototype method when it is eligible for RPC instrumentation.\n */\nfunction getRpcMethodDescriptor(\n  obj: object,\n  prototype: object,\n  methodName: string,\n  excludedMethods?: ReadonlySet<string>,\n): PropertyDescriptor | undefined {\n  if (\n    RESERVED_RPC_METHOD_NAMES.has(methodName) ||\n    Object.prototype.hasOwnProperty.call(obj, methodName) ||\n    excludedMethods?.has(methodName)\n  ) {\n    return undefined;\n  }\n\n  const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);\n\n  if (!descriptor || typeof descriptor.value !== 'function' || getInstrumented(descriptor.value)) {\n    return undefined;\n  }\n\n  return descriptor;\n}\n\n/**\n * Wraps eligible methods on the instance's prototype chain once per class.\n */\nfunction instrumentPrototypeRpcMethods(obj: object, excludedMethods?: ReadonlySet<string>): void {\n  let prototype: object | null = Object.getPrototypeOf(obj);\n\n  while (prototype && prototype !== Object.prototype) {\n    for (const methodName of Object.getOwnPropertyNames(prototype)) {\n      const descriptor = getRpcMethodDescriptor(obj, prototype, methodName, excludedMethods);\n\n      if (!descriptor) {\n        continue;\n      }\n\n      const wrapped = createRpcPrototypeWrapper(methodName, descriptor.value as UncheckedMethod);\n\n      try {\n        Object.defineProperty(prototype, methodName, { ...descriptor, value: wrapped });\n      } catch {}\n\n      // Only the wrapper is marked, not the original method: `wrapMethodWithSentry` resolves\n      // through the same global map and must not resolve the original to this wrapper,\n      // which would recurse.\n      markAsInstrumented(wrapped);\n    }\n\n    prototype = Object.getPrototypeOf(prototype);\n  }\n}\n\n/**\n * Creates a prototype wrapper that traces RPC calls carrying Sentry metadata.\n *\n * The wrapper looks up SDK state from its receiver, allowing one prototype function to serve every\n * instance. Calls without RPC metadata or instance state use the original method directly. The\n * original function name and arity are preserved because frameworks may inspect them for dispatch.\n */\nfunction createRpcPrototypeWrapper(methodName: string, originalMethod: UncheckedMethod): UncheckedMethod {\n  const wrapper = function (this: unknown, ...args: unknown[]): unknown {\n    // Untraced calls are the common case — every internal call the instance makes to one of its\n    // own methods lands here too — so check the arguments before touching per-instance state.\n    if (!hasRpcMeta(args)) {\n      return Reflect.apply(originalMethod, this, args);\n    }\n\n    const state = isObjectLike(this) ? rpcInstanceStates.get(this) : undefined;\n\n    if (!state) {\n      return Reflect.apply(originalMethod, this, args);\n    }\n\n    const tracedMethods = (state.tracedMethods ??= new Map());\n    let traced = tracedMethods.get(methodName);\n\n    if (!traced) {\n      traced = wrapMethodWithSentry(\n        {\n          options: state.options,\n          context: state.context,\n          spanName: methodName,\n          spanOp: 'rpc',\n          origin: 'auto.faas.cloudflare.durable_object',\n        },\n        originalMethod,\n        undefined,\n        true,\n      );\n      tracedMethods.set(methodName, traced);\n    }\n\n    return Reflect.apply(traced, this, args);\n  };\n\n  Object.defineProperties(wrapper, {\n    name: { value: originalMethod.name, configurable: true },\n    length: { value: originalMethod.length, configurable: true },\n  });\n\n  return wrapper as UncheckedMethod;\n}\n\n/**\n * Instruments a Durable Object class to capture errors and performance data.\n *\n * Instruments the following methods by default:\n * - fetch\n * - alarm\n * - webSocketMessage\n * - webSocketClose\n * - webSocketError\n *\n * RPC methods (prototype methods) are instrumented by default. Set `enableRpcTracePropagation`\n * to `false` to opt out.\n *\n * @param optionsCallback Function that returns the options for the SDK initialization.\n * @param DurableObjectClass The Durable Object class to instrument.\n * @returns The instrumented Durable Object class.\n *\n * @example\n * ```ts\n * class MyDurableObjectBase extends DurableObject {\n *   constructor(ctx: DurableObjectState, env: Env) {\n *     super(ctx, env);\n *   }\n * }\n *\n * export const MyDurableObject = instrumentDurableObjectWithSentry(\n *   env => ({\n *     dsn: env.SENTRY_DSN,\n *     tracesSampleRate: 1.0,\n *   }),\n *   MyDurableObjectBase,\n * );\n * ```\n */\nexport function instrumentDurableObjectWithSentry<\n  Env = DefaultEnv,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  T extends DurableObject<any> = DurableObject<Env>,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  C extends new (state: DurableObjectState, env: any) => T = new (state: DurableObjectState, env: any) => T,\n>(optionsCallback: (env: ResolveEnv<C, Env>) => CloudflareOptions, DurableObjectClass: C): C {\n  return new Proxy(DurableObjectClass, {\n    construct(target, [ctx, env], newTarget) {\n      const { obj, options, context, frameworkManagedMethods } = constructInstrumentedDurableObject(\n        target,\n        ctx,\n        env,\n        newTarget,\n        optionsCallback,\n      );\n\n      return finalizeWithRpcInstrumentation(obj, options, context, frameworkManagedMethods);\n    },\n  });\n}\n\n/**\n * Instruments a Cloudflare [`agents`](https://www.npmjs.com/package/agents) Agent class with Sentry.\n *\n * An `Agent` is a Durable Object under the hood, so this applies the same instrumentation as\n * {@link instrumentDurableObjectWithSentry} (request transactions, `alarm`, WebSocket handlers, RPC\n * trace propagation, SQL spans) and additionally captures Agent-specific telemetry via\n * `instrumentCloudflareAgent`:\n *\n * - **Callable RPC spans** — a span (op `rpc`) for each `@callable()` method invoked over WebSocket.\n * - **Breadcrumbs** — for every Agent observability event (`rpc`, `state:update`, `connect`,\n *   `disconnect`, `schedule:*`, `queue:*`, `workflow:*`, `email:*`, `mcp:*`, ...).\n *\n * Cloudflare Workers cannot auto-instrument, so the Agent class must be wrapped manually.\n *\n * @param optionsCallback Function that returns the options for the SDK initialization.\n * @param AgentClass The Agent class to instrument.\n * @returns The instrumented Agent class.\n *\n * @example\n * ```ts\n * import { Agent, callable, routeAgentRequest } from 'agents';\n * import * as Sentry from '@sentry/cloudflare';\n *\n * class MyAgentBase extends Agent<Env> {\n *   @callable()\n *   async greet(name: string): Promise<string> {\n *     return `Hello, ${name}!`;\n *   }\n * }\n *\n * export const MyAgent = Sentry.instrumentAgentWithSentry(\n *   env => ({\n *     dsn: env.SENTRY_DSN,\n *     tracesSampleRate: 1.0,\n *   }),\n *   MyAgentBase,\n * );\n * ```\n */\nexport function instrumentAgentWithSentry<\n  Env = DefaultEnv,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  T extends DurableObject<any> = DurableObject<Env>,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  C extends new (state: DurableObjectState, env: any) => T = new (state: DurableObjectState, env: any) => T,\n>(optionsCallback: (env: ResolveEnv<C, Env>) => CloudflareOptions, AgentClass: C): C {\n  return new Proxy(AgentClass, {\n    construct(target, [ctx, env], newTarget) {\n      const { obj, options, context, frameworkManagedMethods } = constructInstrumentedDurableObject(\n        target,\n        ctx,\n        env,\n        newTarget,\n        optionsCallback,\n      );\n\n      instrumentCloudflareAgent(obj);\n\n      // Apply RPC prototype-method instrumentation last, so the Agent-specific own-property\n      // handlers we just installed are excluded from RPC method tracing. Methods the Agent\n      // framework installed itself are excluded too — `instrumentCloudflareAgent` traces those by\n      // wrapping the dispatch instead of the method.\n      return finalizeWithRpcInstrumentation(obj, options, context, frameworkManagedMethods);\n    },\n  });\n}\n"],"names":["setAsyncLocalStorageAsyncContextStrategy","options","getFinalOptions","instrumentContext","instrumentEnv","ensureInstrumented","wrapRequestHandlerWithInit","init","wrapMethodWithSentry","captureException","getInstrumented","markAsInstrumented","hasRpcMeta","isObjectLike","instrumentCloudflareAgent"],"mappings":";;;;;;;;;;;;;;AAyCO,SAAS,kCAAA,CACd,MAAA,EACA,GAAA,EACA,GAAA,EACA,WACA,eAAA,EAMA;AACA,EAAAA,6DAAA,EAAyC;AACzC,EAAA,MAAMC,SAAA,GAAUC,uBAAA,CAAgB,eAAA,CAAgB,GAAG,GAAG,GAAG,CAAA;AAIzD,EAAA,MAAM,OAAA,GAAUC,oCAAkB,GAAU,CAAA;AAC5C,EAAA,MAAM,eAAA,GAAkBC,2BAAA,CAAc,GAAA,EAAgCH,SAAO,CAAA;AAE7E,EAAA,MAAM,SAAA,GAAa,SAAA,CAAgD,SAAA,IAAa,MAAA,CAAO,SAAA;AACvF,EAAA,MAAM,6BAAA,GAAgC,4BAAA,CAA6B,GAAA,CAAI,SAAS,CAAA;AAChF,EAAA,MAAM,yBAAA,GAA4B,6BAAA,GAAgC,MAAA,GAAY,uBAAA,CAAwB,SAAS,CAAA;AAK/G,EAAA,MAAM,GAAA,GAAM,QAAQ,SAAA,CAAU,MAAA,EAAQ,CAAC,OAAA,EAAS,eAAe,GAAG,SAAS,CAAA;AAE3E,EAAA,MAAM,uBAAA,GAA0B,8BAAA;AAAA,IAC9B,SAAA;AAAA,IACA,GAAA;AAAA,IACA,yBAAA;AAAA,IACA;AAAA,GACF;AAEA,EAAA,+BAAA,CAAgC,GAAA,EAAKA,WAAS,OAAO,CAAA;AAErD,EAAA,OAAO,EAAE,GAAA,WAAKA,SAAA,EAAS,OAAA,EAAS,uBAAA,EAAwB;AAC1D;AAEA,MAAM,4BAAA,uBAAmC,OAAA,EAAqC;AAM9E,SAAS,wBAAwB,SAAA,EAAgD;AAC/E,EAAA,MAAM,OAAA,uBAAc,GAAA,EAAqB;AAEzC,EAAA,KAAA,IAAS,OAAA,GAAU,SAAA,EAAW,OAAA,IAAW,OAAA,KAAY,MAAA,CAAO,WAAW,OAAA,GAAU,MAAA,CAAO,cAAA,CAAe,OAAO,CAAA,EAAG;AAC/G,IAAA,KAAA,MAAW,IAAA,IAAQ,MAAA,CAAO,mBAAA,CAAoB,OAAO,CAAA,EAAG;AAEtD,MAAA,IAAI,IAAA,KAAS,aAAA,IAAiB,OAAA,CAAQ,GAAA,CAAI,IAAI,CAAA,EAAG;AAC/C,QAAA;AAAA,MACF;AAEA,MAAA,MAAM,UAAA,GAAa,MAAA,CAAO,wBAAA,CAAyB,OAAA,EAAS,IAAI,CAAA;AAEhE,MAAA,IAAI,UAAA,IAAc,OAAO,UAAA,CAAW,KAAA,KAAU,UAAA,EAAY;AACxD,QAAA,OAAA,CAAQ,GAAA,CAAI,IAAA,EAAM,UAAA,CAAW,KAAK,CAAA;AAAA,MACpC;AAAA,IACF;AAAA,EACF;AAEA,EAAA,OAAO,OAAA;AACT;AASA,SAAS,8BAAA,CACP,SAAA,EACA,GAAA,EACA,yBAAA,EACA,MAAA,EACqB;AACrB,EAAA,IAAI,MAAA,EAAQ;AACV,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,MAAM,wBAAA,GAA2B,uBAAA,CAAwB,MAAA,CAAO,cAAA,CAAe,GAAG,CAAW,CAAA;AAC7F,EAAA,MAAM,OAAA,uBAAc,GAAA,EAAY;AAEhC,EAAA,KAAA,MAAW,CAAC,IAAA,EAAM,MAAM,CAAA,IAAK,wBAAA,EAA0B;AACrD,IAAA,MAAM,MAAA,GAAS,yBAAA,EAA2B,GAAA,CAAI,IAAI,CAAA;AAElD,IAAA,IAAI,MAAA,IAAU,WAAW,MAAA,EAAQ;AAC/B,MAAA,OAAA,CAAQ,IAAI,IAAI,CAAA;AAAA,IAClB;AAAA,EACF;AAEA,EAAA,4BAAA,CAA6B,GAAA,CAAI,WAAW,OAAO,CAAA;AAEnD,EAAA,OAAO,OAAA;AACT;AAeA,SAAS,+BAAA,CACP,GAAA,EACA,OAAA,EACA,OAAA,EACM;AAGN,EAAA,IAAI,GAAA,CAAI,KAAA,IAAS,OAAO,GAAA,CAAI,UAAU,UAAA,EAAY;AAChD,IAAA,GAAA,CAAI,KAAA,GAAQI,6BAAA;AAAA,MACV,GAAA,CAAI,KAAA,CAAM,IAAA,CAAK,GAAG,CAAA;AAAA,MAClB,CAAA,QAAA,KACE,IAAI,KAAA,CAAM,QAAA,EAAU;AAAA,QAClB,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,IAAA,EAAM;AAC3B,UAAA,OAAOC,kCAAA;AAAA,YACL,EAAE,OAAA,EAAS,OAAA,EAAS,IAAA,CAAK,CAAC,GAAG,OAAA,EAAQ;AAAA,YACrC,MAAM;AACJ,cAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,IAAI,CAAA;AAAA,YAC5C,CAAA;AAAA,YACAC;AAAA,WACF;AAAA,QACF;AAAA,OACD;AAAA,KACL;AAAA,EACF;AAEA,EAAA,IAAI,GAAA,CAAI,KAAA,IAAS,OAAO,GAAA,CAAI,UAAU,UAAA,EAAY;AAEhD,IAAA,GAAA,CAAI,KAAA,GAAQC,yCAAA;AAAA,MACV;AAAA,QACE,OAAA;AAAA,QACA,OAAA;AAAA,QACA,QAAA,EAAU,OAAA;AAAA,QACV,MAAA,EAAQ,UAAA;AAAA,QACR,aAAA,EAAe,IAAA;AAAA,QACf,MAAA,EAAQ;AAAA,OACV;AAAA,MACA,GAAA,CAAI,KAAA,CAAM,IAAA,CAAK,GAAG;AAAA,KACpB;AAAA,EACF;AAEA,EAAA,IAAI,GAAA,CAAI,gBAAA,IAAoB,OAAO,GAAA,CAAI,qBAAqB,UAAA,EAAY;AACtE,IAAA,GAAA,CAAI,gBAAA,GAAmBA,yCAAA;AAAA,MACrB,EAAE,OAAA,EAAS,OAAA,EAAS,QAAA,EAAU,kBAAA,EAAoB,QAAQ,qCAAA,EAAsC;AAAA,MAChG,GAAA,CAAI,gBAAA,CAAiB,IAAA,CAAK,GAAG;AAAA,KAC/B;AAAA,EACF;AAEA,EAAA,IAAI,GAAA,CAAI,cAAA,IAAkB,OAAO,GAAA,CAAI,mBAAmB,UAAA,EAAY;AAClE,IAAA,GAAA,CAAI,cAAA,GAAiBA,yCAAA;AAAA,MACnB,EAAE,OAAA,EAAS,OAAA,EAAS,QAAA,EAAU,gBAAA,EAAkB,QAAQ,qCAAA,EAAsC;AAAA,MAC9F,GAAA,CAAI,cAAA,CAAe,IAAA,CAAK,GAAG;AAAA,KAC7B;AAAA,EACF;AAEA,EAAA,IAAI,GAAA,CAAI,cAAA,IAAkB,OAAO,GAAA,CAAI,mBAAmB,UAAA,EAAY;AAClE,IAAA,GAAA,CAAI,cAAA,GAAiBA,yCAAA;AAAA,MACnB,EAAE,OAAA,EAAS,OAAA,EAAS,QAAA,EAAU,gBAAA,EAAkB,QAAQ,qCAAA,EAAsC;AAAA,MAC9F,GAAA,CAAI,cAAA,CAAe,IAAA,CAAK,GAAG,CAAA;AAAA,MAC3B,CAAC,CAAA,EAAG,KAAA,KACFC,qBAAA,CAAiB,KAAA,EAAO;AAAA,QACtB,SAAA,EAAW;AAAA,UACT,IAAA,EAAM,+CAAA;AAAA,UACN,OAAA,EAAS;AAAA;AACX,OACD;AAAA,KACL;AAAA,EACF;AACF;AAgBA,MAAM,yBAAA,uBAAqD,GAAA,CAAI;AAAA,EAC7D,aAAA;AAAA,EACA,OAAA;AAAA,EACA,SAAA;AAAA,EACA,OAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,gBAAA;AAAA,EACA;AACF,CAAC,CAAA;AAGD,MAAM,iBAAA,uBAAwB,OAAA,EAAkC;AAoBzD,SAAS,8BAAA,CACd,GAAA,EACA,OAAA,EACA,OAAA,EACA,eAAA,EACG;AAEH,EAAA,IAAI,OAAA,CAAQ,8BAA8B,KAAA,EAAO;AAC/C,IAAA,OAAO,GAAA;AAAA,EACT;AAEA,EAAA,iBAAA,CAAkB,GAAA,CAAI,GAAA,EAAK,EAAE,OAAA,EAAS,SAAS,CAAA;AAE/C,EAAA,6BAAA,CAA8B,KAAK,eAAe,CAAA;AAElD,EAAA,OAAO,GAAA;AACT;AAKA,SAAS,sBAAA,CACP,GAAA,EACA,SAAA,EACA,UAAA,EACA,eAAA,EACgC;AAChC,EAAA,IACE,yBAAA,CAA0B,GAAA,CAAI,UAAU,CAAA,IACxC,OAAO,SAAA,CAAU,cAAA,CAAe,IAAA,CAAK,GAAA,EAAK,UAAU,CAAA,IACpD,eAAA,EAAiB,GAAA,CAAI,UAAU,CAAA,EAC/B;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,MAAM,UAAA,GAAa,MAAA,CAAO,wBAAA,CAAyB,SAAA,EAAW,UAAU,CAAA;AAExE,EAAA,IAAI,CAAC,cAAc,OAAO,UAAA,CAAW,UAAU,UAAA,IAAcC,0BAAA,CAAgB,UAAA,CAAW,KAAK,CAAA,EAAG;AAC9F,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,OAAO,UAAA;AACT;AAKA,SAAS,6BAAA,CAA8B,KAAa,eAAA,EAA6C;AAC/F,EAAA,IAAI,SAAA,GAA2B,MAAA,CAAO,cAAA,CAAe,GAAG,CAAA;AAExD,EAAA,OAAO,SAAA,IAAa,SAAA,KAAc,MAAA,CAAO,SAAA,EAAW;AAClD,IAAA,KAAA,MAAW,UAAA,IAAc,MAAA,CAAO,mBAAA,CAAoB,SAAS,CAAA,EAAG;AAC9D,MAAA,MAAM,UAAA,GAAa,sBAAA,CAAuB,GAAA,EAAK,SAAA,EAAW,YAAY,eAAe,CAAA;AAErF,MAAA,IAAI,CAAC,UAAA,EAAY;AACf,QAAA;AAAA,MACF;AAEA,MAAA,MAAM,OAAA,GAAU,yBAAA,CAA0B,UAAA,EAAY,UAAA,CAAW,KAAwB,CAAA;AAEzF,MAAA,IAAI;AACF,QAAA,MAAA,CAAO,cAAA,CAAe,WAAW,UAAA,EAAY,EAAE,GAAG,UAAA,EAAY,KAAA,EAAO,SAAS,CAAA;AAAA,MAChF,CAAA,CAAA,MAAQ;AAAA,MAAC;AAKT,MAAAC,6BAAA,CAAmB,OAAO,CAAA;AAAA,IAC5B;AAEA,IAAA,SAAA,GAAY,MAAA,CAAO,eAAe,SAAS,CAAA;AAAA,EAC7C;AACF;AASA,SAAS,yBAAA,CAA0B,YAAoB,cAAA,EAAkD;AACvG,EAAA,MAAM,OAAA,GAAU,YAA4B,IAAA,EAA0B;AAGpE,IAAA,IAAI,CAACC,kBAAA,CAAW,IAAI,CAAA,EAAG;AACrB,MAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,cAAA,EAAgB,IAAA,EAAM,IAAI,CAAA;AAAA,IACjD;AAEA,IAAA,MAAM,QAAQC,iBAAA,CAAa,IAAI,IAAI,iBAAA,CAAkB,GAAA,CAAI,IAAI,CAAA,GAAI,MAAA;AAEjE,IAAA,IAAI,CAAC,KAAA,EAAO;AACV,MAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,cAAA,EAAgB,IAAA,EAAM,IAAI,CAAA;AAAA,IACjD;AAEA,IAAA,MAAM,gBAAiB,KAAA,CAAM,aAAA,KAAN,KAAA,CAAM,aAAA,uBAAsB,GAAA,EAAI,CAAA;AACvD,IAAA,IAAI,MAAA,GAAS,aAAA,CAAc,GAAA,CAAI,UAAU,CAAA;AAEzC,IAAA,IAAI,CAAC,MAAA,EAAQ;AACX,MAAA,MAAA,GAASL,yCAAA;AAAA,QACP;AAAA,UACE,SAAS,KAAA,CAAM,OAAA;AAAA,UACf,SAAS,KAAA,CAAM,OAAA;AAAA,UACf,QAAA,EAAU,UAAA;AAAA,UACV,MAAA,EAAQ,KAAA;AAAA,UACR,MAAA,EAAQ;AAAA,SACV;AAAA,QACA,cAAA;AAAA,QACA,KAAA,CAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,aAAA,CAAc,GAAA,CAAI,YAAY,MAAM,CAAA;AAAA,IACtC;AAEA,IAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,MAAA,EAAQ,IAAA,EAAM,IAAI,CAAA;AAAA,EACzC,CAAA;AAEA,EAAA,MAAA,CAAO,iBAAiB,OAAA,EAAS;AAAA,IAC/B,MAAM,EAAE,KAAA,EAAO,cAAA,CAAe,IAAA,EAAM,cAAc,IAAA,EAAK;AAAA,IACvD,QAAQ,EAAE,KAAA,EAAO,cAAA,CAAe,MAAA,EAAQ,cAAc,IAAA;AAAK,GAC5D,CAAA;AAED,EAAA,OAAO,OAAA;AACT;AAoCO,SAAS,iCAAA,CAMd,iBAAiE,kBAAA,EAA0B;AAC3F,EAAA,OAAO,IAAI,MAAM,kBAAA,EAAoB;AAAA,IACnC,UAAU,MAAA,EAAQ,CAAC,GAAA,EAAK,GAAG,GAAG,SAAA,EAAW;AACvC,MAAA,MAAM,EAAE,GAAA,EAAK,OAAA,EAAS,OAAA,EAAS,yBAAwB,GAAI,kCAAA;AAAA,QACzD,MAAA;AAAA,QACA,GAAA;AAAA,QACA,GAAA;AAAA,QACA,SAAA;AAAA,QACA;AAAA,OACF;AAEA,MAAA,OAAO,8BAAA,CAA+B,GAAA,EAAK,OAAA,EAAS,OAAA,EAAS,uBAAuB,CAAA;AAAA,IACtF;AAAA,GACD,CAAA;AACH;AAyCO,SAAS,yBAAA,CAMd,iBAAiE,UAAA,EAAkB;AACnF,EAAA,OAAO,IAAI,MAAM,UAAA,EAAY;AAAA,IAC3B,UAAU,MAAA,EAAQ,CAAC,GAAA,EAAK,GAAG,GAAG,SAAA,EAAW;AACvC,MAAA,MAAM,EAAE,GAAA,EAAK,OAAA,EAAS,OAAA,EAAS,yBAAwB,GAAI,kCAAA;AAAA,QACzD,MAAA;AAAA,QACA,GAAA;AAAA,QACA,GAAA;AAAA,QACA,SAAA;AAAA,QACA;AAAA,OACF;AAEA,MAAAM,+BAAA,CAA0B,GAAG,CAAA;AAM7B,MAAA,OAAO,8BAAA,CAA+B,GAAA,EAAK,OAAA,EAAS,OAAA,EAAS,uBAAuB,CAAA;AAAA,IACtF;AAAA,GACD,CAAA;AACH;;;;;;;"}

package/build/cjs/dev/flush.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flush.js","sources":["../../../src/flush.ts"],"sourcesContent":["import type { ExecutionContext } from '@cloudflare/workers-types';\nimport type { Client } from '@sentry/core';\nimport { debug, flush } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { ExecutionContextCompat } from './executionContext';\n\ntype FlushLock = {\n  readonly ready: Promise<void>;\n  readonly finalize: () => Promise<void>;\n};\n\ntype FlushLockRegistry = {\n  readonly locks: Set<FlushLockInternal>;\n  readonly originalWaitUntil: ExecutionContext['waitUntil'];\n};\n\ntype FlushLockInternal = FlushLock & {\n  readonly acquire: () => void;\n  readonly release: () => void;\n};\n\nconst flushLockRegistries = new WeakMap<ExecutionContext['waitUntil'], FlushLockRegistry>();\n\n/**\n * Returns the original (un-instrumented) waitUntil function for a context.\n * This should be used when calling waitUntil with flushAndDispose to avoid deadlock.\n *\n * The flush lock mechanism wraps context.waitUntil to track pending tasks.\n * If we call waitUntil(flushAndDispose(client)) through the instrumented version,\n * it creates a deadlock because:\n * 1. The instrumented waitUntil acquires the flush lock\n * 2. flushAndDispose calls client.flush() which waits for the lock to be released\n * 3. The lock won't be released until the waitUntil promise completes\n * 4. The waitUntil promise won't complete until flush() returns\n *\n * By using the original waitUntil for flush operations, we bypass this issue.\n */\nexport function getOriginalWaitUntil(context: ExecutionContextCompat): ExecutionContext['waitUntil'] {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  const currentWaitUntil = context.waitUntil;\n  const original = flushLockRegistries.get(currentWaitUntil)?.originalWaitUntil;\n  return original ?? currentWaitUntil;\n}\n\n/**\n * Enhances the given execution context by wrapping its `waitUntil` method with a proxy\n * to monitor pending tasks, and provides a flusher function to ensure all tasks\n * have been completed before executing any subsequent logic.\n *\n * @param {ExecutionContext} context - The execution context to be enhanced. If no context is provided, the function returns undefined.\n * @return {FlushLock} Returns a flusher function if a valid context is provided, otherwise undefined.\n */\nexport function makeFlushLock(context: ExecutionContextCompat): FlushLock {\n  const registry = getOrCreateFlushLockRegistry(context);\n  let resolveAllDone: () => void = () => undefined;\n  const allDone = new Promise<void>(res => {\n    resolveAllDone = res;\n  });\n  let pending = 0;\n\n  const lock: FlushLockInternal = {\n    ready: allDone,\n    acquire: () => {\n      pending++;\n    },\n    release: () => {\n      if (--pending === 0) {\n        registry.locks.delete(lock);\n        resolveAllDone();\n      }\n    },\n    finalize: () => {\n      if (pending === 0) {\n        registry.locks.delete(lock);\n        resolveAllDone();\n      }\n      return allDone;\n    },\n  };\n\n  registry.locks.add(lock);\n  return Object.freeze(lock);\n}\n\nfunction getOrCreateFlushLockRegistry(context: ExecutionContextCompat): FlushLockRegistry {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  const waitUntil = context.waitUntil;\n  const existingRegistry = flushLockRegistries.get(waitUntil);\n\n  if (existingRegistry) {\n    return existingRegistry;\n  }\n\n  const originalWaitUntil = context.waitUntil.bind(context) as typeof context.waitUntil;\n  const registry: FlushLockRegistry = { locks: new Set(), originalWaitUntil };\n  const instrumentedWaitUntil: typeof context.waitUntil = promise => {\n    // Snapshot active locks so locks created after this call do not wait for earlier waitUntil work.\n    const locks = [...registry.locks];\n\n    for (const lock of locks) {\n      lock.acquire();\n    }\n\n    return originalWaitUntil(\n      promise.finally(() => {\n        for (const lock of locks) {\n          lock.release();\n        }\n      }),\n    );\n  };\n\n  flushLockRegistries.set(instrumentedWaitUntil, registry);\n  context.waitUntil = instrumentedWaitUntil;\n\n  return registry;\n}\n\n/**\n * Flushes the client and then disposes of it to allow garbage collection.\n * This should be called at the end of each request to prevent memory leaks.\n *\n * This function never rejects. On Workers, a rejected promise passed to\n * `ctx.waitUntil` marks the whole invocation as `outcome: exception` even when\n * the handler itself completed successfully. Since flush/dispose is internal\n * SDK housekeeping, a failure here must not fail the user's invocation.\n *\n * @param client - The CloudflareClient instance to flush and dispose\n * @param timeout - Timeout in milliseconds for the flush operation\n * @returns A promise that resolves when flush and dispose are complete\n */\nexport async function flushAndDispose(client: Client | undefined, timeout = 2000): Promise<void> {\n  try {\n    if (!client) {\n      await flush(timeout);\n      return;\n    }\n    await client.flush(timeout);\n  } catch (e) {\n    DEBUG_BUILD && debug.warn('Failed to flush client', e);\n  } finally {\n    try {\n      client?.dispose();\n    } catch (e) {\n      DEBUG_BUILD && debug.warn('Failed to dispose client', e);\n    }\n  }\n}\n"],"names":["flush","DEBUG_BUILD","debug"],"mappings":"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"}

package/build/cjs/{index.js → dev/index.js}

@@ -5,17 +5,15 @@ const withSentry = require('./withSentry.js');
 const defineCloudflareOptions = require('./defineCloudflareOptions.js');
 const durableobject = require('./durableobject.js');
 const pagesPlugin = require('./pages-plugin.js');
-const request = require('./request.js');
 const client = require('./client.js');
 const sdk = require('./sdk.js');
 const httpServer = require('./integrations/httpServer.js');
 const fetch = require('./integrations/fetch.js');
 const spotlight = require('./integrations/spotlight.js');
 const vercelai = require('./integrations/tracing/vercelai.js');
-const hono = require('./integrations/hono.js');
-const instrumentD1 = require('./instrumentations/worker/instrumentD1.js');
+const serverUtils = require('@sentry/server-utils');
 const workflows = require('./workflows.js');
-const async = require('./async.js');
+const noDiagnosticChannels = require('@sentry/server-utils/no-diagnostic-channels');
 
 
 
@@ -40,7 +38,6 @@ exports.consoleIntegration = core.consoleIntegration;
 exports.consoleLoggingIntegration = core.consoleLoggingIntegration;
 exports.continueTrace = core.continueTrace;
 exports.createConsolaReporter = core.createConsolaReporter;
-exports.createLangChainCallbackHandler = core.createLangChainCallbackHandler;
 exports.createTransport = core.createTransport;
 exports.dedupeIntegration = core.dedupeIntegration;
 exports.eventFiltersIntegration = core.eventFiltersIntegration;
@@ -59,15 +56,7 @@ exports.getSpanStatusFromHttpCode = core.getSpanStatusFromHttpCode;
 exports.getTraceData = core.getTraceData;
 exports.getTraceMetaTags = core.getTraceMetaTags;
 exports.growthbookIntegration = core.growthbookIntegration;
-exports.inboundFiltersIntegration = core.inboundFiltersIntegration;
-exports.instrumentAnthropicAiClient = core.instrumentAnthropicAiClient;
-exports.instrumentCreateReactAgent = core.instrumentCreateReactAgent;
-exports.instrumentGoogleGenAIClient = core.instrumentGoogleGenAIClient;
-exports.instrumentLangChainEmbeddings = core.instrumentLangChainEmbeddings;
-exports.instrumentLangGraph = core.instrumentLangGraph;
-exports.instrumentOpenAiClient = core.instrumentOpenAiClient;
 exports.instrumentPostgresJsSql = core.instrumentPostgresJsSql;
-exports.instrumentStateGraph = core.instrumentStateGraph;
 exports.instrumentSupabaseClient = core.instrumentSupabaseClient;
 exports.isEnabled = core.isEnabled;
 exports.isInitialized = core.isInitialized;
@@ -93,6 +82,7 @@ exports.setUser = core.setUser;
 exports.spanStreamingIntegration = core.spanStreamingIntegration;
 exports.spanToBaggageHeader = core.spanToBaggageHeader;
 exports.spanToJSON = core.spanToJSON;
+exports.spanToStaticSpanJSON = core.spanToStaticSpanJSON;
 exports.spanToTraceHeader = core.spanToTraceHeader;
 exports.startInactiveSpan = core.startInactiveSpan;
 exports.startNewTrace = core.startNewTrace;
@@ -106,6 +96,7 @@ exports.withActiveSpan = core.withActiveSpan;
 exports.withIsolationScope = core.withIsolationScope;
 exports.withMonitor = core.withMonitor;
 exports.withScope = core.withScope;
+exports.withStaticSpan = core.withStaticSpan;
 exports.withStreamedSpan = core.withStreamedSpan;
 exports.wrapMcpServerWithSentry = core.wrapMcpServerWithSentry;
 exports.zodErrorsIntegration = core.zodErrorsIntegration;
@@ -114,15 +105,23 @@ exports.defineCloudflareOptions = defineCloudflareOptions.defineCloudflareOption
 exports.instrumentAgentWithSentry = durableobject.instrumentAgentWithSentry;
 exports.instrumentDurableObjectWithSentry = durableobject.instrumentDurableObjectWithSentry;
 exports.sentryPagesPlugin = pagesPlugin.sentryPagesPlugin;
-exports.wrapRequestHandler = request.wrapRequestHandler;
 exports.CloudflareClient = client.CloudflareClient;
 exports.getDefaultIntegrations = sdk.getDefaultIntegrations;
 exports.httpServerIntegration = httpServer.httpServerIntegration;
 exports.fetchIntegration = fetch.fetchIntegration;
 exports.spotlightIntegration = spotlight.spotlightIntegration;
 exports.vercelAIIntegration = vercelai.vercelAIIntegration;
-exports.honoIntegration = hono.honoIntegration;
-exports.instrumentD1WithSentry = instrumentD1.instrumentD1WithSentry;
+exports.createLangChainCallbackHandler = serverUtils.createLangChainCallbackHandler;
+exports.getOtlpTracesEndpoint = serverUtils.getOtlpTracesEndpoint;
+exports.instrumentAnthropicAiClient = serverUtils.instrumentAnthropicAiClient;
+exports.instrumentCreateReactAgent = serverUtils.instrumentCreateReactAgent;
+exports.instrumentGoogleGenAIClient = serverUtils.instrumentGoogleGenAIClient;
+exports.instrumentLangChainEmbeddings = serverUtils.instrumentLangChainEmbeddings;
+exports.instrumentOpenAiClient = serverUtils.instrumentOpenAiClient;
+exports.instrumentStateGraph = serverUtils.instrumentStateGraph;
+exports.instrumentWorkersAiClient = serverUtils.instrumentWorkersAiClient;
+exports.otlpIntegration = serverUtils.otlpIntegration;
+exports.prismaIntegration = serverUtils.prismaIntegration;
 exports.instrumentWorkflowWithSentry = workflows.instrumentWorkflowWithSentry;
-exports.setAsyncLocalStorageAsyncContextStrategy = async.setAsyncLocalStorageAsyncContextStrategy;
+exports.setAsyncLocalStorageAsyncContextStrategy = noDiagnosticChannels.setAsyncLocalStorageAsyncContextStrategy;
 //# sourceMappingURL=index.js.map

package/build/cjs/{index.js.map → dev/index.js.map}

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/cjs/dev/instrument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument.js","sources":["../../../src/instrument.ts"],"sourcesContent":["// Use a global WeakMap to track instrumented objects across module instances.\n// This is important for Cloudflare Workers where the module may be bundled\n// separately for workers and Durable Objects, but they share the same global scope.\n// The WeakMap stores original -> instrumented mappings so we can retrieve the\n// instrumented version even if we only have a reference to the original.\nimport { isObjectLike } from '@sentry/core';\n\nconst GLOBAL_KEY = '__SENTRY_INSTRUMENTED_MAP__' as const;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction getInstrumentedMap(): WeakMap<any, any> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const globalObj = globalThis as typeof globalThis & { [GLOBAL_KEY]?: WeakMap<any, any> };\n  if (!globalObj[GLOBAL_KEY]) {\n    globalObj[GLOBAL_KEY] = new WeakMap();\n  }\n  return globalObj[GLOBAL_KEY];\n}\n\n/**\n * Check if a value can be used as a WeakMap key.\n * WeakMap keys must be objects or non-registered symbols.\n */\nfunction isWeakMapKey(value: unknown): value is object {\n  return isObjectLike(value) || typeof value === 'function';\n}\n\n/**\n * Mark an object as instrumented, storing the instrumented version.\n * @param original The original uninstrumented object\n * @param instrumented The instrumented version (defaults to original if not provided)\n */\nexport function markAsInstrumented<T>(original: T, instrumented?: T): void {\n  try {\n    if (isWeakMapKey(original)) {\n      // Store mapping from original to instrumented version\n      // If instrumented is not provided, store original (for backwards compat)\n      getInstrumentedMap().set(original, instrumented ?? original);\n    }\n    // Also mark the instrumented version itself so we recognize it\n    if (isWeakMapKey(instrumented) && instrumented !== original) {\n      getInstrumentedMap().set(instrumented, instrumented);\n    }\n  } catch {\n    // ignore errors here\n  }\n}\n\n/**\n * Get the instrumented version of an object, if available.\n * Returns the instrumented version if the object was previously instrumented,\n * or undefined if not found.\n */\nexport function getInstrumented<T>(obj: T): T | undefined {\n  try {\n    if (isWeakMapKey(obj)) {\n      return getInstrumentedMap().get(obj) as T | undefined;\n    }\n\n    return undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Returns the already-instrumented version of `original` if one exists,\n * otherwise calls `instrumentFn` to create it, marks the mapping, and returns it.\n *\n * @param noMark - If true, skips storing the original→instrumented mapping.\n */\nexport function ensureInstrumented<T>(original: T, instrumentFn: (original: T) => T, noMark?: boolean): T {\n  const existing = getInstrumented(original);\n\n  if (existing) {\n    return existing;\n  }\n\n  const instrumented = instrumentFn(original);\n\n  if (!noMark) {\n    markAsInstrumented(original, instrumented);\n  }\n\n  return instrumented;\n}\n"],"names":["isObjectLike"],"mappings":";;;;AAOA,MAAM,UAAA,GAAa,6BAAA;AAGnB,SAAS,kBAAA,GAAwC;AAE/C,EAAA,MAAM,SAAA,GAAY,UAAA;AAClB,EAAA,IAAI,CAAC,SAAA,CAAU,UAAU,CAAA,EAAG;AAC1B,IAAA,SAAA,CAAU,UAAU,CAAA,mBAAI,IAAI,OAAA,EAAQ;AAAA,EACtC;AACA,EAAA,OAAO,UAAU,UAAU,CAAA;AAC7B;AAMA,SAAS,aAAa,KAAA,EAAiC;AACrD,EAAA,OAAOA,iBAAA,CAAa,KAAK,CAAA,IAAK,OAAO,KAAA,KAAU,UAAA;AACjD;AAOO,SAAS,kBAAA,CAAsB,UAAa,YAAA,EAAwB;AACzE,EAAA,IAAI;AACF,IAAA,IAAI,YAAA,CAAa,QAAQ,CAAA,EAAG;AAG1B,MAAA,kBAAA,EAAmB,CAAE,GAAA,CAAI,QAAA,EAAU,YAAA,IAAgB,QAAQ,CAAA;AAAA,IAC7D;AAEA,IAAA,IAAI,YAAA,CAAa,YAAY,CAAA,IAAK,YAAA,KAAiB,QAAA,EAAU;AAC3D,MAAA,kBAAA,EAAmB,CAAE,GAAA,CAAI,YAAA,EAAc,YAAY,CAAA;AAAA,IACrD;AAAA,EACF,CAAA,CAAA,MAAQ;AAAA,EAER;AACF;AAOO,SAAS,gBAAmB,GAAA,EAAuB;AACxD,EAAA,IAAI;AACF,IAAA,IAAI,YAAA,CAAa,GAAG,CAAA,EAAG;AACrB,MAAA,OAAO,kBAAA,EAAmB,CAAE,GAAA,CAAI,GAAG,CAAA;AAAA,IACrC;AAEA,IAAA,OAAO,KAAA,CAAA;AAAA,EACT,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAQO,SAAS,kBAAA,CAAsB,QAAA,EAAa,YAAA,EAAkC,MAAA,EAAqB;AACxG,EAAA,MAAM,QAAA,GAAW,gBAAgB,QAAQ,CAAA;AAEzC,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,OAAO,QAAA;AAAA,EACT;AAEA,EAAA,MAAM,YAAA,GAAe,aAAa,QAAQ,CAAA;AAE1C,EAAA,IAAI,CAAC,MAAA,EAAQ;AACX,IAAA,kBAAA,CAAmB,UAAU,YAAY,CAAA;AAAA,EAC3C;AAEA,EAAA,OAAO,YAAA;AACT;;;;;;"}

package/build/cjs/dev/instrumentations/agents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/instrumentations/agents/index.ts"],"sourcesContent":["import { instrumentAgentCallableRpc } from './instrumentAgentCallableRpc';\nimport { instrumentAgentRequestConversation } from './instrumentAgentRequestConversation';\nimport { instrumentChatAgentConversation } from './instrumentChatAgentConversation';\nimport type { AgentInternals } from './types';\n\n/**\n * Instruments an instance of a Cloudflare [`agents`](https://www.npmjs.com/package/agents) `Agent`\n * with Sentry, adding telemetry that is specific to the Agent's runtime behavior:\n *\n * - **Callable RPC spans** — a span (op `rpc`) for each `@callable()` method invoked over WebSocket.\n * - **Conversation correlation** — sets the conversation id on the scope for each unit of agent\n *   work — chat turn, callable RPC call, or HTTP request — so `gen_ai` spans created within it are\n *   correlated, for chat and plain agents alike. The id is minted once per agent instance and\n *   rotated when the chat is cleared (the `message:clear` observability event); it is persisted to\n *   Durable Object storage so it survives hibernation.\n *\n * It only hooks the `agents` package internals and uses Sentry's tracing primitives. On Cloudflare\n * Workers, prefer `instrumentAgentWithSentry`, which additionally instruments the Durable Object\n * handlers and initializes the SDK; that function calls this one internally.\n *\n * The hooks replace own-properties on the instance and defer to the original implementation, so\n * they compose with any other instrumentation applied to the same instance.\n *\n * @param agent The `agents` `Agent` instance to instrument.\n * @returns The same instance, instrumented.\n *\n * @internal Use `instrumentAgentWithSentry` instead — this is called internally by it.\n */\nexport function instrumentCloudflareAgent<T extends object>(agent: T): T {\n  const internals = agent as T & AgentInternals;\n\n  instrumentAgentCallableRpc(internals);\n  instrumentChatAgentConversation(internals);\n  instrumentAgentRequestConversation(internals);\n\n  return agent;\n}\n"],"names":["instrumentAgentCallableRpc","instrumentChatAgentConversation","instrumentAgentRequestConversation"],"mappings":";;;;;;AA4BO,SAAS,0BAA4C,KAAA,EAAa;AACvE,EAAA,MAAM,SAAA,GAAY,KAAA;AAElB,EAAAA,qDAAA,CAA2B,SAAS,CAAA;AACpC,EAAAC,+DAAA,CAAgC,SAAS,CAAA;AACzC,EAAAC,qEAAA,CAAmC,SAAS,CAAA;AAE5C,EAAA,OAAO,KAAA;AACT;;;;"}

package/build/cjs/dev/instrumentations/agents/instrumentAgentCallableRpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentAgentCallableRpc.js","sources":["../../../../../src/instrumentations/agents/instrumentAgentCallableRpc.ts"],"sourcesContent":["import { debug, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startSpan } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { AGENT_SPAN_ORIGIN, type AgentInternals, getAgentAttributes, setAgentConversationId } from './types';\n\n/**\n * Wraps the Agent's `onMessage` handler to create a span for each `@callable()` RPC invocation.\n * RPC requests arrive as WebSocket messages, so this span nests under the active transaction for\n * the WebSocket message (on Cloudflare, the instrumented Durable Object `webSocketMessage` hook).\n *\n * Also sets the conversation id on the scope for the duration of the call: callable methods are the\n * unit of work for plain (non-chat) agents, which run LLM calls just like chat turns do. It is\n * awaited so the id is on the scope before the method body creates any span; the `agents`\n * `onMessage` own property this wraps is already `async`, so the promise return is nothing new to\n * the WebSocket dispatch upstream.\n */\nexport function instrumentAgentCallableRpc(obj: AgentInternals): void {\n  const original = obj.onMessage;\n  if (typeof original !== 'function') {\n    DEBUG_BUILD && debug.log('[Sentry] Agent `onMessage` not found — callable RPC span instrumentation skipped.');\n    return;\n  }\n\n  obj.onMessage = new Proxy(original, {\n    apply(target, thisArg: AgentInternals, args: unknown[]): unknown {\n      const method = extractCallableMethod(args[1]);\n\n      if (!method) {\n        return Reflect.apply(target, thisArg, args);\n      }\n\n      return startSpan(\n        {\n          name: method,\n          attributes: {\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'rpc',\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: AGENT_SPAN_ORIGIN,\n            ...getAgentAttributes(thisArg),\n          },\n        },\n        async () => {\n          await setAgentConversationId(thisArg);\n          return Reflect.apply(target, thisArg, args);\n        },\n      );\n    },\n  });\n}\n\n/** Extracts the RPC method name from a WebSocket message, mirroring the SDK's `isRPCRequest`. */\nfunction extractCallableMethod(message: unknown): string | undefined {\n  const text =\n    typeof message === 'string'\n      ? message\n      : message instanceof ArrayBuffer\n        ? new TextDecoder().decode(message)\n        : undefined;\n\n  if (!text) {\n    return undefined;\n  }\n\n  try {\n    const parsed = JSON.parse(text) as { type?: unknown; method?: unknown; args?: unknown };\n    if (parsed.type === 'rpc' && typeof parsed.method === 'string' && Array.isArray(parsed.args)) {\n      return parsed.method;\n    }\n  } catch {\n    // Not JSON, or not an RPC request — no span.\n  }\n\n  return undefined;\n}\n"],"names":["DEBUG_BUILD","debug","startSpan","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","AGENT_SPAN_ORIGIN","getAgentAttributes","setAgentConversationId"],"mappings":";;;;;;AAeO,SAAS,2BAA2B,GAAA,EAA2B;AACpE,EAAA,MAAM,WAAW,GAAA,CAAI,SAAA;AACrB,EAAA,IAAI,OAAO,aAAa,UAAA,EAAY;AAClC,IAAAA,sBAAA,IAAeC,UAAA,CAAM,IAAI,wFAAmF,CAAA;AAC5G,IAAA;AAAA,EACF;AAEA,EAAA,GAAA,CAAI,SAAA,GAAY,IAAI,KAAA,CAAM,QAAA,EAAU;AAAA,IAClC,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAyB,IAAA,EAA0B;AAC/D,MAAA,MAAM,MAAA,GAAS,qBAAA,CAAsB,IAAA,CAAK,CAAC,CAAC,CAAA;AAE5C,MAAA,IAAI,CAAC,MAAA,EAAQ;AACX,QAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,IAAI,CAAA;AAAA,MAC5C;AAEA,MAAA,OAAOC,cAAA;AAAA,QACL;AAAA,UACE,IAAA,EAAM,MAAA;AAAA,UACN,UAAA,EAAY;AAAA,YACV,CAACC,iCAA4B,GAAG,KAAA;AAAA,YAChC,CAACC,qCAAgC,GAAGC,uBAAA;AAAA,YACpC,GAAGC,yBAAmB,OAAO;AAAA;AAC/B,SACF;AAAA,QACA,YAAY;AACV,UAAA,MAAMC,6BAAuB,OAAO,CAAA;AACpC,UAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,IAAI,CAAA;AAAA,QAC5C;AAAA,OACF;AAAA,IACF;AAAA,GACD,CAAA;AACH;AAGA,SAAS,sBAAsB,OAAA,EAAsC;AACnE,EAAA,MAAM,IAAA,GACJ,OAAO,OAAA,KAAY,QAAA,GACf,OAAA,GACA,OAAA,YAAmB,WAAA,GACjB,IAAI,WAAA,EAAY,CAAE,MAAA,CAAO,OAAO,CAAA,GAChC,MAAA;AAER,EAAA,IAAI,CAAC,IAAA,EAAM;AACT,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,KAAA,CAAM,IAAI,CAAA;AAC9B,IAAA,IAAI,MAAA,CAAO,IAAA,KAAS,KAAA,IAAS,OAAO,MAAA,CAAO,MAAA,KAAW,QAAA,IAAY,KAAA,CAAM,OAAA,CAAQ,MAAA,CAAO,IAAI,CAAA,EAAG;AAC5F,MAAA,OAAO,MAAA,CAAO,MAAA;AAAA,IAChB;AAAA,EACF,CAAA,CAAA,MAAQ;AAAA,EAER;AAEA,EAAA,OAAO,MAAA;AACT;;;;"}

package/build/cjs/dev/instrumentations/agents/instrumentAgentRequestConversation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentAgentRequestConversation.js","sources":["../../../../../src/instrumentations/agents/instrumentAgentRequestConversation.ts"],"sourcesContent":["import { type AgentInternals, setAgentConversationId } from './types';\n\n/**\n * Correlates the AI spans of an HTTP-driven agent turn with a conversation id on the active scope.\n *\n * `onRequest` is the third unit of agent work, alongside chat turns and `@callable()` RPC: the\n * `agents` router sends every non-WebSocket request to it, which is how REST endpoints and webhooks\n * reach an agent.\n *\n * `agents` installs `onRequest` as an own property in the `Agent` constructor (as it does\n * `onMessage`), and we instrument after construction, so wrapping the own property is what the\n * router ends up calling. That own property is already `async`, and partyserver's `fetch` awaits it,\n * so returning a promise from this wrapper — to get the conversation id onto the scope before the\n * request handler creates any span — keeps the existing contract.\n */\nexport function instrumentAgentRequestConversation(obj: AgentInternals): void {\n  const original = obj.onRequest;\n\n  if (typeof original !== 'function') {\n    return;\n  }\n\n  obj.onRequest = new Proxy(original, {\n    async apply(target, thisArg: AgentInternals, args: unknown[]): Promise<unknown> {\n      await setAgentConversationId(thisArg);\n\n      return Reflect.apply(target, thisArg, args);\n    },\n  });\n}\n"],"names":["setAgentConversationId"],"mappings":";;;;AAeO,SAAS,mCAAmC,GAAA,EAA2B;AAC5E,EAAA,MAAM,WAAW,GAAA,CAAI,SAAA;AAErB,EAAA,IAAI,OAAO,aAAa,UAAA,EAAY;AAClC,IAAA;AAAA,EACF;AAEA,EAAA,GAAA,CAAI,SAAA,GAAY,IAAI,KAAA,CAAM,QAAA,EAAU;AAAA,IAClC,MAAM,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAyB,IAAA,EAAmC;AAC9E,MAAA,MAAMA,6BAAuB,OAAO,CAAA;AAEpC,MAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,IAAI,CAAA;AAAA,IAC5C;AAAA,GACD,CAAA;AACH;;;;"}

package/build/cjs/dev/instrumentations/agents/instrumentChatAgentConversation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentChatAgentConversation.js","sources":["../../../../../src/instrumentations/agents/instrumentChatAgentConversation.ts"],"sourcesContent":["import { uuid4 } from '@sentry/core';\nimport { type AgentInternals, setAgentConversationId, storeAgentConversationId } from './types';\n\n/**\n * For chat agents (`AIChatAgent` from `@cloudflare/ai-chat`), correlates each chat turn's AI spans\n * with a conversation id on the active scope.\n *\n * In the Agents model one agent instance is one long-lived conversation, so the conversation id is\n * minted once per instance and persisted to Durable Object storage, which is what carries it across\n * hibernation (that destroys the in-memory instance). When the user clears the chat, they expect a\n * fresh conversation — but recreating the Durable Object for that would also drop the MCP/OAuth\n * state stored per instance (GitHub/Sentry sign-in). To get a fresh conversation id *without*\n * losing that state, we rotate the persisted id when the SDK reports a cleared chat.\n *\n * The id itself is not attached to spans here — `setAgentConversationId` resolves it, and the SDK's\n * `conversationIdIntegration` picks it off the scope at `spanStart` to stamp\n * `gen_ai.conversation.id` onto the AI spans created inside the turn (e.g. by the Workers AI\n * instrumentation), which correlates a turn's model and tool calls.\n *\n * Plain (non-chat) `Agent`s do not define `onChatMessage`, so they are skipped here — their unit\n * of work is the callable RPC method, where `instrumentAgentCallableRpc` sets the conversation id\n * instead.\n */\nexport function instrumentChatAgentConversation(obj: AgentInternals): void {\n  // Rotate the conversation id when the chat is cleared. `_emit` is the central choke-point through\n  // which all `agents:*` observability events are published, and it already exists on the base\n  // `Agent` class — so this hook composes with the RPC instrumentation, which keys off the same\n  // surface. We shadow it with an own property so the original stays reachable on the prototype.\n  const originalEmit = obj._emit;\n\n  if (typeof originalEmit === 'function') {\n    obj._emit = new Proxy(originalEmit, {\n      apply(target, thisArg: AgentInternals, args: [string, Record<string, unknown>?]) {\n        if (args[0] === 'message:clear') {\n          storeAgentConversationId(thisArg, uuid4());\n        }\n\n        return Reflect.apply(target, thisArg, args);\n      },\n    });\n  }\n\n  const original = obj.onChatMessage;\n\n  if (typeof original !== 'function') {\n    return;\n  }\n\n  obj.onChatMessage = new Proxy(original, {\n    async apply(target, thisArg: AgentInternals, args: unknown[]): Promise<unknown> {\n      await setAgentConversationId(thisArg);\n\n      return Reflect.apply(target, thisArg, args);\n    },\n  });\n}\n"],"names":["storeAgentConversationId","uuid4","setAgentConversationId"],"mappings":";;;;;AAuBO,SAAS,gCAAgC,GAAA,EAA2B;AAKzE,EAAA,MAAM,eAAe,GAAA,CAAI,KAAA;AAEzB,EAAA,IAAI,OAAO,iBAAiB,UAAA,EAAY;AACtC,IAAA,GAAA,CAAI,KAAA,GAAQ,IAAI,KAAA,CAAM,YAAA,EAAc;AAAA,MAClC,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAyB,IAAA,EAA0C;AAC/E,QAAA,IAAI,IAAA,CAAK,CAAC,CAAA,KAAM,eAAA,EAAiB;AAC/B,UAAAA,8BAAA,CAAyB,OAAA,EAASC,YAAO,CAAA;AAAA,QAC3C;AAEA,QAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,IAAI,CAAA;AAAA,MAC5C;AAAA,KACD,CAAA;AAAA,EACH;AAEA,EAAA,MAAM,WAAW,GAAA,CAAI,aAAA;AAErB,EAAA,IAAI,OAAO,aAAa,UAAA,EAAY;AAClC,IAAA;AAAA,EACF;AAEA,EAAA,GAAA,CAAI,aAAA,GAAgB,IAAI,KAAA,CAAM,QAAA,EAAU;AAAA,IACtC,MAAM,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAyB,IAAA,EAAmC;AAC9E,MAAA,MAAMC,6BAAuB,OAAO,CAAA;AAEpC,MAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,IAAI,CAAA;AAAA,IAC5C;AAAA,GACD,CAAA;AACH;;;;"}

package/build/cjs/{instrumentations → dev/instrumentations}/agents/types.js

@@ -1,20 +1,20 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+const attributes = require('@sentry/conventions/attributes');
 const core = require('@sentry/core');
 const debugBuild = require('../../debug-build.js');
 
-const GEN_AI_AGENT_NAME_ATTRIBUTE = "gen_ai.agent.name";
 const AGENT_SPAN_ORIGIN = "auto.faas.cloudflare.agents";
 const AGENT_CONVERSATION_ID_STORAGE_KEY = "__SENTRY_AGENT_CONVERSATION_ID__";
 const AGENT_CONVERSATION_ID_SYMBOL = /* @__PURE__ */ Symbol("sentryAgentConversationId");
 const AGENT_APPLIED_CONVERSATION_ID_SYMBOL = /* @__PURE__ */ Symbol("sentryAgentAppliedConversationId");
 function getAgentAttributes(instance) {
-  const attributes = {};
+  const attributes$1 = {};
   const agentClass = instance._ParentClass?.name;
   if (typeof agentClass === "string" && agentClass) {
-    attributes[GEN_AI_AGENT_NAME_ATTRIBUTE] = agentClass;
+    attributes$1[attributes.GEN_AI_AGENT_NAME] = agentClass;
   }
-  return attributes;
+  return attributes$1;
 }
 function storeAgentConversationId(instance, conversationId) {
   instance[AGENT_CONVERSATION_ID_SYMBOL] = conversationId;

package/build/cjs/dev/instrumentations/agents/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../../../../src/instrumentations/agents/types.ts"],"sourcesContent":["import { GEN_AI_AGENT_NAME } from '@sentry/conventions/attributes';\nimport type { DurableObjectStorage } from '@cloudflare/workers-types';\nimport { debug, getCurrentScope, getIsolationScope, uuid4 } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport type { InstrumentedDurableObjectState } from '../../wrapMethodWithSentry';\n\nexport const AGENT_SPAN_ORIGIN = 'auto.faas.cloudflare.agents';\n\n/** DO storage key under which the conversation id is persisted so it survives hibernation. */\nexport const AGENT_CONVERSATION_ID_STORAGE_KEY = '__SENTRY_AGENT_CONVERSATION_ID__';\n\n/**\n * Instance keys for our conversation-id bookkeeping, keyed by symbol so the state stays invisible\n * to anything enumerating the user-owned agent instance (`Object.keys`, `JSON.stringify`, spread).\n * Exported because the exported `AgentInternals` interface references them.\n */\nexport const AGENT_CONVERSATION_ID_SYMBOL: unique symbol = Symbol('sentryAgentConversationId');\nexport const AGENT_APPLIED_CONVERSATION_ID_SYMBOL: unique symbol = Symbol('sentryAgentAppliedConversationId');\n\n/**\n * The subset of the `agents` `Agent` instance internals that we instrument. These are runtime\n * implementation details of the `agents` package (v0.13.x) rather than part of its public type\n * surface, so every access is guarded and wrapping degrades gracefully if a name changes upstream.\n */\nexport interface AgentInternals {\n  /** Central choke-point through which all `agents:*` observability events are published. */\n  _emit?: (type: string, payload?: Record<string, unknown>) => void;\n  /** WebSocket message handler; dispatches `@callable()` RPC requests. */\n  onMessage?: (...args: unknown[]) => unknown;\n  /**\n   * Chat-turn handler. Only `AIChatAgent` (from `@cloudflare/ai-chat`) defines this; a plain `Agent`\n   * does not, so its presence discriminates a chat agent.\n   */\n  onChatMessage?: (...args: unknown[]) => unknown;\n  /** HTTP request handler; the router sends every non-WebSocket request here. */\n  onRequest?: (...args: unknown[]) => unknown;\n  /** The user's Agent class (used by the SDK for the observability event `agent` field). */\n  _ParentClass?: { name?: string };\n  /** The Agent instance name, reported as the `cloudflare.agent.name` span attribute. */\n  name?: string;\n  /**\n   * The Durable Object state of the instance. Present on every real Agent; guarded like the other\n   * internals so partially-mocked instances keep working.\n   */\n  ctx?: InstrumentedDurableObjectState;\n  /**\n   * The current conversation id for this agent instance. It is cached in memory after being loaded\n   * from Durable Object storage and updated when the conversation rotates. `undefined` means storage\n   * has not been read yet.\n   */\n  [AGENT_CONVERSATION_ID_SYMBOL]?: string;\n  /**\n   * The conversation id this instrumentation most recently applied to the isolation scope. It lets\n   * subsequent units of work distinguish an SDK-applied id, which may be replaced after rotation,\n   * from an id explicitly set by the user, which must be preserved.\n   */\n  [AGENT_APPLIED_CONVERSATION_ID_SYMBOL]?: string;\n}\n\n/** Reads best-effort agent identity attributes from the instance, tolerating missing internals. */\nexport function getAgentAttributes(instance: AgentInternals): Record<string, string> {\n  const attributes: Record<string, string> = {};\n\n  const agentClass = instance._ParentClass?.name;\n  if (typeof agentClass === 'string' && agentClass) {\n    attributes[GEN_AI_AGENT_NAME] = agentClass;\n  }\n\n  return attributes;\n}\n\n/**\n * Persists the conversation id to Durable Object storage, so it survives hibernation, and updates\n * the in-memory cache synchronously so the current wake is immediately consistent even if the\n * write fails. Uses the async storage API, which exists on KV- and SQLite-backed DOs alike.\n * The write is fire-and-forget: DO storage writes are tracked by the runtime and land without\n * awaiting (`waitUntil` is a no-op in Durable Objects), and the catch keeps a rejection from\n * surfacing as unhandled — a failed write just means the next wake starts a new conversation,\n * which must never throw into user code. Uses the original uninstrumented storage so internal\n * bookkeeping doesn't create spans.\n */\nexport function storeAgentConversationId(instance: AgentInternals, conversationId: string): void {\n  instance[AGENT_CONVERSATION_ID_SYMBOL] = conversationId;\n\n  const storage = resolveStorage(instance);\n  if (!storage) {\n    return;\n  }\n\n  try {\n    storage\n      .put(AGENT_CONVERSATION_ID_STORAGE_KEY, conversationId)\n      .catch(error => DEBUG_BUILD && debug.log('[Sentry] Failed to persist agent conversation id', error));\n  } catch (error) {\n    DEBUG_BUILD && debug.log('[Sentry] Failed to persist agent conversation id', error);\n  }\n}\n\n/**\n * Sets the agent instance's conversation id on the active scope for the duration of the\n * surrounding unit of work (chat turn, callable RPC call, HTTP request). In the Agents model one\n * instance is one long-lived conversation, so the id is minted once per instance and persisted to\n * DO storage — for chat and plain agents alike, since plain agents run LLM calls too (e.g. inside\n * `@callable()` methods). The instance `name` is deliberately not used: it is caller-chosen and can\n * be a stable, guessable, or shared value, whereas a conversation id should identify exactly one\n * conversation. Clearing the chat rotates it (see `storeAgentConversationId`) so subsequent LLM\n * calls group under the fresh conversation.\n *\n * Every handler wrapper awaits this before invoking the original, so the id is on the scope before\n * the unit of work — and any `gen_ai` span it creates — starts. Only the first unit of work per wake\n * pays the storage read; the rest resolve from the in-memory cache. Awaiting is safe on all three\n * paths because the `agents` `Agent` constructor already replaces `onMessage` and `onRequest` with\n * `async` wrappers of its own, and `onChatMessage` is async by contract, so every caller upstream\n * already handles a promise.\n *\n * An id the user set explicitly outranks this inferred one, in either order: a `setConversationId()`\n * call that already happened is detected here and left alone, and one made inside the handler lands\n * on the same scope afterwards and therefore wins. That is why the write targets the isolation scope\n * — it is the scope the public `Sentry.setConversationId()` writes to, and `conversationIdIntegration`\n * prefers the current scope over it, so writing there would make a user's call unoverridable.\n *\n * `conversationIdIntegration` reads the id off the scope at `spanStart` and stamps\n * `gen_ai.conversation.id` onto AI spans created within the unit of work, correlating its model and\n * tool calls.\n */\nexport async function setAgentConversationId(instance: AgentInternals): Promise<void> {\n  const isolationScope = getIsolationScope();\n  const existing = isolationScope.getScopeData().conversationId ?? getCurrentScope().getScopeData().conversationId;\n\n  // An id that isn't the one we put there ourselves came from the user — never override it.\n  if (existing && existing !== instance[AGENT_APPLIED_CONVERSATION_ID_SYMBOL]) {\n    return;\n  }\n\n  const conversationId = instance[AGENT_CONVERSATION_ID_SYMBOL] ?? (await loadAgentConversationId(instance));\n\n  instance[AGENT_APPLIED_CONVERSATION_ID_SYMBOL] = conversationId;\n  isolationScope.setConversationId(conversationId);\n}\n\n/**\n * Reads the persisted id into the instance cache, minting and persisting a fresh one when storage\n * holds none, so subsequent units of work resolve from memory. The async `get` exists on KV- and\n * SQLite-backed DOs alike, so this one path covers both.\n *\n * Anything already cached by the time the read lands wins over the read: that covers a rotation\n * (cleared chat) racing the read, and a second concurrent unit of work that must not mint and\n * persist a competing id for the same conversation.\n */\nasync function loadAgentConversationId(instance: AgentInternals): Promise<string> {\n  let stored: unknown;\n  let readFailed = false;\n\n  try {\n    stored = await resolveStorage(instance)?.get<string>(AGENT_CONVERSATION_ID_STORAGE_KEY);\n  } catch (error) {\n    readFailed = true;\n    DEBUG_BUILD && debug.log('[Sentry] Failed to read agent conversation id from storage', error);\n  }\n\n  const cached = instance[AGENT_CONVERSATION_ID_SYMBOL];\n\n  if (cached !== undefined) {\n    return cached;\n  }\n\n  if (typeof stored === 'string' && stored) {\n    instance[AGENT_CONVERSATION_ID_SYMBOL] = stored;\n\n    return stored;\n  }\n\n  const conversationId = uuid4();\n\n  if (readFailed) {\n    // Cache without persisting: a read that failed may still have an id behind it, and overwriting\n    // it would split the conversation for good instead of just for this wake.\n    instance[AGENT_CONVERSATION_ID_SYMBOL] = conversationId;\n  } else {\n    storeAgentConversationId(instance, conversationId);\n  }\n\n  return conversationId;\n}\n\n/**\n * Resolves the uninstrumented DO storage for internal reads/writes, so they don't create spans of\n * their own. Falls back to the instance's regular storage when the uninstrumented one isn't\n * exposed (e.g. when `instrumentCloudflareAgent` is used directly, without `instrumentContext`).\n */\nfunction resolveStorage(instance: AgentInternals): DurableObjectStorage | undefined {\n  return instance.ctx?.originalStorage ?? instance.ctx?.storage;\n}\n"],"names":["attributes","GEN_AI_AGENT_NAME","DEBUG_BUILD","debug","getIsolationScope","getCurrentScope","uuid4"],"mappings":";;;;;;AAMO,MAAM,iBAAA,GAAoB;AAG1B,MAAM,iCAAA,GAAoC;AAO1C,MAAM,4BAAA,0BAAqD,2BAA2B;AACtF,MAAM,oCAAA,0BAA6D,kCAAkC;AA2CrG,SAAS,mBAAmB,QAAA,EAAkD;AACnF,EAAA,MAAMA,eAAqC,EAAC;AAE5C,EAAA,MAAM,UAAA,GAAa,SAAS,YAAA,EAAc,IAAA;AAC1C,EAAA,IAAI,OAAO,UAAA,KAAe,QAAA,IAAY,UAAA,EAAY;AAChD,IAAAA,YAAA,CAAWC,4BAAiB,CAAA,GAAI,UAAA;AAAA,EAClC;AAEA,EAAA,OAAOD,YAAA;AACT;AAYO,SAAS,wBAAA,CAAyB,UAA0B,cAAA,EAA8B;AAC/F,EAAA,QAAA,CAAS,4BAA4B,CAAA,GAAI,cAAA;AAEzC,EAAA,MAAM,OAAA,GAAU,eAAe,QAAQ,CAAA;AACvC,EAAA,IAAI,CAAC,OAAA,EAAS;AACZ,IAAA;AAAA,EACF;AAEA,EAAA,IAAI;AACF,IAAA,OAAA,CACG,GAAA,CAAI,iCAAA,EAAmC,cAAc,CAAA,CACrD,KAAA,CAAM,CAAA,KAAA,KAASE,sBAAA,IAAeC,UAAA,CAAM,GAAA,CAAI,kDAAA,EAAoD,KAAK,CAAC,CAAA;AAAA,EACvG,SAAS,KAAA,EAAO;AACd,IAAAD,sBAAA,IAAeC,UAAA,CAAM,GAAA,CAAI,kDAAA,EAAoD,KAAK,CAAA;AAAA,EACpF;AACF;AA6BA,eAAsB,uBAAuB,QAAA,EAAyC;AACpF,EAAA,MAAM,iBAAiBC,sBAAA,EAAkB;AACzC,EAAA,MAAM,QAAA,GAAW,eAAe,YAAA,EAAa,CAAE,kBAAkBC,oBAAA,EAAgB,CAAE,cAAa,CAAE,cAAA;AAGlG,EAAA,IAAI,QAAA,IAAY,QAAA,KAAa,QAAA,CAAS,oCAAoC,CAAA,EAAG;AAC3E,IAAA;AAAA,EACF;AAEA,EAAA,MAAM,iBAAiB,QAAA,CAAS,4BAA4B,CAAA,IAAM,MAAM,wBAAwB,QAAQ,CAAA;AAExG,EAAA,QAAA,CAAS,oCAAoC,CAAA,GAAI,cAAA;AACjD,EAAA,cAAA,CAAe,kBAAkB,cAAc,CAAA;AACjD;AAWA,eAAe,wBAAwB,QAAA,EAA2C;AAChF,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI,UAAA,GAAa,KAAA;AAEjB,EAAA,IAAI;AACF,IAAA,MAAA,GAAS,MAAM,cAAA,CAAe,QAAQ,CAAA,EAAG,IAAY,iCAAiC,CAAA;AAAA,EACxF,SAAS,KAAA,EAAO;AACd,IAAA,UAAA,GAAa,IAAA;AACb,IAAAH,sBAAA,IAAeC,UAAA,CAAM,GAAA,CAAI,4DAAA,EAA8D,KAAK,CAAA;AAAA,EAC9F;AAEA,EAAA,MAAM,MAAA,GAAS,SAAS,4BAA4B,CAAA;AAEpD,EAAA,IAAI,WAAW,MAAA,EAAW;AACxB,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,MAAA,EAAQ;AACxC,IAAA,QAAA,CAAS,4BAA4B,CAAA,GAAI,MAAA;AAEzC,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,MAAM,iBAAiBG,UAAA,EAAM;AAE7B,EAAA,IAAI,UAAA,EAAY;AAGd,IAAA,QAAA,CAAS,4BAA4B,CAAA,GAAI,cAAA;AAAA,EAC3C,CAAA,MAAO;AACL,IAAA,wBAAA,CAAyB,UAAU,cAAc,CAAA;AAAA,EACnD;AAEA,EAAA,OAAO,cAAA;AACT;AAOA,SAAS,eAAe,QAAA,EAA4D;AAClF,EAAA,OAAO,QAAA,CAAS,GAAA,EAAK,eAAA,IAAmB,QAAA,CAAS,GAAA,EAAK,OAAA;AACxD;;;;;;;;;;"}

package/build/cjs/dev/instrumentations/instrumentDurableObjectNamespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentDurableObjectNamespace.js","sources":["../../../../src/instrumentations/instrumentDurableObjectNamespace.ts"],"sourcesContent":["import type { DurableObjectNamespace, DurableObjectStub } from '@cloudflare/workers-types';\nimport { appendRpcMeta } from '../utils/rpcMeta';\nimport { instrumentFetcher } from './worker/instrumentFetcher';\n\n// Built-in DurableObjectStub methods that are not RPC calls.\nexport const STUB_NON_RPC_METHODS = new Set(['fetch', 'connect', 'dup']);\n\n/**\n * Instruments a DurableObjectNamespace binding to create spans for DO interactions.\n *\n * Wraps:\n * - `namespace.get(id)` / `namespace.getByName(name)` with a span + instruments returned stub\n * - `namespace.idFromName(name)` / `namespace.idFromString(id)` / `namespace.newUniqueId()` with breadcrumbs\n *\n * @param namespace - The DurableObjectNamespace to instrument\n */\nexport function instrumentDurableObjectNamespace(namespace: DurableObjectNamespace): DurableObjectNamespace {\n  return new Proxy(namespace, {\n    get(target, prop, _receiver) {\n      const value = Reflect.get(target, prop) as unknown;\n\n      if (typeof value !== 'function') {\n        return value;\n      }\n\n      if (prop === 'get' || prop === 'getByName') {\n        return function (this: unknown, ...args: unknown[]) {\n          const stub = Reflect.apply(value, target, args);\n\n          return instrumentDurableObjectStub(stub);\n        };\n      }\n\n      return value.bind(target);\n    },\n  });\n}\n\n/**\n * Instruments a DurableObjectStub to create spans for outgoing fetch calls\n * and propagate trace context across RPC calls.\n *\n * @param stub - The DurableObjectStub to instrument\n */\nfunction instrumentDurableObjectStub(stub: DurableObjectStub): DurableObjectStub {\n  return new Proxy(stub, {\n    get(target, prop) {\n      const value = Reflect.get(target, prop);\n\n      if (prop === 'fetch' && typeof value === 'function') {\n        return instrumentFetcher((...args) => Reflect.apply(value, target, args));\n      }\n\n      if (typeof value === 'function' && typeof prop === 'string' && !STUB_NON_RPC_METHODS.has(prop)) {\n        return (...args: unknown[]) => Reflect.apply(value, target, appendRpcMeta(args));\n      }\n\n      return value;\n    },\n  });\n}\n"],"names":["instrumentFetcher","appendRpcMeta"],"mappings":";;;;;AAKO,MAAM,uCAAuB,IAAI,GAAA,CAAI,CAAC,OAAA,EAAS,SAAA,EAAW,KAAK,CAAC;AAWhE,SAAS,iCAAiC,SAAA,EAA2D;AAC1G,EAAA,OAAO,IAAI,MAAM,SAAA,EAAW;AAAA,IAC1B,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,SAAA,EAAW;AAC3B,MAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,IAAI,CAAA;AAEtC,MAAA,IAAI,OAAO,UAAU,UAAA,EAAY;AAC/B,QAAA,OAAO,KAAA;AAAA,MACT;AAEA,MAAA,IAAI,IAAA,KAAS,KAAA,IAAS,IAAA,KAAS,WAAA,EAAa;AAC1C,QAAA,OAAO,YAA4B,IAAA,EAAiB;AAClD,UAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,KAAA,CAAM,KAAA,EAAO,QAAQ,IAAI,CAAA;AAE9C,UAAA,OAAO,4BAA4B,IAAI,CAAA;AAAA,QACzC,CAAA;AAAA,MACF;AAEA,MAAA,OAAO,KAAA,CAAM,KAAK,MAAM,CAAA;AAAA,IAC1B;AAAA,GACD,CAAA;AACH;AAQA,SAAS,4BAA4B,IAAA,EAA4C;AAC/E,EAAA,OAAO,IAAI,MAAM,IAAA,EAAM;AAAA,IACrB,GAAA,CAAI,QAAQ,IAAA,EAAM;AAChB,MAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,IAAI,CAAA;AAEtC,MAAA,IAAI,IAAA,KAAS,OAAA,IAAW,OAAO,KAAA,KAAU,UAAA,EAAY;AACnD,QAAA,OAAOA,mCAAA,CAAkB,IAAI,IAAA,KAAS,OAAA,CAAQ,MAAM,KAAA,EAAO,MAAA,EAAQ,IAAI,CAAC,CAAA;AAAA,MAC1E;AAEA,MAAA,IAAI,OAAO,KAAA,KAAU,UAAA,IAAc,OAAO,IAAA,KAAS,YAAY,CAAC,oBAAA,CAAqB,GAAA,CAAI,IAAI,CAAA,EAAG;AAC9F,QAAA,OAAO,CAAA,GAAI,SAAoB,OAAA,CAAQ,KAAA,CAAM,OAAO,MAAA,EAAQC,qBAAA,CAAc,IAAI,CAAC,CAAA;AAAA,MACjF;AAEA,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,GACD,CAAA;AACH;;;;;"}

package/build/cjs/dev/instrumentations/instrumentDurableObjectStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentDurableObjectStorage.js","sources":["../../../../src/instrumentations/instrumentDurableObjectStorage.ts"],"sourcesContent":["import type { DurableObjectStorage, SyncKvStorage, SqlStorage } from '@cloudflare/workers-types';\nimport { getClient, isThenable, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startSpan } from '@sentry/core';\nimport type { CloudflareClientOptions } from '../client';\nimport { getStorageKeys, targetsCloudflareInternalKey } from '../utils/internalStorageKey';\nimport { storeSpanContext } from '../utils/traceLinks';\nimport { instrumentDurableObjectSyncKvStorage } from './instrumentDurableObjectSyncKvStorage';\nimport { instrumentSqlStorage } from './instrumentSqlStorage';\n\nconst STORAGE_METHODS_TO_INSTRUMENT = ['get', 'put', 'delete', 'list', 'setAlarm', 'getAlarm', 'deleteAlarm'] as const;\n\ntype StorageMethod = (typeof STORAGE_METHODS_TO_INSTRUMENT)[number];\n\ntype WaitUntil = (promise: Promise<unknown>) => void;\n\n/**\n * Instruments DurableObjectStorage methods with Sentry spans.\n *\n * Wraps the following async methods:\n * - get, put, delete, list (KV API)\n * - setAlarm, getAlarm, deleteAlarm (Alarm API)\n *\n * When setAlarm is called, it also stores the current span context so that when\n * the alarm fires later, it can link back to the trace that called setAlarm.\n *\n * @param storage - The DurableObjectStorage instance to instrument\n * @param waitUntil - Optional waitUntil function to defer span context storage\n * @returns An instrumented DurableObjectStorage instance\n */\nexport function instrumentDurableObjectStorage(\n  storage: DurableObjectStorage,\n  waitUntil?: WaitUntil,\n): DurableObjectStorage {\n  return new Proxy(storage, {\n    get(target, prop, _receiver) {\n      // Use `target` as the receiver instead of the proxy (`_receiver`).\n      // Native workerd getters (e.g., `storage.sql`) validate `this` via\n      // internal slots. Passing the proxy as receiver breaks that check,\n      // causing \"Illegal invocation: function called with incorrect `this`\n      // reference\" errors.\n      const original = Reflect.get(target, prop, target);\n\n      if (prop === 'kv' && original != null && 'get' in original && 'put' in original) {\n        return instrumentDurableObjectSyncKvStorage(original as SyncKvStorage);\n      }\n\n      if (prop === 'sql' && original != null && 'databaseSize' in original && 'exec' in original) {\n        return instrumentSqlStorage(original as SqlStorage);\n      }\n\n      if (typeof original !== 'function') {\n        return original;\n      }\n\n      const methodName = prop as string;\n      if (!STORAGE_METHODS_TO_INSTRUMENT.includes(methodName as StorageMethod)) {\n        return (original as (...args: unknown[]) => unknown).bind(target);\n      }\n\n      return function (this: unknown, ...args: unknown[]) {\n        // KV entries managed by the DO framework itself (agents/partyserver state) are bookkeeping\n        // rather than user work — skip the span, mirroring how `cf_` SQL tables are treated.\n        // oxlint-disable-next-line typescript/no-unnecessary-type-assertion -- rule false positive: the cast reaches the Cloudflare-only `durableObjectStorageSpanAllowlist`; tsc errors without it\n        const allowlist = (getClient()?.getOptions() as CloudflareClientOptions | undefined)\n          ?.durableObjectStorageSpanAllowlist;\n        const keys = getStorageKeys(methodName, args);\n        if (keys && keys.length > 0 && keys.every(key => targetsCloudflareInternalKey(key, allowlist))) {\n          return (original as (...a: unknown[]) => unknown).apply(target, args);\n        }\n\n        return startSpan(\n          {\n            // Use underscore naming to match Cloudflare's native instrumentation (e.g., \"durable_object_storage_get\")\n            name: `durable_object_storage_${methodName}`,\n            op: 'db',\n            attributes: {\n              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.db.cloudflare.durable_object',\n              'db.system.name': 'cloudflare.durable_object.storage',\n              'db.operation.name': methodName,\n            },\n          },\n          () => {\n            const teardown = async (): Promise<void> => {\n              // When setAlarm is called, store the current span context so that when the alarm\n              // fires later, it can link back to the trace that called setAlarm.\n              // We use the original (uninstrumented) storage (target) to avoid creating a span\n              // for this internal operation. The storage is deferred via waitUntil to not block.\n              if (methodName === 'setAlarm') {\n                storeSpanContext(target, 'alarm');\n              }\n            };\n\n            const result = (original as (...args: unknown[]) => unknown).apply(target, args);\n\n            if (!isThenable(result)) {\n              waitUntil?.(teardown());\n\n              return result;\n            }\n\n            return result.then(\n              res => {\n                waitUntil?.(teardown());\n                return res;\n              },\n              e => {\n                throw e;\n              },\n            );\n          },\n        );\n      };\n    },\n  });\n}\n"],"names":["instrumentDurableObjectSyncKvStorage","instrumentSqlStorage","getClient","getStorageKeys","targetsCloudflareInternalKey","startSpan","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","storeSpanContext","isThenable"],"mappings":";;;;;;;;AAQA,MAAM,6BAAA,GAAgC,CAAC,KAAA,EAAO,KAAA,EAAO,UAAU,MAAA,EAAQ,UAAA,EAAY,YAAY,aAAa,CAAA;AAoBrG,SAAS,8BAAA,CACd,SACA,SAAA,EACsB;AACtB,EAAA,OAAO,IAAI,MAAM,OAAA,EAAS;AAAA,IACxB,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,SAAA,EAAW;AAM3B,MAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,MAAM,MAAM,CAAA;AAEjD,MAAA,IAAI,SAAS,IAAA,IAAQ,QAAA,IAAY,QAAQ,KAAA,IAAS,QAAA,IAAY,SAAS,QAAA,EAAU;AAC/E,QAAA,OAAOA,0EAAqC,QAAyB,CAAA;AAAA,MACvE;AAEA,MAAA,IAAI,SAAS,KAAA,IAAS,QAAA,IAAY,QAAQ,cAAA,IAAkB,QAAA,IAAY,UAAU,QAAA,EAAU;AAC1F,QAAA,OAAOC,0CAAqB,QAAsB,CAAA;AAAA,MACpD;AAEA,MAAA,IAAI,OAAO,aAAa,UAAA,EAAY;AAClC,QAAA,OAAO,QAAA;AAAA,MACT;AAEA,MAAA,MAAM,UAAA,GAAa,IAAA;AACnB,MAAA,IAAI,CAAC,6BAAA,CAA8B,QAAA,CAAS,UAA2B,CAAA,EAAG;AACxE,QAAA,OAAQ,QAAA,CAA6C,KAAK,MAAM,CAAA;AAAA,MAClE;AAEA,MAAA,OAAO,YAA4B,IAAA,EAAiB;AAIlD,QAAA,MAAM,SAAA,GAAaC,cAAA,EAAU,EAAG,UAAA,EAAW,EACvC,iCAAA;AACJ,QAAA,MAAM,IAAA,GAAOC,iCAAA,CAAe,UAAA,EAAY,IAAI,CAAA;AAC5C,QAAA,IAAI,IAAA,IAAQ,IAAA,CAAK,MAAA,GAAS,CAAA,IAAK,IAAA,CAAK,KAAA,CAAM,CAAA,GAAA,KAAOC,+CAAA,CAA6B,GAAA,EAAK,SAAS,CAAC,CAAA,EAAG;AAC9F,UAAA,OAAQ,QAAA,CAA0C,KAAA,CAAM,MAAA,EAAQ,IAAI,CAAA;AAAA,QACtE;AAEA,QAAA,OAAOC,cAAA;AAAA,UACL;AAAA;AAAA,YAEE,IAAA,EAAM,0BAA0B,UAAU,CAAA,CAAA;AAAA,YAC1C,EAAA,EAAI,IAAA;AAAA,YACJ,UAAA,EAAY;AAAA,cACV,CAACC,qCAAgC,GAAG,mCAAA;AAAA,cACpC,gBAAA,EAAkB,mCAAA;AAAA,cAClB,mBAAA,EAAqB;AAAA;AACvB,WACF;AAAA,UACA,MAAM;AACJ,YAAA,MAAM,WAAW,YAA2B;AAK1C,cAAA,IAAI,eAAe,UAAA,EAAY;AAC7B,gBAAAC,2BAAA,CAAiB,QAAQ,OAAO,CAAA;AAAA,cAClC;AAAA,YACF,CAAA;AAEA,YAAA,MAAM,MAAA,GAAU,QAAA,CAA6C,KAAA,CAAM,MAAA,EAAQ,IAAI,CAAA;AAE/E,YAAA,IAAI,CAACC,eAAA,CAAW,MAAM,CAAA,EAAG;AACvB,cAAA,SAAA,GAAY,UAAU,CAAA;AAEtB,cAAA,OAAO,MAAA;AAAA,YACT;AAEA,YAAA,OAAO,MAAA,CAAO,IAAA;AAAA,cACZ,CAAA,GAAA,KAAO;AACL,gBAAA,SAAA,GAAY,UAAU,CAAA;AACtB,gBAAA,OAAO,GAAA;AAAA,cACT,CAAA;AAAA,cACA,CAAA,CAAA,KAAK;AACH,gBAAA,MAAM,CAAA;AAAA,cACR;AAAA,aACF;AAAA,UACF;AAAA,SACF;AAAA,MACF,CAAA;AAAA,IACF;AAAA,GACD,CAAA;AACH;;;;"}