@depup/artillery 2.0.30-depup.0

package/lib/platform/aws-ecs/legacy/sqs-reporter.js

@@ -0,0 +1,401 @@
+const EventEmitter = require('node:events');
+
+const { Consumer } = require('sqs-consumer');
+const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
+const driftless = require('driftless');
+const debug = require('debug')('sqs-reporter');
+const debugV = require('debug')('sqs-reporter:v');
+
+const _ = require('lodash');
+
+class SqsReporter extends EventEmitter {
+  constructor(opts) {
+    super();
+
+    this.sqsQueueUrl = opts.sqsQueueUrl;
+    this.region = opts.region;
+    this.testId = opts.testId;
+    this.count = opts.count;
+
+    this.periodsReportedFor = [];
+
+    this.ee = new EventEmitter();
+
+    this.workerState = {};
+    this.lastIntermediateReportAt = 0;
+    this.taskWatcher = null;
+
+    this.metricsByPeriod = {}; // individual intermediates by worker
+    this.mergedPeriodMetrics = []; // merged intermediates for a period
+
+    //TODO: this code is repeated from `launch-platform.js` - refactor later
+    this.phaseStartedEventsSeen = {};
+    this.phaseCompletedEventsSeen = {};
+
+    // Debug info:
+    this.messagesProcessed = {};
+    this.metricsMessagesFromWorkers = {};
+
+    this.poolSize =
+      typeof process.env.SQS_CONSUMER_POOL_SIZE !== 'undefined'
+        ? parseInt(process.env.SQS_CONSUMER_POOL_SIZE, 10)
+        : Math.max(Math.ceil(this.count / 10), 75);
+
+    this.s3 = null;
+    this.s3Bucket = process.env.ARTILLERY_S3_BUCKET || null;
+    if (this.s3Bucket) {
+      this.s3 = new S3Client({ region: opts.region });
+    }
+  }
+
+  _allWorkersDone() {
+    return Object.keys(this.workerState).length === this.count;
+  }
+
+  async _fetchFromS3(s3Key) {
+    const response = await this.s3.send(
+      new GetObjectCommand({
+        Bucket: this.s3Bucket,
+        Key: s3Key
+      })
+    );
+    return JSON.parse(await response.Body.transformToString());
+  }
+
+  stop() {
+    debug('stopping');
+    for (const sqsConsumer of this.sqsConsumers) {
+      sqsConsumer.stop();
+    }
+  }
+
+  start() {
+    debug('starting');
+
+    this.sqsDebugInterval = driftless.setDriftlessInterval(() => {
+      debug(this.messagesProcessed);
+      let total = 0;
+      for (const [_k, v] of Object.entries(this.messagesProcessed)) {
+        total += v;
+      }
+      debug('total:', total);
+    }, 10 * 1000);
+
+    this.intermediateReporterInterval = driftless.setDriftlessInterval(() => {
+      if (Object.keys(this.metricsByPeriod).length === 0) {
+        return; // nothing received yet
+      }
+
+      // We always look at the earliest period available so that reports come in chronological order
+      const earliestPeriodAvailable = Object.keys(this.metricsByPeriod)
+        .filter((x) => this.periodsReportedFor.indexOf(x) === -1)
+        .sort()[0];
+
+      // TODO: better name. One above is earliestNotAlreadyReported
+      const earliest = Object.keys(this.metricsByPeriod).sort()[0];
+      if (this.periodsReportedFor.indexOf(earliest) > -1) {
+        global.artillery.log(
+          'Warning: multiple batches of metrics for period',
+          earliest,
+          new Date(Number(earliest))
+        );
+        delete this.metricsByPeriod[earliest]; // FIXME: need to merge them in for the final report
+      }
+
+      // We can process SQS messages in batches of 10 at a time, so
+      // when there are more workers, we need to wait longer:
+      const MAX_WAIT_FOR_PERIOD_MS =
+        (Math.ceil(this.count / 10) * 2 + 20) * 1000;
+
+      if (
+        typeof earliestPeriodAvailable !== 'undefined' &&
+        (this.metricsByPeriod[earliestPeriodAvailable].length === this.count ||
+          Date.now() - Number(earliestPeriodAvailable) > MAX_WAIT_FOR_PERIOD_MS)
+      ) {
+        // TODO: autoscaling. Handle workers that drop off as the first case - self.count needs to be updated dynamically
+        debug(
+          'have metrics from all workers for period or MAX_WAIT_FOR_PERIOD reached',
+          earliestPeriodAvailable
+        );
+
+        debug(
+          'Report @',
+          new Date(Number(earliestPeriodAvailable)),
+          'made up of items:',
+          this.metricsByPeriod[String(earliestPeriodAvailable)].length
+        );
+
+        // TODO: Track how many workers provided metrics in the metrics report
+        const stats = global.artillery.__SSMS.mergeBuckets(
+          this.metricsByPeriod[String(earliestPeriodAvailable)]
+        )[String(earliestPeriodAvailable)];
+        this.mergedPeriodMetrics.push(stats);
+        // summarize histograms for console reporter
+        stats.summaries = {};
+        for (const [name, value] of Object.entries(stats.histograms || {})) {
+          const summary = global.artillery.__SSMS.summarizeHistogram(value);
+          stats.summaries[name] = summary;
+          delete this.metricsByPeriod[String(earliestPeriodAvailable)];
+        }
+
+        this.periodsReportedFor.push(earliestPeriodAvailable);
+
+        debug('Emitting stats event');
+        this.emit('stats', stats);
+      } else {
+        debug('Waiting for more workerStats before emitting stats event');
+      }
+    }, 5 * 1000);
+
+    this.workersDoneWatcher = driftless.setDriftlessInterval(() => {
+      if (!this._allWorkersDone()) {
+        return;
+      }
+
+      // Have we received and processed all intermediate metrics?
+      if (Object.keys(this.metricsByPeriod).length > 0) {
+        debug(
+          'All workers done but still waiting on some intermediate reports'
+        );
+        return;
+      }
+
+      debug('ready to emit done event');
+      debug('mergedPeriodMetrics');
+      debug(this.mergedPeriodMetrics);
+
+      // Merge by period, then compress and emit
+      const stats = global.artillery.__SSMS.pack(this.mergedPeriodMetrics);
+      stats.summaries = {};
+      for (const [name, value] of Object.entries(stats.histograms || {})) {
+        const summary = global.artillery.__SSMS.summarizeHistogram(value);
+        stats.summaries[name] = summary;
+      }
+
+      if (process.env.DEBUG === 'sqs-reporter:v') {
+        for (const [workerId, metrics] of Object.entries(
+          this.metricsMessagesFromWorkers
+        )) {
+          debugV('worker', workerId, '->', metrics.length, 'items');
+        }
+        // fs.writeFileSync('worker-metrics-dump.json', JSON.stringify(self.metricsMessagesFromWorkers));
+      }
+
+      this.emit('done', stats);
+
+      driftless.clearDriftless(this.intermediateReporterInterval);
+      driftless.clearDriftless(this.workersDoneWatcher);
+      driftless.clearDriftless(this.sqsDebugInterval);
+
+      for (const sqsConsumer of this.sqsConsumers) {
+        sqsConsumer.stop();
+      }
+
+      this.emit('workersDone', this.workerState);
+    }, 5 * 1000);
+
+    this.ee.on('message', (body, attrs) => {
+      const workerId = attrs.workerId?.StringValue;
+
+      if (!workerId) {
+        debug('Got message with no workerId');
+        debug(body);
+        return;
+      }
+      if (body.event === 'workerDone' || body.event === 'workerError') {
+        this.workerState[workerId] = body.event;
+        this.emit(body.event, body, attrs);
+
+        debug(workerId, body.event);
+        return;
+      }
+
+      //TODO: this code is repeated from `launch-platform.js` - refactor later
+      if (body.event === 'phaseStarted') {
+        if (
+          typeof this.phaseStartedEventsSeen[body.phase.index] === 'undefined'
+        ) {
+          this.phaseStartedEventsSeen[body.phase.index] = Date.now();
+          this.emit(body.event, body.phase);
+        }
+
+        return;
+      }
+
+      //TODO: this code is repeated from `launch-platform.js` - refactor later
+      if (body.event === 'phaseCompleted') {
+        if (
+          typeof this.phaseCompletedEventsSeen[body.phase.index] === 'undefined'
+        ) {
+          this.phaseCompletedEventsSeen[body.phase.index] = Date.now();
+          this.emit(body.event, body.phase);
+        }
+
+        return;
+      }
+
+      // 'done' event is from SQS Plugin - unused for now
+      if (body.event === 'done') {
+        return;
+      }
+
+      if (body.msg) {
+        this.emit('workerMessage', body, attrs);
+        return;
+      }
+
+      if (body.event === 'workerStats') {
+        // v2 SSMS stats
+        const workerStats = global.artillery.__SSMS.deserializeMetrics(
+          body.stats
+        );
+        const period = workerStats.period;
+
+        debug(
+          'processing workerStats event, worker:',
+          workerId,
+          'period',
+          period
+        );
+
+        debugV(workerStats);
+        if (typeof this.metricsByPeriod[period] === 'undefined') {
+          this.metricsByPeriod[period] = [];
+        }
+        this.metricsByPeriod[period].push(workerStats);
+
+        if (process.env.DEBUG === 'sqs-reporter:v') {
+          if (
+            typeof this.metricsMessagesFromWorkers[workerId] === 'undefined'
+          ) {
+            this.metricsMessagesFromWorkers[workerId] = [];
+          }
+          this.metricsMessagesFromWorkers[workerId].push(workerStats);
+        }
+
+        debugV('metricsByPeriod:');
+        debugV(this.metricsByPeriod);
+        debug('number of periods processed');
+        debug(Object.keys(this.metricsByPeriod));
+        debug('number of metrics collections for period:', period, ':');
+        debug(this.metricsByPeriod[period].length, 'expecting:', this.count);
+      }
+    });
+
+    this.ee.on('messageReceiveTimeout', () => {
+      // TODO: 10 polls with no results, e.g. if all workers crashed
+    });
+
+    const createConsumer = (i) => Consumer.create({
+        queueUrl: process.env.SQS_QUEUE_URL || this.sqsQueueUrl,
+        region: this.region,
+        waitTimeSeconds: 10,
+        messageAttributeNames: ['testId', 'workerId'],
+        visibilityTimeout: 60,
+        batchSize: 10,
+        handleMessage: async (message) => {
+          let body = null;
+          try {
+            body = JSON.parse(message.Body);
+          } catch (err) {
+            console.error(err);
+            console.log(message.Body);
+          }
+
+          //
+          // Ignore any messages that are invalid or not tagged properly.
+          //
+
+          if (process.env.LOG_SQS_MESSAGES) {
+            console.log(message);
+          }
+
+          if (!body) {
+            throw new Error();
+          }
+
+          // Handle overflow messages stored in S3
+          if (body._overflowRef && this.s3 && this.s3Bucket) {
+            try {
+              debug('Fetching overflow payload from S3: %s', body._overflowRef);
+              body = await this._fetchFromS3(body._overflowRef);
+            } catch (s3Err) {
+              console.error('Failed to fetch overflow message from S3:', s3Err);
+              throw new Error(
+                `Failed to fetch overflow message: ${body._overflowRef}`
+              );
+            }
+          }
+
+          const attrs = message.MessageAttributes;
+          if (!attrs || !attrs.testId) {
+            throw new Error();
+          }
+
+          if (this.testId !== attrs.testId.StringValue) {
+            throw new Error();
+          }
+
+          if (!this.messagesProcessed[i]) {
+            this.messagesProcessed[i] = 0;
+          }
+          this.messagesProcessed[i] += 1;
+
+          process.nextTick(() => {
+            this.ee.emit('message', body, attrs);
+          });
+        }
+      });
+
+    this.sqsConsumers = [];
+    for (let i = 0; i < this.poolSize; i++) {
+      const sqsConsumer = createConsumer(i);
+
+      sqsConsumer.on('error', (err) => {
+        // TODO: Ignore "SQSError: SQS delete message failed:" errors
+        if (err.message?.match(/ReceiptHandle.+expired/i)) {
+          debug(err.name, err.message);
+        } else {
+          artillery.log(err);
+          sqsConsumer.stop();
+          this.emit('error', err);
+        }
+      });
+
+      let empty = 0;
+      sqsConsumer.on('empty', () => {
+        empty++;
+        if (empty > 10) {
+          this.ee.emit('messageReceiveTimeout'); // TODO:
+        }
+      });
+      sqsConsumer.start();
+
+      this.sqsConsumers.push(sqsConsumer);
+    }
+  }
+
+  // Given a (combined) stats object, what's the difference between the
+  // time of earliest and latest requests made?
+  calculateSpread(stats) {
+    const period = _.reduce(
+      stats._requestTimestamps,
+      (acc, ts) => {
+        acc.min = Math.min(acc.min, ts);
+        acc.max = Math.max(acc.max, ts);
+        return acc;
+      },
+      { min: Infinity, max: 0 }
+    );
+
+    const spread = round((period.max - period.min) / 1000, 1);
+    return spread;
+  }
+}
+
+function round(number, decimals) {
+  const m = 10 ** decimals;
+  return Math.round(number * m) / m;
+}
+
+module.exports = { SqsReporter };

