@sentry/cloudflare 10.70.0 → 11.0.0-alpha.1

package/build/cjs/prod/durableobject.js

@@ -0,0 +1,234 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+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 index = require('./instrumentations/agents/index.js');
+const wrapMethodWithSentry = require('./wrapMethodWithSentry.js');
+
+function constructInstrumentedDurableObject(target, ctx, env, newTarget, optionsCallback) {
+  noDiagnosticChannels.setAsyncLocalStorageAsyncContextStrategy();
+  const options$1 = options.getFinalOptions(optionsCallback(env), env);
+  const context = instrumentContext.instrumentContext(ctx);
+  const instrumentedEnv = instrumentEnv.instrumentEnv(env, options$1);
+  const prototype = newTarget.prototype ?? target.prototype;
+  const cachedFrameworkManagedMethods = frameworkManagedMethodsCache.get(prototype);
+  const methodsBeforeConstruction = cachedFrameworkManagedMethods ? void 0 : resolvePrototypeMethods(prototype);
+  const obj = Reflect.construct(target, [context, instrumentedEnv], newTarget);
+  const frameworkManagedMethods = resolveFrameworkManagedMethods(
+    prototype,
+    obj,
+    methodsBeforeConstruction,
+    cachedFrameworkManagedMethods
+  );
+  instrumentDurableObjectHandlers(obj, options$1, context);
+  return { obj, options: options$1, context, frameworkManagedMethods };
+}
+const frameworkManagedMethodsCache = /* @__PURE__ */ new WeakMap();
+function resolvePrototypeMethods(prototype) {
+  const methods = /* @__PURE__ */ new Map();
+  for (let current = prototype; current && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
+    for (const name of Object.getOwnPropertyNames(current)) {
+      if (name === "constructor" || methods.has(name)) {
+        continue;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(current, name);
+      if (descriptor && typeof descriptor.value === "function") {
+        methods.set(name, descriptor.value);
+      }
+    }
+  }
+  return methods;
+}
+function resolveFrameworkManagedMethods(prototype, obj, methodsBeforeConstruction, cached) {
+  if (cached) {
+    return cached;
+  }
+  const methodsAfterConstruction = resolvePrototypeMethods(Object.getPrototypeOf(obj));
+  const managed = /* @__PURE__ */ new Set();
+  for (const [name, method] of methodsAfterConstruction) {
+    const before = methodsBeforeConstruction?.get(name);
+    if (before && before !== method) {
+      managed.add(name);
+    }
+  }
+  frameworkManagedMethodsCache.set(prototype, managed);
+  return managed;
+}
+function instrumentDurableObjectHandlers(obj, options, context) {
+  if (obj.fetch && typeof obj.fetch === "function") {
+    obj.fetch = instrument.ensureInstrumented(
+      obj.fetch.bind(obj),
+      (original) => new Proxy(original, {
+        apply(target, thisArg, args) {
+          return request.wrapRequestHandlerWithInit(
+            { options, request: args[0], context },
+            () => {
+              return Reflect.apply(target, thisArg, args);
+            },
+            sdk.init
+          );
+        }
+      })
+    );
+  }
+  if (obj.alarm && typeof obj.alarm === "function") {
+    obj.alarm = wrapMethodWithSentry.wrapMethodWithSentry(
+      {
+        options,
+        context,
+        spanName: "alarm",
+        spanOp: "function",
+        startNewTrace: true,
+        origin: "auto.faas.cloudflare.durable_object"
+      },
+      obj.alarm.bind(obj)
+    );
+  }
+  if (obj.webSocketMessage && typeof obj.webSocketMessage === "function") {
+    obj.webSocketMessage = wrapMethodWithSentry.wrapMethodWithSentry(
+      { options, context, spanName: "webSocketMessage", origin: "auto.faas.cloudflare.durable_object" },
+      obj.webSocketMessage.bind(obj)
+    );
+  }
+  if (obj.webSocketClose && typeof obj.webSocketClose === "function") {
+    obj.webSocketClose = wrapMethodWithSentry.wrapMethodWithSentry(
+      { options, context, spanName: "webSocketClose", origin: "auto.faas.cloudflare.durable_object" },
+      obj.webSocketClose.bind(obj)
+    );
+  }
+  if (obj.webSocketError && typeof obj.webSocketError === "function") {
+    obj.webSocketError = wrapMethodWithSentry.wrapMethodWithSentry(
+      { options, context, spanName: "webSocketError", origin: "auto.faas.cloudflare.durable_object" },
+      obj.webSocketError.bind(obj),
+      (_, error) => core.captureException(error, {
+        mechanism: {
+          type: "auto.faas.cloudflare.durable_object_websocket",
+          handled: false
+        }
+      })
+    );
+  }
+}
+const RESERVED_RPC_METHOD_NAMES = /* @__PURE__ */ new Set([
+  "constructor",
+  "fetch",
+  "connect",
+  "alarm",
+  "webSocketMessage",
+  "webSocketClose",
+  "webSocketError",
+  "dup"
+]);
+const rpcInstanceStates = /* @__PURE__ */ new WeakMap();
+function finalizeWithRpcInstrumentation(obj, options, context, excludedMethods) {
+  if (options.enableRpcTracePropagation === false) {
+    return obj;
+  }
+  rpcInstanceStates.set(obj, { options, context });
+  instrumentPrototypeRpcMethods(obj, excludedMethods);
+  return obj;
+}
+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);
+  if (!descriptor || typeof descriptor.value !== "function" || instrument.getInstrumented(descriptor.value)) {
+    return void 0;
+  }
+  return descriptor;
+}
+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);
+      if (!descriptor) {
+        continue;
+      }
+      const wrapped = createRpcPrototypeWrapper(methodName, descriptor.value);
+      try {
+        Object.defineProperty(prototype, methodName, { ...descriptor, value: wrapped });
+      } catch {
+      }
+      instrument.markAsInstrumented(wrapped);
+    }
+    prototype = Object.getPrototypeOf(prototype);
+  }
+}
+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) {
+      return Reflect.apply(originalMethod, this, args);
+    }
+    const tracedMethods = state.tracedMethods ?? (state.tracedMethods = /* @__PURE__ */ new Map());
+    let traced = tracedMethods.get(methodName);
+    if (!traced) {
+      traced = wrapMethodWithSentry.wrapMethodWithSentry(
+        {
+          options: state.options,
+          context: state.context,
+          spanName: methodName,
+          spanOp: "rpc",
+          origin: "auto.faas.cloudflare.durable_object"
+        },
+        originalMethod,
+        void 0,
+        true
+      );
+      tracedMethods.set(methodName, traced);
+    }
+    return Reflect.apply(traced, this, args);
+  };
+  Object.defineProperties(wrapper, {
+    name: { value: originalMethod.name, configurable: true },
+    length: { value: originalMethod.length, configurable: true }
+  });
+  return wrapper;
+}
+function instrumentDurableObjectWithSentry(optionsCallback, DurableObjectClass) {
+  return new Proxy(DurableObjectClass, {
+    construct(target, [ctx, env], newTarget) {
+      const { obj, options, context, frameworkManagedMethods } = constructInstrumentedDurableObject(
+        target,
+        ctx,
+        env,
+        newTarget,
+        optionsCallback
+      );
+      return finalizeWithRpcInstrumentation(obj, options, context, frameworkManagedMethods);
+    }
+  });
+}
+function instrumentAgentWithSentry(optionsCallback, AgentClass) {
+  return new Proxy(AgentClass, {
+    construct(target, [ctx, env], newTarget) {
+      const { obj, options, context, frameworkManagedMethods } = constructInstrumentedDurableObject(
+        target,
+        ctx,
+        env,
+        newTarget,
+        optionsCallback
+      );
+      index.instrumentCloudflareAgent(obj);
+      return finalizeWithRpcInstrumentation(obj, options, context, frameworkManagedMethods);
+    }
+  });
+}
+
+exports.constructInstrumentedDurableObject = constructInstrumentedDurableObject;
+exports.finalizeWithRpcInstrumentation = finalizeWithRpcInstrumentation;
+exports.instrumentAgentWithSentry = instrumentAgentWithSentry;
+exports.instrumentDurableObjectWithSentry = instrumentDurableObjectWithSentry;
+//# sourceMappingURL=durableobject.js.map

