Memory leakage + upgrade packages with vulnerabilities + support for running requests one time before start of test

.gitignore

@@ -20,4 +20,5 @@ lib-cov
 artillery_report*
 coverage/*
 .vagrant/
-.vscode
+.vscode
+.history

core/lib/runner.js

@@ -25,6 +25,8 @@ const Engines = {
   socketio: {}
 };
 
+let contextVars;
+
 JSCK.Draft4 = JSCK.draft4;
 
 const schema = new JSCK.Draft4(require('./schemas/artillery_test_script.json'));
@@ -124,132 +126,136 @@ function runner(script, payload, options, callback) {
       }
   );
 
-  //
-  // load plugins:
-  //
-  let runnerPlugins = [];
-  let requirePaths = [];
 
-  let pro = null;
-  if (tryResolve('artillery-pro')) {
-    pro = require('artillery-pro');
-    requirePaths = requirePaths.concat(pro.getPluginPath());
-  } else {
-    debug('Artillery Pro is not installed.');
-  }
+  return handleBeforeRequests(script, runnableScript, runnerEngines)
+    .then(function(){
+        //
+        // load plugins:
+        //
+        let runnerPlugins = [];
+        let requirePaths = [];
+
+        let pro = null;
+        if (tryResolve('artillery-pro')) {
+            pro = require('artillery-pro');
+            requirePaths = requirePaths.concat(pro.getPluginPath());
+        } else {
+            debug('Artillery Pro is not installed.');
+        }
 
-  requirePaths.push('');
+        requirePaths.push('');
 
-  if (process.env.ARTILLERY_PLUGIN_PATH) {
-    requirePaths = requirePaths.concat(process.env.ARTILLERY_PLUGIN_PATH.split(':'));
-  }
-
-  debug('require paths: ', requirePaths);
+        if (process.env.ARTILLERY_PLUGIN_PATH) {
+            requirePaths = requirePaths.concat(process.env.ARTILLERY_PLUGIN_PATH.split(':'));
+        }
 
-  runnableScript.config.plugins = runnableScript.config.plugins || {};
+        debug('require paths: ', requirePaths);
 
-  if (process.env.ARTILLERY_PLUGINS) {
-    let additionalPlugins = {};
-    try {
-      additionalPlugins = JSON.parse(process.env.ARTILLERY_PLUGINS);
-    } catch (ignoreErr) {
-      debug(ignoreErr);
-    }
-    runnableScript.config.plugins = Object.assign(
-      runnableScript.config.plugins,
-      additionalPlugins);
-  }
+        runnableScript.config.plugins = runnableScript.config.plugins || {};
 
-  _.each(runnableScript.config.plugins, function tryToLoadPlugin(pluginConfig, pluginName) {
-    let pluginConfigScope = pluginConfig.scope || runnableScript.config.pluginsScope;
-    let pluginPrefix = pluginConfigScope ? pluginConfigScope : 'artillery-plugin-';
-    let requireString = pluginPrefix + pluginName;
-    let Plugin, plugin;
-
-    requirePaths.forEach(function(rp) {
-      try {
-        Plugin = require(path.join(rp, requireString));
-        if (typeof Plugin === 'function') {
-          // Plugin interface v1
-          plugin = new Plugin(runnableScript.config, ee);
-          plugin.__name = pluginName;
-        } else if (typeof Plugin === 'object' && typeof Plugin.Plugin === 'function') {
-          // Plugin interface 2+
-          plugin = new Plugin.Plugin(runnableScript, ee, options);
-          plugin.__name = pluginName;
+        if (process.env.ARTILLERY_PLUGINS) {
+            let additionalPlugins = {};
+            try {
+            additionalPlugins = JSON.parse(process.env.ARTILLERY_PLUGINS);
+            } catch (ignoreErr) {
+            debug(ignoreErr);
+            }
+            runnableScript.config.plugins = Object.assign(
+            runnableScript.config.plugins,
+            additionalPlugins);
         }
-      } catch (err) {
-        debug(err);
-      }
-    });
 
-    if (!Plugin || !plugin) {
-      console.log(
-        'WARNING: plugin %s specified but module %s could not be loaded',
-        pluginName,
-        requireString);
-      warnings.plugins[pluginName] = {
-        message: 'Could not load'
-      };
-    } else {
-      debug('Plugin %s loaded from %s', pluginName, requireString);
-      runnerPlugins.push(plugin);
-    }
-  });
-
-  const promise = new Promise(function(resolve, reject) {
-    ee.run = function() {
-      let runState = {
-        pendingScenarios: 0,
-        pendingRequests: 0,
-        compiledScenarios: null,
-        scenarioEvents: null,
-        picker: undefined,
-        plugins: runnerPlugins,
-        engines: runnerEngines
-      };
-      debug('run() with: %j', runnableScript);
-      run(runnableScript, ee, opts, runState);
-    };
-
-    ee.stop = function (done) {
-      // allow plugins to cleanup
-      A.eachSeries(
-        runnerPlugins,
-        function(plugin, next) {
-          if (plugin.cleanup) {
-            plugin.cleanup(function(err) {
-              if (err) {
+        _.each(runnableScript.config.plugins, function tryToLoadPlugin(pluginConfig, pluginName) {
+            let pluginConfigScope = pluginConfig.scope || runnableScript.config.pluginsScope;
+            let pluginPrefix = pluginConfigScope ? pluginConfigScope : 'artillery-plugin-';
+            let requireString = pluginPrefix + pluginName;
+            let Plugin, plugin;
+
+            requirePaths.forEach(function(rp) {
+            try {
+                Plugin = require(path.join(rp, requireString));
+                if (typeof Plugin === 'function') {
+                // Plugin interface v1
+                plugin = new Plugin(runnableScript.config, ee);
+                plugin.__name = pluginName;
+                } else if (typeof Plugin === 'object' && typeof Plugin.Plugin === 'function') {
+                // Plugin interface 2+
+                plugin = new Plugin.Plugin(runnableScript, ee, options);
+                plugin.__name = pluginName;
+                }
+            } catch (err) {
                 debug(err);
-              }
-              return next();
+            }
             });
-          } else {
-            return next();
-          }
-        },
-        function(err) {
-          return done(err);
-        });
-    };
 
-    // FIXME: Warnings should be returned from this function instead along with
-    // the event emitter. That will be a breaking change.
-    ee.warnings = warnings;
+            if (!Plugin || !plugin) {
+            console.log(
+                'WARNING: plugin %s specified but module %s could not be loaded',
+                pluginName,
+                requireString);
+            warnings.plugins[pluginName] = {
+                message: 'Could not load'
+            };
+            } else {
+            debug('Plugin %s loaded from %s', pluginName, requireString);
+            runnerPlugins.push(plugin);
+            }
+        });
 
-    resolve(ee);
-  });
+        const promise = new Promise(function(resolve, reject) {
+            ee.run = function() {
+            let runState = {
+                pendingScenarios: 0,
+                pendingRequests: 0,
+                compiledScenarios: null,
+                scenarioEvents: null,
+                picker: undefined,
+                plugins: runnerPlugins,
+                engines: runnerEngines
+            };
+            debug('run() with: %j', runnableScript);
+            run(runnableScript, ee, opts, runState);
+            };
+
+            ee.stop = function (done) {
+            // allow plugins to cleanup
+            A.eachSeries(
+                runnerPlugins,
+                function(plugin, next) {
+                if (plugin.cleanup) {
+                    plugin.cleanup(function(err) {
+                    if (err) {
+                        debug(err);
+                    }
+                    return next();
+                    });
+                } else {
+                    return next();
+                }
+                },
+                function(err) {
+                return done(err);
+                });
+            };
+
+            // FIXME: Warnings should be returned from this function instead along with
+            // the event emitter. That will be a breaking change.
+            ee.warnings = warnings;
+
+            resolve(ee);
+    });
 
-  if (callback && typeof callback === 'function') {
-    promise.then(callback.bind(null, null), callback);
-  }
+    if (callback && typeof callback === 'function') {
+        promise.then(callback.bind(null, null), callback);
+    }
 
-  return promise;
+    return promise;
+  });
 }
 
 function run(script, ee, options, runState) {
-  let intermediate = Stats.create();
-  let aggregate = [];
+    let intermediate = Stats.create();
+    let aggregate = [];
 
   let phaser = createPhaser(script.config.phases);
   phaser.on('arrival', function() {
@@ -392,19 +398,28 @@ function runScenario(script, intermediate, runState) {
  * Create initial context for a scenario.
  */
 function createContext(script) {
-  const INITIAL_CONTEXT = {
-    vars: {
-      target: script.config.target,
-      $environment: script._environment,
-      $processEnvironment: process.env
-    },
-    funcs: {
-      $randomNumber: $randomNumber,
-      $randomString: $randomString,
-      $template: input => engineUtil.template(input, { vars: result.vars })
-    }
-  };
-  let result = _.cloneDeep(INITIAL_CONTEXT);
+  let initialContext = {};
+  if (contextVars) {
+    initialContext = {
+      vars: contextVars
+    };
+  } else {
+    initialContext = {
+      vars: {
+        target: script.config.target,
+        $environment: script._environment,
+        $processEnvironment: process.env
+      }
+    };
+  }
+  initialContext.funcs = {
+    $randomNumber: $randomNumber,
+    $randomString: $randomString,
+    $template: input => engineUtil.template(input, { vars: result.vars })
+
+};
+
+  let result = _.cloneDeep(initialContext);
 
   //
   // variables from payloads
@@ -450,3 +465,25 @@ function $randomNumber(min, max) {
 function $randomString(length) {
   return Math.random().toString(36).substr(2, length);
 }
+
+function handleBeforeRequests(script, runnableScript, runnerEngines) {
+    return new Promise(function(resolve, reject){
+        if (script.before) {
+            let name = runnableScript.before.engine || 'http';
+            let engine = runnerEngines.find((e) => e.__name === name);
+            let beforeTestScenario = engine.createScenario(runnableScript.before);
+            let beforeTestContext = createContext(script);
+            beforeTestScenario(beforeTestContext, function(err, context) {
+              if (err) {
+                debug(err);
+                return reject(err);
+              } else {
+                contextVars = context.vars;
+                return resolve();
+              }
+            });
+        } else {
+            return resolve();
+        }
+    });
+}

core/lib/schemas/artillery_test_script.json

@@ -31,6 +31,18 @@
         }
       }
     },
+    "before": {
+      "type": "object",
+      "properties": {
+        "flow": {
+          "type": "array",
+          "items": {
+            "type": "object"            
+          }
+        }
+      },
+      "required": ["flow"]
+    },
     "scenarios": {
       "type": "array"
     }

core/lib/stats2.js

@@ -26,9 +26,6 @@ function create() {
 function combine(statsObjects) {
   let result = create();
   L.each(statsObjects, function(stats) {
-    L.each(stats._entries, function(entry) {
-      result._entries.push(entry);
-    });
     L.each(stats._latencies, function(latency) {
       result._latencies.push(latency);
     });
@@ -169,9 +166,7 @@ Stats.prototype.report = function() {
   result.scenariosCompleted = this._completedScenarios;
   result.requestsCompleted = this._completedRequests;
 
-  let latencies = L.map(this._entries, (e) => {
-    return e[2];
-  });
+  let latencies = this._latencies;
 
   result.latency = {
     min: round(L.min(latencies) / 1e6, 1),