feat(fargate): use adot image for otel

packages/artillery-plugin-publish-metrics/index.js

@@ -6,6 +6,11 @@ const NS = 'plugin:publish-metrics';
 const debug = require('debug')(NS);
 const A = require('async');
 
+const {
+  getADOTRelevantReporterConfigs,
+  resolveADOTConfigSettings
+} = require('./lib/open-telemetry/vendor-translators');
+
 // List of reporters that use OpenTelemetry
 const REPORTERS_USING_OTEL = [
   'open-telemetry',
@@ -16,7 +21,9 @@ const REPORTERS_USING_OTEL = [
 ];
 module.exports = {
   Plugin,
-  LEGACY_METRICS_FORMAT: false
+  LEGACY_METRICS_FORMAT: false,
+  getADOTRelevantReporterConfigs,
+  resolveADOTConfigSettings
 };
 
 function Plugin(script, events) {

packages/artillery-plugin-publish-metrics/lib/open-telemetry/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const debug = require('debug')('plugin:publish-metrics:open-telemetry');
-const vendorTranslators = require('./vendor-translators');
+const { vendorTranslators } = require('./vendor-translators');
 const {
   diag,
   DiagConsoleLogger,
@@ -60,9 +60,6 @@ class OTelReporter {
       return this;
     }
 
-    // Warn if traces are configured in multiple reporters
-    this.warnIfDuplicateTracesConfigured(this.translatedConfigsList);
-
     // Create set of all engines used in test -> even though we only support Playwright and HTTP engine for now this is future compatible
     this.getEngines(this.script.scenarios || []);
 
@@ -112,14 +109,7 @@ class OTelReporter {
       }
     }
   }
-  warnIfDuplicateTracesConfigured(configList) {
-    const tracesConfigs = configList.filter((config) => config.traces);
-    if (tracesConfigs.length > 1) {
-      console.warn(
-        'WARNING: Multiple reporters configured for traces. Currently, you can only use one reporter at a time for reporting traces. Only the first reporter will be used.'
-      );
-    }
-  }
+
   translateToOtel(config) {
     return vendorTranslators[config.type](config);
   }
@@ -137,6 +127,11 @@ class OTelReporter {
     if (!this.metricsConfig && !this.tracesConfig) {
       return done();
     }
+
+    // Waiting for flush period to complete here rather than in trace/metric reporters
+    debug('Waiting for flush period to end');
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+
     if (this.metricReporter) {
       await this.metricReporter.cleanup();
     }

packages/artillery-plugin-publish-metrics/lib/open-telemetry/tracing/base.js

@@ -175,8 +175,6 @@ class OTelTraceBase {
     }
 
     debug('Pending traces done');
-    debug('Waiting for flush period to complete');
-    await new Promise((resolve) => setTimeout(resolve, 5000));
   }
 }
 

packages/artillery-plugin-publish-metrics/lib/open-telemetry/vendor-translators.js

@@ -112,4 +112,145 @@ function attributeListToObject(attributeList, reporterType) {
   return attributes;
 }
 
-module.exports = vendorTranslators;
+//////// ADOT COLLECTOR HANDLING
+
+const ADOTSupportedTraceReporters = ['datadog'];
+const ADOTSupportedMetricReporters = [];
+
+// Getting the relevant configurations for ADOT from the full list of reporter configurations
+
+function getADOTRelevantReporterConfigs(configList) {
+  const configs = configList.filter(
+    (reporterConfig) =>
+      (ADOTSupportedTraceReporters.includes(reporterConfig.type) &&
+        reporterConfig.traces) ||
+      (ADOTSupportedMetricReporters.includes(reporterConfig.type) &&
+        reporterConfig.metrics)
+  );
+
+  return configs.length > 0 ? configs : null;
+}
+
+// Handling relevant environment variables
+
+function getADOTEnvVars(adotRelevantconfigs, dotenv) {
+  const envVars = {};
+  try {
+    adotRelevantconfigs.forEach((config) => {
+      const vendorVars = vendorSpecificEnvVarsForCollector[config.type](
+        config,
+        dotenv
+      );
+      Object.assign(envVars, vendorVars);
+    });
+  } catch (err) {
+    throw new Error(err);
+  }
+  return envVars;
+}
+
+const vendorSpecificEnvVarsForCollector = {
+  datadog: (config, dotenv) => {
+    const apiKey = config.apiKey || dotenv?.DD_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "Datadog reporter Error: Missing Datadog API key. Provide it under 'apiKey' setting in your script or under 'DD_API_KEY' environment variable set in your dotenv file."
+      );
+    }
+    return { DD_API_KEY: apiKey };
+  }
+};
+
+// Assembling the configuration for ADOT (in OTel Collector format)
+
+// Different vendors can be used for metrics and tracing so we need to merge all the parts of the config from each vendor into one collector config
+function assembleCollectorConfig(adotRelevantConfigs) {
+  // Translate each vendor-specific config to OpenTelemetry Collector config
+  const collectorConfigList = adotRelevantConfigs.map((config) =>
+    vendorToCollectorConfigTranslators[config.type](config)
+  );
+
+  const collectorConfig = { ...collectorConfigTemplate };
+  // Assemble the final collector config by adding all parts of the config from each vendor
+  collectorConfigList.forEach((config) => {
+    collectorConfig.processors = Object.assign(
+      collectorConfig.processors,
+      config.processors
+    );
+    collectorConfig.exporters = Object.assign(
+      collectorConfig.exporters,
+      config.exporters
+    );
+    collectorConfig.service.pipelines = Object.assign(
+      collectorConfig.service.pipelines,
+      config.service.pipelines
+    );
+  });
+  return collectorConfig;
+}
+
+const collectorConfigTemplate = {
+  receivers: {
+    otlp: {
+      protocols: {
+        http: {
+          endpoint: '0.0.0.0:4318'
+        },
+        grpc: {
+          endpoint: '0.0.0.0:4317'
+        }
+      }
+    }
+  },
+  processors: {},
+  exporters: {},
+  service: {
+    pipelines: {}
+  }
+};
+
+// Map of functions that translate vendor-specific configuration to OpenTelemetry Collector configuration to be used by ADOT
+const vendorToCollectorConfigTranslators = {
+  datadog: (config) => {
+    const collectorConfig = { ...collectorConfigTemplate };
+    if (config.traces) {
+      collectorConfig.processors['batch/trace'] = {
+        timeout: '10s',
+        send_batch_max_size: 1024,
+        send_batch_size: 200
+      };
+      collectorConfig.exporters['datadog/api'] = {
+        traces: {
+          trace_buffer: 100
+        },
+        api: {
+          key: '${env:DD_API_KEY}'
+        }
+      };
+      collectorConfig.service.pipelines.traces = {
+        receivers: ['otlp'],
+        processors: ['batch/trace'],
+        exporters: ['datadog/api']
+      };
+    }
+    return collectorConfig;
+  }
+};
+
+// Resolve the configuration settings for ADOT
+
+function resolveADOTConfigSettings(options) {
+  try {
+    const adotConfig = assembleCollectorConfig(options.configList);
+    const adotEnvVars = getADOTEnvVars(options.configList, options.dotenv);
+    return { adotConfig, adotEnvVars };
+  } catch (err) {
+    throw new Error(err);
+  }
+}
+
+module.exports = {
+  vendorTranslators,
+  getADOTRelevantReporterConfigs,
+  resolveADOTConfigSettings
+};