package/build/cjs/prod/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/prod/flush.js

@@ -0,0 +1,87 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const debugBuild = require('./debug-build.js');
+
+const flushLockRegistries = /* @__PURE__ */ new WeakMap();
+function getOriginalWaitUntil(context) {
+  const currentWaitUntil = context.waitUntil;
+  const original = flushLockRegistries.get(currentWaitUntil)?.originalWaitUntil;
+  return original ?? currentWaitUntil;
+}
+function makeFlushLock(context) {
+  const registry = getOrCreateFlushLockRegistry(context);
+  let resolveAllDone = () => void 0;
+  const allDone = new Promise((res) => {
+    resolveAllDone = res;
+  });
+  let pending = 0;
+  const lock = {
+    ready: allDone,
+    acquire: () => {
+      pending++;
+    },
+    release: () => {
+      if (--pending === 0) {
+        registry.locks.delete(lock);
+        resolveAllDone();
+      }
+    },
+    finalize: () => {
+      if (pending === 0) {
+        registry.locks.delete(lock);
+        resolveAllDone();
+      }
+      return allDone;
+    }
+  };
+  registry.locks.add(lock);
+  return Object.freeze(lock);
+}
+function getOrCreateFlushLockRegistry(context) {
+  const waitUntil = context.waitUntil;
+  const existingRegistry = flushLockRegistries.get(waitUntil);
+  if (existingRegistry) {
+    return existingRegistry;
+  }
+  const originalWaitUntil = context.waitUntil.bind(context);
+  const registry = { locks: /* @__PURE__ */ new Set(), originalWaitUntil };
+  const instrumentedWaitUntil = (promise) => {
+    const locks = [...registry.locks];
+    for (const lock of locks) {
+      lock.acquire();
+    }
+    return originalWaitUntil(
+      promise.finally(() => {
+        for (const lock of locks) {
+          lock.release();
+        }
+      })
+    );
+  };
+  flushLockRegistries.set(instrumentedWaitUntil, registry);
+  context.waitUntil = instrumentedWaitUntil;
+  return registry;
+}
+async function flushAndDispose(client, timeout = 2e3) {
+  try {
+    if (!client) {
+      await core.flush(timeout);
+      return;
+    }
+    await client.flush(timeout);
+  } catch (e) {
+    debugBuild.DEBUG_BUILD && core.debug.warn("Failed to flush client", e);
+  } finally {
+    try {
+      client?.dispose();
+    } catch (e) {
+      debugBuild.DEBUG_BUILD && core.debug.warn("Failed to dispose client", e);
+    }
+  }
+}
+
+exports.flushAndDispose = flushAndDispose;
+exports.getOriginalWaitUntil = getOriginalWaitUntil;
+exports.makeFlushLock = makeFlushLock;
+//# sourceMappingURL=flush.js.map

