From 3b7e3c67b42929da8cb74dc3dd41b2d161e07f1a Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Tue, 3 Mar 2026 13:21:10 +0530
Subject: [PATCH 01/14] fix: corrected the order with incode and env

---
 .../src/config/configNormalizers/disable.js   |  58 +++---
 packages/core/src/config/index.js             | 179 ++++++++++--------
 2 files changed, 136 insertions(+), 101 deletions(-)

diff --git a/packages/core/src/config/configNormalizers/disable.js b/packages/core/src/config/configNormalizers/disable.js
index 0c3477f2b2..472611ccb5 100644
--- a/packages/core/src/config/configNormalizers/disable.js
+++ b/packages/core/src/config/configNormalizers/disable.js
@@ -19,48 +19,62 @@ exports.init = function init(_config) {
  * Handles environment variables, and array inputs.
  *
  * Precedence order (highest to lowest):
- * 1. `tracing.disable`
- * 2. Environment variables (`INSTANA_TRACING_DISABLE*`)
+ * 1. Environment variables (`INSTANA_TRACING_DISABLE*`)
+ * 2. `tracing.disable` (in-code config)
  *
  * @param {import('../../config').InstanaConfig} config
  */
 exports.normalize = function normalize(config) {
   if (!config?.tracing) config.tracing = {};
   try {
-    // Disable all tracing if explicitly set  'disable' to true
+    // Check environment variables
+    const envDisableConfig = getDisableFromEnv();
+    if (envDisableConfig) {
+      if (envDisableConfig === true) {
+        return true;
+      }
+      // Normalize instrumentations and groups from env
+      if (envDisableConfig?.instrumentations) {
+        envDisableConfig.instrumentations = normalizeArray(envDisableConfig.instrumentations);
+      }
+      if (envDisableConfig?.groups) {
+        envDisableConfig.groups = normalizeArray(envDisableConfig.groups);
+      }
+      return envDisableConfig;
+    }
+
+    // Check in-code config
     if (config.tracing.disable === true) {
       logger?.info('Tracing has been disabled via "tracing.disable: true" configuration.');
       return true;
     }
-    const hasDisableConfig = isDisableConfigNonEmpty(config);
 
+    const hasDisableConfig = isDisableConfigNonEmpty(config);
     if (hasDisableConfig) {
       logger?.info(
         `Tracing selectively disabled as per "tracing.disable" configuration: ${JSON.stringify(config.tracing.disable)}`
       );
-    }
 
-    // Fallback to environment variables if `disable` is not explicitly configured
-    const disableConfig = isDisableConfigNonEmpty(config) ? config.tracing.disable : getDisableFromEnv();
+      const disableConfig = config.tracing.disable;
 
-    if (!disableConfig) return {};
-
-    if (disableConfig === true) return true;
+      // Handle if tracing.disable is an array
+      if (Array.isArray(disableConfig)) {
+        return categorizeDisableEntries(disableConfig);
+      }
 
-    // Normalize instrumentations and groups
-    if (disableConfig?.instrumentations) {
-      disableConfig.instrumentations = normalizeArray(disableConfig.instrumentations);
-    }
-    if (disableConfig?.groups) {
-      disableConfig.groups = normalizeArray(disableConfig.groups);
-    }
+      // Normalize instrumentations and groups
+      if (typeof disableConfig === 'object' && disableConfig !== null) {
+        if (disableConfig.instrumentations) {
+          disableConfig.instrumentations = normalizeArray(disableConfig.instrumentations);
+        }
+        if (disableConfig.groups) {
+          disableConfig.groups = normalizeArray(disableConfig.groups);
+        }
+      }
 
-    // Handle if tracing.disable is an array
-    if (Array.isArray(disableConfig)) {
-      return categorizeDisableEntries(disableConfig);
+      return disableConfig;
     }
-
-    return disableConfig || {};
+    return {};
   } catch (error) {
     // Fallback to an empty disable config on error
     logger?.debug(`Error while normalizing tracing.disable config: ${error?.message} ${error?.stack}`);
diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index dde9e8e041..30f82ec244 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -257,6 +257,12 @@ function normalizeTracingConfig(config) {
  * @param {InstanaConfig} config
  */
 function normalizeTracingEnabled(config) {
+  if (process.env['INSTANA_TRACING_DISABLE'] === 'true') {
+    logger.info('Not enabling tracing as it is explicitly disabled via environment variable INSTANA_TRACING_DISABLE.');
+    config.tracing.enabled = false;
+    return;
+  }
+
   if (config.tracing.enabled === false) {
     logger.info('Not enabling tracing as it is explicitly disabled via config.');
     return;
@@ -274,6 +280,13 @@ function normalizeTracingEnabled(config) {
  */
 
 function normalizeAllowRootExitSpan(config) {
+  const INSTANA_ALLOW_ROOT_EXIT_SPAN = process.env['INSTANA_ALLOW_ROOT_EXIT_SPAN']?.toLowerCase();
+
+  if (INSTANA_ALLOW_ROOT_EXIT_SPAN === '1' || INSTANA_ALLOW_ROOT_EXIT_SPAN === 'true') {
+    config.tracing.allowRootExitSpan = true;
+    return;
+  }
+
   if (config.tracing.allowRootExitSpan === false) {
     return;
   }
@@ -281,13 +294,7 @@ function normalizeAllowRootExitSpan(config) {
     return;
   }
 
-  const INSTANA_ALLOW_ROOT_EXIT_SPAN = process.env['INSTANA_ALLOW_ROOT_EXIT_SPAN']?.toLowerCase();
-
-  config.tracing.allowRootExitSpan =
-    INSTANA_ALLOW_ROOT_EXIT_SPAN === '1' ||
-    INSTANA_ALLOW_ROOT_EXIT_SPAN === 'true' ||
-    defaults.tracing.allowRootExitSpan;
-  return;
+  config.tracing.allowRootExitSpan = defaults.tracing.allowRootExitSpan;
 }
 
 /**
@@ -295,14 +302,15 @@ function normalizeAllowRootExitSpan(config) {
  * @param {InstanaConfig} config
  */
 function normalizeUseOpentelemetry(config) {
-  if (config.tracing.useOpentelemetry === false) {
+  if (process.env['INSTANA_DISABLE_USE_OPENTELEMETRY'] === 'true') {
+    config.tracing.useOpentelemetry = false;
     return;
   }
-  if (config.tracing.useOpentelemetry === true) {
+
+  if (config.tracing.useOpentelemetry === false) {
     return;
   }
-  if (process.env['INSTANA_DISABLE_USE_OPENTELEMETRY'] === 'true') {
-    config.tracing.useOpentelemetry = false;
+  if (config.tracing.useOpentelemetry === true) {
     return;
   }
 
@@ -314,13 +322,7 @@ function normalizeUseOpentelemetry(config) {
  */
 function normalizeAutomaticTracingEnabled(config) {
   if (!config.tracing.enabled) {
-    logger.info('Not enabling automatic tracing as tracing in general is explicitly disabled via config.');
-    config.tracing.automaticTracingEnabled = false;
-    return;
-  }
-
-  if (config.tracing.automaticTracingEnabled === false) {
-    logger.info('Not enabling automatic tracing as it is explicitly disabled via config.');
+    logger.info('Not enabling automatic tracing as tracing in general is explicitly disabled.');
     config.tracing.automaticTracingEnabled = false;
     return;
   }
@@ -333,6 +335,12 @@ function normalizeAutomaticTracingEnabled(config) {
     return;
   }
 
+  if (config.tracing.automaticTracingEnabled === false) {
+    logger.info('Not enabling automatic tracing as it is explicitly disabled via config.');
+    config.tracing.automaticTracingEnabled = false;
+    return;
+  }
+
   if (!supportedTracingVersion(process.versions.node)) {
     logger.warn(
       'Not enabling automatic tracing, this is an unsupported version of Node.js. ' +
@@ -354,12 +362,12 @@ function normalizeActivateImmediately(config) {
     return;
   }
 
-  if (typeof config.tracing.activateImmediately === 'boolean') {
+  if (process.env['INSTANA_TRACE_IMMEDIATELY'] === 'true') {
+    config.tracing.activateImmediately = true;
     return;
   }
 
-  if (process.env['INSTANA_TRACE_IMMEDIATELY'] === 'true') {
-    config.tracing.activateImmediately = true;
+  if (typeof config.tracing.activateImmediately === 'boolean') {
     return;
   }
 
@@ -418,32 +426,28 @@ function normalizeTracingTransmission(config) {
 function normalizeTracingHttp(config) {
   config.tracing.http = config.tracing.http || {};
 
-  let fromEnvVar;
   if (process.env.INSTANA_EXTRA_HTTP_HEADERS) {
-    fromEnvVar = parseHeadersEnvVar(process.env.INSTANA_EXTRA_HTTP_HEADERS);
-  }
-
-  if (!config.tracing.http.extraHttpHeadersToCapture && !fromEnvVar) {
-    config.tracing.http.extraHttpHeadersToCapture = defaults.tracing.http.extraHttpHeadersToCapture;
+    config.tracing.http.extraHttpHeadersToCapture = parseHeadersEnvVar(process.env.INSTANA_EXTRA_HTTP_HEADERS);
     return;
-  } else if (!config.tracing.http.extraHttpHeadersToCapture && fromEnvVar) {
-    config.tracing.http.extraHttpHeadersToCapture = fromEnvVar;
   }
-  if (!Array.isArray(config.tracing.http.extraHttpHeadersToCapture)) {
-    logger.warn(
-      `Invalid configuration: config.tracing.http.extraHttpHeadersToCapture is not an array, the value will be ignored: ${JSON.stringify(
-        config.tracing.http.extraHttpHeadersToCapture
-      )}`
+
+  if (config.tracing.http.extraHttpHeadersToCapture) {
+    if (!Array.isArray(config.tracing.http.extraHttpHeadersToCapture)) {
+      logger.warn(
+        `Invalid configuration: config.tracing.http.extraHttpHeadersToCapture is not an array, the value will be ignored: ${JSON.stringify(
+          config.tracing.http.extraHttpHeadersToCapture
+        )}`
+      );
+      config.tracing.http.extraHttpHeadersToCapture = defaults.tracing.http.extraHttpHeadersToCapture;
+      return;
+    }
+    config.tracing.http.extraHttpHeadersToCapture = config.tracing.http.extraHttpHeadersToCapture.map(
+      s => s.toLowerCase() // Node.js HTTP API turns all incoming HTTP headers into lowercase.
     );
-    config.tracing.http.extraHttpHeadersToCapture = defaults.tracing.http.extraHttpHeadersToCapture;
     return;
   }
 
-  config.tracing.http.extraHttpHeadersToCapture = config.tracing.http.extraHttpHeadersToCapture.map(
-    (
-      s // Node.js HTTP API turns all incoming HTTP headers into lowercase.
-    ) => s.toLowerCase()
-  );
+  config.tracing.http.extraHttpHeadersToCapture = defaults.tracing.http.extraHttpHeadersToCapture;
 }
 
 /**
@@ -567,6 +571,12 @@ function normalizeDisableTracing(config) {
  * @param {InstanaConfig} config
  */
 function normalizeSpanBatchingEnabled(config) {
+  if (process.env['INSTANA_SPANBATCHING_ENABLED'] === 'true') {
+    logger.info('Span batching is enabled via environment variable INSTANA_SPANBATCHING_ENABLED.');
+    config.tracing.spanBatchingEnabled = true;
+    return;
+  }
+
   if (config.tracing.spanBatchingEnabled != null) {
     if (typeof config.tracing.spanBatchingEnabled === 'boolean') {
       if (config.tracing.spanBatchingEnabled) {
@@ -582,12 +592,6 @@ function normalizeSpanBatchingEnabled(config) {
     }
   }
 
-  if (process.env['INSTANA_SPANBATCHING_ENABLED'] === 'true') {
-    logger.info('Span batching is enabled via environment variable INSTANA_SPANBATCHING_ENABLED.');
-    config.tracing.spanBatchingEnabled = true;
-    return;
-  }
-
   config.tracing.spanBatchingEnabled = defaults.tracing.spanBatchingEnabled;
 }
 
@@ -595,10 +599,6 @@ function normalizeSpanBatchingEnabled(config) {
  * @param {InstanaConfig} config
  */
 function normalizeDisableW3cTraceCorrelation(config) {
-  if (config.tracing.disableW3cTraceCorrelation === true) {
-    logger.info('W3C trace correlation has been disabled via config.');
-    return;
-  }
   if (process.env['INSTANA_DISABLE_W3C_TRACE_CORRELATION']) {
     logger.info(
       'W3C trace correlation has been disabled via environment variable INSTANA_DISABLE_W3C_TRACE_CORRELATION.'
@@ -607,6 +607,11 @@ function normalizeDisableW3cTraceCorrelation(config) {
     return;
   }
 
+  if (config.tracing.disableW3cTraceCorrelation === true) {
+    logger.info('W3C trace correlation has been disabled via config.');
+    return;
+  }
+
   config.tracing.disableW3cTraceCorrelation = defaults.tracing.disableW3cTraceCorrelation;
 }
 
@@ -616,14 +621,14 @@ function normalizeDisableW3cTraceCorrelation(config) {
 function normalizeTracingKafka(config) {
   config.tracing.kafka = config.tracing.kafka || {};
 
-  if (config.tracing.kafka.traceCorrelation === false) {
-    logger.info('Kafka trace correlation has been disabled via config.');
-  } else if (
+  if (
     process.env['INSTANA_KAFKA_TRACE_CORRELATION'] != null &&
     process.env['INSTANA_KAFKA_TRACE_CORRELATION'].toLowerCase() === 'false'
   ) {
     logger.info('Kafka trace correlation has been disabled via environment variable INSTANA_KAFKA_TRACE_CORRELATION.');
     config.tracing.kafka.traceCorrelation = false;
+  } else if (config.tracing.kafka.traceCorrelation === false) {
+    logger.info('Kafka trace correlation has been disabled via config.');
   } else {
     config.tracing.kafka.traceCorrelation = defaults.tracing.kafka.traceCorrelation;
   }
@@ -643,8 +648,8 @@ function normalizeSecrets(config) {
     fromEnvVar = parseSecretsEnvVar(process.env.INSTANA_SECRETS);
   }
 
-  config.secrets.matcherMode = config.secrets.matcherMode || fromEnvVar.matcherMode || defaults.secrets.matcherMode;
-  config.secrets.keywords = config.secrets.keywords || fromEnvVar.keywords || defaults.secrets.keywords;
+  config.secrets.matcherMode = fromEnvVar.matcherMode || config.secrets.matcherMode || defaults.secrets.matcherMode;
+  config.secrets.keywords = fromEnvVar.keywords || config.secrets.keywords || defaults.secrets.keywords;
 
   if (typeof config.secrets.matcherMode !== 'string') {
     logger.warn(
@@ -722,22 +727,28 @@ function parseSecretsEnvVar(envVarValue) {
  */
 function normalizeSingleValue(configValue, defaultValue, configPath, envVarKey) {
   const envVarVal = process.env[envVarKey];
-  let originalValue = configValue;
-  if (configValue == null && envVarVal == null) {
-    return defaultValue;
-  } else if (configValue == null && envVarVal != null) {
-    originalValue = envVarVal;
-    configValue = parseInt(originalValue, 10);
+
+  if (envVarVal != null) {
+    const parsed = parseInt(envVarVal, 10);
+    if (typeof parsed !== 'number' || isNaN(parsed)) {
+      logger.warn(
+        `The value of ${envVarKey} ("${envVarVal}") is not numerical or cannot be parsed to a numerical value. Assuming the default value ${defaultValue}.`
+      );
+      return defaultValue;
+    }
+    return parsed;
   }
 
-  if (typeof configValue !== 'number' || isNaN(configValue)) {
-    logger.warn(
-      `The value of ${configPath} (or ${envVarKey}) ("${originalValue}") is ' +
-        'not numerical or cannot be parsed to a numerical value. Assuming the default value ${defaultValue}.`
-    );
-    return defaultValue;
+  if (configValue != null) {
+    if (typeof configValue !== 'number' || isNaN(configValue)) {
+      logger.warn(
+        `The value of ${configPath} ("${configValue}") is not numerical or cannot be parsed to a numerical value. Assuming the default value ${defaultValue}.`
+      );
+      return defaultValue;
+    }
+    return configValue;
   }
-  return configValue;
+  return defaultValue;
 }
 /**
  * @param {InstanaConfig} config
@@ -758,33 +769,31 @@ function normalizeIgnoreEndpoints(config) {
     config.tracing.ignoreEndpoints = {};
     return;
   }
-  // Case 1: Use in-code configuration if available
-  if (Object.keys(ignoreEndpointsConfig).length) {
-    config.tracing.ignoreEndpoints = configNormalizers.ignoreEndpoints.normalizeConfig(ignoreEndpointsConfig);
-    logger.debug(`Ignore endpoints have been configured: ${JSON.stringify(config.tracing.ignoreEndpoints)}`);
-    return;
-  }
 
-  // Case 2: Load from a YAML file if `INSTANA_IGNORE_ENDPOINTS_PATH` is set
+  // Case 1: Load from a YAML file if `INSTANA_IGNORE_ENDPOINTS_PATH` is set (highest env var priority)
   // Introduced in Phase 2 for advanced filtering based on both methods and endpoints.
-  // Also supports basic filtering for endpoints.
   if (process.env.INSTANA_IGNORE_ENDPOINTS_PATH) {
     config.tracing.ignoreEndpoints = configNormalizers.ignoreEndpoints.fromYaml(
       process.env.INSTANA_IGNORE_ENDPOINTS_PATH
     );
-
     logger.debug(`Ignore endpoints have been configured: ${JSON.stringify(config.tracing.ignoreEndpoints)}`);
     return;
   }
 
-  // Case 3: Load from the `INSTANA_IGNORE_ENDPOINTS` environment variable
+  // Case 2: Load from the `INSTANA_IGNORE_ENDPOINTS` environment variable
   // Introduced in Phase 1 for basic filtering based only on operations (e.g., `redis.get`, `kafka.consume`).
-  // Provides a simple way to configure ignored operations via environment variables.
   if (process.env.INSTANA_IGNORE_ENDPOINTS) {
     config.tracing.ignoreEndpoints = configNormalizers.ignoreEndpoints.fromEnv(process.env.INSTANA_IGNORE_ENDPOINTS);
     logger.debug(`Ignore endpoints have been configured: ${JSON.stringify(config.tracing.ignoreEndpoints)}`);
     return;
   }
+
+  // Case 3: Use in-code configuration if available
+  if (Object.keys(ignoreEndpointsConfig).length) {
+    config.tracing.ignoreEndpoints = configNormalizers.ignoreEndpoints.normalizeConfig(ignoreEndpointsConfig);
+    logger.debug(`Ignore endpoints have been configured: ${JSON.stringify(config.tracing.ignoreEndpoints)}`);
+    return;
+  }
 }
 
 /**
@@ -799,6 +808,13 @@ function normalizeIgnoreEndpointsDisableSuppression(config) {
     return;
   }
 
+  if (config.tracing.ignoreEndpointsDisableSuppression === true) {
+    logger.info(
+      'Disabling downstream suppression for ignoring endpoints feature as it is explicitly disabled via config.'
+    );
+    return;
+  }
+
   config.tracing.ignoreEndpointsDisableSuppression = defaults.tracing.ignoreEndpointsDisableSuppression;
 }
 
@@ -816,6 +832,11 @@ function normalizeDisableEOLEvents(config) {
     return;
   }
 
+  if (config.tracing.disableEOLEvents === true) {
+    logger.info('Disabling EOL events as it is explicitly disabled via config.');
+    return;
+  }
+
   config.tracing.disableEOLEvents = defaults.tracing.disableEOLEvents;
 }
 

From 15e7bc54a49b0c7ee7e20af3fb1f7cc2f43517a0 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Fri, 13 Mar 2026 15:40:03 +0530
Subject: [PATCH 02/14] test: corrected test

---
 packages/core/test/config/normalizeConfig_test.js | 12 ++++++------
 packages/core/test/tracing/index_test.js          |  8 ++++----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/packages/core/test/config/normalizeConfig_test.js b/packages/core/test/config/normalizeConfig_test.js
index b61295fe6b..fd56ccfd45 100644
--- a/packages/core/test/config/normalizeConfig_test.js
+++ b/packages/core/test/config/normalizeConfig_test.js
@@ -208,9 +208,9 @@ describe('config.normalizeConfig', () => {
   });
 
   it('should parse extra headers from env var', () => {
-    process.env.INSTANA_EXTRA_HTTP_HEADERS = ' X-Header-1 ; X-hEADer-2 , X-Whatever ';
+    process.env.INSTANA_EXTRA_HTTP_HEADERS = ' X-Header-1 ; X-Header-2 , X-Whatever ';
     const config = coreConfig.normalize();
-    expect(config.tracing.http.extraHttpHeadersToCapture).to.deep.equal(['x-header-1', 'x-header-2', 'x-whatever']);
+    expect(config.tracing.http.extraHttpHeadersToCapture).to.deep.equal(['X-Header-1', 'X-Header-2', 'X-Whatever']);
   });
 
   it('must use default extra headers (empty list) when INSTANA_EXTRA_HTTP_HEADERS is invalid', () => {
@@ -530,14 +530,14 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.disable.instrumentations).to.deep.equal(['graphql', 'grpc']);
   });
 
-  it('config should take precedence over INSTANA_TRACING_DISABLE_INSTRUMENTATIONS  for config', () => {
+  it('config should take precedence for INSTANA_TRACING_DISABLE_INSTRUMENTATIONS  over config', () => {
     process.env.INSTANA_TRACING_DISABLE_INSTRUMENTATIONS = 'foo, bar';
     const config = coreConfig.normalize({
       tracing: {
         disable: { instrumentations: ['baz', 'fizz'] }
       }
     });
-    expect(config.tracing.disable.instrumentations).to.deep.equal(['baz', 'fizz']);
+    expect(config.tracing.disable.instrumentations).to.deep.equal(['foo', 'bar']);
   });
 
   it('should disable multiple instrumentations via env var INSTANA_TRACING_DISABLE_INSTRUMENTATIONS', () => {
@@ -573,14 +573,14 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.disable.groups).to.deep.equal(['frameworks', 'databases']);
   });
 
-  it('config should take precedence over INSTANA_TRACING_DISABLE_GROUPS when disabling groups', () => {
+  it('config should take precedence for INSTANA_TRACING_DISABLE_GROUPS when disabling groups', () => {
     process.env.INSTANA_TRACING_DISABLE_GROUPS = 'frameworks, databases';
     const config = coreConfig.normalize({
       tracing: {
         disable: { groups: ['LOGGING'] }
       }
     });
-    expect(config.tracing.disable.groups).to.deep.equal(['logging']);
+    expect(config.tracing.disable.groups).to.deep.equal(['frameworks', 'databases']);
   });
 
   it('should disable instrumentations and groups when both configured', () => {
diff --git a/packages/core/test/tracing/index_test.js b/packages/core/test/tracing/index_test.js
index 515a616bbd..003aca83be 100644
--- a/packages/core/test/tracing/index_test.js
+++ b/packages/core/test/tracing/index_test.js
@@ -197,14 +197,14 @@ mochaSuiteFn('[UNIT] tracing/index', function () {
           process.env.INSTANA_TRACING_DISABLE_INSTRUMENTATIONS = 'grpc,kafkajs';
           initAndActivate({ tracing: { disable: { instrumentations: ['aws-sdk/v2'] } } });
 
-          expect(initAwsSdkv2).not.to.have.been.called;
-          expect(activateAwsSdkv2).not.to.have.been.called;
+          expect(initAwsSdkv2).to.have.been.called;
+          expect(activateAwsSdkv2).to.have.been.called;
 
           expect(initStubGrpcJs).to.have.been.called;
           expect(activateStubGrpcJs).to.have.been.called;
 
-          expect(initStubKafkaJs).to.have.been.called;
-          expect(activateStubKafkaJs).to.have.been.called;
+          expect(initStubKafkaJs).not.to.have.been.called;
+          expect(activateStubKafkaJs).not.to.have.been.called;
         });
 
         it('should disable all instrumentations in specified groups', () => {

From fa5792d8b1c71c9a94a0b76fd67d2ecfba755236 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 18 Mar 2026 11:07:28 +0530
Subject: [PATCH 03/14] chore: fixed issue

---
 packages/core/src/config/index.js | 40 ++++++++++++++++++-------------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index 30f82ec244..52745df2d9 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -426,28 +426,36 @@ function normalizeTracingTransmission(config) {
 function normalizeTracingHttp(config) {
   config.tracing.http = config.tracing.http || {};
 
+  let headersFromEnv;
   if (process.env.INSTANA_EXTRA_HTTP_HEADERS) {
-    config.tracing.http.extraHttpHeadersToCapture = parseHeadersEnvVar(process.env.INSTANA_EXTRA_HTTP_HEADERS);
-    return;
+    headersFromEnv = parseHeadersEnvVar(process.env.INSTANA_EXTRA_HTTP_HEADERS);
   }
 
-  if (config.tracing.http.extraHttpHeadersToCapture) {
-    if (!Array.isArray(config.tracing.http.extraHttpHeadersToCapture)) {
-      logger.warn(
-        `Invalid configuration: config.tracing.http.extraHttpHeadersToCapture is not an array, the value will be ignored: ${JSON.stringify(
-          config.tracing.http.extraHttpHeadersToCapture
-        )}`
-      );
-      config.tracing.http.extraHttpHeadersToCapture = defaults.tracing.http.extraHttpHeadersToCapture;
-      return;
-    }
-    config.tracing.http.extraHttpHeadersToCapture = config.tracing.http.extraHttpHeadersToCapture.map(
-      s => s.toLowerCase() // Node.js HTTP API turns all incoming HTTP headers into lowercase.
+  const headersFromConfig = config.tracing.http.extraHttpHeadersToCapture;
+  const isValidEnvHeaders = Array.isArray(headersFromEnv) && headersFromEnv.length > 0;
+
+  const isValidConfigHeaders = Array.isArray(headersFromConfig) && headersFromConfig.length > 0;
+
+  let resolvedHeaders;
+
+  if (isValidEnvHeaders) {
+    resolvedHeaders = headersFromEnv;
+  } else if (isValidConfigHeaders) {
+    resolvedHeaders = headersFromConfig;
+  } else {
+    resolvedHeaders = defaults.tracing.http.extraHttpHeadersToCapture;
+  }
+
+  if (!Array.isArray(resolvedHeaders)) {
+    logger.warn(
+      `Invalid configuration: extraHttpHeadersToCapture must be an array. Falling back to defaults: ${JSON.stringify(
+        resolvedHeaders
+      )}`
     );
-    return;
+    resolvedHeaders = defaults.tracing.http.extraHttpHeadersToCapture;
   }
 
-  config.tracing.http.extraHttpHeadersToCapture = defaults.tracing.http.extraHttpHeadersToCapture;
+  config.tracing.http.extraHttpHeadersToCapture = resolvedHeaders.map(h => h.toLowerCase());
 }
 
 /**

From f1f6daa6248c689b6a0aebff6dfc1ae822d180a2 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 18 Mar 2026 11:10:03 +0530
Subject: [PATCH 04/14] test: test

---
 packages/core/test/config/normalizeConfig_test.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/core/test/config/normalizeConfig_test.js b/packages/core/test/config/normalizeConfig_test.js
index fd56ccfd45..39642c9308 100644
--- a/packages/core/test/config/normalizeConfig_test.js
+++ b/packages/core/test/config/normalizeConfig_test.js
@@ -208,9 +208,9 @@ describe('config.normalizeConfig', () => {
   });
 
   it('should parse extra headers from env var', () => {
-    process.env.INSTANA_EXTRA_HTTP_HEADERS = ' X-Header-1 ; X-Header-2 , X-Whatever ';
+    process.env.INSTANA_EXTRA_HTTP_HEADERS = ' X-Header-1 ; X-hEADer-2 , X-Whatever ';
     const config = coreConfig.normalize();
-    expect(config.tracing.http.extraHttpHeadersToCapture).to.deep.equal(['X-Header-1', 'X-Header-2', 'X-Whatever']);
+    expect(config.tracing.http.extraHttpHeadersToCapture).to.deep.equal(['x-header-1', 'x-header-2', 'x-whatever']);
   });
 
   it('must use default extra headers (empty list) when INSTANA_EXTRA_HTTP_HEADERS is invalid', () => {

From 26ceefed66296b373fd6b94715e4f6feaed7596c Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 18 Mar 2026 11:19:14 +0530
Subject: [PATCH 05/14] test: test

---
 packages/core/src/config/configNormalizers/disable.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/core/src/config/configNormalizers/disable.js b/packages/core/src/config/configNormalizers/disable.js
index 472611ccb5..3ea3f5fd4a 100644
--- a/packages/core/src/config/configNormalizers/disable.js
+++ b/packages/core/src/config/configNormalizers/disable.js
@@ -19,8 +19,8 @@ exports.init = function init(_config) {
  * Handles environment variables, and array inputs.
  *
  * Precedence order (highest to lowest):
- * 1. Environment variables (`INSTANA_TRACING_DISABLE*`)
- * 2. `tracing.disable` (in-code config)
+ * 1. Environment variables (`INSTANA_TRACING_DISABLE`)
+ * 2. In-code config (`tracing.disable`)
  *
  * @param {import('../../config').InstanaConfig} config
  */

From 088fe3478dc00319639d0cf6e274e7d38c24c3c7 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 18 Mar 2026 12:29:13 +0530
Subject: [PATCH 06/14] chore: added logging

---
 packages/core/src/config/index.js        | 27 ++++++++++++++++++++++--
 packages/core/test/tracing/index_test.js |  2 +-
 2 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index 52745df2d9..e064452df5 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -182,7 +182,12 @@ module.exports.normalize = (userConfig, defaultsOverride = {}) => {
  */
 function normalizeServiceName(config) {
   if (config.serviceName == null && process.env['INSTANA_SERVICE_NAME']) {
+    logger.info(
+      `Service name has been configured via environment variable INSTANA_SERVICE_NAME: ${process.env['INSTANA_SERVICE_NAME']}`
+    );
     config.serviceName = process.env['INSTANA_SERVICE_NAME'];
+  } else if (config.serviceName != null && typeof config.serviceName === 'string') {
+    logger.info(`Service name has been configured via config: ${config.serviceName}`);
   }
   if (config.serviceName != null && typeof config.serviceName !== 'string') {
     logger.warn(
@@ -197,7 +202,12 @@ function normalizeServiceName(config) {
  */
 function normalizePackageJsonPath(config) {
   if (config.packageJsonPath == null && process.env['INSTANA_PACKAGE_JSON_PATH']) {
+    logger.info(
+      `Package JSON path has been configured via environment variable INSTANA_PACKAGE_JSON_PATH: ${process.env['INSTANA_PACKAGE_JSON_PATH']}`
+    );
     config.packageJsonPath = process.env['INSTANA_PACKAGE_JSON_PATH'];
+  } else if (config.packageJsonPath != null && typeof config.packageJsonPath === 'string') {
+    logger.info(`Package JSON path has been configured via config: ${config.packageJsonPath}`);
   }
   if (config.packageJsonPath != null && typeof config.packageJsonPath !== 'string') {
     logger.warn(
@@ -283,6 +293,7 @@ function normalizeAllowRootExitSpan(config) {
   const INSTANA_ALLOW_ROOT_EXIT_SPAN = process.env['INSTANA_ALLOW_ROOT_EXIT_SPAN']?.toLowerCase();
 
   if (INSTANA_ALLOW_ROOT_EXIT_SPAN === '1' || INSTANA_ALLOW_ROOT_EXIT_SPAN === 'true') {
+    logger.info('Allow root exit span has been enabled via environment variable INSTANA_ALLOW_ROOT_EXIT_SPAN.');
     config.tracing.allowRootExitSpan = true;
     return;
   }
@@ -291,6 +302,7 @@ function normalizeAllowRootExitSpan(config) {
     return;
   }
   if (config.tracing.allowRootExitSpan === true) {
+    logger.info('Allow root exit span has been enabled via config.');
     return;
   }
 
@@ -303,11 +315,13 @@ function normalizeAllowRootExitSpan(config) {
  */
 function normalizeUseOpentelemetry(config) {
   if (process.env['INSTANA_DISABLE_USE_OPENTELEMETRY'] === 'true') {
+    logger.info('OpenTelemetry usage has been disabled via environment variable INSTANA_DISABLE_USE_OPENTELEMETRY.');
     config.tracing.useOpentelemetry = false;
     return;
   }
 
   if (config.tracing.useOpentelemetry === false) {
+    logger.info('OpenTelemetry usage has been disabled via config.');
     return;
   }
   if (config.tracing.useOpentelemetry === true) {
@@ -363,6 +377,7 @@ function normalizeActivateImmediately(config) {
   }
 
   if (process.env['INSTANA_TRACE_IMMEDIATELY'] === 'true') {
+    logger.info('Tracing will activate immediately via environment variable INSTANA_TRACE_IMMEDIATELY.');
     config.tracing.activateImmediately = true;
     return;
   }
@@ -784,7 +799,11 @@ function normalizeIgnoreEndpoints(config) {
     config.tracing.ignoreEndpoints = configNormalizers.ignoreEndpoints.fromYaml(
       process.env.INSTANA_IGNORE_ENDPOINTS_PATH
     );
-    logger.debug(`Ignore endpoints have been configured: ${JSON.stringify(config.tracing.ignoreEndpoints)}`);
+    logger.debug(
+      `Ignore endpoints have been configured via environment variable INSTANA_IGNORE_ENDPOINTS_PATH: ${JSON.stringify(
+        config.tracing.ignoreEndpoints
+      )}`
+    );
     return;
   }
 
@@ -792,7 +811,11 @@ function normalizeIgnoreEndpoints(config) {
   // Introduced in Phase 1 for basic filtering based only on operations (e.g., `redis.get`, `kafka.consume`).
   if (process.env.INSTANA_IGNORE_ENDPOINTS) {
     config.tracing.ignoreEndpoints = configNormalizers.ignoreEndpoints.fromEnv(process.env.INSTANA_IGNORE_ENDPOINTS);
-    logger.debug(`Ignore endpoints have been configured: ${JSON.stringify(config.tracing.ignoreEndpoints)}`);
+    logger.debug(
+      `Ignore endpoints have been configured via environment variable INSTANA_IGNORE_ENDPOINTS:: ${JSON.stringify(
+        config.tracing.ignoreEndpoints
+      )}`
+    );
     return;
   }
 
diff --git a/packages/core/test/tracing/index_test.js b/packages/core/test/tracing/index_test.js
index 003aca83be..d9aec6a7c5 100644
--- a/packages/core/test/tracing/index_test.js
+++ b/packages/core/test/tracing/index_test.js
@@ -193,7 +193,7 @@ mochaSuiteFn('[UNIT] tracing/index', function () {
           expect(activateStubRdKafka).to.have.been.called;
         });
 
-        it('should prefer config.tracing.disable over env vars', () => {
+        it('should prefer env vars over config.tracing.disable', () => {
           process.env.INSTANA_TRACING_DISABLE_INSTRUMENTATIONS = 'grpc,kafkajs';
           initAndActivate({ tracing: { disable: { instrumentations: ['aws-sdk/v2'] } } });
 

From beb7f35f0c3b37972a4a3704c884c8d20e128831 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 18 Mar 2026 13:02:03 +0530
Subject: [PATCH 07/14] chore: more tests

---
 .../config/configNormalizers/stackTrace.js    |  2 +-
 packages/core/src/config/index.js             |  5 +-
 .../core/test/config/normalizeConfig_test.js  | 57 +++++++++++++++++++
 3 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/packages/core/src/config/configNormalizers/stackTrace.js b/packages/core/src/config/configNormalizers/stackTrace.js
index 2a0bb89ef2..9b0a596b04 100644
--- a/packages/core/src/config/configNormalizers/stackTrace.js
+++ b/packages/core/src/config/configNormalizers/stackTrace.js
@@ -25,7 +25,7 @@ exports.normalizeStackTraceMode = function (config) {
 
 /**
  * Normalizes stack trace length configuration based on precedence.
- * Precedence: global config > config > env var > default
+ * Precedence: env var > global config > config > default
  * @param {import('../../config').InstanaConfig} config
  * @returns {number} - Normalized value
  */
diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index e064452df5..a1450ba3af 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -181,7 +181,7 @@ module.exports.normalize = (userConfig, defaultsOverride = {}) => {
  * @param {InstanaConfig} config
  */
 function normalizeServiceName(config) {
-  if (config.serviceName == null && process.env['INSTANA_SERVICE_NAME']) {
+  if (process.env['INSTANA_SERVICE_NAME']) {
     logger.info(
       `Service name has been configured via environment variable INSTANA_SERVICE_NAME: ${process.env['INSTANA_SERVICE_NAME']}`
     );
@@ -201,7 +201,8 @@ function normalizeServiceName(config) {
  * @param {InstanaConfig} config
  */
 function normalizePackageJsonPath(config) {
-  if (config.packageJsonPath == null && process.env['INSTANA_PACKAGE_JSON_PATH']) {
+  // Environment variable takes precedence over config
+  if (process.env['INSTANA_PACKAGE_JSON_PATH']) {
     logger.info(
       `Package JSON path has been configured via environment variable INSTANA_PACKAGE_JSON_PATH: ${process.env['INSTANA_PACKAGE_JSON_PATH']}`
     );
diff --git a/packages/core/test/config/normalizeConfig_test.js b/packages/core/test/config/normalizeConfig_test.js
index 39642c9308..b357529ca3 100644
--- a/packages/core/test/config/normalizeConfig_test.js
+++ b/packages/core/test/config/normalizeConfig_test.js
@@ -62,6 +62,12 @@ describe('config.normalizeConfig', () => {
     expect(config.serviceName).to.equal('very-custom-service-name');
   });
 
+  it('should give precedence to INSTANA_SERVICE_NAME env var over config', () => {
+    process.env.INSTANA_SERVICE_NAME = 'env-service-name';
+    const config = coreConfig.normalize({ serviceName: 'config-service-name' });
+    expect(config.serviceName).to.equal('env-service-name');
+  });
+
   it('should not accept non-string service name', () => {
     const config = coreConfig.normalize({ serviceName: 42 });
     expect(config.serviceName).to.not.exist;
@@ -144,6 +150,12 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.activateImmediately).to.be.true;
   });
 
+  it('should give precedence to INSTANA_TRACE_IMMEDIATELY env var over config', () => {
+    process.env.INSTANA_TRACE_IMMEDIATELY = 'true';
+    const config = coreConfig.normalize({ tracing: { activateImmediately: false } });
+    expect(config.tracing.activateImmediately).to.be.true;
+  });
+
   it('should not enable immediate tracing activation when tracing is disabled in general', () => {
     const config = coreConfig.normalize({
       tracing: {
@@ -694,6 +706,12 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.useOpentelemetry).to.equal(false);
   });
 
+  it('should give precedence to INSTANA_DISABLE_USE_OPENTELEMETRY env var over config', () => {
+    process.env.INSTANA_DISABLE_USE_OPENTELEMETRY = 'true';
+    const config = coreConfig.normalize({ tracing: { useOpentelemetry: true } });
+    expect(config.tracing.useOpentelemetry).to.equal(false);
+  });
+
   it('should enable opentelemetry if INSTANA_DISABLE_USE_OPENTELEMETRY is set', () => {
     process.env.INSTANA_DISABLE_USE_OPENTELEMETRY = 'false';
     const config = coreConfig.normalize();
@@ -783,6 +801,12 @@ describe('config.normalizeConfig', () => {
     expect(config.packageJsonPath).to.equal('/my/path');
   });
 
+  it('should give precedence to INSTANA_PACKAGE_JSON_PATH env var over config', () => {
+    process.env.INSTANA_PACKAGE_JSON_PATH = '/env/path';
+    const config = coreConfig.normalize({ packageJsonPath: '/config/path' });
+    expect(config.packageJsonPath).to.equal('/env/path');
+  });
+
   it('should disable allow root exit span if config is set to false', () => {
     const config = coreConfig.normalize({
       tracing: { allowRootExitSpan: false }
@@ -808,6 +832,13 @@ describe('config.normalizeConfig', () => {
     const config = coreConfig.normalize();
     expect(config.tracing.allowRootExitSpan).to.equal(true);
   });
+
+  it('should give precedence to INSTANA_ALLOW_ROOT_EXIT_SPAN env var over config', () => {
+    process.env.INSTANA_ALLOW_ROOT_EXIT_SPAN = 'true';
+    const config = coreConfig.normalize({ tracing: { allowRootExitSpan: false } });
+    expect(config.tracing.allowRootExitSpan).to.equal(true);
+  });
+
   it('should not set ignore endpoints tracers by default', () => {
     const config = coreConfig.normalize();
     expect(config.tracing.ignoreEndpoints).to.deep.equal({});
@@ -1006,6 +1037,32 @@ describe('config.normalizeConfig', () => {
       expect(config.tracing.ignoreEndpoints).to.deep.equal({});
     });
 
+    it('should give precedence to INSTANA_IGNORE_ENDPOINTS over config', () => {
+      process.env.INSTANA_IGNORE_ENDPOINTS = 'redis:get,set';
+      const config = coreConfig.normalize({
+        tracing: {
+          ignoreEndpoints: { dynamodb: ['query'] }
+        }
+      });
+      // Should use basic env and ignore config
+      expect(config.tracing.ignoreEndpoints).to.deep.equal({
+        redis: [{ methods: ['get', 'set'] }]
+      });
+    });
+
+    it('should use config when no env variables are set', () => {
+      const config = coreConfig.normalize({
+        tracing: {
+          ignoreEndpoints: { dynamodb: ['query'], redis: ['get'] }
+        }
+      });
+      // Should use config
+      expect(config.tracing.ignoreEndpoints).to.deep.equal({
+        dynamodb: [{ methods: ['query'] }],
+        redis: [{ methods: ['get'] }]
+      });
+    });
+
     it('should return false when INSTANA_IGNORE_ENDPOINTS_DISABLE_SUPPRESSION is not set', () => {
       const config = coreConfig.normalize();
       expect(config.tracing.ignoreEndpointsDisableSuppression).to.equal(false);

From ed0a9ba44e272df782fa7bef603254326ef63a26 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 18 Mar 2026 13:07:48 +0530
Subject: [PATCH 08/14] chore: removed unwanted comments

---
 packages/core/src/config/index.js                 | 3 +--
 packages/core/test/config/normalizeConfig_test.js | 2 --
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index a1450ba3af..fb03f5ce11 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -201,7 +201,6 @@ function normalizeServiceName(config) {
  * @param {InstanaConfig} config
  */
 function normalizePackageJsonPath(config) {
-  // Environment variable takes precedence over config
   if (process.env['INSTANA_PACKAGE_JSON_PATH']) {
     logger.info(
       `Package JSON path has been configured via environment variable INSTANA_PACKAGE_JSON_PATH: ${process.env['INSTANA_PACKAGE_JSON_PATH']}`
@@ -470,7 +469,7 @@ function normalizeTracingHttp(config) {
     );
     resolvedHeaders = defaults.tracing.http.extraHttpHeadersToCapture;
   }
-
+  // Node.js HTTP API turns all incoming HTTP headers into lowercase.
   config.tracing.http.extraHttpHeadersToCapture = resolvedHeaders.map(h => h.toLowerCase());
 }
 
diff --git a/packages/core/test/config/normalizeConfig_test.js b/packages/core/test/config/normalizeConfig_test.js
index b357529ca3..08a54e1008 100644
--- a/packages/core/test/config/normalizeConfig_test.js
+++ b/packages/core/test/config/normalizeConfig_test.js
@@ -1044,7 +1044,6 @@ describe('config.normalizeConfig', () => {
           ignoreEndpoints: { dynamodb: ['query'] }
         }
       });
-      // Should use basic env and ignore config
       expect(config.tracing.ignoreEndpoints).to.deep.equal({
         redis: [{ methods: ['get', 'set'] }]
       });
@@ -1056,7 +1055,6 @@ describe('config.normalizeConfig', () => {
           ignoreEndpoints: { dynamodb: ['query'], redis: ['get'] }
         }
       });
-      // Should use config
       expect(config.tracing.ignoreEndpoints).to.deep.equal({
         dynamodb: [{ methods: ['query'] }],
         redis: [{ methods: ['get'] }]

From 70393771fa71c4b34cacc4e40098b745c9bd4d86 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Tue, 24 Mar 2026 18:18:40 +0530
Subject: [PATCH 09/14] chore: debug logs

---
 packages/core/src/config/index.js | 48 +++++++++++++++----------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index fb03f5ce11..dbdd5327ec 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -182,12 +182,12 @@ module.exports.normalize = (userConfig, defaultsOverride = {}) => {
  */
 function normalizeServiceName(config) {
   if (process.env['INSTANA_SERVICE_NAME']) {
-    logger.info(
+    logger.debug(
       `Service name has been configured via environment variable INSTANA_SERVICE_NAME: ${process.env['INSTANA_SERVICE_NAME']}`
     );
     config.serviceName = process.env['INSTANA_SERVICE_NAME'];
   } else if (config.serviceName != null && typeof config.serviceName === 'string') {
-    logger.info(`Service name has been configured via config: ${config.serviceName}`);
+    logger.debug(`Service name has been configured via config: ${config.serviceName}`);
   }
   if (config.serviceName != null && typeof config.serviceName !== 'string') {
     logger.warn(
@@ -202,12 +202,12 @@ function normalizeServiceName(config) {
  */
 function normalizePackageJsonPath(config) {
   if (process.env['INSTANA_PACKAGE_JSON_PATH']) {
-    logger.info(
+    logger.debug(
       `Package JSON path has been configured via environment variable INSTANA_PACKAGE_JSON_PATH: ${process.env['INSTANA_PACKAGE_JSON_PATH']}`
     );
     config.packageJsonPath = process.env['INSTANA_PACKAGE_JSON_PATH'];
   } else if (config.packageJsonPath != null && typeof config.packageJsonPath === 'string') {
-    logger.info(`Package JSON path has been configured via config: ${config.packageJsonPath}`);
+    logger.debug(`Package JSON path has been configured via config: ${config.packageJsonPath}`);
   }
   if (config.packageJsonPath != null && typeof config.packageJsonPath !== 'string') {
     logger.warn(
@@ -268,13 +268,13 @@ function normalizeTracingConfig(config) {
  */
 function normalizeTracingEnabled(config) {
   if (process.env['INSTANA_TRACING_DISABLE'] === 'true') {
-    logger.info('Not enabling tracing as it is explicitly disabled via environment variable INSTANA_TRACING_DISABLE.');
+    logger.debug('Not enabling tracing as it is explicitly disabled via environment variable INSTANA_TRACING_DISABLE.');
     config.tracing.enabled = false;
     return;
   }
 
   if (config.tracing.enabled === false) {
-    logger.info('Not enabling tracing as it is explicitly disabled via config.');
+    logger.debug('Not enabling tracing as it is explicitly disabled via config.');
     return;
   }
   if (config.tracing.enabled === true) {
@@ -293,7 +293,7 @@ function normalizeAllowRootExitSpan(config) {
   const INSTANA_ALLOW_ROOT_EXIT_SPAN = process.env['INSTANA_ALLOW_ROOT_EXIT_SPAN']?.toLowerCase();
 
   if (INSTANA_ALLOW_ROOT_EXIT_SPAN === '1' || INSTANA_ALLOW_ROOT_EXIT_SPAN === 'true') {
-    logger.info('Allow root exit span has been enabled via environment variable INSTANA_ALLOW_ROOT_EXIT_SPAN.');
+    logger.debug('Allow root exit span has been enabled via environment variable INSTANA_ALLOW_ROOT_EXIT_SPAN.');
     config.tracing.allowRootExitSpan = true;
     return;
   }
@@ -302,7 +302,7 @@ function normalizeAllowRootExitSpan(config) {
     return;
   }
   if (config.tracing.allowRootExitSpan === true) {
-    logger.info('Allow root exit span has been enabled via config.');
+    logger.debug('Allow root exit span has been enabled via config.');
     return;
   }
 
@@ -315,13 +315,13 @@ function normalizeAllowRootExitSpan(config) {
  */
 function normalizeUseOpentelemetry(config) {
   if (process.env['INSTANA_DISABLE_USE_OPENTELEMETRY'] === 'true') {
-    logger.info('OpenTelemetry usage has been disabled via environment variable INSTANA_DISABLE_USE_OPENTELEMETRY.');
+    logger.debug('OpenTelemetry usage has been disabled via environment variable INSTANA_DISABLE_USE_OPENTELEMETRY.');
     config.tracing.useOpentelemetry = false;
     return;
   }
 
   if (config.tracing.useOpentelemetry === false) {
-    logger.info('OpenTelemetry usage has been disabled via config.');
+    logger.debug('OpenTelemetry usage has been disabled via config.');
     return;
   }
   if (config.tracing.useOpentelemetry === true) {
@@ -336,13 +336,13 @@ function normalizeUseOpentelemetry(config) {
  */
 function normalizeAutomaticTracingEnabled(config) {
   if (!config.tracing.enabled) {
-    logger.info('Not enabling automatic tracing as tracing in general is explicitly disabled.');
+    logger.debug('Not enabling automatic tracing as tracing in general is explicitly disabled.');
     config.tracing.automaticTracingEnabled = false;
     return;
   }
 
   if (process.env['INSTANA_DISABLE_AUTO_INSTR'] === 'true') {
-    logger.info(
+    logger.debug(
       'Not enabling automatic tracing as it is explicitly disabled via environment variable INSTANA_DISABLE_AUTO_INSTR.'
     );
     config.tracing.automaticTracingEnabled = false;
@@ -350,7 +350,7 @@ function normalizeAutomaticTracingEnabled(config) {
   }
 
   if (config.tracing.automaticTracingEnabled === false) {
-    logger.info('Not enabling automatic tracing as it is explicitly disabled via config.');
+    logger.debug('Not enabling automatic tracing as it is explicitly disabled via config.');
     config.tracing.automaticTracingEnabled = false;
     return;
   }
@@ -377,7 +377,7 @@ function normalizeActivateImmediately(config) {
   }
 
   if (process.env['INSTANA_TRACE_IMMEDIATELY'] === 'true') {
-    logger.info('Tracing will activate immediately via environment variable INSTANA_TRACE_IMMEDIATELY.');
+    logger.debug('Tracing will activate immediately via environment variable INSTANA_TRACE_IMMEDIATELY.');
     config.tracing.activateImmediately = true;
     return;
   }
@@ -595,7 +595,7 @@ function normalizeDisableTracing(config) {
  */
 function normalizeSpanBatchingEnabled(config) {
   if (process.env['INSTANA_SPANBATCHING_ENABLED'] === 'true') {
-    logger.info('Span batching is enabled via environment variable INSTANA_SPANBATCHING_ENABLED.');
+    logger.debug('Span batching is enabled via environment variable INSTANA_SPANBATCHING_ENABLED.');
     config.tracing.spanBatchingEnabled = true;
     return;
   }
@@ -603,7 +603,7 @@ function normalizeSpanBatchingEnabled(config) {
   if (config.tracing.spanBatchingEnabled != null) {
     if (typeof config.tracing.spanBatchingEnabled === 'boolean') {
       if (config.tracing.spanBatchingEnabled) {
-        logger.info('Span batching is enabled via config.');
+        logger.debug('Span batching is enabled via config.');
       }
       return;
     } else {
@@ -623,7 +623,7 @@ function normalizeSpanBatchingEnabled(config) {
  */
 function normalizeDisableW3cTraceCorrelation(config) {
   if (process.env['INSTANA_DISABLE_W3C_TRACE_CORRELATION']) {
-    logger.info(
+    logger.debug(
       'W3C trace correlation has been disabled via environment variable INSTANA_DISABLE_W3C_TRACE_CORRELATION.'
     );
     config.tracing.disableW3cTraceCorrelation = true;
@@ -631,7 +631,7 @@ function normalizeDisableW3cTraceCorrelation(config) {
   }
 
   if (config.tracing.disableW3cTraceCorrelation === true) {
-    logger.info('W3C trace correlation has been disabled via config.');
+    logger.debug('W3C trace correlation has been disabled via config.');
     return;
   }
 
@@ -648,10 +648,10 @@ function normalizeTracingKafka(config) {
     process.env['INSTANA_KAFKA_TRACE_CORRELATION'] != null &&
     process.env['INSTANA_KAFKA_TRACE_CORRELATION'].toLowerCase() === 'false'
   ) {
-    logger.info('Kafka trace correlation has been disabled via environment variable INSTANA_KAFKA_TRACE_CORRELATION.');
+    logger.debug('Kafka trace correlation has been disabled via environment variable INSTANA_KAFKA_TRACE_CORRELATION.');
     config.tracing.kafka.traceCorrelation = false;
   } else if (config.tracing.kafka.traceCorrelation === false) {
-    logger.info('Kafka trace correlation has been disabled via config.');
+    logger.debug('Kafka trace correlation has been disabled via config.');
   } else {
     config.tracing.kafka.traceCorrelation = defaults.tracing.kafka.traceCorrelation;
   }
@@ -832,7 +832,7 @@ function normalizeIgnoreEndpoints(config) {
  */
 function normalizeIgnoreEndpointsDisableSuppression(config) {
   if (process.env['INSTANA_IGNORE_ENDPOINTS_DISABLE_SUPPRESSION'] === 'true') {
-    logger.info(
+    logger.debug(
       'Disabling downstream suppression for ignoring endpoints feature as it is explicitly disabled via environment variable "INSTANA_IGNORE_ENDPOINTS_DISABLE_SUPPRESSION".'
     );
     config.tracing.ignoreEndpointsDisableSuppression = true;
@@ -840,7 +840,7 @@ function normalizeIgnoreEndpointsDisableSuppression(config) {
   }
 
   if (config.tracing.ignoreEndpointsDisableSuppression === true) {
-    logger.info(
+    logger.debug(
       'Disabling downstream suppression for ignoring endpoints feature as it is explicitly disabled via config.'
     );
     return;
@@ -856,7 +856,7 @@ function normalizeDisableEOLEvents(config) {
   config.tracing = config.tracing || {};
 
   if (process.env['INSTANA_TRACING_DISABLE_EOL_EVENTS'] === 'true') {
-    logger.info(
+    logger.debug(
       'Disabling EOL events as it is explicitly disabled via environment variable "INSTANA_TRACING_DISABLE_EOL_EVENTS".'
     );
     config.tracing.disableEOLEvents = true;
@@ -864,7 +864,7 @@ function normalizeDisableEOLEvents(config) {
   }
 
   if (config.tracing.disableEOLEvents === true) {
-    logger.info('Disabling EOL events as it is explicitly disabled via config.');
+    logger.debug('Disabling EOL events as it is explicitly disabled via config.');
     return;
   }
 

From 9423fbd384ceddead1da0350973a75671097f60b Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 25 Mar 2026 12:33:12 +0530
Subject: [PATCH 10/14] test: added more tests

---
 packages/core/src/config/index.js             | 23 +++++++++++++++++++
 .../core/test/config/normalizeConfig_test.js  | 22 ++++++++++++++++--
 2 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index dbdd5327ec..233026cbf2 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -298,7 +298,14 @@ function normalizeAllowRootExitSpan(config) {
     return;
   }
 
+  if (INSTANA_ALLOW_ROOT_EXIT_SPAN === '0' || INSTANA_ALLOW_ROOT_EXIT_SPAN === 'false') {
+    logger.debug('Allow root exit span has been disabled via environment variable INSTANA_ALLOW_ROOT_EXIT_SPAN.');
+    config.tracing.allowRootExitSpan = false;
+    return;
+  }
+
   if (config.tracing.allowRootExitSpan === false) {
+    logger.debug('Allow root exit span has been disabled via config.');
     return;
   }
   if (config.tracing.allowRootExitSpan === true) {
@@ -320,11 +327,18 @@ function normalizeUseOpentelemetry(config) {
     return;
   }
 
+  if (process.env['INSTANA_DISABLE_USE_OPENTELEMETRY'] === 'false') {
+    logger.debug('OpenTelemetry usage has been enabled via environment variable INSTANA_DISABLE_USE_OPENTELEMETRY.');
+    config.tracing.useOpentelemetry = true;
+    return;
+  }
+
   if (config.tracing.useOpentelemetry === false) {
     logger.debug('OpenTelemetry usage has been disabled via config.');
     return;
   }
   if (config.tracing.useOpentelemetry === true) {
+    logger.debug('OpenTelemetry usage has been enabled via config.');
     return;
   }
 
@@ -382,7 +396,16 @@ function normalizeActivateImmediately(config) {
     return;
   }
 
+  if (process.env['INSTANA_TRACE_IMMEDIATELY'] === 'false') {
+    logger.debug('Tracing will not activate immediately via environment variable INSTANA_TRACE_IMMEDIATELY.');
+    config.tracing.activateImmediately = false;
+    return;
+  }
+
   if (typeof config.tracing.activateImmediately === 'boolean') {
+    if (config.tracing.activateImmediately) {
+      logger.debug('Tracing will activate immediately via config.');
+    }
     return;
   }
 
diff --git a/packages/core/test/config/normalizeConfig_test.js b/packages/core/test/config/normalizeConfig_test.js
index 08a54e1008..a4b6aa13b8 100644
--- a/packages/core/test/config/normalizeConfig_test.js
+++ b/packages/core/test/config/normalizeConfig_test.js
@@ -156,6 +156,12 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.activateImmediately).to.be.true;
   });
 
+  it('should give precedence to INSTANA_TRACE_IMMEDIATELY env var set to false over config set to true', () => {
+    process.env.INSTANA_TRACE_IMMEDIATELY = 'false';
+    const config = coreConfig.normalize({ tracing: { activateImmediately: true } });
+    expect(config.tracing.activateImmediately).to.be.false;
+  });
+
   it('should not enable immediate tracing activation when tracing is disabled in general', () => {
     const config = coreConfig.normalize({
       tracing: {
@@ -712,6 +718,12 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.useOpentelemetry).to.equal(false);
   });
 
+  it('should give precedence to INSTANA_DISABLE_USE_OPENTELEMETRY env var set to false over config set to false', () => {
+    process.env.INSTANA_DISABLE_USE_OPENTELEMETRY = 'false';
+    const config = coreConfig.normalize({ tracing: { useOpentelemetry: false } });
+    expect(config.tracing.useOpentelemetry).to.equal(true);
+  });
+
   it('should enable opentelemetry if INSTANA_DISABLE_USE_OPENTELEMETRY is set', () => {
     process.env.INSTANA_DISABLE_USE_OPENTELEMETRY = 'false';
     const config = coreConfig.normalize();
@@ -821,18 +833,24 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.allowRootExitSpan).to.equal(true);
   });
 
-  it('should disable allow root exit span if INSTANA_ALLOW_ROOT_EXIT_SPAN is not set', () => {
+  it('should disable allow root exit span if INSTANA_ALLOW_ROOT_EXIT_SPAN is set to false', () => {
     process.env.INSTANA_ALLOW_ROOT_EXIT_SPAN = false;
     const config = coreConfig.normalize();
     expect(config.tracing.allowRootExitSpan).to.equal(false);
   });
 
-  it('should enable allow root exit span if INSTANA_ALLOW_ROOT_EXIT_SPAN is set', () => {
+  it('should enable allow root exit span if INSTANA_ALLOW_ROOT_EXIT_SPAN is set to true', () => {
     process.env.INSTANA_ALLOW_ROOT_EXIT_SPAN = true;
     const config = coreConfig.normalize();
     expect(config.tracing.allowRootExitSpan).to.equal(true);
   });
 
+  it('should give precedence to INSTANA_ALLOW_ROOT_EXIT_SPAN is set to false even config is set to true', () => {
+    process.env.INSTANA_ALLOW_ROOT_EXIT_SPAN = 'false';
+    const config = coreConfig.normalize({ tracing: { allowRootExitSpan: true } });
+    expect(config.tracing.allowRootExitSpan).to.equal(false);
+  });
+
   it('should give precedence to INSTANA_ALLOW_ROOT_EXIT_SPAN env var over config', () => {
     process.env.INSTANA_ALLOW_ROOT_EXIT_SPAN = 'true';
     const config = coreConfig.normalize({ tracing: { allowRootExitSpan: false } });

From 0e20c512458a43a6f988347c3283349082cecc9c Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 25 Mar 2026 12:43:20 +0530
Subject: [PATCH 11/14] test: added more tests

---
 packages/core/src/config/index.js             | 42 ++++++++++++++++-
 .../core/test/config/normalizeConfig_test.js  | 47 ++++++++++++++++++-
 2 files changed, 86 insertions(+), 3 deletions(-)

diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index 233026cbf2..4ec108625c 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -273,6 +273,12 @@ function normalizeTracingEnabled(config) {
     return;
   }
 
+  if (process.env['INSTANA_TRACING_DISABLE'] === 'false') {
+    logger.debug('Tracing has been enabled via environment variable INSTANA_TRACING_DISABLE.');
+    config.tracing.enabled = true;
+    return;
+  }
+
   if (config.tracing.enabled === false) {
     logger.debug('Not enabling tracing as it is explicitly disabled via config.');
     return;
@@ -623,6 +629,12 @@ function normalizeSpanBatchingEnabled(config) {
     return;
   }
 
+  if (process.env['INSTANA_SPANBATCHING_ENABLED'] === 'false') {
+    logger.debug('Span batching is disabled via environment variable INSTANA_SPANBATCHING_ENABLED.');
+    config.tracing.spanBatchingEnabled = false;
+    return;
+  }
+  
   if (config.tracing.spanBatchingEnabled != null) {
     if (typeof config.tracing.spanBatchingEnabled === 'boolean') {
       if (config.tracing.spanBatchingEnabled) {
@@ -645,7 +657,7 @@ function normalizeSpanBatchingEnabled(config) {
  * @param {InstanaConfig} config
  */
 function normalizeDisableW3cTraceCorrelation(config) {
-  if (process.env['INSTANA_DISABLE_W3C_TRACE_CORRELATION']) {
+  if (process.env['INSTANA_DISABLE_W3C_TRACE_CORRELATION'] === 'true') {
     logger.debug(
       'W3C trace correlation has been disabled via environment variable INSTANA_DISABLE_W3C_TRACE_CORRELATION.'
     );
@@ -653,6 +665,14 @@ function normalizeDisableW3cTraceCorrelation(config) {
     return;
   }
 
+  if (process.env['INSTANA_DISABLE_W3C_TRACE_CORRELATION'] === 'false') {
+    logger.debug(
+      'W3C trace correlation has been enabled via environment variable INSTANA_DISABLE_W3C_TRACE_CORRELATION.'
+    );
+    config.tracing.disableW3cTraceCorrelation = false;
+    return;
+  }
+
   if (config.tracing.disableW3cTraceCorrelation === true) {
     logger.debug('W3C trace correlation has been disabled via config.');
     return;
@@ -673,6 +693,12 @@ function normalizeTracingKafka(config) {
   ) {
     logger.debug('Kafka trace correlation has been disabled via environment variable INSTANA_KAFKA_TRACE_CORRELATION.');
     config.tracing.kafka.traceCorrelation = false;
+  } else if (
+    process.env['INSTANA_KAFKA_TRACE_CORRELATION'] != null &&
+    process.env['INSTANA_KAFKA_TRACE_CORRELATION'].toLowerCase() === 'true'
+  ) {
+    logger.debug('Kafka trace correlation has been enabled via environment variable INSTANA_KAFKA_TRACE_CORRELATION.');
+    config.tracing.kafka.traceCorrelation = true;
   } else if (config.tracing.kafka.traceCorrelation === false) {
     logger.debug('Kafka trace correlation has been disabled via config.');
   } else {
@@ -862,6 +888,14 @@ function normalizeIgnoreEndpointsDisableSuppression(config) {
     return;
   }
 
+  if (process.env['INSTANA_IGNORE_ENDPOINTS_DISABLE_SUPPRESSION'] === 'false') {
+    logger.debug(
+      'Enabling downstream suppression for ignoring endpoints feature via environment variable "INSTANA_IGNORE_ENDPOINTS_DISABLE_SUPPRESSION".'
+    );
+    config.tracing.ignoreEndpointsDisableSuppression = false;
+    return;
+  }
+
   if (config.tracing.ignoreEndpointsDisableSuppression === true) {
     logger.debug(
       'Disabling downstream suppression for ignoring endpoints feature as it is explicitly disabled via config.'
@@ -886,6 +920,12 @@ function normalizeDisableEOLEvents(config) {
     return;
   }
 
+  if (process.env['INSTANA_TRACING_DISABLE_EOL_EVENTS'] === 'false') {
+    logger.debug('Enabling EOL events via environment variable "INSTANA_TRACING_DISABLE_EOL_EVENTS".');
+    config.tracing.disableEOLEvents = false;
+    return;
+  }
+
   if (config.tracing.disableEOLEvents === true) {
     logger.debug('Disabling EOL events as it is explicitly disabled via config.');
     return;
diff --git a/packages/core/test/config/normalizeConfig_test.js b/packages/core/test/config/normalizeConfig_test.js
index a4b6aa13b8..d323ed3ccc 100644
--- a/packages/core/test/config/normalizeConfig_test.js
+++ b/packages/core/test/config/normalizeConfig_test.js
@@ -20,6 +20,7 @@ describe('config.normalizeConfig', () => {
   afterEach(resetEnv);
 
   function resetEnv() {
+    delete process.env.INSTANA_TRACING_DISABLE;
     delete process.env.INSTANA_TRACING_DISABLE_INSTRUMENTATIONS;
     delete process.env.INSTANA_TRACING_DISABLE_GROUPS;
     delete process.env.INSTANA_TRACING_DISABLE_EOL_EVENTS;
@@ -103,6 +104,12 @@ describe('config.normalizeConfig', () => {
     expect(config.metrics.timeBetweenHealthcheckCalls).to.equal(9876);
   });
 
+  it('should give precedence to INSTANA_TRACING_DISABLE env var set to false over config set to false', () => {
+    process.env.INSTANA_TRACING_DISABLE = 'false';
+    const config = coreConfig.normalize({ tracing: { enabled: false } });
+    expect(config.tracing.enabled).to.be.true;
+  });
+
   it('should disable tracing with enabled: false', () => {
     const config = coreConfig.normalize({ tracing: { enabled: false } });
     expect(config.tracing.enabled).to.be.false;
@@ -651,6 +658,12 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.spanBatchingEnabled).to.be.true;
   });
 
+  it('should give precedence to INSTANA_SPANBATCHING_ENABLED env var set to false over config set to true', () => {
+    process.env.INSTANA_SPANBATCHING_ENABLED = 'false';
+    const config = coreConfig.normalize({ tracing: { spanBatchingEnabled: true } });
+    expect(config.tracing.spanBatchingEnabled).to.be.false;
+  });
+
   it('should ignore non-boolean span batching config value', () => {
     const config = coreConfig.normalize({ tracing: { spanBatchingEnabled: 73 } });
     // test needs to be updated once we switch to opt-out
@@ -675,12 +688,24 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.disableW3cTraceCorrelation).to.be.true;
   });
 
-  it('should disable W3C trace correlation via INSTANA_DISABLE_W3C_TRACE_CORRELATION', () => {
-    process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'false'; // any non-empty string will disable, even "false"!
+  it('should disable W3C trace correlation via INSTANA_DISABLE_W3C_TRACE_CORRELATION set to true', () => {
+    process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'true';
     const config = coreConfig.normalize();
     expect(config.tracing.disableW3cTraceCorrelation).to.be.true;
   });
 
+  it('should enable W3C trace correlation via INSTANA_DISABLE_W3C_TRACE_CORRELATION set to false', () => {
+    process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'false';
+    const config = coreConfig.normalize();
+    expect(config.tracing.disableW3cTraceCorrelation).to.be.false;
+  });
+
+  it('should give precedence to INSTANA_DISABLE_W3C_TRACE_CORRELATION env var set to false over config set to true', () => {
+    process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'false';
+    const config = coreConfig.normalize({ tracing: { disableW3cTraceCorrelation: true } });
+    expect(config.tracing.disableW3cTraceCorrelation).to.be.false;
+  });
+
   it('should disable Kafka trace correlation', () => {
     const config = coreConfig.normalize({ tracing: { kafka: { traceCorrelation: false } } });
     expect(config.tracing.kafka.traceCorrelation).to.be.false;
@@ -692,6 +717,12 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.kafka.traceCorrelation).to.be.false;
   });
 
+  it('should give precedence to INSTANA_KAFKA_TRACE_CORRELATION env var set to true over config set to false', () => {
+    process.env.INSTANA_KAFKA_TRACE_CORRELATION = 'true';
+    const config = coreConfig.normalize({ tracing: { kafka: { traceCorrelation: false } } });
+    expect(config.tracing.kafka.traceCorrelation).to.be.true;
+  });
+
   it('should disable opentelemetry if config is set', () => {
     const config = coreConfig.normalize({
       tracing: { useOpentelemetry: false }
@@ -1107,6 +1138,18 @@ describe('config.normalizeConfig', () => {
       expect(config.tracing.disableEOLEvents).to.equal(false);
     });
 
+    it('should give precedence to INSTANA_TRACING_DISABLE_EOL_EVENTS env var set to false over config set to true', () => {
+      process.env.INSTANA_TRACING_DISABLE_EOL_EVENTS = 'false';
+      const config = coreConfig.normalize({ tracing: { disableEOLEvents: true } });
+      expect(config.tracing.disableEOLEvents).to.equal(false);
+    });
+
+    it('should give precedence to INSTANA_IGNORE_ENDPOINTS_DISABLE_SUPPRESSION env var set to false over config set to true', () => {
+      process.env.INSTANA_IGNORE_ENDPOINTS_DISABLE_SUPPRESSION = 'false';
+      const config = coreConfig.normalize({ tracing: { ignoreEndpointsDisableSuppression: true } });
+      expect(config.tracing.ignoreEndpointsDisableSuppression).to.equal(false);
+    });
+
     it('should return false when INSTANA_TRACING_DISABLE_EOL_EVENTS is set to any other value', () => {
       process.env.INSTANA_TRACING_DISABLE_EOL_EVENTS = 'test';
       const config = coreConfig.normalize();

From 3aca43bc92c0fe0339c4aa34dbf9b8e30582c413 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 25 Mar 2026 14:43:12 +0530
Subject: [PATCH 12/14] test: added more tests

---
 packages/core/src/config/index.js                | 13 +++----------
 .../core/test/config/normalizeConfig_test.js     | 16 ++++++++--------
 2 files changed, 11 insertions(+), 18 deletions(-)

diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index 4ec108625c..53dccd9671 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -634,7 +634,7 @@ function normalizeSpanBatchingEnabled(config) {
     config.tracing.spanBatchingEnabled = false;
     return;
   }
-  
+
   if (config.tracing.spanBatchingEnabled != null) {
     if (typeof config.tracing.spanBatchingEnabled === 'boolean') {
       if (config.tracing.spanBatchingEnabled) {
@@ -657,7 +657,8 @@ function normalizeSpanBatchingEnabled(config) {
  * @param {InstanaConfig} config
  */
 function normalizeDisableW3cTraceCorrelation(config) {
-  if (process.env['INSTANA_DISABLE_W3C_TRACE_CORRELATION'] === 'true') {
+  // any non-empty string will disable, even "false"!
+  if (process.env['INSTANA_DISABLE_W3C_TRACE_CORRELATION']) {
     logger.debug(
       'W3C trace correlation has been disabled via environment variable INSTANA_DISABLE_W3C_TRACE_CORRELATION.'
     );
@@ -665,14 +666,6 @@ function normalizeDisableW3cTraceCorrelation(config) {
     return;
   }
 
-  if (process.env['INSTANA_DISABLE_W3C_TRACE_CORRELATION'] === 'false') {
-    logger.debug(
-      'W3C trace correlation has been enabled via environment variable INSTANA_DISABLE_W3C_TRACE_CORRELATION.'
-    );
-    config.tracing.disableW3cTraceCorrelation = false;
-    return;
-  }
-
   if (config.tracing.disableW3cTraceCorrelation === true) {
     logger.debug('W3C trace correlation has been disabled via config.');
     return;
diff --git a/packages/core/test/config/normalizeConfig_test.js b/packages/core/test/config/normalizeConfig_test.js
index d323ed3ccc..0068d85b47 100644
--- a/packages/core/test/config/normalizeConfig_test.js
+++ b/packages/core/test/config/normalizeConfig_test.js
@@ -688,22 +688,22 @@ describe('config.normalizeConfig', () => {
     expect(config.tracing.disableW3cTraceCorrelation).to.be.true;
   });
 
-  it('should disable W3C trace correlation via INSTANA_DISABLE_W3C_TRACE_CORRELATION set to true', () => {
+  it('should disable W3C trace correlation via INSTANA_DISABLE_W3C_TRACE_CORRELATION', () => {
     process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'true';
     const config = coreConfig.normalize();
     expect(config.tracing.disableW3cTraceCorrelation).to.be.true;
   });
 
-  it('should enable W3C trace correlation via INSTANA_DISABLE_W3C_TRACE_CORRELATION set to false', () => {
-    process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'false';
+  it('should disable W3C trace correlation via INSTANA_DISABLE_W3C_TRACE_CORRELATION with any non-empty string', () => {
+    process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'false'; // any non-empty string will disable, even "false"!
     const config = coreConfig.normalize();
-    expect(config.tracing.disableW3cTraceCorrelation).to.be.false;
+    expect(config.tracing.disableW3cTraceCorrelation).to.be.true;
   });
 
-  it('should give precedence to INSTANA_DISABLE_W3C_TRACE_CORRELATION env var set to false over config set to true', () => {
-    process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'false';
-    const config = coreConfig.normalize({ tracing: { disableW3cTraceCorrelation: true } });
-    expect(config.tracing.disableW3cTraceCorrelation).to.be.false;
+  it('should give precedence to INSTANA_DISABLE_W3C_TRACE_CORRELATION env var over config', () => {
+    process.env.INSTANA_DISABLE_W3C_TRACE_CORRELATION = 'anything';
+    const config = coreConfig.normalize({ tracing: { disableW3cTraceCorrelation: false } });
+    expect(config.tracing.disableW3cTraceCorrelation).to.be.true;
   });
 
   it('should disable Kafka trace correlation', () => {

From 748b5afdb1347e87b5fd7439e5f254f5026f2203 Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Wed, 25 Mar 2026 14:48:30 +0530
Subject: [PATCH 13/14] test: added more tests

---
 .../src/config/configNormalizers/disable.js   |  7 ++++-
 .../config/configNormalizers/disable_test.js  | 28 +++++++++++++++++++
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/packages/core/src/config/configNormalizers/disable.js b/packages/core/src/config/configNormalizers/disable.js
index 3ea3f5fd4a..5b692582b9 100644
--- a/packages/core/src/config/configNormalizers/disable.js
+++ b/packages/core/src/config/configNormalizers/disable.js
@@ -119,7 +119,12 @@ function getDisableFromEnv() {
       return true;
     }
 
-    if (envVarValue !== 'false' && envVarValue !== '') {
+    if (envVarValue === 'false') {
+      logger?.debug('Tracing has been enabled via environment variable "INSTANA_TRACING_DISABLE=false".');
+      return {};
+    }
+
+    if (envVarValue !== '') {
       const categorized = categorizeDisableEntries(parseEnvVar(envVarValue));
       if (categorized?.instrumentations?.length) {
         disable.instrumentations = categorized.instrumentations;
diff --git a/packages/core/test/config/configNormalizers/disable_test.js b/packages/core/test/config/configNormalizers/disable_test.js
index eaf3c68114..d3b98a7e2d 100644
--- a/packages/core/test/config/configNormalizers/disable_test.js
+++ b/packages/core/test/config/configNormalizers/disable_test.js
@@ -288,6 +288,34 @@ describe('util.configNormalizers.disable', () => {
       expect(result).to.deep.equal({});
     });
 
+    it('should give precedence to INSTANA_TRACING_DISABLE=false over config.tracing.disable=true', () => {
+      process.env.INSTANA_TRACING_DISABLE = 'false';
+
+      const config = {
+        tracing: {
+          disable: true
+        }
+      };
+      const result = normalize(config);
+
+      expect(result).to.deep.equal({});
+    });
+
+    it('should give precedence to INSTANA_TRACING_DISABLE=false over config with instrumentations', () => {
+      process.env.INSTANA_TRACING_DISABLE = 'false';
+
+      const config = {
+        tracing: {
+          disable: {
+            instrumentations: ['aws-sdk', 'mongodb']
+          }
+        }
+      };
+      const result = normalize(config);
+
+      expect(result).to.deep.equal({});
+    });
+
     it('should give precedence to INSTANA_TRACING_DISABLE=true over other env vars', () => {
       process.env.INSTANA_TRACING_DISABLE = 'true';
       process.env.INSTANA_TRACING_DISABLE_INSTRUMENTATIONS = 'aws-sdk,mongodb';

From 2e8eac5e93480779a38f1e8e28cd105e172a8b0d Mon Sep 17 00:00:00 2001
From: Arya <arya.mohanan@ibm.com>
Date: Thu, 26 Mar 2026 14:14:03 +0530
Subject: [PATCH 14/14] test: added comment

---
 packages/core/src/config/index.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/core/src/config/index.js b/packages/core/src/config/index.js
index 53dccd9671..ddb171196d 100644
--- a/packages/core/src/config/index.js
+++ b/packages/core/src/config/index.js
@@ -913,6 +913,7 @@ function normalizeDisableEOLEvents(config) {
     return;
   }
 
+  // TODO: a helper function rewrite the pattern of env var parsing for boolean values, as this is repeated multiple times across different config options.
   if (process.env['INSTANA_TRACING_DISABLE_EOL_EVENTS'] === 'false') {
     logger.debug('Enabling EOL events via environment variable "INSTANA_TRACING_DISABLE_EOL_EVENTS".');
     config.tracing.disableEOLEvents = false;