refactor: updated the config validator for stacktrace

packages/collector/src/announceCycle/unannounced.js

@@ -9,11 +9,9 @@ const {
   secrets,
   tracing,
   util: { ensureNestedObjectExists },
-  coreConfig: { configNormalizers, configValidators }
+  coreConfig
 } = require('@instana/core');
 
-const { validateStackTraceMode, validateStackTraceLength } = configValidators.stackTraceValidation;
-
 const { constants: tracingConstants } = tracing;
 
 const agentConnection = require('../agentConnection');
@@ -274,7 +272,8 @@ function applyIgnoreEndpointsConfiguration(agentResponse) {
   if (!ignoreEndpointsConfig) return;
 
   ensureNestedObjectExists(agentOpts.config, ['tracing', 'ignoreEndpoints']);
-  agentOpts.config.tracing.ignoreEndpoints = configNormalizers.ignoreEndpoints.normalizeConfig(ignoreEndpointsConfig);
+  agentOpts.config.tracing.ignoreEndpoints =
+    coreConfig.configNormalizers.ignoreEndpoints.normalizeConfig(ignoreEndpointsConfig);
 }
 
 /**
@@ -289,9 +288,9 @@ function applyStackTraceConfiguration(agentResponse) {
   ensureNestedObjectExists(agentOpts.config, ['tracing', 'global']);
 
   if (globalConfig['stack-trace'] !== undefined) {
-    const stackTraceModeValidation = validateStackTraceMode(globalConfig['stack-trace']);
+    const stackTraceModeValidation = coreConfig.validate.validateStackTraceMode(globalConfig['stack-trace']);
     if (stackTraceModeValidation.isValid) {
-      const normalizedStackTrace = configNormalizers.stackTrace.normalizeStackTraceModeFromAgent(
+      const normalizedStackTrace = coreConfig.configNormalizers.stackTrace.normalizeStackTraceModeFromAgent(
         globalConfig['stack-trace']
       );
       if (normalizedStackTrace != null) {
@@ -303,9 +302,9 @@ function applyStackTraceConfiguration(agentResponse) {
   }
 
   if (globalConfig['stack-trace-length'] !== undefined) {
-    const stackTraceLengthValidation = validateStackTraceLength(globalConfig['stack-trace-length']);
+    const stackTraceLengthValidation = coreConfig.validate.validateStackTraceLength(globalConfig['stack-trace-length']);
     if (stackTraceLengthValidation.isValid) {
-      const normalizedStackTraceLength = configNormalizers.stackTrace.normalizeStackTraceLengthFromAgent(
+      const normalizedStackTraceLength = coreConfig.configNormalizers.stackTrace.normalizeStackTraceLengthFromAgent(
         globalConfig['stack-trace-length']
       );
       if (normalizedStackTraceLength != null) {
@@ -330,7 +329,7 @@ function applyDisableConfiguration(agentResponse) {
   if (!disablingConfig) return;
 
   ensureNestedObjectExists(agentOpts.config, ['tracing', 'disable']);
-  agentOpts.config.tracing.disable = configNormalizers.disable.normalizeExternalConfig({
+  agentOpts.config.tracing.disable = coreConfig.configNormalizers.disable.normalizeExternalConfig({
     tracing: { disable: disablingConfig }
   }).value;
 }

packages/core/src/config/index.js

@@ -6,12 +6,11 @@
 'use strict';
 
 const configNormalizers = require('./configNormalizers');
-const configValidators = require('./configValidators');
 const deepMerge = require('../util/deepMerge');
 const { DEFAULT_STACK_TRACE_LENGTH, DEFAULT_STACK_TRACE_MODE, CONFIG_SOURCES } = require('../util/constants');
-const { validateStackTraceMode, validateStackTraceLength } = require('./configValidators/stackTraceValidation');
 const util = require('./util');
 const validate = require('./validator');
+const { validateStackTraceMode, validateStackTraceLength } = validate;
 
 // @typedef {{ [x: string]: any }} configMeta
 /** @type {configMeta} */
@@ -189,7 +188,7 @@ let defaults = {
 const validSecretsMatcherModes = ['equals-ignore-case', 'equals', 'contains-ignore-case', 'contains', 'regex', 'none'];
 
 module.exports.configNormalizers = configNormalizers;
-module.exports.configValidators = configValidators;
+module.exports.validate = validate;
 
 /**
  * @param {import('../core').GenericLogger} [_logger]

packages/core/src/config/validator.js

@@ -4,6 +4,8 @@
 
 'use strict';
 
+const { validStackTraceModes } = require('../util/constants');
+
 /**
  * @param {any} value
  * @returns {number|undefined}
@@ -49,3 +51,74 @@ exports.validateTruthyBoolean = function validateTruthyBoolean(value) {
   // Return true if value is truthy, undefined otherwise
   return value ? true : undefined;
 };
+
+/**
+ * Validates the stack trace mode value.
+ *
+ * @param {*} value - The value to validate
+ * @returns {{ isValid: boolean, error: string | null }} - Validation result
+ */
+exports.validateStackTraceMode = function validateStackTraceMode(value) {
+  if (value === null) {
+    return { isValid: false, error: `The value cannot be null. Valid values are: ${validStackTraceModes.join(', ')}.` };
+  }
+
+  if (typeof value !== 'string') {
+    return {
+      isValid: false,
+      error: `The value has the non-supported type ${typeof value}. Valid values are: ${validStackTraceModes.join(
+        ', '
+      )}.`
+    };
+  }
+
+  const normalizedValue = value.toLowerCase();
+  if (validStackTraceModes.includes(normalizedValue)) {
+    return { isValid: true, error: null };
+  }
+
+  return {
+    isValid: false,
+    error: `Invalid value: "${value}". Valid values are: ${validStackTraceModes.join(', ')}.`
+  };
+};
+
+/**
+ * Validates the stack trace length value.
+ *
+ * @param {*} value - The value to validate
+ * @returns {{ isValid: boolean, error: string | null }} - Validation result
+ */
+exports.validateStackTraceLength = function validateStackTraceLength(value) {
+  if (value == null) {
+    return { isValid: false, error: 'The value cannot be null' };
+  }
+
+  let parsedValue;
+
+  if (typeof value === 'number') {
+    parsedValue = value;
+  } else if (typeof value === 'string') {
+    parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+      return {
+        isValid: false,
+        error: `The value ("${value}") cannot be parsed to a numerical value.`
+      };
+    }
+  } else {
+    return {
+      isValid: false,
+      error: `The value has the non-supported type ${typeof value}.`
+    };
+  }
+
+  if (!Number.isFinite(parsedValue)) {
+    return {
+      isValid: false,
+      error: `Invalid value: ${value}. Expected a number or numeric string.`
+    };
+  }
+
+  return { isValid: true, error: null };
+};