feat(cli): add typescript support by bundling processor with esbuild (#…

…2360)

* feat(cli): add typescript support by bundling processor with esbuild

* fix(cli): call ts handler function

* refactor(cli): only allow typescript processor in non-lambda

* feat(cli): handle error in ts bundling

* refactor(cli): use original processor file name

* test(cli): add basic tests for typescript support

* fix(cli): only extract extname if processor exists

* test(cli): add assert for error log

packages/artillery/lib/cmds/run.js

@@ -21,6 +21,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const os = require('os');
+const esbuild = require('esbuild-wasm');
 const createLauncher = require('../launch-platform');
 const createConsoleReporter = require('../../console-reporter');
 
@@ -436,6 +437,57 @@ RunCommand.runCommandImplementation = async function (flags, argv, args) {
   }
 };
 
+function replaceProcessorIfTypescript(script, scriptPath, platform) {
+  const relativeProcessorPath = script.config.processor;
+
+  if (!relativeProcessorPath) {
+    return script;
+  }
+  const extensionType = path.extname(relativeProcessorPath);
+
+  if (extensionType != '.ts') {
+    return script;
+  }
+
+  if (platform == 'aws:lambda') {
+    throw new Error('Typescript processor is not supported on AWS Lambda');
+  }
+
+  const actualProcessorPath = path.resolve(
+    path.dirname(scriptPath),
+    relativeProcessorPath
+  );
+  const processorFileName = path.basename(actualProcessorPath, extensionType);
+
+  const tmpDir = os.tmpdir();
+  const newProcessorPath = path.join(
+    tmpDir,
+    `${processorFileName}-${Date.now()}.js`
+  );
+
+  try {
+    esbuild.buildSync({
+      entryPoints: [actualProcessorPath],
+      outfile: newProcessorPath,
+      bundle: true,
+      platform: 'node',
+      format: 'cjs',
+      sourcemap: 'inline',
+      sourceRoot: '/' //TODO: review this?
+    });
+  } catch (error) {
+    throw new Error(`Failed to compile Typescript processor\n${error.message}`);
+  }
+
+  global.artillery.hasTypescriptProcessor = true;
+  console.log(
+    `Bundled Typescript file into JS. New processor path: ${newProcessorPath}`
+  );
+
+  script.config.processor = newProcessorPath;
+  return script;
+}
+
 async function prepareTestExecutionPlan(inputFiles, flags, args) {
   let script1 = {};
 
@@ -500,7 +552,13 @@ async function prepareTestExecutionPlan(inputFiles, flags, args) {
   script5.config.statsInterval = script5.config.statsInterval || 30;
 
   const script6 = addDefaultPlugins(script5);
-  return script6;
+  const script7 = replaceProcessorIfTypescript(
+    script6,
+    inputFiles[0],
+    flags.platform
+  );
+
+  return script7;
 }
 
 async function readPayload(script) {

packages/artillery/lib/platform/aws-lambda/index.js

@@ -290,7 +290,8 @@ class PlatformLambda {
         'detective',
         'is-builtin-module',
         'try-require',
-        'walk-sync'
+        'walk-sync',
+        'esbuild-wasm'
       ],
       {
         cwd: a9cwd

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

@@ -10,6 +10,18 @@ const STATES = require('../worker-states');
 
 const awaitOnEE = require('../../util/await-on-ee');
 
+const returnWorkerEnv = (needsSourcemap) => {
+  let 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;
@@ -20,13 +32,19 @@ class ArtilleryWorker {
   async init(_opts) {
     this.state = STATES.initializing;
 
-    this.worker = new Worker(path.join(__dirname, 'worker.js'));
+    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);
     });
+
+    //eslint-disable-next-line handle-callback-err
     this.worker.on('messageerror', (err) => {});
 
     // TODO: Expose performance metrics via getHeapSnapshot() and performance object.

packages/artillery/package.json

@@ -110,6 +110,7 @@
     "dependency-tree": "^10.0.9",
     "detective": "^5.1.0",
     "dotenv": "^16.0.1",
+    "esbuild-wasm": "^0.19.8",
     "eventemitter3": "^4.0.4",
     "fs-extra": "^10.1.0",
     "ip": "^1.1.8",

packages/artillery/test/cli/run-typescript.test.js

@@ -0,0 +1,71 @@
+const tap = require('tap');
+const { execute, returnTmpPath } = require('../cli/_helpers.js');
+const { createHash } = require('crypto');
+const fs = require('fs');
+
+let reportFilePath;
+tap.beforeEach(async (t) => {
+  reportFilePath = returnTmpPath(
+    `report-${createHash('md5')
+      .update(t.name)
+      .digest('hex')}-${Date.now()}.json`
+  );
+});
+
+// tap.test('Can run a Typescript processor', async (t) => {
+//   const [exitCode, output] = await execute([
+//     'run',
+//     '-o',
+//     `${reportFilePath}`,
+//     'test/scripts/scenarios-typescript/lodash.yml'
+//   ]);
+
+//   t.equal(exitCode, 0, 'CLI should exit with code 0');
+//   t.ok(
+//     output.stdout.includes('Got context using lodash: true'),
+//     'Should be able to use lodash in a scenario to get context'
+//   );
+//   const json = JSON.parse(fs.readFileSync(reportFilePath, 'utf8'));
+
+//   t.equal(
+//     json.aggregate.counters['http.codes.200'],
+//     2,
+//     'Should have made 2 requests'
+//   );
+//   t.equal(
+//     json.aggregate.counters['hey_from_ts'],
+//     2,
+//     'Should have emitted 2 custom metrics from ts processor'
+//   );
+// });
+
+tap.test(
+  'Failure from a Typescript processor has a resolvable stack trace via source maps',
+  async (t) => {
+    const [exitCode, output] = await execute([
+      'run',
+      '-o',
+      `${reportFilePath}`,
+      'test/scripts/scenarios-typescript/error.yml'
+    ]);
+
+    t.equal(exitCode, 11, 'CLI should exit with code 11');
+    t.ok(
+      output.stdout.includes('error_from_ts_processor'),
+      'Should have logged error from ts processor'
+    );
+
+    // Search for the path
+    const pathRegex = /\((.*?):\d+:\d+\)/;
+    const match = output.stdout.match(pathRegex);
+
+    // Extract the path if found
+    const extractedPath = match ? match[1] : null;
+
+    t.ok(
+      extractedPath.includes('.ts'),
+      'Should be using source maps to resolve the path to a .ts file'
+    );
+    t.ok(fs.existsSync(extractedPath), 'Error path should exist');
+  }
+);

packages/artillery/test/scripts/scenarios-typescript/error.yml

@@ -0,0 +1,15 @@
+config:
+  target: "http://asciiart.artillery.io:8080"
+  phases:
+    - duration: 2
+      arrivalRate: 1
+      name: "Phase 1"
+  processor: "./processor.ts"
+  variables:
+    isTypescript: true
+
+scenarios:
+  - flow:
+      - function: processorWithError
+      - get:
+          url: "/"

packages/artillery/test/scripts/scenarios-typescript/lodash.yml

@@ -0,0 +1,15 @@
+config:
+  target: "http://asciiart.artillery.io:8080"
+  phases:
+    - duration: 2
+      arrivalRate: 1
+      name: "Phase 1"
+  processor: "./processor.ts"
+  variables:
+    isTypescript: true
+
+scenarios:
+  - flow:
+      - function: myTest
+      - get:
+          url: "/"

packages/artillery/test/scripts/scenarios-typescript/processor.ts

@@ -0,0 +1,16 @@
+import _ from 'lodash';
+
+export const myTest = async (context, ee, next) => {
+  const isTypescript = _.get(context, 'vars.isTypescript');
+
+  console.log(`Got context using lodash: ${JSON.stringify(isTypescript)}`);
+
+  ee.emit('counter', 'hey_from_ts', 1);
+
+  next();
+};
+
+export const processorWithError = async (context, ee, next) => {
+  throw new Error('error_from_ts_processor');
+  next();
+};