loadtest 6.4.0 → 7.1.0

package/lib/httpClient.js

@@ -15,94 +15,94 @@ let uniqueIndex = 1
  * Create a new HTTP client.
  * Seem parameters below.
  */
-export function create(operation, params) {
-	return new HttpClient(operation, params);
+export function create(loadTest, options) {
+	return new HttpClient(loadTest, options);
 }
 
 /**
- * A client for an HTTP connection.
- * Operation is an object which has these attributes:
- *	- latency: a variable to measure latency.
- *	- running: if the operation is running or not.
- * Params is an object with the same options as exports.loadTest.
+ * A client for an HTTP connection. Constructor:
+ *	- `loadTest`: an object with the following attributes:
+ *		- latency: a variable to measure latency.
+ *		- running: if the loadTest is running or not.
+ *	- `options`: same options as exports.loadTest.
  */
 class HttpClient {
-	constructor(operation, params) {
-		this.operation = operation
-		this.params = params
+	constructor(loadTest, options) {
+		this.loadTest = loadTest
+		this.options = options
 		this.stopped = false
 		this.init();
 	}
 
 	/**
-	 * Init options and message to send.
+	 * Init and message to send.
 	 */
 	init() {
-		this.options = urlLib.parse(this.params.url);
-		this.options.headers = this.params.headers || {}
-		if (this.params.cert && this.params.key) {
-			this.options.cert = this.params.cert;
-			this.options.key = this.params.key;
+		this.params = urlLib.parse(this.options.url);
+		this.params.headers = this.options.headers || {}
+		if (this.options.cert && this.options.key) {
+			this.params.cert = this.options.cert;
+			this.params.key = this.options.key;
 		}
-		this.options.agent = false;
-		if (this.params.requestsPerSecond) {
+		this.params.agent = false;
+		if (this.options.requestsPerSecond) {
 			// rps for each client is total / concurrency (# of clients)
-			this.options.requestsPerSecond = this.params.requestsPerSecond / this.params.concurrency
+			this.params.requestsPerSecond = this.options.requestsPerSecond / this.options.concurrency
 		}
-		if (this.params.agentKeepAlive) {
-			const KeepAlive = (this.options.protocol == 'https:') ? agentkeepalive.HttpsAgent : agentkeepalive.default;
+		if (this.options.agentKeepAlive) {
+			const KeepAlive = (this.params.protocol == 'https:') ? agentkeepalive.HttpsAgent : agentkeepalive.default;
 			let maxSockets = 10;
-			if (this.options.requestsPerSecond) {
-				maxSockets += Math.floor(this.options.requestsPerSecond);
+			if (this.params.requestsPerSecond) {
+				maxSockets += Math.floor(this.params.requestsPerSecond);
 			}
-			this.options.agent = new KeepAlive({
+			this.params.agent = new KeepAlive({
 				maxSockets: maxSockets,
 				maxKeepAliveRequests: 0, // max requests per keepalive socket, default is 0, no limit
 				maxKeepAliveTime: 30000  // keepalive for 30 seconds
 			});
 		}
-		if (this.params.method) {
-			this.options.method = this.params.method;
+		if (this.options.method) {
+			this.params.method = this.options.method;
 		}
-		if (this.params.body) {
-			if (typeof this.params.body == 'string') {
-				this.generateMessage = () => this.params.body;
-			} else if (typeof this.params.body == 'object') {
-				if (this.params.contentType === 'application/x-www-form-urlencoded') {
-					this.params.body = querystring.stringify(this.params.body);
+		if (this.options.body) {
+			if (typeof this.options.body == 'string') {
+				this.generateMessage = () => this.options.body;
+			} else if (typeof this.options.body == 'object') {
+				if (this.options.contentType === 'application/x-www-form-urlencoded') {
+					this.options.body = querystring.stringify(this.options.body);
 				}
-				this.generateMessage = () => this.params.body;
-			} else if (typeof this.params.body == 'function') {
-				this.generateMessage = this.params.body;
+				this.generateMessage = () => this.options.body;
+			} else if (typeof this.options.body == 'function') {
+				this.generateMessage = this.options.body;
 			} else {
-				throw new Error(`Unrecognized body: ${typeof this.params.body}`);
+				throw new Error(`Unrecognized body: ${typeof this.options.body}`);
 			}
-			this.options.headers['Content-Type'] = this.params.contentType || 'text/plain';
+			this.params.headers['Content-Type'] = this.options.contentType || 'text/plain';
 		}
-		if (this.params.cookies) {
-			if (Array.isArray(this.params.cookies)) {
-				this.options.headers.Cookie =  this.params.cookies.join('; ');
-			} else if (typeof this.params.cookies == 'string') {
-				this.options.headers.Cookie = this.params.cookies;
+		if (this.options.cookies) {
+			if (Array.isArray(this.options.cookies)) {
+				this.params.headers.Cookie =  this.options.cookies.join('; ');
+			} else if (typeof this.options.cookies == 'string') {
+				this.params.headers.Cookie = this.options.cookies;
 			} else {
-				throw new Error(`Invalid cookies ${JSON.stringify(this.params.cookies)}, please use an array or a string`);
+				throw new Error(`Invalid cookies ${JSON.stringify(this.options.cookies)}, please use an array or a string`);
 			}
 		}
-		addUserAgent(this.options.headers);
-		if (this.params.secureProtocol) {
-			this.options.secureProtocol = this.params.secureProtocol;
+		addUserAgent(this.params.headers);
+		if (this.options.secureProtocol) {
+			this.params.secureProtocol = this.options.secureProtocol;
 		}
 		// adding proxy configuration
-		if (this.params.proxy) {
-			const proxy = this.params.proxy;
+		if (this.options.proxy) {
+			const proxy = this.options.proxy;
 			const agent = new HttpsProxyAgent(proxy);
-			this.options.agent = agent;
+			this.params.agent = agent;
 		}
-		if (this.params.indexParam) {
-			this.options.indexParamFinder = new RegExp(this.params.indexParam, 'g');
+		if (this.options.indexParam) {
+			this.params.indexParamFinder = new RegExp(this.options.indexParam, 'g');
 		}
 		// Disable certificate checking
-		if (this.params.insecure === true) {
+		if (this.options.insecure === true) {
 			process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
 		}
 	}
@@ -116,10 +116,10 @@ class HttpClient {
 			// so sometimes they are stopped before they have even started
 			return
 		}
-		if (!this.options.requestsPerSecond) {
+		if (!this.params.requestsPerSecond) {
 			return this.makeRequest();
 		}
-		const interval = 1000 / this.options.requestsPerSecond;
+		const interval = 1000 / this.params.requestsPerSecond;
 		this.requestTimer = new HighResolutionTimer(interval, () => this.makeRequest());
 	}
 
@@ -137,159 +137,147 @@ class HttpClient {
 	 * Make a single request to the server.
 	 */
 	makeRequest() {
-		if (!this.operation.running) {
+		if (!this.loadTest.running) {
 			return;
 		}
-		if (this.operation.options.maxRequests && this.operation.requests >= this.operation.options.maxRequests) return
-		this.operation.requests += 1;
+		if (this.loadTest.options.maxRequests && this.loadTest.requests >= this.loadTest.options.maxRequests) return
+		this.loadTest.requests += 1;
 
-		const id = this.operation.latency.start();
-		const options = {...this.options, headers: {...this.options.headers}}
-		const requestFinished = this.getRequestFinisher(id);
-		this.customizeIndex(options)
-		const request = this.getRequest(id, options, requestFinished)
-		if (this.params.timeout) {
-			const timeout = parseInt(this.params.timeout);
+		const id = this.loadTest.latency.start();
+		const params = {...this.params, headers: {...this.params.headers}}
+		this.customizeIndex(params)
+		const request = this.getRequest(id, params)
+		if (this.options.timeout) {
+			const timeout = parseInt(this.options.timeout);
 			if (!timeout) {
-				console.error('Invalid timeout %s', this.params.timeout);
+				console.error(`Invalid timeout ${this.options.timeout}`);
 			}
 			request.setTimeout(timeout, () => {
-				requestFinished('Connection timed out');
+				this.finishRequest(id, 'Connection timed out');
 			});
 		}
-		const message = this.getMessage(id, options)
+		const message = this.getMessage(id, params)
 		if (message) {
 			request.write(message);
-			options.headers['Content-Length'] = Buffer.byteLength(message);
+			params.headers['Content-Length'] = Buffer.byteLength(message);
 		}
 		request.on('error', error => {
-			requestFinished('Connection error: ' + error.message);
+			this.finishRequest(id, `Connection error: ${error.message}`);
 		});
 		request.end();
 	}
 
-	customizeIndex(options) {
-		if (!this.options.indexParamFinder) {
+	customizeIndex(params) {
+		if (!this.params.indexParamFinder) {
 			return
 		}
-		options.customIndex = this.getCustomIndex()
-		options.path = this.options.path.replace(this.options.indexParamFinder, options.customIndex);
+		params.customIndex = this.getCustomIndex()
+		params.path = this.params.path.replace(this.params.indexParamFinder, params.customIndex);
 	}
 
 	getCustomIndex() {
-		if (this.options.indexParamCallback instanceof Function) {
-			return this.options.indexParamCallback();
+		if (this.params.indexParamCallback instanceof Function) {
+			return this.params.indexParamCallback();
 		}
 		const customIndex = uniqueIndex
 		uniqueIndex += 1
 		return customIndex
 	}
 
-	getLib() {
-		if (this.options.protocol == 'https:') {
-			return https;
-		}
-		if (this.options.protocol == 'ws:') {
-			return websocket;
-		}
-		return http;
-	}
-
-	getMessage(id, options) {
+	getMessage(id, params) {
 		if (!this.generateMessage) {
 			return
 		}
 		const candidate = this.generateMessage(id);
 		const message = typeof candidate === 'object' ? JSON.stringify(candidate) : candidate
-		if (this.options.indexParamFinder) {
-			return message.replace(this.options.indexParamFinder, options.customIndex);
+		if (this.params.indexParamFinder) {
+			return message.replace(this.params.indexParamFinder, params.customIndex);
 		}
 		return message
 	}
 
-	getRequest(id, options, requestFinished) {
+	getRequest(id, params) {
 		const lib = this.getLib()
-		if (typeof this.params.requestGenerator == 'function') {
-			const connect = this.getConnect(id, requestFinished, this.params.contentInspector)
-			return this.params.requestGenerator(this.params, options, lib.request, connect);
+		if (typeof this.options.requestGenerator == 'function') {
+			return this.options.requestGenerator(this.options, params, lib.request, connection => this.connect(connection, id))
 		}
-		return lib.request(options, this.getConnect(id, requestFinished, this.params.contentInspector));
+		return lib.request(params, connection => this.connect(connection, id))
 	}
 
-	/**
-	 * Get a function that finishes one request and goes for the next.
-	 */
-	getRequestFinisher(id) {
-		return (error, result) => {
-			let errorCode = null;
-			if (error) {
-				if (result) {
-					errorCode = result.statusCode;
-					if (result.customErrorCode !== undefined) {
-						errorCode = errorCode + ":" + result.customErrorCode
-					}
-				} else {
-					errorCode = '-1';
+	getLib() {
+		if (this.params.protocol == 'https:') {
+			return https;
+		}
+		if (this.params.protocol == 'ws:') {
+			return websocket;
+		}
+		return http;
+	}
+
+	finishRequest(id, error, result) {
+		let errorCode = null;
+		if (error) {
+			if (result) {
+				errorCode = result.statusCode;
+				if (result.customErrorCode !== undefined) {
+					errorCode = errorCode + ":" + result.customErrorCode
 				}
+			} else {
+				errorCode = '-1';
 			}
+		}
+		const elapsed = this.loadTest.latency.end(id, errorCode);
+		if (elapsed < 0) {
+			// not found or not running
+			return;
+		}
+		if (result) {
+			result.requestElapsed = elapsed;
+		}
+		this.loadTest.finishRequest(error, result, () => this.makeRequest());
+	}
 
-			const elapsed = this.operation.latency.end(id, errorCode);
-			if (elapsed < 0) {
-				// not found or not running
-				return;
+	connect(connection, id) {
+		const bodyBuffers = []
+		connection.on('data', chunk => {
+			bodyBuffers.push(chunk)
+		});
+		connection.on('error', error => {
+			this.finishRequest(id, `Connection ${id} failed: ${error}`);
+		});
+		connection.on('end', () => {
+			const body = Buffer.concat(bodyBuffers).toString()
+			const result = this.createResult(connection, body)
+			if (this.options.contentInspector) {
+				this.options.contentInspector(result)
 			}
-			const index = this.operation.latency.getRequestIndex(id);
-			if (result) {
-				result.requestElapsed = elapsed;
-				result.requestIndex = index;
-				result.instanceIndex = this.operation.instanceIndex;
+			if (connection.statusCode >= 400) {
+				return this.finishRequest(id, `Status code ${connection.statusCode}`, result);
 			}
-			let callback;
-			if (!this.options.requestsPerSecond) {
-				callback = this.makeRequest.bind(this);
+			if (result?.customError) {
+				return this.finishRequest(id, `Custom error: ${result.customError}`, result);
 			}
-			this.operation.callback(error, result, callback);
-		};
+			this.finishRequest(id, null, result);
+		});
 	}
 
-	/**
-	 * Get a function to connect the player.
-	 */
-	getConnect(id, callback, contentInspector) {
-		let body = '';
-		return connection => {
-			connection.setEncoding('utf8');
-			connection.on('data', chunk => {
-				body += chunk;
-			});
-			connection.on('error', error => {
-				callback('Connection ' + id + ' failed: ' + error, '1');
-			});
-			connection.on('end', () => {
-				const client = connection.connection || connection.client
-				const result = {
-					host: client._host,
-					path: connection.req.path,
-					method: connection.req.method,
-					statusCode: connection.statusCode,
-					body: body,
-					headers: connection.headers,
-				};
-				if (connection.req.labels) {
-					result.labels = connection.req.labels
-				}
-				if (contentInspector) {
-					contentInspector(result)
-				}
-				if (connection.statusCode >= 400) {
-					return callback('Status code ' + connection.statusCode, result);
-				}
-				if (result.customError) {
-					return callback('Custom error: ' + result.customError, result);
-				}
-				callback(null, result);
-			});
+	createResult(connection, body) {
+		if (!this.options.statusCallback && !this.options.contentInspector) {
+			return null
+		}
+		const client = connection.connection || connection.client
+		const result = {
+			host: client._host,
+			path: connection.req.path,
+			method: connection.req.method,
+			statusCode: connection.statusCode,
+			body,
+			headers: connection.headers,
 		};
+		if (connection.req.labels) {
+			result.labels = connection.req.labels
+		}
+		return result
 	}
 }
 

package/lib/latency.js

@@ -1,4 +1,4 @@
-import * as crypto from 'crypto'
+import {randomUUID} from 'crypto'
 import {Result} from './result.js'
 
 
@@ -13,7 +13,7 @@ export class Latency {
 	constructor(options, callback) {
 		this.options = options
 		this.callback = callback
-		this.requests = {};
+		this.requests = new Map();
 		this.partialRequests = 0;
 		this.partialTime = 0;
 		this.partialErrors = 0;
@@ -28,25 +28,14 @@ export class Latency {
 		this.errorCodes = {};
 		this.running = true;
 		this.totalsShown = false;
-		this.requestIndex = 0;
-		this.requestIdToIndex = {};
-	}
-
-	/**
-	 * Return the index of the request. This is useful for determining the order
-	 * in which requests returned values.
-	 */
-	getRequestIndex(requestId) {
-		return this.requestIdToIndex[requestId];
 	}
 
 	/**
 	 * Start the request with the given id.
 	 */
 	start(requestId) {
-		requestId = requestId || createId();
-		this.requests[requestId] = this.getTimeNs();
-		this.requestIdToIndex[requestId] = this.requestIndex++;
+		requestId = requestId || randomUUID();
+		this.requests.set(requestId, this.getTimeNs())
 		return requestId;
 	}
 
@@ -55,15 +44,15 @@ export class Latency {
 	 * Accepts an optional error code signaling an error.
 	 */
 	end(requestId, errorCode) {
-		if (!(requestId in this.requests)) {
+		if (!this.requests.has(requestId)) {
 			return -2;
 		}
 		if (!this.running) {
 			return -1;
 		}
-		const elapsed = this.getElapsedMs(this.requests[requestId]);
+		const elapsed = this.getElapsedMs(this.requests.get(requestId));
 		this.add(elapsed, errorCode);
-		delete this.requests[requestId];
+		this.requests.delete(requestId);
 		return elapsed;
 	}
 
@@ -77,7 +66,7 @@ export class Latency {
 		this.totalTime += time;
 		this.totalRequests++;
 		if (errorCode) {
-			errorCode = '' + errorCode;
+			errorCode = String(errorCode);
 			this.partialErrors++;
 			this.totalErrors++;
 			if (!(errorCode in this.errorCodes)) {
@@ -111,15 +100,12 @@ export class Latency {
 			meanLatencyMs: Math.round(meanTime * 10) / 10,
 			rps: Math.round(this.partialRequests / elapsedSeconds)
 		};
-		let percent = '';
-		if (this.options.maxRequests) {
-			percent = ' (' + Math.round(100 * this.totalRequests / this.options.maxRequests) + '%)';
-		}
+		const requestPercent = this.getRequestPercent()
 		if (!this.options.quiet) {
-			console.info('Requests: %s%s, requests per second: %s, mean latency: %s ms', this.totalRequests, percent, result.rps, result.meanLatencyMs);
+			console.info(`Requests: ${this.totalRequests}${requestPercent}, requests per second: ${result.rps}, mean latency: ${result.meanLatencyMs} ms`)
 			if (this.totalErrors) {
-				percent = Math.round(100 * 10 * this.totalErrors / this.totalRequests) / 10;
-				console.info('Errors: %s, accumulated errors: %s, %s% of total requests', this.partialErrors, this.totalErrors, percent);
+				const errorPercent = Math.round(100 * 10 * this.totalErrors / this.totalRequests) / 10;
+				console.info(`Errors: ${this.partialErrors}, accumulated errors: ${this.totalErrors}, ${errorPercent}% of total requests`)
 			}
 		}
 		this.partialTime = 0;
@@ -128,6 +114,13 @@ export class Latency {
 		this.lastShownNs = this.getTimeNs();
 	}
 
+	getRequestPercent() {
+		if (!this.options.maxRequests) {
+			return ''
+		}
+		return ` (${Math.round(100 * this.totalRequests / this.options.maxRequests)}%)`
+	}
+
 	/**
 	 * Returns the current high-resolution real time in nanoseconds as a big int.
 	 * @return {*}
@@ -194,12 +187,3 @@ export class Latency {
 	}
 }
 
-/**
- * Create a unique, random token.
- */
-function createId() {
-	const value = '' + Date.now() + Math.random();
-	const hash = crypto.createHash('sha256');
-	return hash.update(value).digest('hex').toLowerCase();
-}
-

package/lib/loadtest.js

@@ -16,24 +16,25 @@ https.globalAgent.maxSockets = 1000;
  * Run a load test.
  * Parameters:
  * - `options`: an object which may have:
- *	 - url [string]: URL to access (mandatory).
- *	 - concurrency [number]: how many concurrent clients to use.
- *	 - maxRequests [number]: how many requests to send
- *	 - maxSeconds [number]: how long to run the tests.
- *	 - cookies [array]: a string or an array of strings, each with name:value.
- *	 - headers [map]: a map with headers: {key1: value1, key2: value2}.
- *	 - method [string]: the method to use: POST, PUT. Default: GET, what else.
- *	 - data [string]: the contents to send along a POST or PUT request.
- *	 - contentType [string]: the MIME type to use for the body, default text/plain.
- *	 - requestsPerSecond [number]: how many requests per second to send.
+ *	 - url: URL to access (mandatory).
+ *	 - concurrency: how many concurrent clients to use.
+ *	 - maxRequests: how many requests to send
+ *	 - maxSeconds: how long to run the tests.
+ *	 - cookies: a string or an array of strings, each with name:value.
+ *	 - headers: a map with headers: {key1: value1, key2: value2}.
+ *	 - method: the method to use: POST, PUT. Default: GET, what else.
+ *	 - data: the contents to send along a POST or PUT request.
+ *	 - contentType: the MIME type to use for the body, default text/plain.
+ *	 - requestsPerSecond: how many requests per second to send.
  *	 - agentKeepAlive: if true, then use connection keep-alive.
- *	 - indexParam [string]: string to replace with a unique index.
+ *	 - indexParam: string to replace with a unique index.
  *	 - insecure: allow https using self-signed certs.
- *	 - secureProtocol [string]: TLS/SSL secure protocol method to use.
- *	 - proxy [string]: use a proxy for requests e.g. http://localhost:8080.
+ *	 - secureProtocol: TLS/SSL secure protocol method to use.
+ *	 - proxy: use a proxy for requests e.g. http://localhost:8080.
  *	 - quiet: do not log any messages.
  *	 - debug: show debug messages (deprecated).
- *	 - requestGenerator [function]: use a custom function to generate requests.
+ *	 - requestGenerator: use a custom function to generate requests.
+ *	 - statusCallback: function called after every request.
  * - `callback`: optional `function(result, error)` called if/when the test finishes;
  * if not present a promise is returned.
  */
@@ -46,12 +47,12 @@ export function loadTest(options, callback) {
 
 async function loadTestAsync(options) {
 	const processed = await processOptions(options)
-	return await runOperation(processed)
+	return await runLoadTest(processed)
 }
 
-function runOperation(options) {
+function runLoadTest(options) {
 	return new Promise((resolve, reject) => {
-		const operation = new Operation(options, (error, result) => {
+		const operation = new LoadTest(options, (error, result) => {
 			if (error) {
 				return reject(error)
 			}
@@ -62,14 +63,14 @@ function runOperation(options) {
 }
 
 /**
- * Used to keep track of individual load test Operation runs.
+ * Used to keep track of individual load test runs.
  */
 let operationInstanceIndex = 0;
 
 /**
  * A load test operation.
  */
-class Operation {
+class LoadTest {
 	constructor(options, callback) {
 		this.options = options;
 		this.finalCallback = callback;
@@ -81,6 +82,7 @@ class Operation {
 		this.showTimer = null;
 		this.stopTimeout = null;
 		this.instanceIndex = operationInstanceIndex++;
+		this.requestIndex = 0
 	}
 
 	/**
@@ -97,20 +99,22 @@ class Operation {
 	}
 
 	/**
-	 * Call after each operation has finished.
+	 * Call after each request has finished.
 	 */
-	callback(error, result, next) {
+	finishRequest(error, result, next) {
 		this.completedRequests += 1;
 		if (this.options.maxRequests) {
 			if (this.completedRequests == this.options.maxRequests) {
 				this.stop();
 			}
 		}
-		if (this.running && next) {
+		if (this.running && !this.requestsPerSecond) {
 			next();
 		}
 		if (this.options.statusCallback) {
-			this.options.statusCallback(error, result, this.latency.getResult());
+			result.requestIndex = this.requestIndex++
+			result.instanceIndex = this.instanceIndex
+			this.options.statusCallback(error, result);
 		}
 	}
 

package/lib/options.js

@@ -45,6 +45,7 @@ class Options {
 		this.recover = options.recover || configuration.recover
 		this.proxy = options.proxy || configuration.proxy
 		this.quiet = options.quiet || configuration.quiet
+		this.statusCallback = options.statusCallback
 	}
 
 	getUrl(options) {

package/lib/testserver.js

@@ -103,9 +103,9 @@ class TestServer {
 	 */
 	listen(request, response) {
 		const id = this.latency.start();
-		request.body = '';
+		const bodyBuffers = []
 		request.on('data', data => {
-			request.body += data.toString();
+			bodyBuffers.push(data)
 		});
 		request.on('error', () => {
 			// ignore request
@@ -113,6 +113,7 @@ class TestServer {
 			this.latency.end(id, -1);
 		})
 		request.on('end', () => {
+			request.body = Buffer.concat(bodyBuffers).toString();
 			this.totalRequests += 1
 			const elapsedMs = Date.now() - this.debuggedTime
 			if (elapsedMs > LOG_HEADERS_INTERVAL_MS) {