feat(core): Add isolateTrace option to Sentry.withMonitor()

dev-packages/node-integration-tests/suites/public-api/withMonitor/scenario.ts

@@ -0,0 +1,28 @@
+import { withMonitor } from '@sentry/node';
+
+export async function run(): Promise<void> {
+  // First withMonitor call without isolateTrace (should share trace)
+  await withMonitor('cron-job-1', async () => {
+    // Simulate some work
+    await new Promise<void>((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, 100);
+    });
+  }, {
+    schedule: { type: 'crontab', value: '* * * * *' }
+  });
+
+  // Second withMonitor call with isolateTrace (should have different trace)
+  await withMonitor('cron-job-2', async () => {
+    // Simulate some work
+    await new Promise<void>((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, 100);
+    });
+  }, {
+    schedule: { type: 'crontab', value: '* * * * *' },
+    isolateTrace: true
+  });
+}

dev-packages/node-integration-tests/suites/public-api/withMonitor/test.ts

@@ -0,0 +1,19 @@
+import { expect } from 'vitest';
+import type { Event, TransactionEvent } from '@sentry/types';
+
+export async function testResults(events: Event[]): Promise<void> {
+  // Get all transaction events (which represent traces)
+  const transactionEvents = events.filter((event): event is TransactionEvent => event.type === 'transaction');
+
+  // Should have at least 2 transaction events (one for each withMonitor call)
+  expect(transactionEvents.length).toBeGreaterThanOrEqual(2);
+
+  // Get trace IDs from the transactions
+  const traceIds = transactionEvents.map(event => event.contexts?.trace?.trace_id).filter(Boolean);
+
+  // Should have at least 2 different trace IDs (verifying trace isolation)
+  const uniqueTraceIds = [...new Set(traceIds)];
+  expect(uniqueTraceIds.length).toBeGreaterThanOrEqual(2);
+
+  console.log('✅ Found traces with different trace IDs:', uniqueTraceIds);
+}

packages/core/src/exports.ts

@@ -15,6 +15,7 @@ import { isThenable } from './utils/is';
 import { uuid4 } from './utils/misc';
 import type { ExclusiveEventHintOrCaptureContext } from './utils/prepareEvent';
 import { parseEventHintOrCaptureContext } from './utils/prepareEvent';
+import { startNewTrace } from './tracing/trace';
 import { timestampInSeconds } from './utils/time';
 import { GLOBAL_OBJ } from './utils/worldwide';
 
@@ -167,6 +168,36 @@ export function withMonitor<T>(
   }
 
   return withIsolationScope(() => {
+    // If isolateTrace is enabled, start a new trace for this monitor execution
+    if (upsertMonitorConfig?.isolateTrace) {
+      return startNewTrace(() => {
+        let maybePromiseResult: T;
+        try {
+          maybePromiseResult = callback();
+        } catch (e) {
+          finishCheckIn('error');
+          throw e;
+        }
+
+        if (isThenable(maybePromiseResult)) {
+          return maybePromiseResult.then(
+            r => {
+              finishCheckIn('ok');
+              return r;
+            },
+            e => {
+              finishCheckIn('error');
+              throw e;
+            },
+          ) as T;
+        }
+        finishCheckIn('ok');
+
+        return maybePromiseResult;
+      });
+    }
+
+    // Default behavior without isolateTrace
     let maybePromiseResult: T;
     try {
       maybePromiseResult = callback();

packages/core/src/types-hoist/checkin.ts

@@ -105,4 +105,9 @@ export interface MonitorConfig {
   failureIssueThreshold?: SerializedMonitorConfig['failure_issue_threshold'];
   /** How many consecutive OK check-ins it takes to resolve an issue. */
   recoveryThreshold?: SerializedMonitorConfig['recovery_threshold'];
+  /**
+   * If set to true, creates a new trace for the monitor callback instead of continuing the current trace.
+   * This allows distinguishing between different cron job executions.
+   */
+  isolateTrace?: boolean;
 }

packages/core/test/lib/client.test.ts

@@ -11,6 +11,7 @@ import {
   SyncPromise,
   withMonitor,
 } from '../../src';
+import { startNewTrace } from '../../src/tracing';
 import * as integrationModule from '../../src/integration';
 import { _INTERNAL_captureLog } from '../../src/logs/internal';
 import { _INTERNAL_captureMetric } from '../../src/metrics/internal';
@@ -2600,6 +2601,43 @@ describe('Client', () => {
       const promise = await withMonitor('test-monitor', callback);
       await expect(promise).rejects.toThrowError(error);
     });
+
+    test('accepts isolateTrace option without error', () => {
+      const result = 'foo';
+      const callback = vi.fn().mockReturnValue(result);
+
+      const returnedResult = withMonitor('test-monitor', callback, {
+        schedule: { type: 'crontab', value: '* * * * *' },
+        isolateTrace: true
+      });
+
+      expect(returnedResult).toBe(result);
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    test('works with isolateTrace set to false', () => {
+      const result = 'foo';
+      const callback = vi.fn().mockReturnValue(result);
+
+      const returnedResult = withMonitor('test-monitor', callback, {
+        schedule: { type: 'crontab', value: '* * * * *' },
+        isolateTrace: false
+      });
+
+      expect(returnedResult).toBe(result);
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    test('handles isolateTrace with asynchronous operations', async () => {
+      const result = 'foo';
+      const callback = vi.fn().mockResolvedValue(result);
+
+      const promise = withMonitor('test-monitor', callback, {
+        schedule: { type: 'crontab', value: '* * * * *' },
+        isolateTrace: true
+      });
+      await expect(promise).resolves.toEqual(result);
+    });
   });
 
   describe('log weight-based flushing', () => {