@depup/artillery 2.0.30-depup.0

package/lib/platform/local/artillery-worker-local.js

@@ -0,0 +1,154 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EventEmitter = require('eventemitter3');
+const { Worker } = require('node:worker_threads');
+const path = require('node:path');
+
+const STATES = require('../worker-states');
+
+const awaitOnEE = require('../../util/await-on-ee');
+
+const returnWorkerEnv = (needsSourcemap) => {
+  const env = { ...process.env };
+
+  if (needsSourcemap) {
+    env.NODE_OPTIONS = process.env.NODE_OPTIONS
+      ? `${process.env.NODE_OPTIONS} --enable-source-maps`
+      : '--enable-source-maps';
+  }
+
+  return env;
+};
+
+class ArtilleryWorker {
+  constructor(opts) {
+    this.opts = opts;
+    this.events = new EventEmitter(); // events for consumers of this object
+    this.workerEvents = new EventEmitter(); // turn events delivered via 'message' events into their own messages
+  }
+
+  async init(_opts) {
+    this.state = STATES.initializing;
+
+    const workerEnv = returnWorkerEnv(global.artillery.hasTypescriptProcessor);
+
+    this.worker = new Worker(path.join(__dirname, 'worker.js'), {
+      env: workerEnv
+    });
+    this.workerId = this.worker.threadId;
+    this.worker.on('error', this.onError.bind(this));
+    // TODO:
+    this.worker.on('exit', (exitCode) => {
+      this.events.emit('exit', exitCode);
+    });
+
+    this.worker.on('messageerror', (_err) => {});
+
+    // TODO: Expose performance metrics via getHeapSnapshot() and performance object.
+
+    await awaitOnEE(this.worker, 'online', 10);
+
+    // Relay messages onto the real event emitter:
+    this.worker.on('message', (message) => {
+      switch (message.event) {
+        case 'log':
+          this.events.emit('log', message);
+          this.workerEvents.emit('log', message);
+          break;
+        case 'workerError':
+          this.events.emit('workerError', message);
+          this.workerEvents.emit('workerError', message);
+          break;
+        case 'phaseStarted':
+          this.events.emit('phaseStarted', message);
+          this.workerEvents.emit('phaseStarted', message);
+          break;
+        case 'phaseCompleted':
+          this.events.emit('phaseCompleted', message);
+          this.workerEvents.emit('phaseCompleted', message);
+          break;
+        case 'stats':
+          this.events.emit('stats', message);
+          this.workerEvents.emit('stats', message);
+          break;
+        case 'done':
+          this.events.emit('done', message);
+          this.workerEvents.emit('done', message);
+          break;
+        case 'running':
+          this.events.emit('running', message);
+          this.workerEvents.emit('running', message);
+          break;
+        case 'readyWaiting':
+          this.events.emit('readyWaiting', message);
+          this.workerEvents.emit('readyWaiting', message);
+          break;
+        case 'setSuggestedExitCode':
+          this.events.emit('setSuggestedExitCode', message);
+          break;
+        default:
+          global.artillery.log(
+            `Unknown message from worker ${message}`,
+            'error'
+          );
+      }
+    });
+
+    this.state = STATES.online;
+  }
+
+  async prepare(opts) {
+    this.state = STATES.preparing;
+
+    const { script, payload, options } = opts;
+    let scriptForWorker = script;
+
+    if (script.__transpiledTypeScriptPath && script.__originalScriptPath) {
+      scriptForWorker = {
+        __transpiledTypeScriptPath: script.__transpiledTypeScriptPath,
+        __originalScriptPath: script.__originalScriptPath,
+        __phases: script.config?.phases
+      };
+    }
+
+    this.worker.postMessage({
+      command: 'prepare',
+      opts: {
+        script: scriptForWorker,
+        payload,
+        options,
+        testRunId: global.artillery.testRunId
+      }
+    });
+
+    await awaitOnEE(this.workerEvents, 'readyWaiting', 50);
+    this.state = STATES.readyWaiting;
+  }
+
+  async run(opts) {
+    this.worker.postMessage({
+      command: 'run',
+      opts: JSON.parse(opts)
+    });
+
+    await awaitOnEE(this.workerEvents, 'running', 50);
+    this.state = STATES.running;
+  }
+
+  async stop() {
+    this.worker.postMessage({ command: 'stop' });
+  }
+
+  onError(err) {
+    // TODO: set state, clean up
+    this.events.emit('error', err);
+    console.log('worker error, id:', this.workerId, err);
+  }
+}
+
+module.exports = {
+  ArtilleryWorker,
+  STATES
+};

