loadtest 5.1.2 → 6.0.0

package/lib/headers.js

@@ -1,18 +1,9 @@
-'use strict';
-
-/**
- * Support for custom headers.
- * (C) 2013 Alex Fernández.
- */
-
-// requires
-const testing = require('testing');
 
 
 /**
  * Add all raw headers given to the given array.
  */
-exports.addHeaders = function(rawHeaders, headers) {
+export function addHeaders(rawHeaders, headers) {
 	if (Array.isArray(rawHeaders)) {
 		rawHeaders.forEach(function(header) {
 			addHeader(header, headers);
@@ -22,7 +13,7 @@ exports.addHeaders = function(rawHeaders, headers) {
 	} else {
 		console.error('Invalid header structure %j, it should be an array');
 	}
-};
+}
 
 /**
  * Add a single header to an array.
@@ -37,64 +28,12 @@ function addHeader(rawHeader, headers) {
 	headers[key.toLowerCase()] = value;
 }
 
-function testAddHeaders(callback) {
-	const tests = [ {
-		raw: 'k:v',
-		headers: { 'k': 'v' }
-	}, {
-		raw: ['k:v', 'k:v2'],
-		headers:  { 'k': 'v2' }
-	}, {
-		raw: ['k:v', 'k2:v2'],
-		headers: { 'k': 'v', 'k2': 'v2' }
-	}, {
-		raw: 'K:v',
-		headers: { 'k': 'v' }
-	}, {
-		raw: 'k:v:w',
-		headers: { 'k': 'v:w' }
-	}
-	];
-	tests.forEach(function(test) {
-		const headers = {};
-		exports.addHeaders(test.raw, headers);
-		testing.assertEquals(headers, test.headers, 'Wrong headers', callback);
-	});
-	testing.success(callback);
-}
-
 /**
  * Add a user-agent header if not present.
  */
-exports.addUserAgent = function(headers) {
+export function addUserAgent(headers) {
 	if(!headers['user-agent']) {
 		headers['user-agent'] = 'node.js loadtest bot';
 	}
-};
-
-function testAddUserAgent(callback) {
-	const headers =  {'k': 'v', 'q': 'r' };
-	exports.addUserAgent(headers);
-	testing.assertEquals(Object.keys(headers).length, 3, 'Did not add user agent', callback);
-	const userAgent = headers['user-agent'];
-	testing.assert(userAgent.includes('bot'), 'Invalid user agent', callback);
-	exports.addUserAgent(headers);
-	testing.assertEquals(Object.keys(headers).length, 3, 'Should not add user agent', callback);
-	testing.success(callback);
-}
-
-/**
- * Run all tests.
- */
-exports.test = function(callback) {
-	testing.run([
-		testAddHeaders,
-		testAddUserAgent,
-	], callback);
-};
-
-// run tests if invoked directly
-if (__filename == process.argv[1]) {
-	exports.test(testing.show);
 }
 

package/lib/hrtimer.js

@@ -1,17 +1,3 @@
-'use strict';
-
-/**
- * Measure latency for a load test.
- * (C) 2013 Alex Fernández.
- */
-
-
-// requires
-const testing = require('testing');
-const Log = require('log');
-
-// globals
-const log = new Log('info');
 
 
 /**
@@ -19,7 +5,7 @@ const log = new Log('info');
  *	- delayMs: miliseconds to wait before calls. Can be fractional.
  *	- callback: function to call every time.
  */
-class HighResolutionTimer {
+export class HighResolutionTimer {
 
 	/**
 	 * Create a timer with the given delay.
@@ -58,7 +44,7 @@ class HighResolutionTimer {
 	traceDrift() {
 		const diff = Date.now() - this.start;
 		const drift = diff / this.delayMs - this.counter;
-		log.debug('Seconds: ' + Math.round(diff / 1000) + ', counter: ' + this.counter + ', drift: ' + drift);
+		console.debug('Seconds: ' + Math.round(diff / 1000) + ', counter: ' + this.counter + ', drift: ' + drift);
 	}
 
 	stop() {
@@ -77,42 +63,3 @@ class HighResolutionTimer {
 	}
 }
 
-/**
- * Test a high resolution timer.
- */
-function testTimerStop(callback) {
-	const timer = new HighResolutionTimer(10, callback);
-	setImmediate(() => timer.stop())
-}
-
-function testTimerRun(callback) {
-	let run = 0
-	const timer = new HighResolutionTimer(100, () => run++)
-	setTimeout(() => {
-		testing.equals(run, 3, callback)
-		timer.stop()
-		testing.success(callback)
-	}, 250)
-}
-
-/**
- * Run package tests.
- */
-function test(callback) {
-	const tests = [
-		testTimerStop,
-		testTimerRun,
-	];
-	testing.run(tests, callback);
-}
-
-module.exports = {
-	HighResolutionTimer,
-	test,
-}
-
-// run tests if invoked directly
-if (__filename == process.argv[1]) {
-	test(testing.show);
-}
-

package/lib/httpClient.js

@@ -1,33 +1,21 @@
-'use strict';
-
-/**
- * Load Test a URL, website or websocket.
- * (C) 2013 Alex Fernández.
- */
-
-
-// requires
-const testing = require('testing');
-const urlLib = require('url');
-const http = require('http');
-const https = require('https');
-const qs = require('querystring');
-const websocket = require('websocket');
-const Log = require('log');
-const {HighResolutionTimer} = require('./hrtimer.js');
-const headers = require('./headers.js');
-
-// globals
-const log = new Log('info');
+import * as urlLib from 'url'
+import * as http from 'http'
+import * as https from 'https'
+import * as querystring from 'querystring'
+import * as websocket from 'websocket'
+import {HighResolutionTimer} from './hrtimer.js'
+import {addUserAgent} from './headers.js'
+import * as agentkeepalive from 'agentkeepalive'
+import * as HttpsProxyAgent from 'https-proxy-agent'
 
 
 /**
  * Create a new HTTP client.
  * Seem parameters below.
  */
-exports.create = function(operation, params) {
+export function create(operation, params) {
 	return new HttpClient(operation, params);
-};
+}
 
 /**
  * A client for an HTTP connection.
@@ -58,7 +46,7 @@ class HttpClient {
 		}
 		this.options.agent = false;
 		if (this.params.agentKeepAlive) {
-			const KeepAlive = (this.options.protocol == 'https:') ? require('agentkeepalive').HttpsAgent : require('agentkeepalive');
+			const KeepAlive = (this.options.protocol == 'https:') ? agentkeepalive.HttpsAgent : agentkeepalive;
 			let maxSockets = 10;
 			if (this.params.requestsPerSecond) {
 				maxSockets += Math.floor(this.params.requestsPerSecond);
@@ -74,19 +62,16 @@ class HttpClient {
 		}
 		if (this.params.body) {
 			if (typeof this.params.body == 'string') {
-				log.debug('Received string body');
 				this.generateMessage = () => this.params.body;
 			} else if (typeof this.params.body == 'object') {
-				log.debug('Received JSON body');
 				if (this.params.contentType === 'application/x-www-form-urlencoded') {
-					this.params.body = qs.stringify(this.params.body);
+					this.params.body = querystring.stringify(this.params.body);
 				}
 				this.generateMessage = () => this.params.body;
 			} else if (typeof this.params.body == 'function') {
-				log.debug('Received function body');
 				this.generateMessage = this.params.body;
 			} else {
-				log.error('Unrecognized body: %s', typeof this.params.body);
+				console.error('Unrecognized body: %s', typeof this.params.body);
 			}
 			this.options.headers['Content-Type'] = this.params.contentType || 'text/plain';
 		}
@@ -99,11 +84,10 @@ class HttpClient {
 				console.error('Invalid cookies %j, please use an array or a string', this.params.cookies);
 			}
 		}
-		headers.addUserAgent(this.options.headers);
+		addUserAgent(this.options.headers);
 		if (this.params.secureProtocol) {
 			this.options.secureProtocol = this.params.secureProtocol;
 		}
-		log.debug('Options: %j', this.options);
 	}
 
 	/**
@@ -145,7 +129,6 @@ class HttpClient {
 		if (this.options.protocol == 'ws:') {
 			lib = websocket;
 		}
-		const HttpsProxyAgent = require('https-proxy-agent');
 
 		// adding proxy configuration
 		if (this.params.proxy) {
@@ -178,7 +161,7 @@ class HttpClient {
 		if (this.params.timeout) {
 			const timeout = parseInt(this.params.timeout);
 			if (!timeout) {
-				log.error('Invalid timeout %s', this.params.timeout);
+				console.error('Invalid timeout %s', this.params.timeout);
 			}
 			request.setTimeout(timeout, () => {
 				requestFinished('Connection timed out');
@@ -200,7 +183,6 @@ class HttpClient {
 		return (error, result) => {
 			let errorCode = null;
 			if (error) {
-				log.debug('Connection %s failed: %s', id, error);
 				if (result) {
 					errorCode = result.statusCode;
 					if (result.customErrorCode !== undefined) {
@@ -209,8 +191,6 @@ class HttpClient {
 				} else {
 					errorCode = '-1';
 				}
-			} else {
-				log.debug('Connection %s ended', id);
 			}
 
 			const elapsed = this.operation.latency.end(id, errorCode);
@@ -238,10 +218,8 @@ class HttpClient {
 	getConnect(id, callback, contentInspector) {
 		let body = '';
 		return connection => {
-			log.debug('HTTP client connected to %s with id %s', this.params.url, id);
 			connection.setEncoding('utf8');
 			connection.on('data', chunk => {
-				log.debug('Body: %s', chunk);
 				body += chunk;
 			});
 			connection.on('error', error => {
@@ -257,6 +235,9 @@ class HttpClient {
 					body: body,
 					headers: connection.headers,
 				};
+				if (connection.req.labels) {
+					result.labels = connection.req.labels
+				}
 				if (contentInspector) {
 					contentInspector(result)
 				}
@@ -272,29 +253,3 @@ class HttpClient {
 	}
 }
 
-function testHttpClient(callback) {
-	const options = {
-		url: 'http://localhost:7357/',
-		maxSeconds: 0.1,
-		concurrency: 1,
-		quiet: true,
-	};
-	exports.create({}, options);
-	testing.success(callback);
-}
-
-
-/**
- * Run all tests.
- */
-exports.test = function (callback) {
-	testing.run([
-		testHttpClient,
-	], callback);
-};
-
-// run tests if invoked directly
-if (__filename == process.argv[1]) {
-	exports.test(testing.show);
-}
-

package/lib/latency.js

@@ -1,30 +1,14 @@
-'use strict';
-
-/**
- * Measure latency for a load test.
- * (C) 2013 Alex Fernández.
- */
-
-
-// requires
-const testing = require('testing');
-const util = require('util');
-const crypto = require('crypto');
-const Log = require('log');
-
-// globals
-const log = new Log('info');
+import * as crypto from 'crypto'
 
 
 /**
  * Latency measurements. Options can be:
  *	- maxRequests: max number of requests to measure before stopping.
  *	- maxSeconds: max seconds, alternative to max requests.
- *	- quiet: do not log messages.
  * An optional callback(error, results) will be called with an error,
  * or the results after max is reached.
  */
-class Latency {
+export class Latency {
 	constructor(options, callback) {
 		this.options = options
 		this.callback = callback
@@ -45,12 +29,6 @@ class Latency {
 		this.totalsShown = false;
 		this.requestIndex = 0;
 		this.requestIdToIndex = {};
-		if (options.quiet) {
-			log.level = Log.NOTICE;
-		}
-		if (options.debug) {
-			log.level = Log.DEBUG;
-		}
 	}
 
 	/**
@@ -77,7 +55,6 @@ class Latency {
 	 */
 	end(requestId, errorCode) {
 		if (!(requestId in this.requests)) {
-			log.debug('Message id ' + requestId + ' not found');
 			return -2;
 		}
 		if (!this.running) {
@@ -94,7 +71,6 @@ class Latency {
 	 * Accepts an optional error code signaling an error.
 	 */
 	add(time, errorCode) {
-		log.debug('New value: %s', time);
 		this.partialTime += time;
 		this.partialRequests++;
 		this.totalTime += time;
@@ -108,7 +84,6 @@ class Latency {
 			}
 			this.errorCodes[errorCode] += 1;
 		}
-		log.debug('Partial requests: %s', this.partialRequests);
 		const rounded = Math.floor(time);
 		if (rounded > this.maxLatencyMs) {
 			this.maxLatencyMs = rounded;
@@ -117,7 +92,6 @@ class Latency {
 			this.minLatencyMs = rounded;
 		}
 		if (!this.histogramMs[rounded]) {
-			log.debug('Initializing histogram for %s', rounded);
 			this.histogramMs[rounded] = 0;
 		}
 		this.histogramMs[rounded] += 1;
@@ -140,10 +114,10 @@ class Latency {
 		if (this.options.maxRequests) {
 			percent = ' (' + Math.round(100 * this.totalRequests / this.options.maxRequests) + '%)';
 		}
-		log.info('Requests: %s%s, requests per second: %s, mean latency: %s ms', this.totalRequests, percent, results.rps, results.meanLatencyMs);
+		console.info('Requests: %s%s, requests per second: %s, mean latency: %s ms', this.totalRequests, percent, results.rps, results.meanLatencyMs);
 		if (this.totalErrors) {
 			percent = Math.round(100 * 10 * this.totalErrors / this.totalRequests) / 10;
-			log.info('Errors: %s, accumulated errors: %s, %s% of total requests', this.partialErrors, this.totalErrors, percent);
+			console.info('Errors: %s, accumulated errors: %s, %s% of total requests', this.partialErrors, this.totalErrors, percent);
 		}
 		this.partialTime = 0;
 		this.partialRequests = 0;
@@ -173,14 +147,11 @@ class Latency {
 	 * Check out if the measures are finished.
 	 */
 	isFinished() {
-		log.debug('Total requests %s, max requests: %s', this.totalRequests, this.options.maxRequests);
 		if (this.options.maxRequests && this.totalRequests >= this.options.maxRequests) {
-			log.debug('Max requests reached: %s', this.totalRequests);
 			return true;
 		}
 		const elapsedSeconds = this.getElapsed(this.initialTime) / 1000;
 		if (this.options.maxSeconds && elapsedSeconds >= this.options.maxSeconds) {
-			log.debug('Max seconds reached: %s', this.totalRequests);
 			return true;
 		}
 		return false;
@@ -194,7 +165,6 @@ class Latency {
 		if (this.callback) {
 			return this.callback(null, this.getResults());
 		}
-		this.show();
 	}
 
 	/**
@@ -220,7 +190,6 @@ class Latency {
 	 * Compute the percentiles.
 	 */
 	computePercentiles() {
-		log.debug('Histogram: %s', util.inspect(this.histogramMs));
 		const percentiles = {
 			50: false,
 			90: false,
@@ -233,12 +202,10 @@ class Latency {
 			if (!this.histogramMs[ms]) {
 				continue;
 			}
-			log.debug('Histogram for %s: %s', ms, this.histogramMs[ms]);
 			counted += this.histogramMs[ms];
 			const percent = counted / this.totalRequests * 100;
 
 			Object.keys(percentiles).forEach(percentile => {
-				log.debug('Checking percentile %s for %s', percentile, percent);
 				if (!percentiles[percentile] && percent > percentile) {
 					percentiles[percentile] = ms;
 				}
@@ -256,43 +223,43 @@ class Latency {
 		}
 		this.totalsShown = true;
 		const results = this.getResults();
-		log.info('');
-		log.info('Target URL:          %s', this.options.url);
+		console.info('');
+		console.info('Target URL:          %s', this.options.url);
 		if (this.options.maxRequests) {
-			log.info('Max requests:        %s', this.options.maxRequests);
+			console.info('Max requests:        %s', this.options.maxRequests);
 		} else if (this.options.maxSeconds) {
-			log.info('Max time (s):        %s', this.options.maxSeconds);
+			console.info('Max time (s):        %s', this.options.maxSeconds);
 		}
-		log.info('Concurrency level:   %s', this.options.concurrency);
+		console.info('Concurrency level:   %s', this.options.concurrency);
 		let agent = 'none';
 		if (this.options.agentKeepAlive) {
 			agent = 'keepalive';
 		}
-		log.info('Agent:               %s', agent);
+		console.info('Agent:               %s', agent);
 		if (this.options.requestsPerSecond) {
-			log.info('Requests per second: %s', this.options.requestsPerSecond * this.options.concurrency);
+			console.info('Requests per second: %s', this.options.requestsPerSecond * this.options.concurrency);
 		}
-		log.info('');
-		log.info('Completed requests:  %s', results.totalRequests);
-		log.info('Total errors:        %s', results.totalErrors);
-		log.info('Total time:          %s s', results.totalTimeSeconds);
-		log.info('Requests per second: %s', results.rps);
-		log.info('Mean latency:        %s ms', results.meanLatencyMs);
-		log.info('');
-		log.info('Percentage of the requests served within a certain time');
+		console.info('');
+		console.info('Completed requests:  %s', results.totalRequests);
+		console.info('Total errors:        %s', results.totalErrors);
+		console.info('Total time:          %s s', results.totalTimeSeconds);
+		console.info('Requests per second: %s', results.rps);
+		console.info('Mean latency:        %s ms', results.meanLatencyMs);
+		console.info('');
+		console.info('Percentage of the requests served within a certain time');
 
 		Object.keys(results.percentiles).forEach(percentile => {
-			log.info('  %s%      %s ms', percentile, results.percentiles[percentile]);
+			console.info('  %s%      %s ms', percentile, results.percentiles[percentile]);
 		});
 
-		log.info(' 100%      %s ms (longest request)', this.maxLatencyMs);
+		console.info(' 100%      %s ms (longest request)', this.maxLatencyMs);
 		if (results.totalErrors) {
-			log.info('');
-			log.info(' 100%      %s ms (longest request)', this.maxLatencyMs);
-			log.info('');
+			console.info('');
+			console.info(' 100%      %s ms (longest request)', this.maxLatencyMs);
+			console.info('');
 			Object.keys(results.errorCodes).forEach(errorCode => {
 				const padding = ' '.repeat(errorCode.length < 4 ? 4 - errorCode.length : 1);
-				log.info(' %s%s:   %s errors', padding, errorCode, results.errorCodes[errorCode]);
+				console.info(' %s%s:   %s errors', padding, errorCode, results.errorCodes[errorCode]);
 			});
 		}
 	}
@@ -308,92 +275,3 @@ function createId() {
 	return hash.update(value).digest('hex').toLowerCase();
 }
 
-/**
- * Test latency ids.
- */
-function testLatencyIds(callback) {
-	const latency = new Latency({});
-	const firstId = latency.start();
-	testing.assert(firstId, 'Invalid first latency id %s', firstId, callback);
-	const secondId = latency.start();
-	testing.assert(secondId, 'Invalid second latency id', callback);
-	testing.assert(firstId != secondId, 'Repeated latency ids', callback);
-	testing.success(callback);
-}
-
-/**
- * Test latency measurements.
- */
-function testLatencyRequests(callback) {
-	const options = {
-		maxRequests: 10,
-	};
-	const errorCode = '500';
-	const latency = new Latency(options, (error, result) => {
-		testing.check(error, 'Could not compute latency', callback);
-		testing.assertEquals(result.totalRequests, 10, 'Invalid total requests', callback);
-		testing.assertEquals(result.totalErrors, 1, 'Invalid total errors', callback);
-		testing.assert(errorCode in result.errorCodes, 'Error code not found', callback);
-		testing.assertEquals(result.errorCodes[errorCode], 1, 'Should have one ' + errorCode, callback);
-		testing.success(callback);
-	});
-	let id;
-	for (let i = 0; i < 9; i++) {
-		id = latency.start();
-		latency.end(id);
-	}
-	id = latency.start();
-	latency.end(id, errorCode);
-}
-
-/**
- * Check that percentiles are correct.
- */
-function testLatencyPercentiles(callback) {
-	const options = {
-		maxRequests: 10
-	};
-	const latency = new Latency(options, error => {
-		testing.check(error, 'Error while testing latency percentiles', callback);
-		const percentiles = latency.getResults().percentiles;
-
-		Object.keys(percentiles).forEach(percentile => {
-			testing.assert(percentiles[percentile] !== false, 'Empty percentile for %s', percentile, callback);
-		});
-
-		testing.success(percentiles, callback);
-	});
-	for (let ms = 1; ms <= 10; ms++) {
-		log.debug('Starting %s', ms);
-		(function() {
-			const id = latency.start();
-			setTimeout(() => {
-				log.debug('Ending %s', id);
-				latency.end(id);
-			}, ms);
-		})();
-	}
-}
-
-/**
- * Run package tests.
- */
-function test(callback) {
-	const tests = [
-		testLatencyIds,
-		testLatencyRequests,
-		testLatencyPercentiles,
-	];
-	testing.run(tests, callback);
-}
-
-module.exports = {
-	Latency,
-	test,
-}
-
-// run tests if invoked directly
-if (__filename == process.argv[1]) {
-	test(testing.show);
-}
-