loadtest 7.0.0 → 7.1.1

package/.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: alexfernandez
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/README.md

@@ -28,8 +28,9 @@ Versions 6 and later should be used at least with Node.js v16 or later:
 
 * Node.js v16 or later: ^6.0.0
 * Node.js v10 or later: ^5.0.0
-* Node.js v8 or later: 4.x.y.
-* Node.js v6 or earlier: ^3.1.0.
+* Node.js v8 or later: 4.x.y
+* Node.js v6 or earlier: ^3.1.0
+* ES5 support (no `let`, `const` or arrow functions): ^2.0.0.
 
 ## Usage
 
@@ -84,14 +85,18 @@ so that you can abort deployment e.g. if 99% of the requests don't finish in 10
 but it is still limited.
 `loadtest` saturates a single CPU pretty quickly,
 so it uses half the available cores in your processor.
-If you see that the Node.js processes are above 100% usage in `top`,
-which happens approx. when your load is above 4000~5000 rps per core,
-please adjust the number of cores.
+The Node.js processes can reach 100% usage in `top`,
+which happens approx. when your load is above 4000~7000 rps per core.
+In this case please adjust the number of cores.
 So for instance with eight cores you can expect to get a maximum performance of
-8 * 5000 ~ 40 krps.
-(You can measure the practical limits of `loadtest` on your specific test machines by running it against a simple
+8 * 5000 = 40 krps.
+
+You can measure the practical limits of `loadtest` on your specific test machines by running it against a simple
 [test server](#test-server)
-and seeing when it reaches 100% CPU.)
+and seeing when it reaches 100% CPU. Run the following commands on two different consoles:
+
+    $ node bin/testserver.js
+    $ node bin/loadtest.js -n 1000000 -c 100 http://localhost:7357/
 
 If you have reached the limits of `loadtest` even after using all cores,
 there are other tools that you can try.
@@ -99,7 +104,7 @@ there are other tools that you can try.
 * [AutoCannon](https://www.npmjs.com/package/autocannon): also an `npm` package,
 awesome tool with an interface similar to `wrk`.
 * [Apache `ab`](http://httpd.apache.org/docs/2.2/programs/ab.html)
-has great performance, but it is also limited by a single CPU performance.
+has great performance, but it is limited by a single CPU performance.
 Its practical limit is somewhere around ~40 krps.
 * [weighttp](http://redmine.lighttpd.net/projects/weighttp/wiki) is also `ab`-compatible
 and is supposed to be very fast (the author has not personally used it).
@@ -557,15 +562,14 @@ const server = await startServer({port: 8000})
 await server.close()
 ```
 
-The following options are available:
+The following options are available,
+see [doc/api.md](doc/api.md) for details.
+
 * `port`: optional port to use for the server, default 7357.
 * `delay`: milliseconds to wait before answering each request.
 * `error`: HTTP status code to return, default 200 (no error).
 * `percent`: return error only for the given % of requests.
-* `logger(request, response)`
-
-A function to be called as `logger(request, response)` after every request served by the test server.
-Where `request` and `response` are the usual HTTP objects.
+* `logger(request, response)`: function to call after every request.
 
 ### Configuration file
 
@@ -611,14 +615,8 @@ For more information about the actual configuration file name, read the [confino
 
 ### Complete Example
 
-The file `test/integration.js` shows a complete example, which is also a full integration test:
-it starts the server, send 1000 requests, waits for the callback and closes down the server.
-
-## Versioning
-
-Version 3.x uses ES2015 (ES6) features,
-such as `const` or `let` and arrow functions.
-For ES5 support please use versions 2.x.
+The file `test/integration.js` contains complete examples, which are also a full integration test suite:
+they start the server with different options, send requests, waits for finalization and close down the server.
 
 ## Licensed under The MIT License
 

package/lib/baseClient.js

@@ -3,9 +3,9 @@ import {addUserAgent} from './headers.js'
 
 
 export class BaseClient {
-	constructor(operation, params) {
-		this.operation = operation;
-		this.params = params;
+	constructor(loadTest, options) {
+		this.loadTest = loadTest;
+		this.options = options;
 		this.generateMessage = undefined;
 	}
 
@@ -22,44 +22,44 @@ export class BaseClient {
 					errorCode = '-1';
 				}
 			}
-			this.operation.latency.end(id, errorCode);
+			this.loadTest.latency.end(id, errorCode);
 			let callback;
-			if (!this.params.requestsPerSecond) {
+			if (!this.options.requestsPerSecond) {
 				callback = () => this.makeRequest();
 			}
-			this.operation.callback(error, result, callback);
+			this.loadTest.finishRequest(error, result, callback);
 		};
 	}
 
 	/**
-	 * Init options and message to send.
+	 * Init params and message to send.
 	 */
 	init() {
-		this.options = urlLib.parse(this.params.url);
-		this.options.headers = {};
-		if (this.params.headers) {
-			this.options.headers = this.params.headers;
+		this.params = urlLib.parse(this.options.url);
+		this.params.headers = {};
+		if (this.options.headers) {
+			this.params.headers = this.options.headers;
 		}
-		if (this.params.cert && this.params.key) {
-			this.options.cert = this.params.cert;
-			this.options.key = this.params.key;
+		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.body) {
-			if (typeof this.params.body == 'string') {
-				this.generateMessage = () => this.params.body;
-			} else if (typeof this.params.body == 'object') {
-				this.generateMessage = () => this.params.body;
-			} else if (typeof this.params.body == 'function') {
-				this.generateMessage = this.params.body;
+		this.params.agent = false;
+		if (this.options.body) {
+			if (typeof this.options.body == 'string') {
+				this.generateMessage = () => this.options.body;
+			} else if (typeof this.options.body == 'object') {
+				this.generateMessage = () => this.options.body;
+			} else if (typeof this.options.body == 'function') {
+				this.generateMessage = this.options.body;
 			} else {
-				console.error('Unrecognized body: %s', typeof this.params.body);
+				console.error('Unrecognized body: %s', typeof this.options.body);
 			}
-			this.options.headers['Content-Type'] = this.params.contentType || 'text/plain';
+			this.params.headers['Content-Type'] = this.options.contentType || 'text/plain';
 		}
-		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;
 		}
 	}
 }

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

@@ -47,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)
 			}
@@ -63,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;
@@ -82,6 +82,7 @@ class Operation {
 		this.showTimer = null;
 		this.stopTimeout = null;
 		this.instanceIndex = operationInstanceIndex++;
+		this.requestIndex = 0
 	}
 
 	/**
@@ -98,19 +99,21 @@ 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.options.requestsPerSecond) {
 			next();
 		}
 		if (this.options.statusCallback) {
+			result.requestIndex = this.requestIndex++
+			result.instanceIndex = this.instanceIndex
 			this.options.statusCallback(error, result);
 		}
 	}

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) {

package/lib/websocket.js

@@ -7,16 +7,16 @@ let latency;
 /**
  * Create a client for a websocket.
  */
-export function create(operation, params) {
-	return new WebsocketClient(operation, params);
+export function create(loadTest, options) {
+	return new WebsocketClient(loadTest, options);
 }
 
 /**
  * A client that connects to a websocket.
  */
 class WebsocketClient extends BaseClient {
-	constructor(operation, params) {
-		super(operation, params);
+	constructor(loadTest, options) {
+		super(loadTest, options);
 		this.connection = null;
 		this.lastCall = null;
 		this.client = null;
@@ -30,7 +30,7 @@ class WebsocketClient extends BaseClient {
 		this.client = new websocket.client();
 		this.client.on('connectFailed', () => {});
 		this.client.on('connect', connection => this.connect(connection));
-		this.client.connect(this.params.url, []);
+		this.client.connect(this.options.url, []);
 	}
 
 	/**
@@ -55,7 +55,7 @@ class WebsocketClient extends BaseClient {
 	 * Make a single request to the server.
 	 */
 	makeRequest() {
-		const id = this.operation.latency.start();
+		const id = this.loadTest.latency.start();
 		const requestFinished = this.getRequestFinisher(id);
 
 		if (this.connection.connected) {
@@ -115,7 +115,7 @@ class WebsocketClient extends BaseClient {
 			if (this.generateMessage) {
 				message = this.generateMessage(id);
 			}
-			if (typeof this.params.requestGenerator == 'function') {
+			if (typeof this.options.requestGenerator == 'function') {
 				// create a 'fake' object which can function like the http client
 				const req = () => {
 					return {
@@ -124,7 +124,7 @@ class WebsocketClient extends BaseClient {
 						}
 					};
 				};
-				this.params.requestGenerator(this.params, this.options, req, requestFinished);
+				this.options.requestGenerator(this.options, this.params, req, requestFinished);
 			} else {
 				this.connection.sendUTF(JSON.stringify(message));
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "loadtest",
-	"version": "7.0.0",
+	"version": "7.1.1",
 	"type": "module",
 	"description": "Run load tests for your web application. Mostly ab-compatible interface, with an option to force requests per second. Includes an API for automated load testing.",
 	"homepage": "https://github.com/alexfernandez/loadtest",
@@ -23,7 +23,8 @@
 		"websocket": "^1.0.34"
 	},
 	"devDependencies": {
-		"eslint": "^8.47.0"
+		"eslint": "^8.47.0",
+		"microprofiler": "^2.0.0"
 	},
 	"keywords": [
 		"testing",