package/lib/platform/local/index.js

@@ -0,0 +1,174 @@
+const { ArtilleryWorker } = require('./artillery-worker-local');
+const core = require('../../dispatcher');
+const { handleScriptHook, prepareScript, loadProcessor } =
+  core.runner.runnerFuncs;
+const debug = require('debug')('platform:local');
+const EventEmitter = require('node:events');
+const _ = require('lodash');
+const divideWork = require('../../dist');
+const STATES = require('../worker-states');
+const os = require('node:os');
+class PlatformLocal {
+  constructor(script, payload, opts, platformOpts) {
+    // We need these to run before/after hooks:
+    this.script = script;
+    this.payload = payload;
+    this.opts = opts;
+    this.events = new EventEmitter(); // send worker events such as workerError, etc
+    this.platformOpts = platformOpts;
+    this.workers = {};
+    this.workerScripts = {};
+    this.count = Infinity;
+  }
+
+  getDesiredWorkerCount() {
+    return this.count;
+  }
+
+  async startJob() {
+    await this.init();
+
+    if (this.platformOpts.mode === 'distribute') {
+      // Disable worker threads for Playwright-based load tests
+      const count = this.script.config.engines?.playwright
+        ? 1
+        : Math.max(1, os.cpus().length - 1);
+      this.workerScripts = divideWork(this.script, count);
+      this.count = this.workerScripts.length;
+    } else {
+      // --count may only be used when mode is "multiply"
+      this.count = this.platformOpts.count;
+      this.workerScripts = new Array(this.count).fill().map((_) => this.script);
+    }
+
+    for (const script of this.workerScripts) {
+      const w1 = await this.createWorker();
+
+      this.workers[w1.workerId] = {
+        id: w1.workerId,
+        script,
+        state: STATES.initializing,
+        proc: w1
+      };
+      debug(`worker init ok: ${w1.workerId}`);
+    }
+
+    for (const [workerId, w] of Object.entries(this.workers)) {
+      this.opts.cliArgs = this.platformOpts.cliArgs;
+      await this.prepareWorker(workerId, {
+        script: w.script,
+        payload: this.payload,
+        options: this.opts
+      });
+      this.workers[workerId].state = STATES.preparing;
+    }
+    debug('workers prepared');
+
+    // the initial context is stringified and copied to the workers
+    const contextVarsString = JSON.stringify(this.contextVars);
+
+    for (const [workerId, _w] of Object.entries(this.workers)) {
+      await this.runWorker(workerId, contextVarsString);
+      this.workers[workerId].state = STATES.initializing;
+    }
+  }
+
+  async init() {
+    // 'before' hook is executed in the main thread,
+    // its context is then passed to the workers
+    const contextVars = await this.runHook('before');
+    this.contextVars = contextVars; // TODO: Rename to something more descriptive
+  }
+
+  async createWorker() {
+    const worker = new ArtilleryWorker();
+
+    await worker.init();
+
+    const workerId = worker.workerId;
+    worker.events.on('workerError', (message) => {
+      this.events.emit('workerError', workerId, message);
+    });
+    worker.events.on('log', (message) => {
+      this.events.emit('log', workerId, message);
+    });
+    worker.events.on('phaseStarted', (message) => {
+      this.events.emit('phaseStarted', workerId, message);
+    });
+    worker.events.on('phaseCompleted', (message) => {
+      this.events.emit('phaseCompleted', workerId, message);
+    });
+    worker.events.on('stats', (message) => {
+      this.events.emit('stats', workerId, message);
+    });
+    worker.events.on('done', (message) => {
+      this.events.emit('done', workerId, message);
+    });
+    worker.events.on('readyWaiting', (message) => {
+      this.events.emit('readyWaiting', workerId, message);
+    });
+    worker.events.on('setSuggestedExitCode', (message) => {
+      this.events.emit('setSuggestedExitCode', workerId, message);
+    });
+    worker.events.on('exit', (message) => {
+      this.events.emit('exit', workerId, message);
+    });
+
+    worker.events.on('error', (_err) => {
+      // TODO: Only exit if ALL workers fail, otherwise log and carry on
+      process.nextTick(() => process.exit(11));
+    });
+
+    return worker;
+  }
+
+  async prepareWorker(workerId, opts) {
+    return this.workers[workerId].proc.prepare(opts);
+  }
+
+  async runWorker(workerId, contextVarsString) {
+    // TODO: this will become opts
+    debug('runWorker', workerId);
+    return this.workers[workerId].proc.run(contextVarsString);
+  }
+
+  async stopWorker(workerId) {
+    return this.workers[workerId].proc.stop();
+  }
+
+  async shutdown() {
+    // 'after' hook is executed in the main thread, after all workers
+    // are done
+    await this.runHook('after', this.contextVars);
+
+    for (const [workerId, _w] of Object.entries(this.workers)) {
+      await this.stopWorker(workerId);
+    }
+  }
+
+  // ********
+
+  async runHook(hook, initialContextVars) {
+    if (!this.script[hook]) {
+      return {};
+    }
+
+    const runnableScript = await loadProcessor(
+      prepareScript(this.script, _.cloneDeep(this.payload)),
+      this.opts
+    );
+
+    const contextVars = await handleScriptHook(
+      hook,
+      runnableScript,
+      this.events,
+      initialContextVars
+    );
+
+    debug(`hook ${hook} context vars`, contextVars);
+
+    return contextVars;
+  }
+}
+
+module.exports = PlatformLocal;

