@artilleryio/int-core 1.0.0 → 2.0.1

package/index.js

@@ -1,10 +1,8 @@
 const EventEmitter = require('events');
 const chalk = require('chalk');
 
-const { createGlobalObject } = require('../artillery/lib/artillery-global');
-
 // NOTE: This may be called more than once, and so should be non-destructive
-async function updateGlobalObject(opts) {
+async function updateGlobalObject(opts = {}) {
   global.artillery = global.artillery || {};
 
   global.artillery.runtimeOptions = global.artillery.runtimeOptions || {};
@@ -57,10 +55,28 @@ async function updateGlobalObject(opts) {
       }
     });
   }
+
+  global.artillery.logger = global.artillery.logger || function (opts) {
+    return {
+      log: (...args) => {
+        global.artillery.globalEvents.emit('log', opts, ...args);
+      }
+    };
+  };
+
+  global.artillery.log = global.artillery.log || function (...args) {
+    global.artillery.globalEvents.emit('log', {}, ...args);
+  };
+
+  if (opts.version) {
+    global.artillery.version = opts.version;
+  }
+  if (opts.telemetry) {
+    global.artillery.telemetry = opts.telemetry;
+  }
 }
 
 async function main() {
-  await createGlobalObject();
   await updateGlobalObject();
 }
 

package/lib/engine_http.js

@@ -26,6 +26,8 @@ const decompressResponse = require('decompress-response');
 
 const { promisify } = require('node:util');
 
