fix: Fall back to default interval (not minimum) when collectionIntervalMs is NaN

Previously, non-finite values like NaN would fall back to the 1000ms
minimum, which could surprise users expecting the documented default.
Distinguish between two error cases:
- NaN/Infinity: invalid input → fall back to the integration's default
- Below minimum: too low → clamp to 1000ms minimum

Update _INTERNAL_normalizeCollectionInterval to accept a defaultInterval
parameter and apply it for non-finite inputs. Update deno's inline logic
and all tests accordingly.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: chargome

packages/bun/src/integrations/bunRuntimeMetrics.ts

@@ -67,6 +67,7 @@ export const bunRuntimeMetricsIntegration = defineIntegration((options: BunRunti
   const collectionIntervalMs = _INTERNAL_normalizeCollectionInterval(
     options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS,
     INTEGRATION_NAME,
+    DEFAULT_INTERVAL_MS,
   );
   const collect = {
     // Default on

packages/bun/test/integrations/bunRuntimeMetrics.test.ts

@@ -231,12 +231,20 @@ describe('bunRuntimeMetricsIntegration', () => {
       expect(gaugeSpy).toHaveBeenCalled();
     });
 
-    it('falls back to minimum when NaN', () => {
+    it('falls back to default when NaN', () => {
       const warnSpy = spyOn(globalThis.console, 'warn').mockImplementation(() => {});
 
-      bunRuntimeMetricsIntegration({ collectionIntervalMs: NaN });
+      const integration = bunRuntimeMetricsIntegration({ collectionIntervalMs: NaN });
+      integration.setup();
 
       expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('collectionIntervalMs'));
+
+      // Should fire at the default 30000ms, not at 1000ms
+      jest.advanceTimersByTime(1000);
+      expect(gaugeSpy).not.toHaveBeenCalled();
+
+      jest.advanceTimersByTime(29_000);
+      expect(gaugeSpy).toHaveBeenCalled();
     });
   });
 });

packages/deno/src/integrations/denoRuntimeMetrics.ts

@@ -49,13 +49,22 @@ export interface DenoRuntimeMetricsOptions {
  */
 export const denoRuntimeMetricsIntegration = defineIntegration((options: DenoRuntimeMetricsOptions = {}) => {
   const rawInterval = options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS;
-  if (!Number.isFinite(rawInterval) || rawInterval < MIN_INTERVAL_MS) {
+  let collectionIntervalMs: number;
+  if (!Number.isFinite(rawInterval)) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[Sentry] denoRuntimeMetricsIntegration: collectionIntervalMs (${rawInterval}) is invalid. Using default of ${DEFAULT_INTERVAL_MS}ms.`,
+    );
+    collectionIntervalMs = DEFAULT_INTERVAL_MS;
+  } else if (rawInterval < MIN_INTERVAL_MS) {
     // eslint-disable-next-line no-console
     console.warn(
       `[Sentry] denoRuntimeMetricsIntegration: collectionIntervalMs (${rawInterval}) is below the minimum of ${MIN_INTERVAL_MS}ms. Using minimum of ${MIN_INTERVAL_MS}ms.`,
     );
+    collectionIntervalMs = MIN_INTERVAL_MS;
+  } else {
+    collectionIntervalMs = rawInterval;
   }
-  const collectionIntervalMs = Number.isFinite(rawInterval) ? Math.max(rawInterval, MIN_INTERVAL_MS) : MIN_INTERVAL_MS;
   const collect = {
     // Default on
     memRss: true,

packages/deno/test/deno-runtime-metrics.test.ts

@@ -135,7 +135,7 @@ Deno.test('warns and enforces minimum collectionIntervalMs', () => {
   assertStringIncludes(warnings[0]!, '1000');
 });
 
-Deno.test('warns and falls back to minimum when collectionIntervalMs is NaN', () => {
+Deno.test('warns and falls back to default when collectionIntervalMs is NaN', () => {
   const warnings: string[] = [];
   const originalWarn = globalThis.console.warn;
   globalThis.console.warn = (msg: string) => warnings.push(msg);
@@ -148,4 +148,5 @@ Deno.test('warns and falls back to minimum when collectionIntervalMs is NaN', ()
 
   assertEquals(warnings.length, 1);
   assertStringIncludes(warnings[0]!, 'collectionIntervalMs');
+  assertStringIncludes(warnings[0]!, 'invalid');
 });

packages/node-core/src/integrations/nodeRuntimeMetrics.ts

@@ -8,17 +8,30 @@ const EVENT_LOOP_DELAY_RESOLUTION_MS = 10;
 
 /**
  * Normalizes a `collectionIntervalMs` value, enforcing a minimum of 1000ms.
- * Warns if the value is below the minimum or non-finite (e.g. NaN).
+ * - Non-finite values (NaN, Infinity): warns and falls back to `defaultInterval`.
+ * - Values below the minimum: warns and clamps to 1000ms.
  * @internal
  */
-export function _INTERNAL_normalizeCollectionInterval(rawInterval: number, integrationName: string): number {
-  if (!Number.isFinite(rawInterval) || rawInterval < MIN_COLLECTION_INTERVAL_MS) {
+export function _INTERNAL_normalizeCollectionInterval(
+  rawInterval: number,
+  integrationName: string,
+  defaultInterval: number,
+): number {
+  if (!Number.isFinite(rawInterval)) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[Sentry] ${integrationName}: collectionIntervalMs (${rawInterval}) is invalid. Using default of ${defaultInterval}ms.`,
+    );
+    return defaultInterval;
+  }
+  if (rawInterval < MIN_COLLECTION_INTERVAL_MS) {
     // eslint-disable-next-line no-console
     console.warn(
       `[Sentry] ${integrationName}: collectionIntervalMs (${rawInterval}) is below the minimum of ${MIN_COLLECTION_INTERVAL_MS}ms. Using minimum of ${MIN_COLLECTION_INTERVAL_MS}ms.`,
     );
+    return MIN_COLLECTION_INTERVAL_MS;
   }
-  return Number.isFinite(rawInterval) ? Math.max(rawInterval, MIN_COLLECTION_INTERVAL_MS) : MIN_COLLECTION_INTERVAL_MS;
+  return rawInterval;
 }
 
 export interface NodeRuntimeMetricsOptions {
@@ -83,6 +96,7 @@ export const nodeRuntimeMetricsIntegration = defineIntegration((options: NodeRun
   const collectionIntervalMs = _INTERNAL_normalizeCollectionInterval(
     options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS,
     INTEGRATION_NAME,
+    DEFAULT_INTERVAL_MS,
   );
   const collect = {
     // Default on

packages/node-core/test/integrations/nodeRuntimeMetrics.test.ts

@@ -349,13 +349,21 @@ describe('nodeRuntimeMetricsIntegration', () => {
       warnSpy.mockRestore();
     });
 
-    it('falls back to minimum when collectionIntervalMs is NaN', () => {
+    it('falls back to default when collectionIntervalMs is NaN', () => {
       const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
 
-      nodeRuntimeMetricsIntegration({ collectionIntervalMs: NaN });
+      const integration = nodeRuntimeMetricsIntegration({ collectionIntervalMs: NaN });
+      integration.setup();
 
       expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('collectionIntervalMs'));
 
+      // Should fire at the default 30000ms, not at 1000ms
+      vi.advanceTimersByTime(1000);
+      expect(gaugeSpy).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(29_000);
+      expect(gaugeSpy).toHaveBeenCalled();
+
       warnSpy.mockRestore();
     });
   });