package/lib/platform/local/worker.js

@@ -0,0 +1,261 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//
+// Artillery Core worker process
+//
+
+
+
+const {
+  parentPort,
+  threadId
+} = require('node:worker_threads');
+
+const { getStash } = require('../../../lib/stash');
+
+const { createGlobalObject } = require('../../artillery-global');
+
+const core = require('@artilleryio/int-core');
+const createRunner = core.runner.runner;
+const debug = require('debug')('artillery:worker');
+
+const _path = require('node:path');
+
+const { SSMS } = require('@artilleryio/int-core').ssms;
+const { loadPlugins, loadPluginsConfig } = require('../../load-plugins');
+
+const EventEmitter = require('eventemitter3');
+const p = require('node:util').promisify;
+const { loadProcessor } = core.runner.runnerFuncs;
+
+const prepareTestExecutionPlan = require('../../util/prepare-test-execution-plan');
+
+process.env.LOCAL_WORKER_ID = threadId;
+
+parentPort.on('message', onMessage);
+
+let shuttingDown = false;
+
+let runnerInstance = null;
+
+global.artillery._workerThreadSend = send;
+
+//
+// Supported messages: run, stop
+//
+
+async function onMessage(message) {
+  if (message.command === 'prepare') {
+    await prepare(message.opts);
+    return;
+  }
+
+  if (message.command === 'run') {
+    run(message.opts);
+    return;
+  }
+
+  if (message.command === 'stop') {
+    await cleanup();
+
+    // Unload plugins
+    // TODO: v3 plugins
+    for (const o of global.artillery.plugins) {
+      if (o.plugin.cleanup) {
+        try {
+          await p(o.plugin.cleanup.bind(o.plugin))();
+          debug('plugin unloaded:', o.name);
+        } catch (cleanupErr) {
+          send({
+            event: 'workerError',
+            error: cleanupErr,
+            level: 'error',
+            aggregatable: true
+          });
+        }
+      }
+    }
+
+    process.exit(0);
+  }
+}
+
+async function cleanup() {
+  return new Promise((resolve, _reject) => {
+    if (shuttingDown) {
+      resolve();
+    }
+    shuttingDown = true;
+
+    if (runnerInstance && typeof runnerInstance.stop === 'function') {
+      runnerInstance.stop().then(() => {
+        resolve();
+      });
+    } else {
+      resolve();
+    }
+  });
+}
+
+async function createGlobalStashClient(cliArgs) {
+  try {
+    global.artillery.stash = await getStash({
+      apiKey: cliArgs?.key || process.env.ARTILLERY_CLOUD_API_KEY
+    });
+  } catch (error) {
+    if (error.name !== 'CloudAPIKeyMissing') {
+      console.error(error);
+    }
+    global.artillery.stash = null;
+  }
+}
+
+async function prepare(opts) {
+  await createGlobalObject();
+  await createGlobalStashClient(opts.options.cliArgs);
+
+  global.artillery.globalEvents.on('log', (...args) => {
+    send({ event: 'log', args });
+  });
+
+  let _script;
+  if (
+    opts.script.__transpiledTypeScriptPath &&
+    opts.script.__originalScriptPath
+  ) {
+    // Load and process pre-compiled TypeScript file
+    _script = await prepareTestExecutionPlan(
+      [opts.script.__originalScriptPath],
+      opts.options.cliArgs,
+      []
+    );
+  } else {
+    _script = opts.script;
+  }
+
+  const { payload, options } = opts;
+  const script = await loadProcessor(_script, options);
+
+  if (opts.script.__phases) {
+    script.config.phases = opts.script.__phases;
+  }
+
+  global.artillery.testRunId = opts.testRunId;
+
+  //
+  // load plugins
+  //
+  const plugins = await loadPlugins(script.config.plugins, script, options);
+
+  // NOTE: We don't subscribe plugins to stats/done events from
+  // individual runner instances here - those are handled in
+  // launch-platform instead. (If we subscribe plugins to events here,
+  // they will receive individual stats/done events from workers,
+  // instead of objects that have been properly aggregated.)
+  const stubEE = new EventEmitter();
+  for (const [name, result] of Object.entries(plugins)) {
+    if (result.isLoaded) {
+      global.artillery.plugins[name] = result.plugin;
+      if (result.version === 3) {
+        // TODO: v3 plugins
+      } else {
+        //         const msg = `WARNING: Legacy plugin detected: ${name}
+        // See https://artillery.io/docs/resources/core/v2.html for more details.`;
+        //         send({
+        //           event: 'workerError',
+        //           error: new Error(msg),
+        //           level: 'warn',
+        //           aggregatable: true
+        //         });
+
+        script.config = {
+          ...script.config,
+          // Load additional plugins configuration from the environment
+          plugins: loadPluginsConfig(script.config.plugins)
+        };
+
+        if (result.version === 1) {
+          result.plugin = new result.PluginExport(script.config, stubEE);
+          global.artillery.plugins.push(result);
+        } else if (result.version === 2) {
+          result.plugin = new result.PluginExport.Plugin(
+            script,
+            stubEE,
+            options
+          );
+          global.artillery.plugins.push(result);
+        } else {
+          // TODO:
+        }
+      }
+    } else {
+      const msg = `WARNING: Could not load plugin: ${name}`;
+      send({
+        event: 'workerError',
+        error: new Error(msg),
+        level: 'warn',
+        aggregatable: true
+      });
+    }
+  }
+
+  // TODO: use await
+  createRunner(script, payload, options)
+    .then((runner) => {
+      runnerInstance = runner;
+
+      runner.on('phaseStarted', onPhaseStarted);
+      runner.on('phaseCompleted', onPhaseCompleted);
+      runner.on('stats', onStats);
+      runner.on('done', onDone);
+
+      // TODO: Enum for all event types
+      send({ event: 'readyWaiting' });
+    })
+    .catch((err) => {
+      // TODO: Clean up and exit (error state)
+      // TODO: Handle workerError in launcher when readyWaiting
+      // is not received and worker exits.
+      send({
+        event: 'workerError',
+        error: err,
+        level: 'error',
+        aggregatable: true
+      });
+    });
+
+  function onPhaseStarted(phase) {
+    send({ event: 'phaseStarted', phase: phase });
+  }
+
+  function onPhaseCompleted(phase) {
+    send({ event: 'phaseCompleted', phase: phase });
+  }
+
+  function onStats(stats) {
+    send({ event: 'stats', stats: SSMS.serializeMetrics(stats) });
+  }
+
+  async function onDone(report) {
+    await runnerInstance.stop();
+    send({ event: 'done', report: SSMS.serializeMetrics(report) });
+  }
+}
+
+async function run(opts) {
+  if (runnerInstance) {
+    runnerInstance.run(opts);
+    send({ event: 'running' });
+  } else {
+    // TODO: Emit error / set state
+  }
+}
+
+// TODO: id -> workerId, ts -> _ts
+function send(data) {
+  const payload = Object.assign({ id: threadId, ts: Date.now() }, data);
+  debug(payload);
+  parentPort.postMessage(payload);
+}

