@artilleryio/int-core 2.24.0 → 2.25.0-37061d0

package/lib/engine_http.js

@@ -4,7 +4,6 @@
 
 const async = require('async');
 const _ = require('lodash');
-const request = require('got');
 const tough = require('tough-cookie');
 const debug = require('debug')('http');
 const debugRequests = require('debug')('http:request');
@@ -30,6 +29,30 @@ const crypto = require('node:crypto');
 
 module.exports = HttpEngine;
 
+const GOT_OPTION_NAMES = [
+  'url',
+  'searchParams',
+  'method',
+  'headers',
+  'body',
+  'json',
+  'form',
+  'allowGetBody',
+  'timeout',
+  'retry',
+  'encoding',
+  'cookieJar',
+  'followRedirect',
+  'maxRedirects',
+  'decompress',
+  'http2',
+  'agent',
+  'username',
+  'password',
+  'https',
+  'throwHttpErrors'
+];
+
 const DEFAULT_AGENT_OPTIONS = {
   keepAlive: true,
   keepAliveMsec: 1000
@@ -126,6 +149,66 @@ function HttpEngine(script) {
   }
 }
 
+HttpEngine.prototype.init = async function () {
+  this.request = (await import('got')).default;
+};
+
+HttpEngine.prototype._isDistributedTracingEnabled = function (config) {
+  const dtConfig = config.http?.distributedTracing;
+  if (!dtConfig) {
+    return false;
+  }
+  
+  // Handle both boolean and object forms
+  if (typeof dtConfig === 'boolean') {
+    return dtConfig;
+  }
+  
+  if (typeof dtConfig === 'object' && dtConfig.enabled !== undefined) {
+    return dtConfig.enabled;
+  }
+  
+  // Default to true if distributedTracing is set but enabled is not specified
+  return true;
+};
+
+HttpEngine.prototype._generateTraceparent = function (config) {
+  // W3C Trace Context format: version-trace-id-parent-id-trace-flags
+  const version = '00';
+  
+  // Get configuration
+  const dtConfig = config.http?.distributedTracing;
+  let sampled = true; // Default to sampled
+  let traceIdPrefix = 'a9'; // Default prefix
+  
+  if (typeof dtConfig === 'object') {
+    if (dtConfig.sampled !== undefined) {
+      sampled = dtConfig.sampled;
+    }
+    if (dtConfig.traceIdPrefix !== undefined) {
+      traceIdPrefix = dtConfig.traceIdPrefix;
+    }
+  }
+  
+  // Validate and normalize prefix (must be valid hex, max 8 chars)
+  traceIdPrefix = traceIdPrefix.toLowerCase().replace(/[^0-9a-f]/g, '').slice(0, 8);
+  if (traceIdPrefix.length === 0) {
+    traceIdPrefix = 'a9'; // Fallback to default if invalid
+  }
+  
+  // Generate trace-id with prefix (32 hex chars total)
+  const remainingBytes = Math.ceil((32 - traceIdPrefix.length) / 2);
+  const randomPart = crypto.randomBytes(remainingBytes).toString('hex');
+  const traceId = (traceIdPrefix + randomPart).slice(0, 32);
+  
+  // Generate 8-byte parent-id (16 hex chars)
+  const parentId = crypto.randomBytes(8).toString('hex');
+  
+  const traceFlags = sampled ? '01' : '00';
+  
+  return `${version}-${traceId}-${parentId}-${traceFlags}`;
+};
+
 HttpEngine.prototype.createScenario = function (scenarioSpec, ee) {
   ensurePropertyIsAList(scenarioSpec, 'beforeRequest');
   ensurePropertyIsAList(scenarioSpec, 'afterResponse');
@@ -274,7 +357,7 @@ HttpEngine.prototype.step = function step(requestSpec, ee, opts) {
     const requestParams = _.extend(_.clone(params), {
       url: maybePrependBase(params.url || params.uri, config), // *NOT* templating here
       method: method,
-      timeout: timeout * 1000,
+      timeout: timeout,
       uuid: crypto.randomUUID()
     });
 
@@ -683,10 +766,21 @@ HttpEngine.prototype.step = function step(requestSpec, ee, opts) {
           );
         }
 
-        requestParams.retry = 0; // disable retries - ignored when using streams
+        requestParams.retry = { limit: 0 }; // disable retries - ignored when using streams
+        // Convert scalar seconds to Got v14 timeout object right before request
+        const gotOptions = _.pick(requestParams, GOT_OPTION_NAMES);
+        gotOptions.timeout = { response: requestParams.timeout * 1000 };
+
+        // Add W3C Trace Context headers if distributed tracing is enabled
+        if (self._isDistributedTracingEnabled(config)) {
+          const traceparent = self._generateTraceparent(config);
+          gotOptions.headers = gotOptions.headers || {};
+          gotOptions.headers.traceparent = traceparent;
+        }
 
         let totalDownloaded = 0;
-        request(_.omit(requestParams, ['uuid']))
+        self
+          .request(gotOptions)
           .on('request', (req) => {
             ee.emit('trace:http:request', requestParams, requestParams.uuid);
 
@@ -937,10 +1031,16 @@ HttpEngine.prototype.compile = function compile(tasks, _scenarioSpec, ee) {
         context = await promisify(task)(context);
       } catch (taskErr) {
         ee.emit('error', taskErr.code || taskErr.message);
-        return callback(taskErr, context); // calling back for now for existing client code
+        if (callback) {
+          return callback(taskErr, context);
+        }
+        throw taskErr;
       }
     }
-    return callback(null, context);
+    if (callback) {
+      return callback(null, context);
+    }
+    return context;
   };
 };
 

