v6: Prepare Config Changes for v6 (Refactor + Breaking Changes)

packages/aws-lambda/src/wrapper.js

@@ -36,7 +36,7 @@ const latestRuntime = semver.gte(process.version, '24.0.0');
 
 const logger = serverlessLogger.init();
 coreConfig.init(logger);
-let config = coreConfig.normalize({}, lambdaConfigDefaults);
+let config = coreConfig.normalize({ defaultsOverride: lambdaConfigDefaults });
 let coldStart = true;
 
 // Initialize instrumentations early to allow for require statements after our
@@ -286,7 +286,7 @@ function init(event, arnInfo, _config) {
   //         - late env variables (less likely)
   //         - custom logger
   //         - we always renormalize unconditionally to ensure safety.
-  config = coreConfig.normalize(userConfig, lambdaConfigDefaults);
+  config = coreConfig.normalize({ userConfig, defaultsOverride: lambdaConfigDefaults });
 
   if (!config.tracing.enabled) {
     return false;

packages/collector/src/announceCycle/agentready.js

@@ -12,7 +12,7 @@ try {
   // Worker threads are not available, so we know that this is the main thread.
 }
 
-const { tracing } = require('@instana/core');
+const { tracing, coreConfig, util } = require('@instana/core');
 const agentConnection = require('../agentConnection');
 const agentOpts = require('../agent/opts');
 const initializedTooLate = require('../util/initializedTooLate');
@@ -130,7 +130,11 @@ function enter(_ctx) {
     }
   }
 
-  tracing.activate(agentOpts.config);
+  const updatedConfig = coreConfig.update({
+    externalConfig: agentOpts.config,
+    source: util.constants.CONFIG_SOURCES.AGENT
+  });
+  tracing.activate(updatedConfig);
 
   if (agentOpts.autoProfile && autoprofile) {
     profiler = autoprofile.start();

packages/collector/src/announceCycle/unannounced.js

@@ -305,7 +305,7 @@ function applyDisableConfiguration(agentResponse) {
   ensureNestedObjectExists(agentOpts.config, ['tracing', 'disable']);
   agentOpts.config.tracing.disable = configNormalizers.disable.normalizeExternalConfig({
     tracing: { disable: disablingConfig }
-  });
+  }).value;
 }
 module.exports = {
   init,

packages/collector/src/index.js

@@ -103,7 +103,7 @@ const instanaSharedMetrics = require('@instana/shared-metrics');
 require('./tracing'); // load additional instrumentations
 
 const log = require('./logger');
-const normalizeCollectorConfig = require('./util/normalizeConfig');
+const normalizeConfig = require('./util/normalizeConfig');
 const experimental = require('./experimental');
 
 // NOTE: Default collector logger && config for cases like `preinit`.
@@ -158,8 +158,11 @@ function init(userConfig = {}) {
     log.init(userConfig);
   }
 
-  config = normalizeCollectorConfig(userConfig);
-  config = instanaNodeJsCore.coreConfig.normalize(config);
+  const finalCollectorConfig = normalizeConfig(userConfig);
+  config = instanaNodeJsCore.coreConfig.normalize({
+    userConfig,
+    finalConfigBase: finalCollectorConfig
+  });
 
   agentConnection = require('./agentConnection');
   const agentOpts = require('./agent/opts');

packages/collector/src/types/collector.d.ts

@@ -29,7 +29,7 @@ export interface CollectorConfig {
     stackTraceLength?: number;
     [key: string]: any;
   };
-  autoProfile?: boolean | string;
+  autoProfile?: boolean;
   reportUnhandledPromiseRejections?: boolean;
   logger?: GenericLogger;
   level?: string | number;

packages/collector/src/util/normalizeConfig.js

@@ -3,10 +3,11 @@
  * (c) Copyright Instana Inc. and contributors 2019
  */
 
-/* eslint-disable dot-notation */
-
 'use strict';
 
+const util = require('@instana/core/src/config/util');
+const validate = require('@instana/core/src/config/validator');
+
 const defaults = {
   agentHost: '127.0.0.1',
   agentPort: 42699,
@@ -16,38 +17,105 @@ const defaults = {
 
 /**
  * Merges the config that was passed to the init function with environment variables and default values.
- * @param {import('../types/collector').CollectorConfig} config
+ * @param {import('../types/collector').CollectorConfig} userConfig
  * @returns {import('../types/collector').CollectorConfig}
  */
-module.exports = function normalizeConfig(config = {}) {
-  config.agentHost = config.agentHost || process.env.INSTANA_AGENT_HOST || defaults.agentHost;
-  config.agentPort = config.agentPort || parseToPositiveInteger(process.env.INSTANA_AGENT_PORT, defaults.agentPort);
-  config.agentRequestTimeout =
-    config.agentRequestTimeout ||
-    parseToPositiveInteger(process.env.INSTANA_AGENT_REQUEST_TIMEOUT, defaults.agentRequestTimeout);
-
-  config.autoProfile = config.autoProfile || process.env.INSTANA_AUTO_PROFILE || defaults.autoProfile;
-  config.tracing = config.tracing || {};
+module.exports = function normalizeConfig(userConfig = {}) {
+  const finalConfig = {};
 
-  if (config.reportUnhandledPromiseRejections == null) {
-    config.reportUnhandledPromiseRejections = false;
-  }
+  // NOTE: This function only normalizes collector-specific configuration fields.
+  // Other userConfig fields (like serviceName, tracing, etc.) are passed through as-is
+  // and will be normalized later by core/config when this collector config is passed
+  // as extraFinalConfig to core's normalize function.
+  finalConfig.agentHost = normalizeAgentHost(userConfig, defaults);
+  finalConfig.agentPort = normalizeAgentPort(userConfig, defaults);
+  finalConfig.agentRequestTimeout = normalizeAgentRequestTimeout(userConfig, defaults);
+  finalConfig.autoProfile = normalizeAutoProfile(userConfig, defaults);
+  finalConfig.reportUnhandledPromiseRejections = normalizeUnhandledRejections(userConfig);
+  finalConfig.tracing = userConfig.tracing || {};
 
-  return config;
+  return finalConfig;
 };
 
 /**
- * @param {string | number} value
- * @param {number} defaultValue
+ * @param {import('../types/collector').CollectorConfig} userConfig
+ * @param {{ agentHost: string }} defaultConfig
+ * @returns {string}
+ */
+function normalizeAgentHost(userConfig, defaultConfig) {
+  const { value } = util.resolve(
+    {
+      envValue: 'INSTANA_AGENT_HOST',
+      inCodeValue: userConfig.agentHost,
+      defaultValue: defaultConfig.agentHost
+    },
+    [validate.stringValidator]
+  );
+  return value;
+}
+
+/**
+ * @param {import('../types/collector').CollectorConfig} userConfig
+ * @param {{ agentPort: number }} defaultConfig
+ * @returns {number}
+ */
+function normalizeAgentPort(userConfig, defaultConfig) {
+  const { value } = util.resolve(
+    {
+      envValue: 'INSTANA_AGENT_PORT',
+      inCodeValue: userConfig.agentPort,
+      defaultValue: defaultConfig.agentPort
+    },
+    [validate.numberValidator]
+  );
+  return value;
+}
+
+/**
+ * @param {import('../types/collector').CollectorConfig} userConfig
+ * @param {{ agentRequestTimeout: number }} defaultConfig
  * @returns {number}
  */
-function parseToPositiveInteger(value, defaultValue) {
-  if (typeof value !== 'string') {
-    return defaultValue;
-  }
-  value = parseInt(value, 10);
-  if (!isNaN(value)) {
-    return Math.abs(Math.round(value));
-  }
-  return defaultValue;
+function normalizeAgentRequestTimeout(userConfig, defaultConfig) {
+  const { value } = util.resolve(
+    {
+      envValue: 'INSTANA_AGENT_REQUEST_TIMEOUT',
+      inCodeValue: userConfig.agentRequestTimeout,
+      defaultValue: defaultConfig.agentRequestTimeout
+    },
+    [validate.numberValidator]
+  );
+  return value;
+}
+
+/**
+ * @param {import('../types/collector').CollectorConfig} userConfig
+ * @param {{ autoProfile: boolean }} defaultConfig
+ * @returns {boolean}
+ */
+function normalizeAutoProfile(userConfig, defaultConfig) {
+  const { value } = util.resolve(
+    {
+      envValue: 'INSTANA_AUTO_PROFILE',
+      inCodeValue: userConfig.autoProfile,
+      defaultValue: defaultConfig.autoProfile
+    },
+    [validate.booleanValidator]
+  );
+  return value;
+}
+
+/**
+ * @param {import('../types/collector').CollectorConfig} userConfig
+ * @returns {boolean}
+ */
+function normalizeUnhandledRejections(userConfig) {
+  const { value } = util.resolve(
+    {
+      inCodeValue: userConfig.reportUnhandledPromiseRejections,
+      defaultValue: false
+    },
+    [validate.booleanValidator]
+  );
+  return value;
 }

packages/collector/test/integration/currencies/messaging/kafkajs/test_base.js

@@ -411,6 +411,152 @@ module.exports = function (name, version, isLatest, mode) {
       );
     });
 
+    describe('traceCorrelation configuration precedence', function () {
+      describe('when agent enables traceCorrelation (overriding default)', function () {
+        const customAgentControls = new AgentStubControls();
+
+        let consumerControls;
+        let producerControls;
+
+        before(async () => {
+          await customAgentControls.startAgent({
+            kafkaConfig: { traceCorrelation: true }
+          });
+
+          consumerControls = new ProcessControls({
+            dirname: __dirname,
+            appName: 'consumer',
+            agentControls: customAgentControls,
+            env: { ...libraryEnv }
+          });
+          producerControls = new ProcessControls({
+            dirname: __dirname,
+            appName: 'producer',
+            agentControls: customAgentControls,
+            env: { ...libraryEnv }
+          });
+
+          await consumerControls.startAndWaitForAgentConnection(retryTime, retryTimeUntil());
+          await producerControls.startAndWaitForAgentConnection(retryTime, retryTimeUntil());
+        });
+
+        beforeEach(async () => {
+          await customAgentControls.clearReceivedTraceData();
+          await resetMessages(consumerControls);
+        });
+
+        afterEach(async () => {
+          await resetMessages(consumerControls);
+        });
+
+        after(async () => {
+          await customAgentControls.stopAgent();
+          await producerControls.stop();
+          await consumerControls.stop();
+        });
+
+        it('must maintain trace continuity when agent config enables traceCorrelation', async () => {
+          await producerControls.sendRequest({
+            method: 'POST',
+            path: '/send-messages',
+            simple: true,
+            body: JSON.stringify({
+              key: 'someKey',
+              value: 'someMessage'
+            }),
+            headers: {
+              'Content-Type': 'application/json'
+            }
+          });
+
+          await retry(async () => {
+            const messages = await getMessages(consumerControls);
+            checkMessages(messages, {});
+            const spans = await customAgentControls.getSpans();
+            const httpEntry = verifyHttpEntry(spans);
+            verifyKafkaExits(spans, httpEntry, {});
+            verifyFollowUpHttpExit(spans, httpEntry);
+          });
+        });
+      });
+
+      describe('when both agent and environment variable configuration are provided', function () {
+        const customAgentControls = new AgentStubControls();
+
+        let consumerControls;
+        let producerControls;
+
+        before(async () => {
+          await customAgentControls.startAgent({
+            kafkaConfig: { traceCorrelation: true }
+          });
+
+          consumerControls = new ProcessControls({
+            dirname: __dirname,
+            appName: 'consumer',
+            agentControls: customAgentControls,
+            env: {
+              ...libraryEnv,
+              INSTANA_KAFKA_TRACE_CORRELATION: 'false'
+            }
+          });
+          producerControls = new ProcessControls({
+            dirname: __dirname,
+            appName: 'producer',
+            agentControls: customAgentControls,
+            env: {
+              ...libraryEnv,
+              INSTANA_KAFKA_TRACE_CORRELATION: 'false'
+            }
+          });
+
+          await consumerControls.startAndWaitForAgentConnection(retryTime, retryTimeUntil());
+          await producerControls.startAndWaitForAgentConnection(retryTime, retryTimeUntil());
+        });
+
+        beforeEach(async () => {
+          await customAgentControls.clearReceivedTraceData();
+          await resetMessages(consumerControls);
+        });
+
+        afterEach(async () => {
+          await resetMessages(consumerControls);
+        });
+
+        after(async () => {
+          await customAgentControls.stopAgent();
+          await producerControls.stop();
+          await consumerControls.stop();
+        });
+
+        const kafkaCorrelation = 'correlation-disabled';
+
+        it('must not maintain trace continuity when env var disables traceCorrelation (taking precedence over agent config)', async () => {
+          await producerControls.sendRequest({
+            method: 'POST',
+            path: '/send-messages',
+            simple: true,
+            body: JSON.stringify({
+              key: 'someKey',
+              value: 'someMessage'
+            }),
+            headers: {
+              'Content-Type': 'application/json'
+            }
+          });
+
+          await retry(async () => {
+            const messages = await getMessages(consumerControls);
+            checkMessages(messages, { kafkaCorrelation });
+            const spans = await customAgentControls.getSpans();
+            const httpEntry = verifyHttpEntry(spans);
+            verifyKafkaExits(spans, httpEntry, { kafkaCorrelation });
+            verifyFollowUpHttpExit(spans, httpEntry);
+          });
+        });
+      });
+    });
+
     describe('tracing disabled', () => {
       let consumerControls;
       let producerControls;

packages/collector/test/integration/currencies/protocols/http/client/clientApp.js

@@ -89,6 +89,14 @@ app.get('/request-options-only', (req, res) => {
       ],
       'x-exit-options-not-captured-header': 'whatever'
     };
+  } else if (req.query.withHeader === 'config-test') {
+    downstreamRequest.headers = {
+      'X-Agent-Header-1': 'agent-value-1',
+      'X-Agent-Header-2': 'agent-value-2',
+      'X-Incode-Header-1': 'incode-value-1',
+      'X-Incode-Header-2': 'incode-value-2',
+      'X-Not-Configured-Header': 'should-not-be-captured'
+    };
   }
   const requestObject = httpModule.request(downstreamRequest, () => res.sendStatus(200));
   if (req.query.withHeader === 'set-on-request') {