@sentry/cloudflare 10.53.1 → 10.55.0

package/build/esm/durableobject.js

@@ -8,182 +8,95 @@ import { instrumentContext } from './utils/instrumentContext.js';
 import { getEffectiveRpcPropagation } from './utils/rpcOptions.js';
 import { wrapMethodWithSentry } from './wrapMethodWithSentry.js';
 
-/* eslint-disable @typescript-eslint/unbound-method */
-
-const BUILT_IN_DO_METHODS = new Set([
-  'constructor',
-  'fetch',
-  'alarm',
-  'webSocketError',
-  'webSocketClose',
-  'webSocketMessage',
+const BUILT_IN_DO_METHODS = /* @__PURE__ */ new Set([
+  "constructor",
+  "fetch",
+  "alarm",
+  "webSocketError",
+  "webSocketClose",
+  "webSocketMessage"
 ]);
-
-/**
- * Instruments a Durable Object class to capture errors and performance data.
- *
- * Instruments the following methods by default:
- * - fetch
- * - alarm
- * - webSocketMessage
- * - webSocketClose
- * - webSocketError
- *
- * To instrument RPC methods (prototype methods), enable the `enableRpcTracePropagation` option.
- *
- * @param optionsCallback Function that returns the options for the SDK initialization.
- * @param DurableObjectClass The Durable Object class to instrument.
- * @returns The instrumented Durable Object class.
- *
- * @example
- * ```ts
- * class MyDurableObjectBase extends DurableObject {
- *   constructor(ctx: DurableObjectState, env: Env) {
- *     super(ctx, env);
- *   }
- * }
- *
- * export const MyDurableObject = instrumentDurableObjectWithSentry(
- *   env => ({
- *     dsn: env.SENTRY_DSN,
- *     tracesSampleRate: 1.0,
- *   }),
- *   MyDurableObjectBase,
- * );
- * ```
- */
-function instrumentDurableObjectWithSentry
-
-(optionsCallback, DurableObjectClass) {
+function instrumentDurableObjectWithSentry(optionsCallback, DurableObjectClass) {
   return new Proxy(DurableObjectClass, {
     construct(target, [ctx, env]) {
       setAsyncLocalStorageAsyncContextStrategy();
       const context = instrumentContext(ctx);
       const options = getFinalOptions(optionsCallback(env), env);
       const instrumentedEnv = instrumentEnv(env, options);
-
       const obj = new target(context, instrumentedEnv);
-
-      // These are the methods that are available on a Durable Object
-      // ref: https://developers.cloudflare.com/durable-objects/api/base/
-      // obj.alarm
-      // obj.fetch
-      // obj.webSocketError
-      // obj.webSocketClose
-      // obj.webSocketMessage
-
-      // Any other public methods on the Durable Object instance are RPC calls.
-
-      if (obj.fetch && typeof obj.fetch === 'function') {
+      if (obj.fetch && typeof obj.fetch === "function") {
         obj.fetch = ensureInstrumented(
           obj.fetch,
-          original =>
-            new Proxy(original, {
-              apply(target, thisArg, args) {
-                return wrapRequestHandler({ options, request: args[0], context }, () => {
-                  return Reflect.apply(target, thisArg, args);
-                });
-              },
-            }),
+          (original) => new Proxy(original, {
+            apply(target2, thisArg, args) {
+              return wrapRequestHandler({ options, request: args[0], context }, () => {
+                return Reflect.apply(target2, thisArg, args);
+              });
+            }
+          })
         );
       }
-
-      if (obj.alarm && typeof obj.alarm === 'function') {
-        // Alarms are independent invocations, so we start a new trace and link to the previous alarm
+      if (obj.alarm && typeof obj.alarm === "function") {
         obj.alarm = wrapMethodWithSentry(
-          { options, context, spanName: 'alarm', spanOp: 'function', startNewTrace: true },
-          obj.alarm,
+          { options, context, spanName: "alarm", spanOp: "function", startNewTrace: true },
+          obj.alarm
         );
       }
-
-      if (obj.webSocketMessage && typeof obj.webSocketMessage === 'function') {
+      if (obj.webSocketMessage && typeof obj.webSocketMessage === "function") {
         obj.webSocketMessage = wrapMethodWithSentry(
-          { options, context, spanName: 'webSocketMessage' },
-          obj.webSocketMessage,
+          { options, context, spanName: "webSocketMessage" },
+          obj.webSocketMessage
         );
       }
-
-      if (obj.webSocketClose && typeof obj.webSocketClose === 'function') {
-        obj.webSocketClose = wrapMethodWithSentry({ options, context, spanName: 'webSocketClose' }, obj.webSocketClose);
+      if (obj.webSocketClose && typeof obj.webSocketClose === "function") {
+        obj.webSocketClose = wrapMethodWithSentry({ options, context, spanName: "webSocketClose" }, obj.webSocketClose);
       }
-
-      if (obj.webSocketError && typeof obj.webSocketError === 'function') {
+      if (obj.webSocketError && typeof obj.webSocketError === "function") {
         obj.webSocketError = wrapMethodWithSentry(
-          { options, context, spanName: 'webSocketError' },
+          { options, context, spanName: "webSocketError" },
           obj.webSocketError,
-          (_, error) =>
-            captureException(error, {
-              mechanism: {
-                type: 'auto.faas.cloudflare.durable_object_websocket',
-                handled: false,
-              },
-            }),
+          (_, error) => captureException(error, {
+            mechanism: {
+              type: "auto.faas.cloudflare.durable_object_websocket",
+              handled: false
+            }
+          })
         );
       }
-
-      // Get effective RPC propagation setting (handles deprecation of instrumentPrototypeMethods)
       const rpcPropagation = getEffectiveRpcPropagation(options);
-
-      // Skip RPC instrumentation if not enabled
       if (!rpcPropagation) {
         return obj;
       }
-
-      // If `instrumentPrototypeMethods` was passed as an array (deprecated),
-      // only the listed method names should be instrumented.
-      const instrumentPrototypeMethods = Array.isArray(options.instrumentPrototypeMethods)
-        ? options.instrumentPrototypeMethods
-        : undefined;
+      const instrumentPrototypeMethods = Array.isArray(options.instrumentPrototypeMethods) ? options.instrumentPrototypeMethods : void 0;
       const allowSet = instrumentPrototypeMethods ? new Set(instrumentPrototypeMethods) : null;
-
-      // Return a Proxy that lazily wraps prototype methods on access.
-      // This avoids iterating the prototype chain at construction time —
-      // we only check if a property is an RPC method when it's accessed.
-      const rpcMethodCache = new Map();
-
+      const rpcMethodCache = /* @__PURE__ */ new Map();
       return new Proxy(obj, {
         get(proxyTarget, prop, receiver) {
           const value = Reflect.get(proxyTarget, prop, receiver);
-
-          if (typeof prop !== 'string' || BUILT_IN_DO_METHODS.has(prop)) {
+          if (typeof prop !== "string" || BUILT_IN_DO_METHODS.has(prop)) {
             return value;
           }
-
           const cached = rpcMethodCache.get(prop);
-
           if (cached) {
             return cached;
           }
-
-          if (
-            typeof value !== 'function' ||
-            Object.prototype.hasOwnProperty.call(proxyTarget, prop) ||
-            (allowSet && !allowSet.has(prop)) ||
-            // Exclude inherited Object.prototype methods (toString, valueOf, etc.)
-            // These are not RPC methods and should not create spans
-            prop in Object.prototype
-          ) {
+          if (typeof value !== "function" || Object.prototype.hasOwnProperty.call(proxyTarget, prop) || allowSet && !allowSet.has(prop) || // Exclude inherited Object.prototype methods (toString, valueOf, etc.)
+          // These are not RPC methods and should not create spans
+          prop in Object.prototype) {
             return value;
           }
-
-          // Bind the method to the original object to ensure private fields work correctly.
-          // When called via the Proxy, `this` would be the Proxy, but private fields require
-          // the original object. Bound functions ignore the thisArg passed via Reflect.apply.
-          const boundValue = (value ).bind(proxyTarget);
-
+          const boundValue = value.bind(proxyTarget);
           const wrapped = wrapMethodWithSentry(
-            { options, context, spanName: prop, spanOp: 'rpc' },
+            { options, context, spanName: prop, spanOp: "rpc" },
             boundValue,
-            undefined,
-            true,
+            void 0,
+            true
           );
-
           rpcMethodCache.set(prop, wrapped);
-
           return wrapped;
-        },
+        }
       });
-    },
+    }
   });
 }
 

package/build/esm/durableobject.js.map

@@ -1 +1 @@
-{"version":3,"file":"durableobject.js","sources":["../../src/durableobject.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/unbound-method */\nimport { captureException } from '@sentry/core';\nimport type { DurableObject } from 'cloudflare:workers';\nimport { setAsyncLocalStorageAsyncContextStrategy } from './async';\nimport type { CloudflareOptions } from './client';\nimport { ensureInstrumented } from './instrument';\nimport { instrumentEnv } from './instrumentations/worker/instrumentEnv';\nimport { getFinalOptions } from './options';\nimport { wrapRequestHandler } from './request';\nimport { instrumentContext } from './utils/instrumentContext';\nimport { getEffectiveRpcPropagation } from './utils/rpcOptions';\nimport { type UncheckedMethod, wrapMethodWithSentry } from './wrapMethodWithSentry';\n\nconst BUILT_IN_DO_METHODS = new Set([\n  'constructor',\n  'fetch',\n  'alarm',\n  'webSocketError',\n  'webSocketClose',\n  'webSocketMessage',\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 * To instrument RPC methods (prototype methods), enable the `enableRpcTracePropagation` option.\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  E,\n  T extends DurableObject<E>,\n  C extends new (state: DurableObjectState, env: E) => T,\n>(optionsCallback: (env: E) => CloudflareOptions, DurableObjectClass: C): C {\n  return new Proxy(DurableObjectClass, {\n    construct(target, [ctx, env]) {\n      setAsyncLocalStorageAsyncContextStrategy();\n      const context = instrumentContext(ctx);\n      const options = getFinalOptions(optionsCallback(env), env);\n      const instrumentedEnv = instrumentEnv(env, options);\n\n      const obj = new target(context, instrumentedEnv);\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\n      if (obj.fetch && typeof obj.fetch === 'function') {\n        obj.fetch = ensureInstrumented(\n          obj.fetch,\n          original =>\n            new Proxy(original, {\n              apply(target, thisArg, args) {\n                return wrapRequestHandler({ options, request: args[0], context }, () => {\n                  return Reflect.apply(target, thisArg, args);\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          { options, context, spanName: 'alarm', spanOp: 'function', startNewTrace: true },\n          obj.alarm,\n        );\n      }\n\n      if (obj.webSocketMessage && typeof obj.webSocketMessage === 'function') {\n        obj.webSocketMessage = wrapMethodWithSentry(\n          { options, context, spanName: 'webSocketMessage' },\n          obj.webSocketMessage,\n        );\n      }\n\n      if (obj.webSocketClose && typeof obj.webSocketClose === 'function') {\n        obj.webSocketClose = wrapMethodWithSentry({ options, context, spanName: 'webSocketClose' }, obj.webSocketClose);\n      }\n\n      if (obj.webSocketError && typeof obj.webSocketError === 'function') {\n        obj.webSocketError = wrapMethodWithSentry(\n          { options, context, spanName: 'webSocketError' },\n          obj.webSocketError,\n          (_, error) =>\n            captureException(error, {\n              mechanism: {\n                type: 'auto.faas.cloudflare.durable_object_websocket',\n                handled: false,\n              },\n            }),\n        );\n      }\n\n      // Get effective RPC propagation setting (handles deprecation of instrumentPrototypeMethods)\n      const rpcPropagation = getEffectiveRpcPropagation(options);\n\n      // Skip RPC instrumentation if not enabled\n      if (!rpcPropagation) {\n        return obj;\n      }\n\n      // If `instrumentPrototypeMethods` was passed as an array (deprecated),\n      // only the listed method names should be instrumented.\n      const instrumentPrototypeMethods = Array.isArray(options.instrumentPrototypeMethods)\n        ? options.instrumentPrototypeMethods\n        : undefined;\n      const allowSet = instrumentPrototypeMethods ? new Set(instrumentPrototypeMethods) : null;\n\n      // Return a Proxy that lazily wraps prototype methods on access.\n      // This avoids iterating the prototype chain at construction time —\n      // we only check if a property is an RPC method when it's accessed.\n      const rpcMethodCache = new Map<string, UncheckedMethod>();\n\n      return new Proxy(obj, {\n        get(proxyTarget, prop, receiver) {\n          const value = Reflect.get(proxyTarget, prop, receiver);\n\n          if (typeof prop !== 'string' || BUILT_IN_DO_METHODS.has(prop)) {\n            return value;\n          }\n\n          const cached = rpcMethodCache.get(prop);\n\n          if (cached) {\n            return cached;\n          }\n\n          if (\n            typeof value !== 'function' ||\n            Object.prototype.hasOwnProperty.call(proxyTarget, prop) ||\n            (allowSet && !allowSet.has(prop)) ||\n            // Exclude inherited Object.prototype methods (toString, valueOf, etc.)\n            // These are not RPC methods and should not create spans\n            prop in Object.prototype\n          ) {\n            return value;\n          }\n\n          // Bind the method to the original object to ensure private fields work correctly.\n          // When called via the Proxy, `this` would be the Proxy, but private fields require\n          // the original object. Bound functions ignore the thisArg passed via Reflect.apply.\n          const boundValue = (value as UncheckedMethod).bind(proxyTarget);\n\n          const wrapped = wrapMethodWithSentry(\n            { options, context, spanName: prop, spanOp: 'rpc' },\n            boundValue,\n            undefined,\n            true,\n          );\n\n          rpcMethodCache.set(prop, wrapped);\n\n          return wrapped;\n        },\n      });\n    },\n  });\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"durableobject.js","sources":["../../src/durableobject.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/unbound-method */\nimport { captureException } from '@sentry/core';\nimport type { DurableObject } from 'cloudflare:workers';\nimport { setAsyncLocalStorageAsyncContextStrategy } from './async';\nimport type { CloudflareOptions } from './client';\nimport { ensureInstrumented } from './instrument';\nimport { instrumentEnv } from './instrumentations/worker/instrumentEnv';\nimport { getFinalOptions } from './options';\nimport { wrapRequestHandler } from './request';\nimport { instrumentContext } from './utils/instrumentContext';\nimport { getEffectiveRpcPropagation } from './utils/rpcOptions';\nimport { type UncheckedMethod, wrapMethodWithSentry } from './wrapMethodWithSentry';\n\nconst BUILT_IN_DO_METHODS = new Set([\n  'constructor',\n  'fetch',\n  'alarm',\n  'webSocketError',\n  'webSocketClose',\n  'webSocketMessage',\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 * To instrument RPC methods (prototype methods), enable the `enableRpcTracePropagation` option.\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  E,\n  T extends DurableObject<E>,\n  C extends new (state: DurableObjectState, env: E) => T,\n>(optionsCallback: (env: E) => CloudflareOptions, DurableObjectClass: C): C {\n  return new Proxy(DurableObjectClass, {\n    construct(target, [ctx, env]) {\n      setAsyncLocalStorageAsyncContextStrategy();\n      const context = instrumentContext(ctx);\n      const options = getFinalOptions(optionsCallback(env), env);\n      const instrumentedEnv = instrumentEnv(env, options);\n\n      const obj = new target(context, instrumentedEnv);\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\n      if (obj.fetch && typeof obj.fetch === 'function') {\n        obj.fetch = ensureInstrumented(\n          obj.fetch,\n          original =>\n            new Proxy(original, {\n              apply(target, thisArg, args) {\n                return wrapRequestHandler({ options, request: args[0], context }, () => {\n                  return Reflect.apply(target, thisArg, args);\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          { options, context, spanName: 'alarm', spanOp: 'function', startNewTrace: true },\n          obj.alarm,\n        );\n      }\n\n      if (obj.webSocketMessage && typeof obj.webSocketMessage === 'function') {\n        obj.webSocketMessage = wrapMethodWithSentry(\n          { options, context, spanName: 'webSocketMessage' },\n          obj.webSocketMessage,\n        );\n      }\n\n      if (obj.webSocketClose && typeof obj.webSocketClose === 'function') {\n        obj.webSocketClose = wrapMethodWithSentry({ options, context, spanName: 'webSocketClose' }, obj.webSocketClose);\n      }\n\n      if (obj.webSocketError && typeof obj.webSocketError === 'function') {\n        obj.webSocketError = wrapMethodWithSentry(\n          { options, context, spanName: 'webSocketError' },\n          obj.webSocketError,\n          (_, error) =>\n            captureException(error, {\n              mechanism: {\n                type: 'auto.faas.cloudflare.durable_object_websocket',\n                handled: false,\n              },\n            }),\n        );\n      }\n\n      // Get effective RPC propagation setting (handles deprecation of instrumentPrototypeMethods)\n      const rpcPropagation = getEffectiveRpcPropagation(options);\n\n      // Skip RPC instrumentation if not enabled\n      if (!rpcPropagation) {\n        return obj;\n      }\n\n      // If `instrumentPrototypeMethods` was passed as an array (deprecated),\n      // only the listed method names should be instrumented.\n      const instrumentPrototypeMethods = Array.isArray(options.instrumentPrototypeMethods)\n        ? options.instrumentPrototypeMethods\n        : undefined;\n      const allowSet = instrumentPrototypeMethods ? new Set(instrumentPrototypeMethods) : null;\n\n      // Return a Proxy that lazily wraps prototype methods on access.\n      // This avoids iterating the prototype chain at construction time —\n      // we only check if a property is an RPC method when it's accessed.\n      const rpcMethodCache = new Map<string, UncheckedMethod>();\n\n      return new Proxy(obj, {\n        get(proxyTarget, prop, receiver) {\n          const value = Reflect.get(proxyTarget, prop, receiver);\n\n          if (typeof prop !== 'string' || BUILT_IN_DO_METHODS.has(prop)) {\n            return value;\n          }\n\n          const cached = rpcMethodCache.get(prop);\n\n          if (cached) {\n            return cached;\n          }\n\n          if (\n            typeof value !== 'function' ||\n            Object.prototype.hasOwnProperty.call(proxyTarget, prop) ||\n            (allowSet && !allowSet.has(prop)) ||\n            // Exclude inherited Object.prototype methods (toString, valueOf, etc.)\n            // These are not RPC methods and should not create spans\n            prop in Object.prototype\n          ) {\n            return value;\n          }\n\n          // Bind the method to the original object to ensure private fields work correctly.\n          // When called via the Proxy, `this` would be the Proxy, but private fields require\n          // the original object. Bound functions ignore the thisArg passed via Reflect.apply.\n          const boundValue = (value as UncheckedMethod).bind(proxyTarget);\n\n          const wrapped = wrapMethodWithSentry(\n            { options, context, spanName: prop, spanOp: 'rpc' },\n            boundValue,\n            undefined,\n            true,\n          );\n\n          rpcMethodCache.set(prop, wrapped);\n\n          return wrapped;\n        },\n      });\n    },\n  });\n}\n"],"names":["target"],"mappings":"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"}

package/build/esm/flush.js

@@ -1,55 +1,73 @@
 import { flush } from '@sentry/core';
 
-/**
- * Enhances the given execution context by wrapping its `waitUntil` method with a proxy
- * to monitor pending tasks, and provides a flusher function to ensure all tasks
- * have been completed before executing any subsequent logic.
- *
- * @param {ExecutionContext} context - The execution context to be enhanced. If no context is provided, the function returns undefined.
- * @return {FlushLock} Returns a flusher function if a valid context is provided, otherwise undefined.
- */
+const flushLockRegistries = /* @__PURE__ */ new WeakMap();
+function getOriginalWaitUntil(context) {
+  const currentWaitUntil = context.waitUntil;
+  const original = flushLockRegistries.get(currentWaitUntil)?.originalWaitUntil;
+  return original ?? currentWaitUntil;
+}
 function makeFlushLock(context) {
-  let resolveAllDone = () => undefined;
-  const allDone = new Promise(res => {
+  const registry = getOrCreateFlushLockRegistry(context);
+  let resolveAllDone = () => void 0;
+  const allDone = new Promise((res) => {
     resolveAllDone = res;
   });
   let pending = 0;
-  const originalWaitUntil = context.waitUntil.bind(context) ;
-  context.waitUntil = promise => {
-    pending++;
+  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(() => {
-        if (--pending === 0) resolveAllDone();
-      }),
+        for (const lock of locks) {
+          lock.release();
+        }
+      })
     );
   };
-  return Object.freeze({
-    ready: allDone,
-    finalize: () => {
-      if (pending === 0) resolveAllDone();
-      return allDone;
-    },
-  });
+  flushLockRegistries.set(instrumentedWaitUntil, registry);
+  context.waitUntil = instrumentedWaitUntil;
+  return registry;
 }
-
-/**
- * Flushes the client and then disposes of it to allow garbage collection.
- * This should be called at the end of each request to prevent memory leaks.
- *
- * @param client - The CloudflareClient instance to flush and dispose
- * @param timeout - Timeout in milliseconds for the flush operation
- * @returns A promise that resolves when flush and dispose are complete
- */
-async function flushAndDispose(client, timeout = 2000) {
+async function flushAndDispose(client, timeout = 2e3) {
   if (!client) {
     await flush(timeout);
-
     return;
   }
-
   await client.flush(timeout);
   client.dispose();
 }
 
-export { flushAndDispose, makeFlushLock };
+export { flushAndDispose, getOriginalWaitUntil, makeFlushLock };
 //# sourceMappingURL=flush.js.map

package/build/esm/flush.js.map

@@ -1 +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 { flush } from '@sentry/core';\n\ntype FlushLock = {\n  readonly ready: Promise<void>;\n  readonly finalize: () => Promise<void>;\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: ExecutionContext): FlushLock {\n  let resolveAllDone: () => void = () => undefined;\n  const allDone = new Promise<void>(res => {\n    resolveAllDone = res;\n  });\n  let pending = 0;\n  const originalWaitUntil = context.waitUntil.bind(context) as typeof context.waitUntil;\n  context.waitUntil = promise => {\n    pending++;\n    return originalWaitUntil(\n      promise.finally(() => {\n        if (--pending === 0) resolveAllDone();\n      }),\n    );\n  };\n  return Object.freeze({\n    ready: allDone,\n    finalize: () => {\n      if (pending === 0) resolveAllDone();\n      return allDone;\n    },\n  });\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 * @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  if (!client) {\n    await flush(timeout);\n\n    return;\n  }\n\n  await client.flush(timeout);\n  client.dispose();\n}\n"],"names":[],"mappings":";;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,aAAa,CAAC,OAAO,EAA+B;AACpE,EAAE,IAAI,cAAc,GAAe,MAAM,SAAS;AAClD,EAAE,MAAM,OAAA,GAAU,IAAI,OAAO,CAAO,OAAO;AAC3C,IAAI,cAAA,GAAiB,GAAG;AACxB,EAAE,CAAC,CAAC;AACJ,EAAE,IAAI,OAAA,GAAU,CAAC;AACjB,EAAE,MAAM,iBAAA,GAAoB,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAA;AAC1D,EAAE,OAAO,CAAC,SAAA,GAAY,WAAW;AACjC,IAAI,OAAO,EAAE;AACb,IAAI,OAAO,iBAAiB;AAC5B,MAAM,OAAO,CAAC,OAAO,CAAC,MAAM;AAC5B,QAAQ,IAAI,EAAE,OAAA,KAAY,CAAC,EAAE,cAAc,EAAE;AAC7C,MAAM,CAAC,CAAC;AACR,KAAK;AACL,EAAE,CAAC;AACH,EAAE,OAAO,MAAM,CAAC,MAAM,CAAC;AACvB,IAAI,KAAK,EAAE,OAAO;AAClB,IAAI,QAAQ,EAAE,MAAM;AACpB,MAAM,IAAI,OAAA,KAAY,CAAC,EAAE,cAAc,EAAE;AACzC,MAAM,OAAO,OAAO;AACpB,IAAI,CAAC;AACL,GAAG,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAe,eAAe,CAAC,MAAM,EAAsB,OAAA,GAAU,IAAI,EAAiB;AACjG,EAAE,IAAI,CAAC,MAAM,EAAE;AACf,IAAI,MAAM,KAAK,CAAC,OAAO,CAAC;;AAExB,IAAI;AACJ,EAAE;;AAEF,EAAE,MAAM,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC;AAC7B,EAAE,MAAM,CAAC,OAAO,EAAE;AAClB;;;;"}
+{"version":3,"file":"flush.js","sources":["../../src/flush.ts"],"sourcesContent":["import type { ExecutionContext } from '@cloudflare/workers-types';\nimport type { Client } from '@sentry/core';\nimport { flush } from '@sentry/core';\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: ExecutionContext): ExecutionContext['waitUntil'] | undefined {\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: ExecutionContext): 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: ExecutionContext): 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 * @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  if (!client) {\n    await flush(timeout);\n\n    return;\n  }\n\n  await client.flush(timeout);\n  client.dispose();\n}\n"],"names":[],"mappings":";;AAmBA,MAAM,mBAAA,uBAA0B,OAAA,EAA0D;AAgBnF,SAAS,qBAAqB,OAAA,EAAsE;AAEzG,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,EAAsC;AAClE,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,EAA8C;AAElF,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;AAUA,eAAsB,eAAA,CAAgB,MAAA,EAA4B,OAAA,GAAU,GAAA,EAAqB;AAC/F,EAAA,IAAI,CAAC,MAAA,EAAQ;AACX,IAAA,MAAM,MAAM,OAAO,CAAA;AAEnB,IAAA;AAAA,EACF;AAEA,EAAA,MAAM,MAAA,CAAO,MAAM,OAAO,CAAA;AAC1B,EAAA,MAAA,CAAO,OAAA,EAAQ;AACjB;;;;"}

package/build/esm/instrument.js

@@ -1,85 +1,44 @@
-// Use a global WeakMap to track instrumented objects across module instances.
-// This is important for Cloudflare Workers where the module may be bundled
-// separately for workers and Durable Objects, but they share the same global scope.
-// The WeakMap stores original -> instrumented mappings so we can retrieve the
-// instrumented version even if we only have a reference to the original.
-const GLOBAL_KEY = '__SENTRY_INSTRUMENTED_MAP__' ;
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const GLOBAL_KEY = "__SENTRY_INSTRUMENTED_MAP__";
 function getInstrumentedMap() {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const globalObj = globalThis ;
+  const globalObj = globalThis;
   if (!globalObj[GLOBAL_KEY]) {
-    globalObj[GLOBAL_KEY] = new WeakMap();
+    globalObj[GLOBAL_KEY] = /* @__PURE__ */ new WeakMap();
   }
   return globalObj[GLOBAL_KEY];
 }
-
-/**
- * Check if a value can be used as a WeakMap key.
- * WeakMap keys must be objects or non-registered symbols.
- */
 function isWeakMapKey(value) {
-  return (typeof value === 'object' && value !== null) || typeof value === 'function';
+  return typeof value === "object" && value !== null || typeof value === "function";
 }
-
-/**
- * Mark an object as instrumented, storing the instrumented version.
- * @param original The original uninstrumented object
- * @param instrumented The instrumented version (defaults to original if not provided)
- */
 function markAsInstrumented(original, instrumented) {
   try {
     if (isWeakMapKey(original)) {
-      // Store mapping from original to instrumented version
-      // If instrumented is not provided, store original (for backwards compat)
       getInstrumentedMap().set(original, instrumented ?? original);
     }
-    // Also mark the instrumented version itself so we recognize it
     if (isWeakMapKey(instrumented) && instrumented !== original) {
       getInstrumentedMap().set(instrumented, instrumented);
     }
   } catch {
-    // ignore errors here
   }
 }
-
-/**
- * Get the instrumented version of an object, if available.
- * Returns the instrumented version if the object was previously instrumented,
- * or undefined if not found.
- */
 function getInstrumented(obj) {
   try {
     if (isWeakMapKey(obj)) {
-      return getInstrumentedMap().get(obj) ;
+      return getInstrumentedMap().get(obj);
     }
-
-    return undefined;
+    return void 0;
   } catch {
-    return undefined;
+    return void 0;
   }
 }
-
-/**
- * Returns the already-instrumented version of `original` if one exists,
- * otherwise calls `instrumentFn` to create it, marks the mapping, and returns it.
- *
- * @param noMark - If true, skips storing the original→instrumented mapping.
- */
 function ensureInstrumented(original, instrumentFn, noMark) {
   const existing = getInstrumented(original);
-
   if (existing) {
     return existing;
   }
-
   const instrumented = instrumentFn(original);
-
   if (!noMark) {
     markAsInstrumented(original, instrumented);
   }
-
   return instrumented;
 }
 

package/build/esm/instrument.js.map

@@ -1 +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.\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 (typeof value === 'object' && value !== null) || 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":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,MAAM,UAAA,GAAa,6BAAA;;AAEnB;AACA,SAAS,kBAAkB,GAAsB;AACjD;AACA,EAAE,MAAM,SAAA,GAAY,UAAA;AACpB,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE;AAC9B,IAAI,SAAS,CAAC,UAAU,CAAA,GAAI,IAAI,OAAO,EAAE;AACzC,EAAE;AACF,EAAE,OAAO,SAAS,CAAC,UAAU,CAAC;AAC9B;;AAEA;AACA;AACA;AACA;AACA,SAAS,YAAY,CAAC,KAAK,EAA4B;AACvD,EAAE,OAAO,CAAC,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,IAAI,KAAK,OAAO,KAAA,KAAU,UAAU;AACrF;;AAEA;AACA;AACA;AACA;AACA;AACO,SAAS,kBAAkB,CAAI,QAAQ,EAAK,YAAY,EAAY;AAC3E,EAAE,IAAI;AACN,IAAI,IAAI,YAAY,CAAC,QAAQ,CAAC,EAAE;AAChC;AACA;AACA,MAAM,kBAAkB,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,YAAA,IAAgB,QAAQ,CAAC;AAClE,IAAI;AACJ;AACA,IAAI,IAAI,YAAY,CAAC,YAAY,KAAK,YAAA,KAAiB,QAAQ,EAAE;AACjE,MAAM,kBAAkB,EAAE,CAAC,GAAG,CAAC,YAAY,EAAE,YAAY,CAAC;AAC1D,IAAI;AACJ,EAAE,EAAE,MAAM;AACV;AACA,EAAE;AACF;;AAEA;AACA;AACA;AACA;AACA;AACO,SAAS,eAAe,CAAI,GAAG,EAAoB;AAC1D,EAAE,IAAI;AACN,IAAI,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE;AAC3B,MAAM,OAAO,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAA;AACzC,IAAI;;AAEJ,IAAI,OAAO,SAAS;AACpB,EAAE,EAAE,MAAM;AACV,IAAI,OAAO,SAAS;AACpB,EAAE;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,kBAAkB,CAAI,QAAQ,EAAK,YAAY,EAAsB,MAAM,EAAe;AAC1G,EAAE,MAAM,QAAA,GAAW,eAAe,CAAC,QAAQ,CAAC;;AAE5C,EAAE,IAAI,QAAQ,EAAE;AAChB,IAAI,OAAO,QAAQ;AACnB,EAAE;;AAEF,EAAE,MAAM,YAAA,GAAe,YAAY,CAAC,QAAQ,CAAC;;AAE7C,EAAE,IAAI,CAAC,MAAM,EAAE;AACf,IAAI,kBAAkB,CAAC,QAAQ,EAAE,YAAY,CAAC;AAC9C,EAAE;;AAEF,EAAE,OAAO,YAAY;AACrB;;;;"}
+{"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.\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 (typeof value === 'object' && value !== null) || 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":[],"mappings":"AAKA,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,OAAQ,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,IAAA,IAAS,OAAO,KAAA,KAAU,UAAA;AAC3E;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/esm/instrumentations/instrumentDurableObjectNamespace.js

@@ -1,61 +1,36 @@
 import { appendRpcMeta } from '../utils/rpcMeta.js';
 import { instrumentFetcher } from './worker/instrumentFetcher.js';
 
-// Built-in DurableObjectStub methods that are not RPC calls.
-const STUB_NON_RPC_METHODS = new Set(['fetch', 'connect', 'dup']);
-
-/**
- * Instruments a DurableObjectNamespace binding to create spans for DO interactions.
- *
- * Wraps:
- * - `namespace.get(id)` / `namespace.getByName(name)` with a span + instruments returned stub
- * - `namespace.idFromName(name)` / `namespace.idFromString(id)` / `namespace.newUniqueId()` with breadcrumbs
- *
- * @param namespace - The DurableObjectNamespace to instrument
- */
+const STUB_NON_RPC_METHODS = /* @__PURE__ */ new Set(["fetch", "connect", "dup"]);
 function instrumentDurableObjectNamespace(namespace) {
   return new Proxy(namespace, {
     get(target, prop, _receiver) {
-      const value = Reflect.get(target, prop) ;
-
-      if (typeof value !== 'function') {
+      const value = Reflect.get(target, prop);
+      if (typeof value !== "function") {
         return value;
       }
-
-      if (prop === 'get' || prop === 'getByName') {
-        return function ( ...args) {
+      if (prop === "get" || prop === "getByName") {
+        return function(...args) {
           const stub = Reflect.apply(value, target, args);
-
           return instrumentDurableObjectStub(stub);
         };
       }
-
       return value.bind(target);
-    },
+    }
   });
 }
-
-/**
- * Instruments a DurableObjectStub to create spans for outgoing fetch calls
- * and propagate trace context across RPC calls.
- *
- * @param stub - The DurableObjectStub to instrument
- */
 function instrumentDurableObjectStub(stub) {
   return new Proxy(stub, {
     get(target, prop) {
       const value = Reflect.get(target, prop);
-
-      if (prop === 'fetch' && typeof value === 'function') {
+      if (prop === "fetch" && typeof value === "function") {
         return instrumentFetcher((...args) => Reflect.apply(value, target, args));
       }
-
-      if (typeof value === 'function' && typeof prop === 'string' && !STUB_NON_RPC_METHODS.has(prop)) {
+      if (typeof value === "function" && typeof prop === "string" && !STUB_NON_RPC_METHODS.has(prop)) {
         return (...args) => Reflect.apply(value, target, appendRpcMeta(args));
       }
-
       return value;
-    },
+    }
   });
 }