ref(cloudflare): Move internal files and functions around

dev-packages/e2e-tests/test-applications/astro-5-cf-workers/wrangler.jsonc

@@ -8,11 +8,10 @@
     "SENTRY_DSN": "https://username@domain/123",
     "SENTRY_ENVIRONMENT": "qa",
     "SENTRY_TRACES_SAMPLE_RATE": "1.0",
-    "SENTRY_TUNNEL": "http://localhost:3031/"
+    "SENTRY_TUNNEL": "http://localhost:3031/",
   },
   "assets": {
     "binding": "ASSETS",
-    "directory": "./dist"
-  }
+    "directory": "./dist",
+  },
 }
-

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);
 

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 => {

packages/cloudflare/src/utils/copyExecutionContext.ts → 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);
 }

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);