+const crypto = require('node:crypto');
+
 module.exports = HttpEngine;
 
 const DEFAULT_AGENT_OPTIONS = {
@@ -534,6 +536,7 @@ HttpEngine.prototype.step = function step(requestSpec, ee, opts) {
               let haveFailedCaptures = false;
 
               if (result !== null) {
+                ee.emit('trace:http:capture', result, uuid);
                 if (
                   Object.keys(result.matches).length > 0 ||
                   Object.keys(result.captures).length > 0
@@ -651,13 +654,16 @@ HttpEngine.prototype.step = function step(requestSpec, ee, opts) {
 
         requestParams.retry = 0; // disable retries - ignored when using streams
 
+        const uuid = crypto.randomUUID();
         request(requestParams)
           .on('request', function (req) {
+            ee.emit('trace:http:request', requestParams, uuid);
+
             debugRequests('request start: %s', req.path);
             ee.emit('counter', 'http.requests', 1);
             ee.emit('rate', 'http.request_rate');
             req.on('response', function (res) {
-
+              ee.emit('trace:http:response', res, uuid);
               self._handleResponse(
                 requestParams,
                 res,
@@ -670,6 +676,7 @@ HttpEngine.prototype.step = function step(requestSpec, ee, opts) {
 
           })
           .on('error', function (err, body, res) {
+            ee.emit('trace:http:error', err, uuid);
             if (err.name === 'HTTPError') {
               return;
             }

package/lib/engine_socketio.js

@@ -8,6 +8,7 @@ const async = require('async');
 const _ = require('lodash');
 
 const io = require('socket.io-client');
+const wildcardPatch = require('socketio-wildcard')(io.Manager);
 
 const deepEqual = require('fast-deep-equal');
 const debug = require('debug')('socketio');
@@ -302,7 +303,9 @@ SocketIoEngine.prototype.loadContextSocket = function (namespace, context, cb) {
     const socket = io(target, options);
     context.sockets[namespace] = socket;
 
-    socket.onAny(() => {
+    wildcardPatch(socket);
+
+    socket.on('*', function () {
       context.__receivedMessageCount++;
     });
 

package/lib/phases.js

@@ -12,6 +12,7 @@ const arrivals = require('arrivals');
 const debug = require('debug')('phases');
 const crypto = require('crypto');
 const driftless = require('driftless');
+const sleep = require('../../artillery/lib/util/sleep');
 
 module.exports = phaser;
 
@@ -96,47 +97,67 @@ function createRamp(spec, ee) {
   const duration = spec.duration || 1;
   const arrivalRate = spec.arrivalRate;
   const rampTo = spec.rampTo;
+  const worker = spec.worker;
+  const totalWorkers = spec.totalWorkers;
 
-  const tick = 1000 / Math.max(arrivalRate, rampTo); // smallest tick
   const difference = rampTo - arrivalRate;
-  const periods = duration * 1000 / tick;
+  const periods = duration;
+  debug(`worker ${worker} totalWorkers ${totalWorkers} arrivalRate ${arrivalRate} rampTo ${rampTo} difference ${difference} periods ${periods}`);
+
+  const periodArrivals = [];
+  const periodTick = [];
+  // if there is only one peridod we generate mean arrivals
+  if (periods === 1) {
+    periodArrivals[0] = Math.floor((rampTo + arrivalRate) / 2);
+    periodTick[0] = 1000 / periodArrivals;
+  } else {
+    // for each period we calculate the corresponding arrivals:
+    // knowing that arrivals(0) = arrivalRate and arrivals(duration -1) = rampTo
+    // then: arrivals(t) = difference / (duration-1) * t + arrivalRate
+    for (let i = 0; i < periods; i++) {
+      const rawPeriodArrivals = (difference / (duration - 1)) * i + arrivalRate;
+
+      // We use the floor of the expected arrivals, then we add up all decimal digits
+      // and evaluate if one or more workers should bump their arrivalRate.
+      periodArrivals[i] = Math.floor(rawPeriodArrivals);
+
+      // Think of fractionalPart * workers as the amount of arrivals that could not be
+      // shared evenly across all workers.
+      if (Math.round((rawPeriodArrivals % 1) * totalWorkers) >= worker) {
+        periodArrivals[i] = periodArrivals[i] + 1;
+      }
 
-  function arrivalProbability(currentStep) {
-    // linear function ax + b
-    // normalized to 0 <= f(t) <= 1
-    // Anything under function value should be an arrival
+      // Needed ticks to get to periodArrivals in 1000ms
+      periodTick[i] = periodArrivals[i] > 0 ? Math.floor(1000 / periodArrivals[i]) : 1000;
+    }
+  }
 
-    let t = currentStep * tick / 1000;
-    return ((difference / duration) * t + arrivalRate) / Math.max(rampTo, arrivalRate);
-  };
+  debug(`periodArrivals ${periodArrivals}`);
+  debug(`periodTick ${periodTick}`);
 
-  let probabilities = Array.from({length: periods}, () => Math.random());
+  return async function rampTask(callback) {
+    ee.emit('phaseStarted', spec);
+    for (let period = 0; period < periods; period++) {
+      ticker(period);
+      await sleep(1000);
+    }
 
-  debug(
-    `rampTo: tick = ${tick}; difference = ${difference}; rampTo = ${rampTo}; arrivalRate = ${arrivalRate}; periods = ${periods}`
-  );
+    ee.emit('phaseCompleted', spec);
+  }
 
-  return function rampTask(callback) {
-    ee.emit('phaseStarted', spec);
-    let currentStep = 1;
-    const timer = driftless.setDriftlessInterval(function maybeArrival() {
-      if (currentStep <= periods) {
-        let arrivalBreakpoint = arrivalProbability(currentStep);
-        let roll = probabilities[currentStep-1];
-        debug(`roll:${roll} <= breakpoint:${arrivalBreakpoint}`);
-        if (roll <= arrivalBreakpoint) {
-          ee.emit('arrival', spec);
-        }
-
-        currentStep++;
+  function ticker(currentPeriod) {
+    let currentArrivals = 0;
+    let arrivalTimer = driftless.setDriftlessInterval(function arrivals() {
+      if (currentArrivals < periodArrivals[currentPeriod]) {
+        ee.emit('arrival', spec);
+        currentArrivals++;
       } else {
-        driftless.clearDriftless(timer);
-        ee.emit('phaseCompleted', spec);
-
-        return callback(null);
+        currentPeriod++;
+        driftless.clearDriftless(arrivalTimer);
       }
-    }, tick);
-  };
+    }, periodTick[currentPeriod]);
+    return;
+  }
 }
 
 function createArrivalCount(spec, ee) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artilleryio/int-core",
-  "version": "1.0.0",
+  "version": "2.0.1",
   "main": "./index.js",
   "dependencies": {
     "@artilleryio/sketches-js": "^1.0.4",
@@ -39,6 +39,8 @@
     "ws": "^7.5.7"
   },
   "scripts": {
+    "lint": "eslint --ext \".js,.ts,.tsx\" .",
+    "lint-fix": "npm run lint -- --fix",
     "test": "tap --no-coverage --timeout=300 test/core/unit/*.test.js && bash test/core/run.sh"
   },
   "devDependencies": {