lib: validate metrics batch/buffer config inputs

Add normalizePositiveFinite() helper that parses a raw value (env
string, pkg value, or JS API input) to a positive finite number,
returning a fallback when invalid.

Refactor both initializeConfig() and updateConfig() to use the shared
helper for metricsBatchSize and metricsBufferSize. This fixes
initializeConfig() which previously used the +env || pkg || default
pattern and would accept Infinity or negative numbers from environment
variables or package.json.

Expand test-nsolid-start-metrics-buffer.js to cover Infinity,
-Infinity, and string variants of invalid values.

Add test-nsolid-config-metrics-env.js to verify that invalid env
values (Infinity, negative, zero, non-numeric) correctly fall back
to defaults during initialization.

Author: santigimeno

lib/nsolid.js

@@ -6,6 +6,8 @@ const {
   DateNow,
   JSONParse,
   JSONStringify,
+  Number,
+  NumberIsFinite,
   NumberParseInt,
   ObjectAssign,
   ObjectDefineProperty,
@@ -769,6 +771,11 @@ function updateConfig(config = {}) {
       if (normalized !== undefined) {
         nsolidConfig.assetsEnabled = normalized;
       }
+    } else if (key === 'metricsBatchSize' || key === 'metricsBufferSize') {
+      const value = normalizePositiveFinite(config[key], undefined);
+      if (value !== undefined) {
+        nsolidConfig[key] = value;
+      }
     } else {
       nsolidConfig[key] = config[key];
     }
@@ -912,15 +919,19 @@ function initializeConfig(nsolidConfig) {
 
   // Metrics batch size
   nsolidConfig.metricsBatchSize =
-    +process.env.NSOLID_METRICS_BATCH_SIZE ||
-    pkgConfig.nsolid.metricsBatchSize ||
-    DEFAULT_METRICS_BATCH_SIZE;
+    normalizePositiveFinite(
+      process.env.NSOLID_METRICS_BATCH_SIZE,
+      normalizePositiveFinite(
+        pkgConfig.nsolid.metricsBatchSize,
+        DEFAULT_METRICS_BATCH_SIZE));
 
   // Metrics buffer size
   nsolidConfig.metricsBufferSize =
-    +process.env.NSOLID_METRICS_BUFFER_SIZE ||
-    pkgConfig.nsolid.metricsBufferSize ||
-    DEFAULT_METRICS_BUFFER_SIZE;
+    normalizePositiveFinite(
+      process.env.NSOLID_METRICS_BUFFER_SIZE,
+      normalizePositiveFinite(
+        pkgConfig.nsolid.metricsBufferSize,
+        DEFAULT_METRICS_BUFFER_SIZE));
 
   nsolidConfig.tags = getTags(process.env.NSOLID_TAGS || pkgConfig.nsolid.tags);
 
@@ -1134,6 +1145,21 @@ function optionToBool(value) {
 }
 
 
+// Parse a raw value (env string, pkg value, or JS API input) to a positive
+// finite number.  Returns the numeric value when valid, otherwise `fallback`.
+function normalizePositiveFinite(raw, fallback) {
+  if (raw == null)
+    return fallback;
+  if (typeof raw === 'number' ||
+      (typeof raw === 'string' && raw.trim() !== '')) {
+    const value = Number(raw);
+    if (NumberIsFinite(value) && value > 0)
+      return value;
+  }
+  return fallback;
+}
+
+
 function genPackageList() {
   let main_path;
   let last_path;

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

@@ -0,0 +1,16 @@
+'use strict';
+
+// This script is used by test-nsolid-config-metrics-env.js
+// to test environment variable configuration for metrics batch/buffer size
+
+require('../common');
+const nsolid = require('nsolid');
+
+// Start N|Solid with default configuration so initializeConfig() runs
+nsolid.start();
+
+// Output the configuration as JSON
+console.log(JSON.stringify({
+  metricsBatchSize: nsolid.config.metricsBatchSize,
+  metricsBufferSize: nsolid.config.metricsBufferSize,
+}));

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

@@ -0,0 +1,96 @@
+'use strict';
+
+// This test verifies that metricsBatchSize and metricsBufferSize are correctly
+// validated when set via environment variables (initializeConfig path).
+// Invalid values (Infinity, negative, zero, non-numeric) must fall back to
+// the default.
+
+require('../common');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const DEFAULT_METRICS_BATCH_SIZE = 1;
+const DEFAULT_METRICS_BUFFER_SIZE = 100;
+
+// Helper to run a small script with specific environment variables
+function runWithEnv(envVars) {
+  const script = path.join(
+    __dirname,
+    '../fixtures/test-nsolid-config-metrics-env-script.js'
+  );
+
+  const result = spawnSync(process.execPath, [script], {
+    env: {
+      ...process.env,
+      ...envVars,
+    },
+    encoding: 'utf8',
+  });
+
+  if (result.status !== 0) {
+    console.error(result.stderr);
+    throw new Error(`Script execution failed with status ${result.status}`);
+  }
+
+  return JSON.parse(result.stdout.trim());
+}
+
+// Test default values (no env vars set)
+{
+  const config = runWithEnv({});
+  assert.strictEqual(config.metricsBatchSize, DEFAULT_METRICS_BATCH_SIZE);
+  assert.strictEqual(config.metricsBufferSize, DEFAULT_METRICS_BUFFER_SIZE);
+}
+
+// Test valid numeric string values
+{
+  const config = runWithEnv({
+    NSOLID_METRICS_BATCH_SIZE: '5',
+    NSOLID_METRICS_BUFFER_SIZE: '200',
+  });
+  assert.strictEqual(config.metricsBatchSize, 5);
+  assert.strictEqual(config.metricsBufferSize, 200);
+}
+
+// Test valid float string values (should be accepted as positive finite)
+{
+  const config = runWithEnv({
+    NSOLID_METRICS_BATCH_SIZE: '2.5',
+    NSOLID_METRICS_BUFFER_SIZE: '50.5',
+  });
+  assert.strictEqual(config.metricsBatchSize, 2.5);
+  assert.strictEqual(config.metricsBufferSize, 50.5);
+}
+
+// Test invalid env values all fall back to default
+const invalidEnvValues = [
+  '0',
+  '-1',
+  '-100',
+  'Infinity',
+  '-Infinity',
+  'NaN',
+  '',
+  '  ',
+  'abc',
+  'true',
+  'false',
+];
+
+for (const value of invalidEnvValues) {
+  const config = runWithEnv({
+    NSOLID_METRICS_BATCH_SIZE: value,
+    NSOLID_METRICS_BUFFER_SIZE: value,
+  });
+  assert.strictEqual(
+    config.metricsBatchSize,
+    DEFAULT_METRICS_BATCH_SIZE,
+    `metricsBatchSize should be default for env value: "${value}"`
+  );
+  assert.strictEqual(
+    config.metricsBufferSize,
+    DEFAULT_METRICS_BUFFER_SIZE,
+    `metricsBufferSize should be default for env value: "${value}"`
+  );
+}

test/parallel/test-nsolid-start-metrics-buffer.js

@@ -0,0 +1,48 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const nsolid = require('nsolid');
+
+const defaultBatchSize = nsolid.config.metricsBatchSize;
+const defaultBufferSize = nsolid.config.metricsBufferSize;
+
+nsolid.start({
+  metricsBatchSize: defaultBatchSize + 1,
+  metricsBufferSize: defaultBufferSize + 50
+});
+assert.strictEqual(nsolid.config.metricsBatchSize, defaultBatchSize + 1);
+assert.strictEqual(nsolid.config.metricsBufferSize, defaultBufferSize + 50);
+
+nsolid.start({
+  metricsBatchSize: `${defaultBatchSize + 2}`,
+  metricsBufferSize: `${defaultBufferSize + 100}`
+});
+assert.strictEqual(nsolid.config.metricsBatchSize, defaultBatchSize + 2);
+assert.strictEqual(nsolid.config.metricsBufferSize, defaultBufferSize + 100);
+
+// Invalid inputs should be ignored
+const invalidValues = [
+  0, -1, NaN, Infinity, -Infinity,
+  undefined, null, true, false, {}, [], () => {},
+  '0', '-1', 'NaN', 'Infinity', '-Infinity', '', '  ',
+];
+for (const value of invalidValues) {
+  nsolid.start({
+    metricsBatchSize: value,
+    metricsBufferSize: value
+  });
+  assert.strictEqual(nsolid.config.metricsBatchSize,
+                     defaultBatchSize + 2,
+                     `metricsBatchSize changed unexpectedly for value: ${String(value)}`);
+  assert.strictEqual(nsolid.config.metricsBufferSize,
+                     defaultBufferSize + 100,
+                     `metricsBufferSize changed unexpectedly for value: ${String(value)}`);
+}
+
+nsolid.start({
+  metricsBatchSize: defaultBatchSize,
+  metricsBufferSize: defaultBufferSize
+});
+assert.strictEqual(nsolid.config.metricsBatchSize, defaultBatchSize);
+assert.strictEqual(nsolid.config.metricsBufferSize, defaultBufferSize);