package/lib/platform/aws-ecs/legacy/tags.js

@@ -0,0 +1,22 @@
+
+
+function parseTags(input) {
+  const tags = [];
+  if (input) {
+    const tagList = input.split(',').map((x) => x.trim());
+    for (const t of tagList) {
+      const cs = t.split(':');
+      if (cs.length !== 2) {
+        console.error(`Invalid tag, skipping: ${t}`);
+      } else {
+        tags.push({ name: cs[0].trim(), value: cs[1].trim() });
+      }
+    }
+  }
+
+  return tags;
+}
+
+module.exports = {
+  parseTags
+};

package/lib/platform/aws-ecs/legacy/test-run-status.js

@@ -0,0 +1,9 @@
+module.exports = {
+  INITIALIZING: 1,
+  LAUNCHING_WORKERS: 2,
+  RECEIVING_REPORTS: 3,
+  TERMINATING: 4,
+  EARLY_STOP: 5,
+  COMPLETED: 6,
+  ERROR: 7
+};

package/lib/platform/aws-ecs/legacy/time.js

@@ -0,0 +1,67 @@
+
+
+const EventEmitter = require('node:events');
+const driftless = require('driftless');
+
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+class Timeout extends EventEmitter {
+  constructor(duration) {
+    super();
+    this._startedAt = null;
+    this._duration = duration;
+  }
+
+  start() {
+    this._startedAt = Date.now();
+    this._timeout = driftless.setDriftlessTimeout(() => {
+      this.emit('timeout');
+    }, this._duration);
+    return this;
+  }
+
+  stop() {
+    driftless.clearDriftless(this._timeout);
+    return this;
+  }
+
+  timedout() {
+    return Date.now() - this._startedAt > this._duration;
+  }
+}
+
+// Turn a string like 2m into number of milliseconds
+// Supported units: ms, s, m, h
+function timeStringToMs(timeStr) {
+  const rx = /^([0-9]+).+$/i;
+
+  if (!rx.test(timeStr)) {
+    throw new Error(`Invalid time string: ${timeStr}`);
+  }
+
+  let multiplier = 0;
+  if (timeStr.endsWith('ms')) {
+    multiplier = 1;
+  } else if (timeStr.endsWith('s')) {
+    multiplier = 1000;
+  } else if (timeStr.endsWith('m')) {
+    multiplier = 60 * 1000;
+  } else if (timeStr.endsWith('h')) {
+    multiplier = 60 * 60 * 1000;
+  } else {
+    throw new Error(
+      `Unknown unit suffix in ${timeStr}. Supported units: ms, s, m, h`
+    );
+  }
+
+  const n = parseInt(timeStr.match(rx)[0], 10);
+  return n * multiplier;
+}
+
+module.exports = {
+  Timeout,
+  sleep,
+  timeStringToMs
+};