packages/artillery/lib/platform/aws-ecs/legacy/aws-util.js

@@ -9,7 +9,8 @@ module.exports = {
   ensureParameterExists,
   parameterExists,
   putParameter,
-  getParameter
+  getParameter,
+  deleteParameter
 };
 
 // Wraps ecs.describeTasks to support more than 100 task ARNs in params.tasks
@@ -124,3 +125,28 @@ async function getParameter(path, region) {
     }
   }
 }
+
+async function deleteParameter(path, region) {
+  if (region) {
+    AWS.config.update({ region });
+  }
+
+  const ssm = new AWS.SSM({ apiVersion: '2014-11-06' });
+
+  try {
+    const ssmResponse = await ssm
+      .deleteParameter({
+        Name: path
+      })
+      .promise();
+
+    debug({ ssmResponse });
+    return ssmResponse;
+  } catch (ssmErr) {
+    if (ssmErr.code === 'ParameterNotFound') {
+      return false;
+    } else {
+      throw ssmErr;
+    }
+  }
+}

packages/artillery/lib/platform/aws-ecs/legacy/bom.js

@@ -14,6 +14,7 @@ const BUILTIN_ENGINES = require('./plugins').getOfficialEngines();
 
 const Table = require('cli-table3');
 
+const { resolveConfigTemplates } = require('../../../../util');
 // NOTE: Code below presumes that all paths are absolute
 
 //Tests in Fargate run on ubuntu, which uses posix paths
@@ -32,12 +33,14 @@ function createBOM(absoluteScriptPath, extraFiles, opts, callback) {
         return next(null, {
           opts: {
             scriptData,
-            absoluteScriptPath
+            absoluteScriptPath,
+            flags: opts.flags
           },
           localFilePaths: [absoluteScriptPath],
           npmModules: []
         });
       },
+      applyScriptChanges,
       getPlugins,
       getCustomEngines,
       getCustomJsDependencies,
@@ -137,7 +140,8 @@ function createBOM(absoluteScriptPath, extraFiles, opts, callback) {
       return callback(null, {
         files: _.uniqWith(files, _.isEqual),
         modules: _.uniq(context.npmModules),
-        pkgDeps: context.pkgDeps
+        pkgDeps: context.pkgDeps,
+        fullyResolvedConfig: context.opts.scriptData.config
       });
     }
   );
@@ -148,6 +152,15 @@ function isLocalModule(modName) {
   return modName.startsWith('.');
 }
 
+function applyScriptChanges(context, next) {
+  resolveConfigTemplates(context.opts.scriptData, context.opts.flags).then(
+    (resolvedConfig) => {
+      context.opts.scriptData = resolvedConfig;
+      return next(null, context);
+    }
+  );
+}
+
 function getPlugins(context, next) {
   let environmentPlugins = _.reduce(
     _.get(context, 'opts.scriptData.config.environments', {}),

packages/artillery/lib/platform/aws-ecs/legacy/create-test.js

@@ -37,7 +37,8 @@ async function createTest(scriptPath, options, callback) {
     originalScriptPath: scriptPath,
     name: options.name, // test name, eg simple-bom or aht_$UUID
     manifestPath: options.manifestPath,
-    packageJsonPath: options.packageJsonPath
+    packageJsonPath: options.packageJsonPath,
+    flags: options.flags
   };
 
   if (typeof options.config === 'string') {
@@ -82,7 +83,7 @@ function prepareManifest(context, callback) {
   createBOM(
     fileToAnalyse,
     extraFiles,
-    { packageJsonPath: context.packageJsonPath },
+    { packageJsonPath: context.packageJsonPath, flags: context.flags},
     (err, bom) => {
       debug(err);
       debug(bom);