package/lib/platform/worker-states.js

@@ -0,0 +1,13 @@
+module.exports = {
+  initializing: 1,
+  online: 2,
+  preparing: 3,
+  readyWaiting: 4,
+  running: 5,
+  unknown: 6,
+  stoppedError: 7,
+  completed: 8,
+  stoppedEarly: 9,
+  stoppedFailed: 10,
+  timedout: 11
+};

package/lib/queue-consumer/index.js

@@ -0,0 +1,56 @@
+const { EventEmitter } = require('eventemitter3');
+const debug = require('debug')('queue-consumer');
+const { Consumer } = require('sqs-consumer');
+
+class QueueConsumer extends EventEmitter {
+  create(opts = { poolSize: 30 }, queueConsumerOpts) {
+    this.events = new EventEmitter();
+
+    this.consumers = [];
+
+    for (let i = 0; i < opts.poolSize; i++) {
+      const sqsConsumer = Consumer.create(queueConsumerOpts);
+
+      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 {
+          sqsConsumer.stop();
+          this.emit('error', err);
+        }
+      });
+
+      let empty = 0;
+      sqsConsumer.on('empty', () => {
+        empty++;
+        if (empty > 10) {
+          this.emit('messageReceiveTimeout'); // TODO:
+        }
+      });
+
+      this.consumers.push(sqsConsumer);
+    }
+
+    return this;
+  }
+
+  constructor(_opts) {
+    super();
+  }
+
+  start() {
+    for (const consumer of this.consumers) {
+      consumer.start();
+    }
+  }
+
+  stop() {
+    for (const consumer of this.consumers) {
+      consumer.stop();
+    }
+  }
+}
+
+module.exports = { QueueConsumer };

package/lib/stash.js

@@ -0,0 +1,41 @@
+const { Redis } = require('@upstash/redis');
+const { createClient } = require('./platform/cloud/api');
+
+async function init(details) {
+  if (details) {
+    return new Redis({ url: details.url, token: details.token });
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Get an Artillery Stash client instance
+ *
+ *
+ * @param {Object} options - Configuration options
+ * @param {string} options.apiKey - Artillery Cloud API key (optional, can use ARTILLERY_CLOUD_API_KEY env var)
+ * @returns {Promise<Redis|null>} - Redis client instance or null if not available
+ */
+async function getStash(options = {}) {
+  const cloud = createClient({
+    apiKey: options.apiKey || process.env.ARTILLERY_CLOUD_API_KEY
+  });
+
+  const whoami = await cloud.whoami();
+  if (!whoami.activeOrg) {
+    return null;
+  }
+
+  const stashDetails = await cloud.getStashDetails({
+    orgId: whoami.activeOrg
+  });
+
+  if (!stashDetails) {
+    return null;
+  }
+
+  return init(stashDetails);
+}
+
+module.exports = { initStash: init, getStash };