loadtest 7.1.1 → 8.0.1

package/lib/pool.js

@@ -0,0 +1,106 @@
+import {HttpClient} from './httpClient.js'
+import {TcpClient} from './tcpClient.js'
+import {WebsocketClient} from './websocket.js'
+import {HighResolutionTimer} from './hrtimer.js'
+
+/**
+ * Used to keep track of individual load test runs.
+ */
+let instanceIndex = 0;
+
+
+/**
+ * A pool of clients.
+ */
+export class Pool {
+	constructor(loadTest) {
+		this.loadTest = loadTest
+		this.options = loadTest.options
+		this.clients = [];
+		this.freeClients = []
+		this.requestTimer = null
+		this.instanceIndex = instanceIndex++
+		this.requestIndex = 0
+	}
+
+	/**
+	 * Start a number of measuring clients.
+	 */
+	start() {
+		if (this.options.requestsPerSecond) {
+			const interval = 1000 / this.options.requestsPerSecond;
+			this.requestTimer = new HighResolutionTimer(interval, () => this.makeRequest());
+			return
+		}
+		for (let index = 0; index < this.options.concurrency; index++) {
+			const client = this.addClient();
+			client.start();
+		}
+	}
+
+	addClient() {
+		const client = this.createClient();
+		this.clients.push(client)
+		this.freeClients.push(client)
+		return client
+	}
+
+	createClient() {
+		// TODO: || this.options.url.startsWith('wss:'))
+		if (this.options.url.startsWith('ws:')) {
+			return new WebsocketClient(this.loadTest)
+		}
+		if (this.options.tcp) {
+			return new TcpClient(this.loadTest)
+		}
+		return new HttpClient(this.loadTest);
+	}
+
+	makeRequest() {
+		if (!this.loadTest.running) {
+			return
+		}
+		if (!this.freeClients.length) {
+			this.addClient()
+		}
+		const client = this.freeClients.shift()
+		client.makeRequest()
+	}
+
+	/**
+	 * Call after each request has finished.
+	 */
+	finishRequest(client, result, error) {
+		if (this.options.statusCallback) {
+			result.requestIndex = this.requestIndex++
+			result.instanceIndex = this.loadTest.instanceIndex
+			this.options.statusCallback(error, result);
+		}
+		if (this.loadTest.checkStop()) {
+			return
+		}
+		if (!this.loadTest.latency.shouldSend()) {
+			if (this.requestTimer) {
+				this.requestTimer.stop()
+			}
+		}
+		if (!this.options.requestsPerSecond) {
+			client.makeRequest()
+		} else {
+			this.freeClients.push(client)
+		}
+	}
+
+	/**
+	 * Stop clients.
+	 */
+	stop() {
+		if (this.requestTimer) {
+			this.requestTimer.stop()
+		}
+		for (const client of this.clients) {
+			client.stop();
+		}
+	}
+}
+

package/lib/result.js