package/build/cjs/prod/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":";;;;;AAqBA,MAAM,mBAAA,uBAA0B,OAAA,EAA0D;AAgBnF,SAAS,qBAAqB,OAAA,EAAgE;AAEnG,EAAA,MAAM,mBAAmB,OAAA,CAAQ,SAAA;AACjC,EAAA,MAAM,QAAA,GAAW,mBAAA,CAAoB,GAAA,CAAI,gBAAgB,CAAA,EAAG,iBAAA;AAC5D,EAAA,OAAO,QAAA,IAAY,gBAAA;AACrB;AAUO,SAAS,cAAc,OAAA,EAA4C;AACxE,EAAA,MAAM,QAAA,GAAW,6BAA6B,OAAO,CAAA;AACrD,EAAA,IAAI,iBAA6B,MAAM,MAAA;AACvC,EAAA,MAAM,OAAA,GAAU,IAAI,OAAA,CAAc,CAAA,GAAA,KAAO;AACvC,IAAA,cAAA,GAAiB,GAAA;AAAA,EACnB,CAAC,CAAA;AACD,EAAA,IAAI,OAAA,GAAU,CAAA;AAEd,EAAA,MAAM,IAAA,GAA0B;AAAA,IAC9B,KAAA,EAAO,OAAA;AAAA,IACP,SAAS,MAAM;AACb,MAAA,OAAA,EAAA;AAAA,IACF,CAAA;AAAA,IACA,SAAS,MAAM;AACb,MAAA,IAAI,EAAE,YAAY,CAAA,EAAG;AACnB,QAAA,QAAA,CAAS,KAAA,CAAM,OAAO,IAAI,CAAA;AAC1B,QAAA,cAAA,EAAe;AAAA,MACjB;AAAA,IACF,CAAA;AAAA,IACA,UAAU,MAAM;AACd,MAAA,IAAI,YAAY,CAAA,EAAG;AACjB,QAAA,QAAA,CAAS,KAAA,CAAM,OAAO,IAAI,CAAA;AAC1B,QAAA,cAAA,EAAe;AAAA,MACjB;AACA,MAAA,OAAO,OAAA;AAAA,IACT;AAAA,GACF;AAEA,EAAA,QAAA,CAAS,KAAA,CAAM,IAAI,IAAI,CAAA;AACvB,EAAA,OAAO,MAAA,CAAO,OAAO,IAAI,CAAA;AAC3B;AAEA,SAAS,6BAA6B,OAAA,EAAoD;AAExF,EAAA,MAAM,YAAY,OAAA,CAAQ,SAAA;AAC1B,EAAA,MAAM,gBAAA,GAAmB,mBAAA,CAAoB,GAAA,CAAI,SAAS,CAAA;AAE1D,EAAA,IAAI,gBAAA,EAAkB;AACpB,IAAA,OAAO,gBAAA;AAAA,EACT;AAEA,EAAA,MAAM,iBAAA,GAAoB,OAAA,CAAQ,SAAA,CAAU,IAAA,CAAK,OAAO,CAAA;AACxD,EAAA,MAAM,WAA8B,EAAE,KAAA,kBAAO,IAAI,GAAA,IAAO,iBAAA,EAAkB;AAC1E,EAAA,MAAM,wBAAkD,CAAA,OAAA,KAAW;AAEjE,IAAA,MAAM,KAAA,GAAQ,CAAC,GAAG,QAAA,CAAS,KAAK,CAAA;AAEhC,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAA,CAAK,OAAA,EAAQ;AAAA,IACf;AAEA,IAAA,OAAO,iBAAA;AAAA,MACL,OAAA,CAAQ,QAAQ,MAAM;AACpB,QAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,UAAA,IAAA,CAAK,OAAA,EAAQ;AAAA,QACf;AAAA,MACF,CAAC;AAAA,KACH;AAAA,EACF,CAAA;AAEA,EAAA,mBAAA,CAAoB,GAAA,CAAI,uBAAuB,QAAQ,CAAA;AACvD,EAAA,OAAA,CAAQ,SAAA,GAAY,qBAAA;AAEpB,EAAA,OAAO,QAAA;AACT;AAeA,eAAsB,eAAA,CAAgB,MAAA,EAA4B,OAAA,GAAU,GAAA,EAAqB;AAC/F,EAAA,IAAI;AACF,IAAA,IAAI,CAAC,MAAA,EAAQ;AACX,MAAA,MAAMA,WAAM,OAAO,CAAA;AACnB,MAAA;AAAA,IACF;AACA,IAAA,MAAM,MAAA,CAAO,MAAM,OAAO,CAAA;AAAA,EAC5B,SAAS,CAAA,EAAG;AACV,IAAAC,sBAAA,IAAeC,UAAA,CAAM,IAAA,CAAK,wBAAA,EAA0B,CAAC,CAAA;AAAA,EACvD,CAAA,SAAE;AACA,IAAA,IAAI;AACF,MAAA,MAAA,EAAQ,OAAA,EAAQ;AAAA,IAClB,SAAS,CAAA,EAAG;AACV,MAAAD,sBAAA,IAAeC,UAAA,CAAM,IAAA,CAAK,0BAAA,EAA4B,CAAC,CAAA;AAAA,IACzD;AAAA,EACF;AACF;;;;;;"}