package/lib/platform/aws-ecs/legacy/util.js

@@ -0,0 +1,97 @@
+
+
+const _debug = require('debug')('artillery:util');
+
+const chalk = require('chalk');
+
+const _ = require('lodash');
+
+const _A = require('async');
+
+const createS3Client = require('./create-s3-client');
+
+const supportedRegions = [
+  'us-east-1',
+  'us-east-2',
+  'us-west-1',
+  'us-west-2',
+  'us-gov-east-1',
+  'us-gov-west-1',
+  'ca-central-1',
+  'eu-west-1',
+  'eu-west-2',
+  'eu-west-3',
+  'eu-central-1',
+  'eu-north-1',
+  'ap-south-1',
+  'ap-east-1',
+  'ap-northeast-2',
+  'ap-southeast-1',
+  'ap-southeast-2',
+  'ap-northeast-1',
+  'me-south-1',
+  'il-central-1',
+  'sa-east-1',
+  'cn-north-1',
+  'cn-northwest-1'
+];
+
+const getAccountId = require('../../aws/aws-get-account-id');
+
+const { S3_BUCKET_NAME_PREFIX } = require('./constants');
+const { paginateListObjectsV2 } = require('@aws-sdk/client-s3');
+
+function atob(data) {
+  return Buffer.from(data, 'base64').toString('ascii');
+}
+function btoa(data) {
+  return Buffer.from(data).toString('base64');
+}
+
+async function getBucketName() {
+  if (process.env.ARTILLERY_S3_BUCKET) {
+    return process.env.ARTILLERY_S3_BUCKET;
+  }
+
+  const accountId = await getAccountId();
+  const bucketName = `${S3_BUCKET_NAME_PREFIX}-${accountId}`;
+  // const bucketArn = `arn:aws:s3:::${bucketName}`;
+  return bucketName;
+}
+
+function formatError(err) {
+  return (
+    `${chalk.red('Error')}: ${err.message}${err.code ? ` (${err.code})` : ''}`
+  );
+}
+
+async function listAllObjectsWithPrefix(bucketName, prefix) {
+  const s3Client = createS3Client();
+  const allObjects = [];
+
+  const paginator = paginateListObjectsV2(
+    { client: s3Client },
+    {
+      Bucket: bucketName,
+      Prefix: prefix,
+      MaxKeys: 1000
+    }
+  );
+    for await (const page of paginator) {
+      if (page.Contents) {
+        allObjects.push(...page.Contents);
+      }
+    }
+
+  return allObjects;
+}
+
+module.exports = {
+  supportedRegions,
+  getAccountId,
+  atob,
+  btoa,
+  formatError,
+  listAllObjectsWithPrefix,
+  getBucketName
+};

