use min value for all runtime metrics

Author: chargome

packages/bun/src/integrations/bunRuntimeMetrics.ts

@@ -1,6 +1,6 @@
 import { performance } from 'perf_hooks';
 import { _INTERNAL_safeDateNow, _INTERNAL_safeUnref, defineIntegration, metrics } from '@sentry/core';
-import type { NodeRuntimeMetricsOptions } from '@sentry/node';
+import { _INTERNAL_normalizeCollectionInterval, type NodeRuntimeMetricsOptions } from '@sentry/node';
 
 const INTEGRATION_NAME = 'BunRuntimeMetrics';
 const DEFAULT_INTERVAL_MS = 30_000;
@@ -44,7 +44,9 @@ export interface BunRuntimeMetricsOptions {
   collect?: BunCollectOptions;
   /**
    * How often to collect metrics, in milliseconds.
+   * Minimum allowed value is 1000ms.
    * @default 30000
+   * @minimum 1000
    */
   collectionIntervalMs?: number;
 }
@@ -62,7 +64,10 @@ export interface BunRuntimeMetricsOptions {
  * ```
  */
 export const bunRuntimeMetricsIntegration = defineIntegration((options: BunRuntimeMetricsOptions = {}) => {
-  const collectionIntervalMs = options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS;
+  const collectionIntervalMs = _INTERNAL_normalizeCollectionInterval(
+    options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS,
+    INTEGRATION_NAME,
+  );
   const collect = {
     // Default on
     cpuUtilization: true,

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

@@ -212,4 +212,31 @@ describe('bunRuntimeMetricsIntegration', () => {
       expect(countSpy).not.toHaveBeenCalledWith('bun.runtime.process.uptime', expect.anything(), expect.anything());
     });
   });
+
+  describe('collectionIntervalMs minimum', () => {
+    it('enforces minimum of 1000ms and warns', () => {
+      const warnSpy = spyOn(globalThis.console, 'warn').mockImplementation(() => {});
+
+      const integration = bunRuntimeMetricsIntegration({ collectionIntervalMs: 100 });
+      integration.setup();
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('collectionIntervalMs'));
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('1000'));
+
+      // Should fire at minimum 1000ms, not at 100ms
+      jest.advanceTimersByTime(100);
+      expect(gaugeSpy).not.toHaveBeenCalled();
+
+      jest.advanceTimersByTime(900);
+      expect(gaugeSpy).toHaveBeenCalled();
+    });
+
+    it('falls back to minimum when NaN', () => {
+      const warnSpy = spyOn(globalThis.console, 'warn').mockImplementation(() => {});
+
+      bunRuntimeMetricsIntegration({ collectionIntervalMs: NaN });
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('collectionIntervalMs'));
+    });
+  });
 });

packages/deno/src/integrations/denoRuntimeMetrics.ts

@@ -28,7 +28,7 @@ export interface DenoRuntimeMetricsOptions {
   };
   /**
    * How often to collect metrics, in milliseconds.
-   * Values below 1000ms are clamped to 1000ms.
+   * Minimum allowed value is 1000ms.
    * @default 30000
    * @minimum 1000
    */
@@ -52,7 +52,7 @@ export const denoRuntimeMetricsIntegration = defineIntegration((options: DenoRun
   if (!Number.isFinite(rawInterval) || 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. Clamping to ${MIN_INTERVAL_MS}ms.`,
+      `[Sentry] denoRuntimeMetricsIntegration: collectionIntervalMs (${rawInterval}) is below the minimum of ${MIN_INTERVAL_MS}ms. Using minimum of ${MIN_INTERVAL_MS}ms.`,
     );
   }
   const collectionIntervalMs = Number.isFinite(rawInterval) ? Math.max(rawInterval, MIN_INTERVAL_MS) : MIN_INTERVAL_MS;

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

@@ -119,7 +119,7 @@ Deno.test('attaches correct sentry.origin attribute', async () => {
   assertEquals(rss?.attributes?.['sentry.origin']?.value, 'auto.deno.runtime_metrics');
 });
 