@@ -11,9 +11,10 @@ export class Result {
 		this.maxSeconds = 0
 		this.concurrency = 0
 		this.agent = null
-		this.requestsPerSecond = 0
+		this.requestsPerSecond = null
+		this.clients = 0
 		this.startTimeMs = Number.MAX_SAFE_INTEGER
-		this.endTimeMs = 0
+		this.stopTimeMs = 0
 		this.elapsedSeconds = 0
 		this.totalRequests = 0
 		this.totalErrors = 0
@@ -25,18 +26,24 @@ export class Result {
 		this.histogramMs = {}
 	}
 
-	compute(options, latency) {
-		// configuration
+	compute(latency) {
+		const options = latency.options
 		this.url = options.url
 		this.cores = options.cores
 		this.maxRequests = parseInt(options.maxRequests)
 		this.maxSeconds = parseInt(options.maxSeconds)
 		this.concurrency = parseInt(options.concurrency)
-		this.agent = options.agentKeepAlive ? 'keepalive' : 'none';
+		this.clients = latency.clients
+		if (options.tcp) {
+			this.agent = 'tcp'
+		} else if (options.agentKeepAlive) {
+			this.agent = 'keepalive'
+		} else {
+			this.agent = 'none'
+		}
 		this.requestsPerSecond = parseInt(options.requestsPerSecond)
-		// result
 		this.startTimeMs = Number(latency.startTimeNs / 1000000n)
-		this.endTimeMs = Number(latency.endTimeNs / 1000000n)
+		this.stopTimeMs = Number(latency.stopTimeNs / 1000000n)
 		this.totalRequests = latency.totalRequests
 		this.totalErrors = latency.totalErrors
 		this.accumulatedMs = latency.totalTime
@@ -48,7 +55,7 @@ export class Result {
 	}
 
 	computeDerived() {
-		this.elapsedSeconds = (this.endTimeMs - this.startTimeMs) / 1000
+		this.elapsedSeconds = (this.stopTimeMs - this.startTimeMs) / 1000
 		this.totalTimeSeconds = this.elapsedSeconds // backwards compatibility
 		const meanTime = this.accumulatedMs / this.totalRequests
 		this.meanLatencyMs = Math.round(meanTime * 10) / 10
@@ -90,9 +97,10 @@ export class Result {
 		this.concurrency = this.concurrency || result.concurrency
 		this.agent = this.agent || result.agent
 		this.requestsPerSecond += result.requestsPerSecond || 0
+		this.clients += result.clients
 		// result
 		this.startTimeMs = Math.min(this.startTimeMs, result.startTimeMs)
-		this.endTimeMs = Math.max(this.endTimeMs, result.endTimeMs)
+		this.stopTimeMs = Math.max(this.stopTimeMs, result.stopTimeMs)
 		this.totalRequests += result.totalRequests
 		this.totalErrors += result.totalErrors
 		this.accumulatedMs += result.accumulatedMs
@@ -125,14 +133,14 @@ export class Result {
 		} else if (this.maxSeconds) {
 			console.info('Max time (s):        %s', this.maxSeconds);
 		}
-		console.info('Concurrency level:   %s', this.concurrency);
+		if (this.requestsPerSecond) {
+			console.info('Target rps:          %s', this.requestsPerSecond);
+		}
+		console.info('Concurrent clients:  %s', this.clients)
 		if (this.cores) {
 			console.info('Running on cores:    %s', this.cores);
 		}
 		console.info('Agent:               %s', this.agent);
-		if (this.requestsPerSecond) {
-			console.info('Target rps:          %s', this.requestsPerSecond);
-		}
 		console.info('');
 		console.info('Completed requests:  %s', this.totalRequests);
 		console.info('Total errors:        %s', this.totalErrors);
@@ -140,7 +148,7 @@ export class Result {
 		console.info('Mean latency:        %s ms', this.meanLatencyMs);
 		console.info('Effective rps:       %s', this.effectiveRps);
 		console.info('');
-		console.info('Percentage of the requests served within a certain time');
+		console.info('Percentage of requests served within a certain time');
 
 		Object.keys(this.percentiles).forEach(percentile => {
 			console.info('  %s%      %s ms', percentile, this.percentiles[percentile]);

package/lib/tcpClient.js

@@ -0,0 +1,198 @@
+import * as urlLib from 'url'
+import * as net from 'net'
+import * as querystring from 'querystring'
+import {addUserAgent} from './headers.js'
+import {Parser} from './parser.js'
+
+const forbiddenOptions = [
+	'indexParam', 'statusCallback', 'requestGenerator'
+]
+
+
+/**
+ * A client for an HTTP connection, using TCP sockets. Constructor:
+ *	- `loadTest`: an object with the following attributes:
+ *		- `latency`: a variable to measure latency.
+ *		- `options`: same options as exports.loadTest.
+ *		- `running`: if the loadTest is running or not.
+ */
+export class TcpClient {
+	constructor(loadTest) {
+		this.loadTest = loadTest
+		this.latency = loadTest.latency
+		this.options = loadTest.options
+		this.running = true
+		this.connection = null
+		this.currentId = null
+		this.init();
+	}
+
+	/**
+	 * Init params and message to send.
+	 */
+	init() {
+		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.params.agent = false;
+		this.params.method = this.options.method || 'GET';
+		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.options.cookies)}, please use an array or a string`);
+			}
+		}
+		addUserAgent(this.params.headers);
+		this.params.headers.Connection = 'keep-alive'
+		this.params.request = this.createRequest()
+		for (const option of forbiddenOptions) {
+			if (this.options[option]) {
+				throw new Error(`${option} not supported with TCP sockets`)
+			}
+		}
+	}
+
+	createRequest() {
+		const body = this.generateBody()
+		if (body?.length) {
+			this.params.headers['Content-Type'] = this.options.contentType || 'text/plain';
+			this.params.headers['Content-Length'] = Buffer.byteLength(body)
+		}
+		const lines = [`${this.params.method} ${this.params.path} HTTP/1.1`]
+		for (const header in this.params.headers) {
+			const value = this.params.headers[header]
+			const line = `${header}: ${value}`
+			lines.push(line)
+		}
+		lines.push(`\r\n`)
+		const text = lines.join('\r\n')
+		return Buffer.from(text)
+	}
+
+	generateBody() {
+		if (!this.options.body) {
+			return ''
+		}
+		if (typeof this.options.body == 'string') {
+			return this.options.body
+		} else if (typeof this.options.body == 'object') {
+			if (this.options.contentType === 'application/x-www-form-urlencoded') {
+				return querystring.stringify(this.options.body);
+			}
+			return JSON.stringify(this.options.body)
+		} else {
+			throw new Error(`Unrecognized body: ${typeof this.options.body}`);
+		}
+	}
+
+	/**
+	 * Start the HTTP client.
+	 */
+	start() {
+		if (!this.options.requestsPerSecond) {
+			return this.makeRequest();
+		}
+	}
+
+	/**
+	 * Stop the HTTP client.
+	 */
+	stop() {
+		this.running = false
+		if (this.connection) {
+			this.connection.end()
+		}
+	}
+
+	/**
+	 * Make a single request to the server.
+	 */
+	makeRequest() {
+		if (!this.running) {
+			return
+		}
+		this.connect()
+		this.parser = new Parser(this.params.method)
+		const id = this.latency.begin();
+		this.currentId = id
+		this.connection.write(this.params.request)
+	}
+
+	connect() {
+		if (this.connection && !this.connection.destroyed) {
+			return
+		}
+		this.connection = net.connect(this.params.port, this.params.hostname)
+		this.connection.on('data', data => {
+			this.parser.addPacket(data)
+			if (this.parser.finished) {
+				this.finishRequest(null);
+			}
+		});
+		this.connection.on('error', error => {
+			this.finishRequest(`Connection ${this.currentId} failed: ${error}`);
+			this.connection = null
+		});
+		this.connection.on('end', () => {
+			this.connection = null
+			if (this.parser) {
+				// connection waiting for a response; remake
+				this.makeRequest()
+			}
+		})
+	}
+
+	finishRequest(error) {
+		// reset parser for next request
+		const parser = this.parser
+		this.parser = null
+		if (!this.running) {
+			return
+		}
+		let errorCode = null;
+		if (parser.statusCode >= 400) {
+			errorCode = parser.statusCode
+		}
+		if (error) {
+			// console.error(error)
+			errorCode = '-1';
+		}
+		const elapsed = this.latency.end(this.currentId, errorCode);
+		if (elapsed < 0) {
+			// not found or not running
+			return;
+		}
+		if (this.options.maxRequests && this.latency.totalRequests >= this.options.maxRequests) {
+			this.loadTest.stop()
+			return;
+
+		}
+		this.makeRequest()
+	}
+
+	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/testserver.js

@@ -3,6 +3,7 @@ import {server as WebSocketServer} from 'websocket'
 import * as util from 'util'
 import * as net from 'net'
 import {Latency} from './latency.js'
+import {readFileSync} from 'fs'
 
 const PORT = 7357;
 const LOG_HEADERS_INTERVAL_MS = 5000;
@@ -17,6 +18,8 @@ const LOG_HEADERS_INTERVAL_MS = 5000;
  *	 - percent: give an error (default 500) on some % of requests.
  *	 - error: set an HTTP error code, default is 500.
  *	 - logger: function to log all incoming requests.
+ *	 - body: to return in requests.
+ *	 - file: to read and return as body.
  * - `callback`: optional callback, called after the server has started.
  *   If not present will return a promise.
  */
@@ -44,7 +47,12 @@ class TestServer {
 		this.wsServer = null;
 		this.latency = new Latency({});
 		this.totalRequests = 0
+		this.partialRequests = 0
 		this.debuggedTime = Date.now();
+		this.body = options.body || 'OK'
+		if (options.file) {
+			this.body = readFileSync(options.file)
+		}
 	}
 
 	/**
@@ -52,7 +60,7 @@ class TestServer {
 	 * The callback parameter will be called after the server has started.
 	 */
 	start(callback) {
-		if (this.options.socket) {
+		if (this.options.tcp) {
 			// just for internal debugging
 			this.server = net.createServer(() => this.socketListen());
 		} else {
@@ -72,7 +80,7 @@ class TestServer {
 		});
 		this.server.listen(this.port, () => {
 			if (!this.options.quiet) console.info(`Listening on http://localhost:${this.port}/`)
-			callback(null, this.server)
+			callback(null, this)
 		});
 		this.wsServer.on('request', request => {
 			// explicity omitting origin check here.
@@ -88,7 +96,7 @@ class TestServer {
 				if (!this.options.quiet) console.info('Peer %s disconnected', connection.remoteAddress);
 			});
 		});
-		return this.server
+		return this
 	}
 
 	/**
@@ -102,7 +110,7 @@ class TestServer {
 	 * Listen to an incoming request.
 	 */
 	listen(request, response) {
-		const id = this.latency.start();
+		const id = this.latency.begin();
 		const bodyBuffers = []
 		request.on('data', data => {
 			bodyBuffers.push(data)
@@ -114,6 +122,7 @@ class TestServer {
 		})
 		request.on('end', () => {
 			request.body = Buffer.concat(bodyBuffers).toString();
+			this.partialRequests += 1
 			this.totalRequests += 1
 			const elapsedMs = Date.now() - this.debuggedTime
 			if (elapsedMs > LOG_HEADERS_INTERVAL_MS) {
@@ -154,7 +163,7 @@ class TestServer {
 		const headers = util.inspect(request.headers)
 		const now = Date.now()
 		const elapsedMs = now - this.debuggedTime
-		const rps = (this.totalRequests / elapsedMs) * 1000
+		const rps = (this.partialRequests / elapsedMs) * 1000
 		if (rps > 1) {
 			console.info(`Requests per second: ${rps.toFixed(0)}`)
 		}
@@ -163,7 +172,7 @@ class TestServer {
 			console.info(`Body: ${request.body}`);
 		}
 		this.debuggedTime = now;
-		this.totalRequests = 0
+		this.partialRequests = 0
 	}
 
 	/**
@@ -175,7 +184,7 @@ class TestServer {
 			response.writeHead(code);
 			response.end('ERROR');
 		} else {
-			response.end('OK');
+			response.end(this.body);
 		}
 		this.latency.end(id);
 		if (this.options.logger) {
@@ -197,5 +206,13 @@ class TestServer {
 		}
 		return (Math.random() < percent / 100);
 	}
+
+	close(callback) {
+		if (callback) {
+			this.server.close(callback)
+			return
+		}
+		return this.server.close()
+	}
 }
 

package/lib/websocket.js

@@ -4,19 +4,13 @@ import {BaseClient} from './baseClient.js'
 let latency;
 
 
-/**
- * Create a client for a websocket.
- */
-export function create(loadTest, options) {
-	return new WebsocketClient(loadTest, options);
-}
-
 /**
  * A client that connects to a websocket.
  */
-class WebsocketClient extends BaseClient {
-	constructor(loadTest, options) {
-		super(loadTest, options);
+export class WebsocketClient extends BaseClient {
+	constructor(loadTest) {
+		super(loadTest);
+		this.latency = loadTest.latency
 		this.connection = null;
 		this.lastCall = null;
 		this.client = null;
@@ -55,7 +49,7 @@ class WebsocketClient extends BaseClient {
 	 * Make a single request to the server.
 	 */
 	makeRequest() {
-		const id = this.loadTest.latency.start();
+		const id = this.latency.begin();
 		const requestFinished = this.getRequestFinisher(id);
 
 		if (this.connection.connected) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "loadtest",
-	"version": "7.1.1",
+	"version": "8.0.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",
@@ -24,7 +24,8 @@
 	},
 	"devDependencies": {
 		"eslint": "^8.47.0",
-		"microprofiler": "^2.0.0"
+		"microprofiler": "^2.0.0",
+		"why-is-node-running": "^2.2.2"
 	},
 	"keywords": [
 		"testing",

package/test/all.js

@@ -15,6 +15,8 @@ import {test as testLoadtest} from './loadtest.js'
 import {test as testWebsocket} from './websocket.js'
 import {test as integrationTest} from './integration.js'
 import {test as testResult} from './result.js'
+import {test as testTcpClient} from './tcpClient.js'
+//import log from 'why-is-node-running'
 
 
 /**
@@ -25,10 +27,13 @@ function test() {
 		testHrtimer, testHeaders, testLatency, testHttpClient,
 		testServer, integrationTest, testLoadtest, testWebsocket,
 		testRequestGenerator, testBodyGenerator, testResult,
+		testTcpClient,
 	];
 	testing.run(tests, 4200);
 }
 
+//setTimeout(log, 4000)
+
 test()
 
 

package/test/body-generator.js

@@ -2,16 +2,16 @@ import testing from 'testing'
 import {loadTest} from '../lib/loadtest.js'
 import {startServer} from '../lib/testserver.js'
 
-const PORT = 10453;
+const port = 10453;
 
 
 function testBodyGenerator(callback) {
-	const server = startServer({port: PORT, quiet: true}, error => {
+	const server = startServer({port, quiet: true}, error => {
 		if (error) {
 			return callback('Could not start test server');
 		}
 		const options = {
-			url: 'http://localhost:' + PORT,
+			url: `http://localhost:${port}`,
 			requestsPerSecond: 1000,
 			maxRequests: 100,
 			concurrency: 10,

package/test/httpClient.js

@@ -1,14 +1,14 @@
 import testing from 'testing'
-import {create} from '../lib/httpClient.js'
+import {HttpClient} from '../lib/httpClient.js'
 
 
 function testHttpClient(callback) {
 	const options = {
-		url: 'http://localhost:7357/',
+		url: 'http://localhost:7358/',
 		maxSeconds: 0.1,
 		concurrency: 1,
 	};
-	create({}, options);
+	new HttpClient({options});
 	testing.success(callback);
 }