package/lib/platform/aws-ecs/worker/Dockerfile

@@ -0,0 +1,64 @@
+# ********************************
+# NOTE: Version we use here needs to be kept consistent with that in
+# artillery-engine-playwright.
+# ********************************
+FROM mcr.microsoft.com/playwright:v1.58.1
+
+ARG TARGETARCH
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install aws-lambda-ric build dependencies
+RUN apt-get update && apt-get install -y \
+    g++ \
+    make \
+    cmake \
+    unzip \
+    libcurl4-openssl-dev \
+    autoconf \
+    libtool \
+    python3-pip && pip3 install awscli --break-system-packages && pip3 install azure-cli==2.76.0 --break-system-packages
+
+RUN <<EOT
+echo 'ipv4' >> ~/.curlrc
+if [ "$TARGETARCH" = "arm64" ]; then
+# Temporal fix for SSL_ERROR_SYSCALL error on arm64
+# see: https://github.com/curl/curl/issues/14154
+echo 'insecure' >> ~/.curlrc
+fi
+EOT
+
+ARG WORKER_VERSION
+ENV WORKER_VERSION=$WORKER_VERSION
+
+# Additional dependencies for Fargate
+RUN apt-get install -y bash jq pwgen curl git zip tree
+
+# Define custom function directory
+ARG FUNCTION_DIR="/artillery"
+RUN mkdir -p ${FUNCTION_DIR}
+WORKDIR ${FUNCTION_DIR}
+
+COPY packages packages
+COPY packages/artillery/lib/platform/aws-lambda/lambda-handler/ .
+COPY package.json package.json
+
+## Copy Fargate worker files
+COPY ./packages/artillery/lib/platform/aws-ecs/worker/loadgen-worker /artillery/loadgen-worker
+COPY ./packages/artillery/lib/platform/aws-ecs/worker/helpers.sh /artillery/helpers.sh
+
+# Install dependencies
+RUN npm install -w artillery --ignore-scripts --omit=dev
+RUN npm install aws-lambda-ric
+
+RUN npm cache clean --force \
+    && rm ./package.json \
+    && rm -rf /root/.cache \
+    && ln -s /artillery/node_modules/.bin/artillery /usr/local/bin/artillery \
+    && rm -rf /ms-playwright/firefox* \
+    && rm -rf /ms-playwright/webkit* \
+    && echo "ok"
+
+RUN chmod +x /artillery/loadgen-worker
+
+ENTRYPOINT ["/artillery/packages/artillery/bin/run"]