feat(http): added configurable 4xx error classification for exit spans

packages/collector/src/announceCycle/unannounced.js

@@ -48,6 +48,19 @@ const maxRetryDelay = 60 * 1000; // one minute
  * @property {boolean} [span-batching-enabled]
  * @property {import('@instana/core/src/config/types').Disable} [disable]
  * @property {StackTraceConfig} [global]
+ * @property {HTTPTracingConfig} [http]
+ */
+
+/**
+ * @typedef {Object} HTTPExitConfig
+ * @property {boolean} [classify-all-4xx-as-errors]
+ * @property {Array<number>} [classify-as-errors]
+ */
+
+/**
+ * @typedef {Object} HTTPTracingConfig
+ *  @property {Array.<string>} [extra-http-headers]
+ * @property {HTTPExitConfig} [exit]
  */
 
 /**
@@ -132,6 +145,7 @@ function tryToAnnounce(ctx, retryDelay = initialRetryDelay) {
 function applyAgentConfiguration(agentResponse) {
   applySecretsConfiguration(agentResponse);
   applyExtraHttpHeaderConfiguration(agentResponse);
+  applyHttpExitConfiguration(agentResponse);
   applyKafkaTracingConfiguration(agentResponse);
   applyOtlpExporterConfiguration(agentResponse);
   applySpanBatchingConfiguration(agentResponse);
@@ -288,7 +302,7 @@ function applyStackTraceConfiguration(agentResponse) {
   ensureNestedObjectExists(agentOpts.config, ['tracing', 'global']);
 
   if (globalConfig['stack-trace'] !== undefined) {
-    const stackTraceModeValidation = coreConfig.validate.validateStackTraceMode(globalConfig['stack-trace']);
+    const stackTraceModeValidation = coreConfig.validators.validateStackTraceMode(globalConfig['stack-trace']);
     if (stackTraceModeValidation.isValid) {
       const normalizedStackTrace = coreConfig.normalizers.stackTrace.normalizeStackTraceModeFromAgent(
         globalConfig['stack-trace']
@@ -302,7 +316,9 @@ function applyStackTraceConfiguration(agentResponse) {
   }
 
   if (globalConfig['stack-trace-length'] !== undefined) {
-    const stackTraceLengthValidation = coreConfig.validate.validateStackTraceLength(globalConfig['stack-trace-length']);
+    const stackTraceLengthValidation = coreConfig.validators.validateStackTraceLength(
+      globalConfig['stack-trace-length']
+    );
     if (stackTraceLengthValidation.isValid) {
       const normalizedStackTraceLength = coreConfig.normalizers.stackTrace.normalizeStackTraceLengthFromAgent(
         globalConfig['stack-trace-length']
@@ -333,6 +349,29 @@ function applyDisableConfiguration(agentResponse) {
     tracing: { disable: disablingConfig }
   }).value;
 }
+
+/**
+ * @param {AgentAnnounceResponse} agentResponse
+ */
+function applyHttpExitConfiguration(agentResponse) {
+  const exitConfig = agentResponse?.tracing?.http?.exit;
+  if (!exitConfig) {
+    return;
+  }
+
+  ensureNestedObjectExists(agentOpts.config, ['tracing', 'http', 'exit']);
+
+  const classifyAll4xxAsErrors = coreConfig.validators.booleanValidator(exitConfig['classify-all-4xx-as-errors']);
+  if (classifyAll4xxAsErrors !== undefined) {
+    agentOpts.config.tracing.http.exit.classifyAll4xxAsErrors = classifyAll4xxAsErrors;
+  }
+
+  const classifyAsErrors = coreConfig.validators.httpExitErrorCodeValidator(exitConfig['classify-as-errors']);
+  if (classifyAsErrors !== undefined) {
+    agentOpts.config.tracing.http.exit.classifyAsErrors = classifyAsErrors;
+  }
+}
+
 module.exports = {
   init,
 

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

@@ -5,6 +5,10 @@ export interface AgentConfig {
   tracing?: {
     http?: {
       extraHttpHeadersToCapture?: string[];
+      exit?: {
+        classifyAll4xxAsErrors?: boolean;
+        classifyAsErrors?: number[];
+      };
     };
     kafka?: {
       traceCorrelation?: boolean;

packages/collector/test/apps/agentStub.js

@@ -47,6 +47,7 @@ const ignoreEndpoints = process.env.IGNORE_ENDPOINTS && JSON.parse(process.env.I
 const disable = process.env.AGENT_DISABLE_TRACING && JSON.parse(process.env.AGENT_DISABLE_TRACING);
 const stackTraceConfig = process.env.STACK_TRACE_CONFIG && JSON.parse(process.env.STACK_TRACE_CONFIG);
 const otlpExporter = process.env.OTLP_EXPORTER && JSON.parse(process.env.OTLP_EXPORTER);
+const httpExitConfig = process.env.AGENT_STUB_HTTP_EXIT_CONFIG && JSON.parse(process.env.AGENT_STUB_HTTP_EXIT_CONFIG);
 
 const uuids = {};
 const agentLogs = [];
@@ -126,7 +127,8 @@ app.put('/com.instana.plugin.nodejs.discovery', (req, res) => {
     ignoreEndpoints ||
     disable ||
     stackTraceConfig ||
-    otlpExporter
+    otlpExporter ||
+    httpExitConfig
   ) {
     response.tracing = {};
 
@@ -157,6 +159,10 @@ app.put('/com.instana.plugin.nodejs.discovery', (req, res) => {
     if (otlpExporter) {
       response.tracing.otlp = otlpExporter;
     }
+    if (httpExitConfig) {
+      response.tracing.http = response.tracing.http || {};
+      response.tracing.http.exit = httpExitConfig;
+    }
   }
 
   res.send(response);

packages/collector/test/apps/agentStubControls.js

@@ -71,6 +71,9 @@ class AgentStubControls {
     if (opts.otlpExporter) {
       env.OTLP_EXPORTER = JSON.stringify(opts.otlpExporter);
     }
+    if (opts.httpExitConfig) {
+      env.AGENT_STUB_HTTP_EXIT_CONFIG = JSON.stringify(opts.httpExitConfig);
+    }
 
     this.agentStub = spawn('node', [path.join(__dirname, 'agentStub.js')], {
       stdio: config.getAppStdio(),

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

@@ -281,6 +281,22 @@ if (process.env.APP_USES_HTTPS === 'true') {
   });
 }
 
+app.get('/fetch-with-status', (req, res) => {
+  const status = req.query.status || '200';
+  const options = {
+    hostname: 'localhost',
+    port: process.env.SERVER_PORT,
+    method: 'GET',
+    path: `/fetch-with-status?status=${status}`
+  };
+  const req_ = httpModule.request(options, response => {
+    response.resume();
+    response.on('end', () => res.status(response.statusCode).send());
+  });
+  req_.on('error', err => res.status(503).send(err.message));
+  req_.end();
+});
+
 app.get('/matrix-params/:params', (req, res) => {
   res.sendStatus(200);
 });

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

@@ -60,6 +60,11 @@ app.get('/timeout', (req, res) => {
   }, 10000);
 });
 
+app.all('/fetch-with-status', (req, res) => {
+  const status = parseInt(req.query.status, 10) || 200;
+  res.status(status).json({ status });
+});
+
 app.put('/continue', (req, res) => {
   // Node http server will automatically send 100 Continue when it receives a request with an "Expect: 100-continue"
   // header present, unless we override the 'checkContinue' listener. For our test case, the default behaviour is just