ref(cloudflare): Move internal files and functions around (#19369)

JPeer264 · web-flow · commit f0e1cb4258a1 · 2026-02-18T11:53:43.000+01:00
This actually doesn't add any functionality or remove functionality. This PR only prepares for future PRs where we add instrumentations for DurableObjects. As the functionality will grow and reduce line size I moved them around Following is being moved: - `copyExecutionContext` -> `instrumentContext` - outsourced `wrapMethodWithSentry` Closes #19370 (added automatically)
diff --git a/packages/cloudflare/src/durableobject.ts b/packages/cloudflare/src/durableobject.ts
@@ -1,159 +1,14 @@
 /* eslint-disable @typescript-eslint/unbound-method */
-import {
-  captureException,
-  flush,
-  getClient,
-  isThenable,
-  type Scope,
-  SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  startSpan,
-  withIsolationScope,
-  withScope,
-} from '@sentry/core';
+import { captureException } from '@sentry/core';
 import type { DurableObject } from 'cloudflare:workers';
 import { setAsyncLocalStorageAsyncContextStrategy } from './async';
 import type { CloudflareOptions } from './client';
 import { isInstrumented, markAsInstrumented } from './instrument';
 import { getFinalOptions } from './options';
 import { wrapRequestHandler } from './request';
-import { init } from './sdk';
-import { copyExecutionContext } from './utils/copyExecutionContext';
-
-type MethodWrapperOptions = {
-  spanName?: string;
-  spanOp?: string;
-  options: CloudflareOptions;
-  context: ExecutionContext | DurableObjectState;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type UncheckedMethod = (...args: any[]) => any;
-type OriginalMethod = UncheckedMethod;
-
-function wrapMethodWithSentry<T extends OriginalMethod>(
-  wrapperOptions: MethodWrapperOptions,
-  handler: T,
-  callback?: (...args: Parameters<T>) => void,
-  noMark?: true,
-): T {
-  if (isInstrumented(handler)) {
-    return handler;
-  }
-
-  if (!noMark) {
-    markAsInstrumented(handler);
-  }
-
-  return new Proxy(handler, {
-    apply(target, thisArg, args: Parameters<T>) {
-      const currentClient = getClient();
-      // if a client is already set, use withScope, otherwise use withIsolationScope
-      const sentryWithScope = currentClient ? withScope : withIsolationScope;
-
-      const wrappedFunction = (scope: Scope): unknown => {
-        // In certain situations, the passed context can become undefined.
-        // For example, for Astro while prerendering pages at build time.
-        // see: https://github.com/getsentry/sentry-javascript/issues/13217
-        const context = wrapperOptions.context as ExecutionContext | undefined;
-
-        const waitUntil = context?.waitUntil?.bind?.(context);
-
-        const currentClient = scope.getClient();
-        if (!currentClient) {
-          const client = init({ ...wrapperOptions.options, ctx: context });
-          scope.setClient(client);
-        }
-
-        if (!wrapperOptions.spanName) {
-          try {
-            if (callback) {
-              callback(...args);
-            }
-            const result = Reflect.apply(target, thisArg, args);
-
-            if (isThenable(result)) {
-              return result.then(
-                (res: unknown) => {
-                  waitUntil?.(flush(2000));
-                  return res;
-                },
-                (e: unknown) => {
-                  captureException(e, {
-                    mechanism: {
-                      type: 'auto.faas.cloudflare.durable_object',
-                      handled: false,
-                    },
-                  });
-                  waitUntil?.(flush(2000));
-                  throw e;
-                },
-              );
-            } else {
-              waitUntil?.(flush(2000));
-              return result;
-            }
-          } catch (e) {
-            captureException(e, {
-              mechanism: {
-                type: 'auto.faas.cloudflare.durable_object',
-                handled: false,
-              },
-            });
-            waitUntil?.(flush(2000));
-            throw e;
-          }
-        }
-
-        const attributes = wrapperOptions.spanOp
-          ? {
-              [SEMANTIC_ATTRIBUTE_SENTRY_OP]: wrapperOptions.spanOp,
-              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.faas.cloudflare.durable_object',
-            }
-          : {};
-
-        return startSpan({ name: wrapperOptions.spanName, attributes }, () => {
-          try {
-            const result = Reflect.apply(target, thisArg, args);
-
-            if (isThenable(result)) {
-              return result.then(
-                (res: unknown) => {
-                  waitUntil?.(flush(2000));
-                  return res;
-                },
-                (e: unknown) => {
-                  captureException(e, {
-                    mechanism: {
-                      type: 'auto.faas.cloudflare.durable_object',
-                      handled: false,
-                    },
-                  });
-                  waitUntil?.(flush(2000));
-                  throw e;
-                },
-              );
-            } else {
-              waitUntil?.(flush(2000));
-              return result;
-            }
-          } catch (e) {
-            captureException(e, {
-              mechanism: {
-                type: 'auto.faas.cloudflare.durable_object',
-                handled: false,
-              },
-            });
-            waitUntil?.(flush(2000));
-            throw e;
-          }
-        });
-      };
-
-      return sentryWithScope(wrappedFunction);
-    },
-  });
-}
+import { instrumentContext } from './utils/instrumentContext';
+import type { UncheckedMethod } from './wrapMethodWithSentry';
+import { wrapMethodWithSentry } from './wrapMethodWithSentry';
 
 /**
  * Instruments a Durable Object class to capture errors and performance data.
@@ -196,7 +51,7 @@ export function instrumentDurableObjectWithSentry<
   return new Proxy(DurableObjectClass, {
     construct(target, [ctx, env]) {
       setAsyncLocalStorageAsyncContextStrategy();
-      const context = copyExecutionContext(ctx);
+      const context = instrumentContext(ctx);
 
       const options = getFinalOptions(optionsCallback(env), env);
 
diff --git a/packages/cloudflare/src/handler.ts b/packages/cloudflare/src/handler.ts
@@ -15,7 +15,7 @@ import { getFinalOptions } from './options';
 import { wrapRequestHandler } from './request';
 import { addCloudResourceContext } from './scope-utils';
 import { init } from './sdk';
-import { copyExecutionContext } from './utils/copyExecutionContext';
+import { instrumentContext } from './utils/instrumentContext';
 
 /**
  * Wrapper for Cloudflare handlers.
@@ -46,7 +46,7 @@ export function withSentry<
       handler.fetch = new Proxy(handler.fetch, {
         apply(target, thisArg, args: Parameters<ExportedHandlerFetchHandler<Env, CfHostMetadata>>) {
           const [request, env, ctx] = args;
-          const context = copyExecutionContext(ctx);
+          const context = instrumentContext(ctx);
           args[2] = context;
 
           const options = getFinalOptions(optionsCallback(env), env);
@@ -82,7 +82,7 @@ export function withSentry<
       handler.scheduled = new Proxy(handler.scheduled, {
         apply(target, thisArg, args: Parameters<ExportedHandlerScheduledHandler<Env>>) {
           const [event, env, ctx] = args;
-          const context = copyExecutionContext(ctx);
+          const context = instrumentContext(ctx);
           args[2] = context;
 
           return withIsolationScope(isolationScope => {
@@ -128,7 +128,7 @@ export function withSentry<
       handler.email = new Proxy(handler.email, {
         apply(target, thisArg, args: Parameters<EmailExportedHandler<Env>>) {
           const [emailMessage, env, ctx] = args;
-          const context = copyExecutionContext(ctx);
+          const context = instrumentContext(ctx);
           args[2] = context;
 
           return withIsolationScope(isolationScope => {
@@ -172,7 +172,7 @@ export function withSentry<
       handler.queue = new Proxy(handler.queue, {
         apply(target, thisArg, args: Parameters<ExportedHandlerQueueHandler<Env, QueueHandlerMessage>>) {
           const [batch, env, ctx] = args;
-          const context = copyExecutionContext(ctx);
+          const context = instrumentContext(ctx);
           args[2] = context;
 
           return withIsolationScope(isolationScope => {
@@ -224,7 +224,7 @@ export function withSentry<
       handler.tail = new Proxy(handler.tail, {
         apply(target, thisArg, args: Parameters<ExportedHandlerTailHandler<Env>>) {
           const [, env, ctx] = args;
-          const context = copyExecutionContext(ctx);
+          const context = instrumentContext(ctx);
           args[2] = context;
 
           return withIsolationScope(async isolationScope => {
diff --git a/packages/cloudflare/src/utils/instrumentContext.ts b/packages/cloudflare/src/utils/instrumentContext.ts
@@ -4,29 +4,35 @@ type ContextType = ExecutionContext | DurableObjectState;
 type OverridesStore<T extends ContextType> = Map<keyof T, (...args: unknown[]) => unknown>;
 
 /**
- * Creates a new copy of the given execution context, optionally overriding methods.
+ * Instruments an execution context or DurableObjectState with Sentry tracing.
  *
- * @param {ContextType|void} ctx - The execution context to be copied. Can be of type `ContextType` or `void`.
- * @return {ContextType|void} A new execution context with the same properties and overridden methods if applicable.
+ * Creates a copy of the context that:
+ * - Allows overriding of methods (e.g., waitUntil)
+ *
+ * @param ctx - The execution context or DurableObjectState to instrument
+ * @returns An instrumented copy of the context
  */
-export function copyExecutionContext<T extends ContextType>(ctx: T): T {
+export function instrumentContext<T extends ContextType>(ctx: T): T {
   if (!ctx) return ctx;
 
   const overrides: OverridesStore<T> = new Map();
   const contextPrototype = Object.getPrototypeOf(ctx);
   const prototypeMethodNames = Object.getOwnPropertyNames(contextPrototype) as unknown as (keyof T)[];
   const ownPropertyNames = Object.getOwnPropertyNames(ctx) as unknown as (keyof T)[];
   const instrumented = new Set<unknown>(['constructor']);
-  const descriptors = [...ownPropertyNames, ...prototypeMethodNames].reduce((prevDescriptors, methodName) => {
-    if (instrumented.has(methodName)) return prevDescriptors;
-    if (typeof ctx[methodName] !== 'function') return prevDescriptors;
-    instrumented.add(methodName);
-    const overridableDescriptor = makeOverridableDescriptor(overrides, ctx, methodName);
-    return {
-      ...prevDescriptors,
-      [methodName]: overridableDescriptor,
-    };
-  }, {});
+  const descriptors: PropertyDescriptorMap = [...ownPropertyNames, ...prototypeMethodNames].reduce(
+    (prevDescriptors, methodName) => {
+      if (instrumented.has(methodName)) return prevDescriptors;
+      if (typeof ctx[methodName] !== 'function') return prevDescriptors;
+      instrumented.add(methodName);
+      const overridableDescriptor = makeOverridableDescriptor(overrides, ctx, methodName);
+      return {
+        ...prevDescriptors,
+        [methodName]: overridableDescriptor,
+      };
+    },
+    {} as PropertyDescriptorMap,
+  );
 
   return Object.create(ctx, descriptors);
 }
diff --git a/packages/cloudflare/src/workflows.ts b/packages/cloudflare/src/workflows.ts
@@ -22,7 +22,7 @@ import { setAsyncLocalStorageAsyncContextStrategy } from './async';
 import type { CloudflareOptions } from './client';
 import { addCloudResourceContext } from './scope-utils';
 import { init } from './sdk';
-import { copyExecutionContext } from './utils/copyExecutionContext';
+import { instrumentContext } from './utils/instrumentContext';
 
 const UUID_REGEX = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i;
 
@@ -158,7 +158,7 @@ export function instrumentWorkflowWithSentry<
   return new Proxy(WorkFlowClass, {
     construct(target: C, args: [ctx: ExecutionContext, env: E], newTarget) {
       const [ctx, env] = args;
-      const context = copyExecutionContext(ctx);
+      const context = instrumentContext(ctx);
       args[0] = context;
 
       const options = optionsCallback(env);
diff --git a/packages/cloudflare/src/wrapMethodWithSentry.ts b/packages/cloudflare/src/wrapMethodWithSentry.ts
diff --git a/packages/cloudflare/test/instrumentContext.test.ts b/packages/cloudflare/test/instrumentContext.test.ts
