lib,test: validate metrics interval updates

Validate interval updates in lib/nsolid.js before assigning them to
nsolidConfig.interval.

Ignore invalid values such as 0, negative numbers, NaN, Infinity, and
non-numeric strings so the previous valid interval is preserved.

Add a parallel test covering valid coercion, invalid updates, and
partial updates that omit interval.

Author: santigimeno

lib/nsolid.js

@@ -775,7 +775,10 @@ function updateConfig(config = {}) {
         nsolidConfig.assetsEnabled = normalized;
       }
     } else if (key === 'interval') {
-      nsolidConfig.interval = +config.interval;
+      const normalized = parsePositiveFiniteNumber(config.interval);
+      if (normalized !== undefined) {
+        nsolidConfig.interval = normalized;
+      }
     } else if (key === 'traceSampleRate') {
       const normalized = parseTraceSampleRate(config.traceSampleRate);
       if (normalized !== undefined) {
@@ -915,9 +918,11 @@ function initializeConfig(nsolidConfig) {
     'prod';
 
   // Metrics send interval
+  const envInterval = parsePositiveFiniteNumber(process.env.NSOLID_INTERVAL);
+  const pkgInterval = parsePositiveFiniteNumber(pkgConfig.nsolid.interval);
   nsolidConfig.interval =
-    +process.env.NSOLID_INTERVAL ||
-    pkgConfig.nsolid.interval ||
+    envInterval ??
+    pkgInterval ??
     DEFAULT_INTERVAL;
 
   nsolidConfig.tags = getTags(process.env.NSOLID_TAGS || pkgConfig.nsolid.tags);
@@ -1172,6 +1177,32 @@ function parseTraceSampleRate(value) {
 }
 
 
+function parsePositiveFiniteNumber(value) {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  let normalized;
+  if (typeof value === 'number') {
+    normalized = value;
+  } else if (typeof value === 'string') {
+    const trimmedValue = StringPrototypeTrim(value);
+    if (trimmedValue === '') {
+      return undefined;
+    }
+    normalized = +trimmedValue;
+  } else {
+    return undefined;
+  }
+
+  if (!NumberIsFinite(normalized) || normalized <= 0) {
+    return undefined;
+  }
+
+  return normalized;
+}
+
+
 function genPackageList() {
   let main_path;
   let last_path;

test/fixtures/nsolid-interval-package.json

@@ -0,0 +1,7 @@
+{
+  "name": "nsolid-interval-fixture",
+  "version": "1.0.0",
+  "nsolid": {
+    "interval": 3000
+  }
+}

test/fixtures/test-nsolid-config-interval-env-script.js

@@ -0,0 +1,10 @@
+'use strict';
+
+require('../common');
+const nsolid = require('nsolid');
+
+nsolid.start();
+
+console.log(JSON.stringify({
+  interval: nsolid.config.interval,
+}));

test/parallel/test-nsolid-config-interval-env.js

@@ -0,0 +1,87 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const script = path.join(__dirname,
+                         '../fixtures/test-nsolid-config-interval-env-script.js');
+const pkgJson = path.join(__dirname,
+                          '../fixtures/nsolid-interval-package.json');
+
+function runWithEnv(envVars) {
+  const filteredEnv = Object.fromEntries(
+    Object.entries(process.env).filter(([key]) => !key.startsWith('NSOLID_')),
+  );
+
+  const result = spawnSync(process.execPath, [script], {
+    env: {
+      ...filteredEnv,
+      ...envVars,
+    },
+    encoding: 'utf8',
+  });
+
+  if (result.status !== 0) {
+    throw new Error(result.stderr || `Script failed with status ${result.status}`);
+  }
+
+  return JSON.parse(result.stdout.trim());
+}
+
+{
+  const config = runWithEnv({});
+  assert.strictEqual(config.interval, 5000);
+}
+
+{
+  const config = runWithEnv({
+    NSOLID_INTERVAL: '2500',
+  });
+  assert.strictEqual(config.interval, 2500);
+}
+
+{
+  const config = runWithEnv({
+    NSOLID_INTERVAL: 'invalid',
+  });
+  assert.strictEqual(config.interval, 5000);
+}
+
+{
+  const config = runWithEnv({
+    NSOLID_INTERVAL: '0',
+  });
+  assert.strictEqual(config.interval, 5000);
+}
+
+{
+  const config = runWithEnv({
+    NSOLID_INTERVAL: '-1',
+  });
+  assert.strictEqual(config.interval, 5000);
+}
+
+{
+  const config = runWithEnv({
+    NSOLID_PACKAGE_JSON: pkgJson,
+  });
+  assert.strictEqual(config.interval, 3000);
+}
+
+{
+  const config = runWithEnv({
+    NSOLID_PACKAGE_JSON: pkgJson,
+    NSOLID_INTERVAL: '2500',
+  });
+  assert.strictEqual(config.interval, 2500);
+}
+
+{
+  const config = runWithEnv({
+    NSOLID_PACKAGE_JSON: pkgJson,
+    NSOLID_INTERVAL: '-1',
+  });
+  assert.strictEqual(config.interval, 3000);
+}

test/parallel/test-nsolid-config-interval.js

@@ -0,0 +1,35 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const nsolid = require('nsolid');
+
+// Valid values should be normalized and persisted.
+nsolid.start({
+  command: 9001,
+  interval: '2500'
+});
+assert.strictEqual(nsolid.config.interval, 2500);
+
+// Invalid updates must preserve the previous valid value.
+for (const interval of [
+  0,
+  -1,
+  '0',
+  '-1',
+  '',
+  '   ',
+  'still-invalid',
+  Number.NaN,
+  Number.POSITIVE_INFINITY,
+  true,
+]) {
+  nsolid.start({ interval });
+  assert.strictEqual(nsolid.config.interval, 2500);
+}
+
+// Partial updates that omit interval must not reset it.
+nsolid.start({
+  tracingEnabled: true
+});
+assert.strictEqual(nsolid.config.interval, 2500);