package/lib/engine_socketio.js

@@ -23,6 +23,10 @@ function SocketIoEngine(script) {
   this.httpDelegate = new EngineHttp(script);
 }
 
+SocketIoEngine.prototype.init = async function () {
+  await this.httpDelegate.init();
+};
+
 SocketIoEngine.prototype.createScenario = function (scenarioSpec, ee) {
   // Adds scenario overridden configuration into the static config
   this.socketioOpts = { ...this.socketioOpts, ...scenarioSpec.socketio };

package/lib/runner.js

@@ -163,6 +163,16 @@ async function runner(script, payload, options, callback) {
     warnings
   );
 
+  for (const e of runnerEngines) {
+    if (
+      e &&
+      typeof e.init === 'function' &&
+      e.init.constructor.name === 'AsyncFunction'
+    ) {
+      await e.init();
+    }
+  }
+
   const promise = new Promise((resolve, _reject) => {
     ee.run = (contextVars) => {
       const runState = {
@@ -506,12 +516,23 @@ function $randomString(length = 10) {
   return s;
 }
 
-function handleScriptHook(hook, script, hookEvents, contextVars = {}) {
+async function handleScriptHook(hook, script, hookEvents, contextVars = {}) {
   if (!script[hook]) {
     return {};
   }
 
   const { loadedEngines: engines } = loadEngines(script, hookEvents);
+
+  for (const e of engines) {
+    if (
+      e &&
+      typeof e.init === 'function' &&
+      e.init.constructor.name === 'AsyncFunction'
+    ) {
+      await e.init();
+    }
+  }
+
   const ee = new EventEmitter();
 
   return new Promise((resolve, reject) => {

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@artilleryio/int-core",
-  "version": "2.24.0",
+  "version": "2.25.0-37061d0",
   "main": "./index.js",
   "license": "MPL-2.0",
   "dependencies": {
-    "@artilleryio/int-commons": "2.20.0",
+    "@artilleryio/int-commons": "2.21.0-37061d0",
     "@artilleryio/sketches-js": "^2.1.1",
     "agentkeepalive": "^4.6.0",
     "arrivals": "^2.1.2",
     "async": "^2.6.4",
     "chalk": "^2.4.2",
-    "cheerio": "^1.1.2",
+    "cheerio": "^1.2.0",
     "cookie-parser": "^1.4.7",
     "csv-parse": "^4.16.3",
     "debug": "^4.4.3",
@@ -22,10 +22,10 @@
     "fast-deep-equal": "^3.1.3",
     "filtrex": "^0.5.4",
     "form-data": "^4.0.5",
-    "got": "^11.8.5",
+    "got": "^14.6.6",
     "hpagent": "^0.1.1",
     "https-proxy-agent": "^5.0.0",
-    "lodash": "^4.17.21",
+    "lodash": "^4.18.0",
     "ms": "^2.1.3",
     "protobufjs": "^7.5.4",
     "socket.io-client": "^4.8.3",