feat(cloudflare): Consolidate startNewTrace and linkPreviousTrace

packages/cloudflare/src/durableobject.ts

@@ -85,7 +85,7 @@ export function instrumentDurableObjectWithSentry<
       if (obj.alarm && typeof obj.alarm === 'function') {
         // Alarms are independent invocations, so we start a new trace and link to the previous alarm
         obj.alarm = wrapMethodWithSentry(
-          { options, context, spanName: 'alarm', spanOp: 'function', startNewTrace: true, linkPreviousTrace: true },
+          { options, context, spanName: 'alarm', spanOp: 'function', startNewTrace: true },
           obj.alarm,
         );
       }

packages/cloudflare/src/wrapMethodWithSentry.ts

@@ -30,17 +30,14 @@ type MethodWrapperOptions = {
   /**
    * If true, starts a fresh trace instead of inheriting from a parent trace.
    * Useful for scheduled/independent invocations like alarms.
-   * @default false
-   */
-  startNewTrace?: boolean;
-  /**
-   * If true, stores the current span context and links to the previous invocation's span.
-   * Requires `startNewTrace` to be true. Uses Durable Object storage to persist the link.
-   * The link is set asynchronously via `span.addLinks()` in a `waitUntil` to avoid blocking.
+   *
+   * If true, it also stores the current span context and links to the previous invocation's span.
+   * Uses Durable Object storage to persist the link. The link is set asynchronously via `span.addLinks()`
+   * in a `waitUntil` to avoid blocking.
    *
    * @default false
    */
-  linkPreviousTrace?: boolean;
+  startNewTrace?: boolean;
 };
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -68,7 +65,7 @@ export function wrapMethodWithSentry<T extends OriginalMethod>(
     original =>
       new Proxy(original, {
         apply(target, thisArg, args: Parameters<T>) {
-          const { startNewTrace, linkPreviousTrace } = wrapperOptions;
+          const { startNewTrace } = wrapperOptions;
 
           // For startNewTrace, always use withIsolationScope to ensure a fresh scope
           // Otherwise, use existing client's scope or isolation scope
@@ -102,7 +99,7 @@ export function wrapMethodWithSentry<T extends OriginalMethod>(
             const methodName = wrapperOptions.spanName || 'unknown';
 
             const teardown = async (): Promise<void> => {
-              if (linkPreviousTrace && storage) {
+              if (startNewTrace && storage) {
                 await storeSpanContext(storage, methodName);
               }
               await flushAndDispose(clientToDispose);
@@ -149,7 +146,6 @@ export function wrapMethodWithSentry<T extends OriginalMethod>(
               }
             }
 
-            const spanName = wrapperOptions.spanName || methodName;
             const attributes = wrapperOptions.spanOp
               ? {
                   [SEMANTIC_ATTRIBUTE_SENTRY_OP]: wrapperOptions.spanOp,
@@ -158,10 +154,10 @@ export function wrapMethodWithSentry<T extends OriginalMethod>(
               : {};
 
             const executeSpan = (): unknown => {
-              return startSpan({ name: spanName, attributes }, span => {
+              return startSpan({ name: methodName, attributes }, span => {
                 // When linking to previous trace, fetch the stored context and add links asynchronously
                 // This avoids blocking the response while fetching from storage
-                if (linkPreviousTrace && storage) {
+                if (startNewTrace && storage) {
                   waitUntil?.(
                     getStoredSpanContext(storage, methodName).then(storedContext => {
                       if (storedContext) {

packages/cloudflare/test/wrapMethodWithSentry.test.ts

@@ -147,7 +147,7 @@ describe('wrapMethodWithSentry', () => {
       expect(handler).toHaveBeenCalled();
     });
 
-    it('does not change sync/async behavior when linkPreviousTrace is true (links are set via waitUntil)', () => {
+    it('does not change sync/async behavior when startNewTrace is true (links are set via waitUntil)', () => {
       const handler = vi.fn().mockReturnValue('sync-result');
       const mockStorage = {
         get: vi.fn().mockResolvedValue(undefined),
@@ -164,13 +164,12 @@ describe('wrapMethodWithSentry', () => {
         context,
         spanName: 'alarm',
         startNewTrace: true,
-        linkPreviousTrace: true,
       };
 
       const wrapped = wrapMethodWithSentry(options, handler);
       const result = wrapped();
 
-      // linkPreviousTrace does not make the result async - links are set via waitUntil
+      // startNewTrace does not make the result async - links are set via waitUntil
       expect(result).not.toBeInstanceOf(Promise);
       expect(result).toBe('sync-result');
 
@@ -345,8 +344,8 @@ describe('wrapMethodWithSentry', () => {
     });
   });
 
-  describe('linkPreviousTrace option', () => {
-    it('retrieves stored span context when linkPreviousTrace is true', async () => {
+  describe('span linking', () => {
+    it('retrieves stored span context when startNewTrace is true', async () => {
       const storedContext = {
         traceId: 'previous-trace-id-1234567890123456',
         spanId: 'previous-span-id',
@@ -365,7 +364,6 @@ describe('wrapMethodWithSentry', () => {
         options: {},
         context,
         startNewTrace: true,
-        linkPreviousTrace: true,
         spanName: 'alarm',
       };
 
@@ -399,7 +397,6 @@ describe('wrapMethodWithSentry', () => {
         options: {},
         context,
         startNewTrace: true,
-        linkPreviousTrace: true,
         spanName: 'alarm',
       };
 
@@ -423,7 +420,7 @@ describe('wrapMethodWithSentry', () => {
       );
     });
 
-    it('stores span context after execution when linkPreviousTrace is true', async () => {
+    it('stores span context after execution when startNewTrace is true', async () => {
       vi.mocked(sentryCore.getActiveSpan).mockReturnValue({
         spanContext: vi.fn().mockReturnValue({
           traceId: 'current-trace-id-123456789012345678',
@@ -445,7 +442,6 @@ describe('wrapMethodWithSentry', () => {
         options: {},
         context,
         startNewTrace: true,
-        linkPreviousTrace: true,
         spanName: 'alarm',
       };
 
@@ -456,7 +452,7 @@ describe('wrapMethodWithSentry', () => {
       expect(mockStorage.put).toHaveBeenCalledWith('__SENTRY_TRACE_LINK__alarm', expect.any(Object));
     });
 
-    it('does not store span context when linkPreviousTrace is false', async () => {
+    it('does not store span context when startNewTrace is false', async () => {
       vi.mocked(sentryCore.getActiveSpan).mockReturnValue({
         spanContext: vi.fn().mockReturnValue({
           traceId: 'current-trace-id-123456789012345678',
@@ -479,8 +475,7 @@ describe('wrapMethodWithSentry', () => {
       const options = {
         options: {},
         context,
-        startNewTrace: true,
-        linkPreviousTrace: false,
+        startNewTrace: false,
         spanName: 'alarm',
       };
 
@@ -490,7 +485,7 @@ describe('wrapMethodWithSentry', () => {
       // Wait for all waitUntil promises to resolve
       await Promise.all(waitUntilPromises);
 
-      // Should NOT store span context when linkPreviousTrace is false
+      // Should NOT store span context when startNewTrace is false
       expect(mockStorage.put).not.toHaveBeenCalledWith('__SENTRY_TRACE_LINK__alarm', expect.any(Object));
     });
   });