-Deno.test('warns and clamps collectionIntervalMs below 1000ms', () => {
+Deno.test('warns and enforces minimum collectionIntervalMs', () => {
   const warnings: string[] = [];
   const originalWarn = globalThis.console.warn;
   globalThis.console.warn = (msg: string) => warnings.push(msg);
@@ -135,7 +135,7 @@ Deno.test('warns and clamps collectionIntervalMs below 1000ms', () => {
   assertStringIncludes(warnings[0]!, '1000');
 });
 
-Deno.test('warns and clamps collectionIntervalMs when NaN', () => {
+Deno.test('warns and falls back to minimum when collectionIntervalMs is NaN', () => {
   const warnings: string[] = [];
   const originalWarn = globalThis.console.warn;
   globalThis.console.warn = (msg: string) => warnings.push(msg);

packages/node-core/src/common-exports.ts

@@ -12,7 +12,11 @@ import * as logger from './logs/exports';
 
 // Node-core integrations (not OTel-dependent)
 export { nodeContextIntegration } from './integrations/context';
-export { nodeRuntimeMetricsIntegration, type NodeRuntimeMetricsOptions } from './integrations/nodeRuntimeMetrics';
+export {
+  nodeRuntimeMetricsIntegration,
+  type NodeRuntimeMetricsOptions,
+  _INTERNAL_normalizeCollectionInterval,
+} from './integrations/nodeRuntimeMetrics';
 export { contextLinesIntegration } from './integrations/contextlines';
 export { localVariablesIntegration } from './integrations/local-variables';
 export { modulesIntegration } from './integrations/modules';

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

@@ -3,8 +3,24 @@ import { _INTERNAL_safeDateNow, _INTERNAL_safeUnref, defineIntegration, metrics
 
 const INTEGRATION_NAME = 'NodeRuntimeMetrics';
 const DEFAULT_INTERVAL_MS = 30_000;
+const MIN_COLLECTION_INTERVAL_MS = 1_000;
 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).
+ * @internal
+ */
+export function _INTERNAL_normalizeCollectionInterval(rawInterval: number, integrationName: string): number {
+  if (!Number.isFinite(rawInterval) || 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 Number.isFinite(rawInterval) ? Math.max(rawInterval, MIN_COLLECTION_INTERVAL_MS) : MIN_COLLECTION_INTERVAL_MS;
+}
+
 export interface NodeRuntimeMetricsOptions {
   /**
    * Which metrics to collect.
@@ -44,7 +60,9 @@ export interface NodeRuntimeMetricsOptions {
   };
   /**
    * How often to collect metrics, in milliseconds.
+   * Minimum allowed value is 1000ms.
    * @default 30000
+   * @minimum 1000
    */
   collectionIntervalMs?: number;
 }
@@ -62,7 +80,10 @@ export interface NodeRuntimeMetricsOptions {
  * ```
  */
 export const nodeRuntimeMetricsIntegration = defineIntegration((options: NodeRuntimeMetricsOptions = {}) => {
-  const collectionIntervalMs = options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS;
+  const collectionIntervalMs = _INTERNAL_normalizeCollectionInterval(
+    options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS,
+    INTEGRATION_NAME,
+  );
   const collect = {
     // Default on
     cpuUtilization: true,

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

@@ -329,5 +329,34 @@ describe('nodeRuntimeMetricsIntegration', () => {
 
       expect(countSpy).not.toHaveBeenCalledWith('node.runtime.process.uptime', expect.anything(), expect.anything());
     });
+
+    it('enforces minimum collectionIntervalMs of 1000ms and warns', () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const integration = nodeRuntimeMetricsIntegration({ collectionIntervalMs: 100 });
+      integration.setup();
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('collectionIntervalMs'));
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('1000'));
+
+      // Should fire at the minimum 1000ms, not at 100ms
+      vi.advanceTimersByTime(100);
+      expect(gaugeSpy).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(900);
+      expect(gaugeSpy).toHaveBeenCalled();
+
+      warnSpy.mockRestore();
+    });
+
+    it('falls back to minimum when collectionIntervalMs is NaN', () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      nodeRuntimeMetricsIntegration({ collectionIntervalMs: NaN });
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('collectionIntervalMs'));
+
+      warnSpy.mockRestore();
+    });
   });
 });

packages/node/src/index.ts

@@ -203,4 +203,5 @@ export {
   cron,
   NODE_VERSION,
   validateOpenTelemetrySetup,
+  _INTERNAL_normalizeCollectionInterval,
 } from '@sentry/node-core';