package/build/cjs/{nodejs_compat → prod}/index.js

@@ -1,28 +1,22 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const serverUtils = require('@sentry/server-utils');
-const vercelai = require('./integrations/tracing/vercelai.js');
-const client = require('../client.js');
 const core = require('@sentry/core');
-const defineCloudflareOptions = require('../defineCloudflareOptions.js');
-const fetch = require('../integrations/fetch.js');
-const sdk = require('../sdk.js');
-const hono = require('../integrations/hono.js');
-const httpServer = require('../integrations/httpServer.js');
-const durableobject = require('../durableobject.js');
-const instrumentD1 = require('../instrumentations/worker/instrumentD1.js');
-const workflows = require('../workflows.js');
-const pagesPlugin = require('../pages-plugin.js');
-const async = require('../async.js');
-const spotlight = require('../integrations/spotlight.js');
-const withSentry = require('../withSentry.js');
-const request = require('../request.js');
+const withSentry = require('./withSentry.js');
+const defineCloudflareOptions = require('./defineCloudflareOptions.js');
+const durableobject = require('./durableobject.js');
+const pagesPlugin = require('./pages-plugin.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 serverUtils = require('@sentry/server-utils');
+const workflows = require('./workflows.js');
+const noDiagnosticChannels = require('@sentry/server-utils/no-diagnostic-channels');
 
 
 
-exports.prismaIntegration = serverUtils.prismaIntegration;
-exports.vercelAIIntegration = vercelai.vercelAIIntegration;
-exports.CloudflareClient = client.CloudflareClient;
 exports.SDK_VERSION = core.SDK_VERSION;
 exports.SEMANTIC_ATTRIBUTE_SENTRY_OP = core.SEMANTIC_ATTRIBUTE_SENTRY_OP;
 exports.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN;
@@ -44,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;
@@ -63,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;
@@ -97,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;
@@ -110,21 +96,32 @@ 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;
+exports.withSentry = withSentry.withSentry;
 exports.defineCloudflareOptions = defineCloudflareOptions.defineCloudflareOptions;
-exports.fetchIntegration = fetch.fetchIntegration;
-exports.getDefaultIntegrations = sdk.getDefaultIntegrations;
-exports.honoIntegration = hono.honoIntegration;
-exports.httpServerIntegration = httpServer.httpServerIntegration;
 exports.instrumentAgentWithSentry = durableobject.instrumentAgentWithSentry;
 exports.instrumentDurableObjectWithSentry = durableobject.instrumentDurableObjectWithSentry;
-exports.instrumentD1WithSentry = instrumentD1.instrumentD1WithSentry;
-exports.instrumentWorkflowWithSentry = workflows.instrumentWorkflowWithSentry;
 exports.sentryPagesPlugin = pagesPlugin.sentryPagesPlugin;
-exports.setAsyncLocalStorageAsyncContextStrategy = async.setAsyncLocalStorageAsyncContextStrategy;
+exports.CloudflareClient = client.CloudflareClient;
+exports.getDefaultIntegrations = sdk.getDefaultIntegrations;
+exports.httpServerIntegration = httpServer.httpServerIntegration;
+exports.fetchIntegration = fetch.fetchIntegration;
 exports.spotlightIntegration = spotlight.spotlightIntegration;
-exports.withSentry = withSentry.withSentry;
-exports.wrapRequestHandler = request.wrapRequestHandler;
+exports.vercelAIIntegration = vercelai.vercelAIIntegration;
+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 = noDiagnosticChannels.setAsyncLocalStorageAsyncContextStrategy;
 //# sourceMappingURL=index.js.map

package/build/cjs/{nodejs_compat → prod}/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/prod/instrument.js

@@ -0,0 +1,52 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+const GLOBAL_KEY = "__SENTRY_INSTRUMENTED_MAP__";
+function getInstrumentedMap() {
+  const globalObj = globalThis;
+  if (!globalObj[GLOBAL_KEY]) {
+    globalObj[GLOBAL_KEY] = /* @__PURE__ */ new WeakMap();
+  }
+  return globalObj[GLOBAL_KEY];
+}
+function isWeakMapKey(value) {
+  return core.isObjectLike(value) || typeof value === "function";
+}
+function markAsInstrumented(original, instrumented) {
+  try {
+    if (isWeakMapKey(original)) {
+      getInstrumentedMap().set(original, instrumented ?? original);
+    }
+    if (isWeakMapKey(instrumented) && instrumented !== original) {
+      getInstrumentedMap().set(instrumented, instrumented);
+    }
+  } catch {
+  }
+}
+function getInstrumented(obj) {
+  try {
+    if (isWeakMapKey(obj)) {
+      return getInstrumentedMap().get(obj);
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function ensureInstrumented(original, instrumentFn, noMark) {
+  const existing = getInstrumented(original);
+  if (existing) {
+    return existing;
+  }
+  const instrumented = instrumentFn(original);
+  if (!noMark) {
+    markAsInstrumented(original, instrumented);
+  }
+  return instrumented;
+}
+
+exports.ensureInstrumented = ensureInstrumented;
+exports.getInstrumented = getInstrumented;
+exports.markAsInstrumented = markAsInstrumented;
+//# sourceMappingURL=instrument.js.map

package/build/cjs/prod/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/prod/instrumentations/agents/index.js

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const instrumentAgentCallableRpc = require('./instrumentAgentCallableRpc.js');
+const instrumentAgentRequestConversation = require('./instrumentAgentRequestConversation.js');
+const instrumentChatAgentConversation = require('./instrumentChatAgentConversation.js');
+
+function instrumentCloudflareAgent(agent) {
+  const internals = agent;
+  instrumentAgentCallableRpc.instrumentAgentCallableRpc(internals);
+  instrumentChatAgentConversation.instrumentChatAgentConversation(internals);
+  instrumentAgentRequestConversation.instrumentAgentRequestConversation(internals);
+  return agent;
+}
+
+exports.instrumentCloudflareAgent = instrumentCloudflareAgent;
+//# sourceMappingURL=index.js.map

package/build/cjs/prod/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;;;;"}