autobench 0.0.1alpha1

data/lib/phantomas/modules/domains/domains.js

@@ -0,0 +1,49 @@
+/**
+ * Domains monitor
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	// count requests per domain
+	var domains = {},
+		domainsCount = 0;
+
+	phantomas.on('recv', function(entry,res) {
+		var domain = entry.domain;
+
+		// base64?
+		if (!domain) {
+			return;
+		}
+
+		// init domain entry
+		if (!domains[domain]) {
+			domainsCount++;
+
+			domains[domain] = {
+				requests: []
+			};
+		}
+
+		domains[domain].requests.push(res.url);
+	});
+
+	// add metrics
+	phantomas.on('loadFinished', function() {
+		//console.log(domains);
+		phantomas.setMetric('domains', domainsCount);
+
+		phantomas.addNotice('Requests per domain:');
+		for(var domain in domains) {
+			var entry = domains[domain],
+				requests = entry.requests;
+
+			// report URLs from each domain
+			phantomas.addNotice(' ' + domain + ': ' + requests.length + ' request(s)');
+			requests.forEach(function(url) {
+				//phantomas.addNotice('   * ' + url);
+			});
+		}
+		phantomas.addNotice();
+	});
+};

data/lib/phantomas/modules/globalVariables/globalVariables.js

@@ -0,0 +1,44 @@
+/**
+ * Counts global JavaScript variables
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+
+	phantomas.on('report', function() {
+		var globals = phantomas.evaluate(function() {
+			var globals = [],
+		    		allowed = ['Components','XPCNativeWrapper','XPCSafeJSObjectWrapper','getInterface','netscape','GetWeakReference', '_phantom', 'callPhantom', 'phantomas'],
+		    		varName,
+		    		iframe,
+		    		cleanWindow;
+
+			// create an empty iframe to get the list of core members
+			iframe = document.createElement('iframe');
+			iframe.style.display = 'none';
+			iframe.src = 'about:blank';
+			document.body.appendChild(iframe);
+
+			cleanWindow = iframe.contentWindow;
+
+			for (varName in cleanWindow) {
+				allowed.push(varName);
+			}
+
+			// get all members of window and filter them
+			for (varName in window) {
+				if (allowed.indexOf(varName) > -1) {
+					continue;
+				}
+
+				globals.push(varName);
+			}
+
+			return globals;
+		}) || [];
+
+		phantomas.setMetric('globalVariables', globals.length);
+		phantomas.addNotice('JavaScript globals (' + globals.length + '): ' + globals.join(', '));
+		phantomas.addNotice();
+	});
+};

data/lib/phantomas/modules/headers/headers.js

@@ -0,0 +1,48 @@
+/**
+ * Analyzes HTTP headers in both requests and responses
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	phantomas.setMetric('headersCount');
+	phantomas.setMetric('headersSentCount');
+	phantomas.setMetric('headersRecvCount');
+
+	phantomas.setMetric('headersSize');
+	phantomas.setMetric('headersSentSize');
+	phantomas.setMetric('headersRecvSize');
+
+	function processHeaders(headers) {
+		var res = {
+			count: 0,
+			size: 0
+		};
+
+		headers && headers.forEach(function(header) {
+			res.count++;
+			res.size += (header.name + ': ' + header.value + '\r\n').length;
+		});
+
+		return res;
+	}
+
+	phantomas.on('send', function(entry, res) {
+		var data = processHeaders(res.headers);
+
+		phantomas.incrMetric('headersCount', data.count);
+		phantomas.incrMetric('headersSize', data.size);
+
+		phantomas.incrMetric('headersSentCount', data.count);
+		phantomas.incrMetric('headersSentSize', data.size);
+	});
+		
+	phantomas.on('recv', function(entry, res) {
+		var data = processHeaders(res.headers);
+
+		phantomas.incrMetric('headersCount', data.count);
+		phantomas.incrMetric('headersSize', data.size);
+
+		phantomas.incrMetric('headersRecvCount', data.count);
+		phantomas.incrMetric('headersRecvSize', data.size);
+	});
+};

data/lib/phantomas/modules/localStorage/localStorage.js

@@ -0,0 +1,14 @@
+/**
+ * localStorage metrics
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	// add metrics
+	phantomas.on('report', function() {
+		//console.log(domains);
+		phantomas.setMetricEvaluate('localStorageEntries', function() {
+			return window.localStorage.length;
+		});
+	});
+};

data/lib/phantomas/modules/requestsStats/requestsStats.js

@@ -0,0 +1,71 @@
+/**
+ * Analyzes HTTP requests and generates stats metrics
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	var smallestResponse,
+		biggestResponse,
+		fastestResponse,
+		slowestResponse;
+
+	var responseTimes = [];
+
+	function median(arr) {
+		var half = Math.floor(arr.length/2);
+
+		arr.sort(function(a,b) {
+			return a - b;
+		});
+
+		return (arr.length % 2) ? arr[half] : ((arr[half-1] + arr[half]) / 2.0);
+	}
+
+	phantomas.on('recv', function(entry, res) {
+		// ignore anything different than HTTP 200
+		if (entry.status !== 200) {
+			return;
+		}
+
+		// size
+		if (!smallestResponse || smallestResponse.bodySize > entry.bodySize) {
+			smallestResponse = entry;
+		}
+
+		if (!biggestResponse || biggestResponse.bodySize < entry.bodySize) {
+			biggestResponse = entry;
+		}
+
+		// time
+		if (!fastestResponse || fastestResponse.timeToLastByte > entry.timeToLastByte) {
+			fastestResponse = entry;
+		}
+
+		if (!slowestResponse || slowestResponse.timeToLastByte < entry.timeToLastByte) {
+			slowestResponse = entry;
+		}
+
+		// store time to calculate median response time
+		responseTimes.push(entry.timeToLastByte);
+	});
+
+	phantomas.on('report', function() {
+		phantomas.setMetric('smallestResponse', smallestResponse.bodySize);
+		phantomas.setMetric('biggestResponse', biggestResponse.bodySize);
+
+		phantomas.addNotice('The smallest response (' + (smallestResponse.bodySize/1024).toFixed(2) + ' kB): ' + smallestResponse.url);
+		phantomas.addNotice('The biggest response (' + (biggestResponse.bodySize/1024).toFixed(2) + ' kB): ' + biggestResponse.url);
+
+		phantomas.addNotice();
+
+		phantomas.setMetric('fastestResponse', fastestResponse.timeToLastByte);
+		phantomas.setMetric('slowestResponse', slowestResponse.timeToLastByte);
+
+		phantomas.addNotice('The fastest response (' + fastestResponse.timeToLastByte + ' ms): ' + fastestResponse.url);
+		phantomas.addNotice('The slowest response (' + slowestResponse.timeToLastByte + ' ms): ' + slowestResponse.url);
+
+		phantomas.addNotice();
+
+		phantomas.setMetric('medianResponse', median(responseTimes));
+	});
+};

data/lib/phantomas/modules/staticAssets/staticAssets.js

@@ -0,0 +1,40 @@
+/**
+ * Analyzes static assets (CSS, JS and images)
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	var BASE64_SIZE_THRESHOLD = 2 * 1024;
+
+	phantomas.setMetric('assetsNotGzipped');
+	phantomas.setMetric('assetsWithQueryString');
+	phantomas.setMetric('smallImages');
+
+	phantomas.on('recv', function(entry, res) {
+		// console.log(JSON.stringify(entry));
+
+		// check for query string -> foo.css?123
+		if (entry.isImage || entry.isJS || entry.isCSS) {
+			if (entry.url.indexOf('?') > -1) {
+				phantomas.addNotice(entry.url + ' (' + entry.type.toUpperCase() + ') served with query string');
+				phantomas.incrMetric('assetsWithQueryString');
+			}
+		}
+
+		// check for not-gzipped CSS / JS / HTML files
+		if (entry.isJS || entry.isCSS || entry.isHTML) {
+			if (!entry.gzip) {
+				phantomas.addNotice(entry.url + ' (' + entry.type.toUpperCase() + ') served without compression');
+				phantomas.incrMetric('assetsNotGzipped');
+			}
+		}
+
+		// check small images that can be base64 encoded
+		if (entry.isImage) {
+			if (entry.bodySize < BASE64_SIZE_THRESHOLD) {
+				phantomas.addNotice(entry.url + ' (' + (entry.bodySize/1024).toFixed(2) + ' kB) should be served as base64 encoded');
+				phantomas.incrMetric('smallImages');
+			}
+		}
+	});
+};

data/lib/phantomas/modules/waterfall/waterfall.js

@@ -0,0 +1,62 @@
+/**
+ * Plots ASCII-art waterfall
+ */
+exports.version = '0.5';
+
+exports.skip = true;
+
+exports.module = function(phantomas) {
+	var requestsTimeline = {},
+		currentRequests = 0,
+		start = Date.now();
+
+	function updatePlot() {
+		requestsTimeline[ Date.now() - start ] = currentRequests;
+	}
+
+	phantomas.on('send', function(res) {
+		currentRequests++;
+		updatePlot();
+	});
+
+	phantomas.on('recv', function(entry,res) {
+		currentRequests--;
+		updatePlot();
+	});
+
+	// plot waterfall
+	phantomas.on('report', function() {
+		phantomas.addNotice('No of requests waterfall:');
+
+		var delta = 100,
+			lastValue = 0,
+			value,
+			lastTime = 0,
+			values = {};
+
+		// gather maximum values from each delta ms bucket
+		for (var time in requestsTimeline) {
+			value = requestsTimeline[time];
+			lastValue = Math.max(lastValue, value);
+
+			if (time > lastTime + delta) {
+				lastTime = Math.ceil(time / delta) * delta;
+
+				values[lastTime] = lastValue;
+
+				lastValue = 0;
+			}
+		}
+
+		// now plot the waterfall for each bucket
+		lastValue = 1;
+		for (var i=0; i<time; i+=delta) {
+			// get the current bucket (or previous one)
+			value = values[i] || lastValue;
+
+			phantomas.addNotice(i + 'ms | ' + (new Array(value+1).join('=')));
+
+			lastValue = value;
+		}
+	});
+};

data/lib/phantomas/modules/windowPerformance/windowPerformance.js

@@ -0,0 +1,36 @@
+/**
+ * Measure when onDOMready and window.onload events are fired
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+
+	// emulate window.performance
+	// @see https://groups.google.com/d/topic/phantomjs/WnXZLIb_jVc/discussion
+	phantomas.on('init', function() {
+		phantomas.evaluate(function() {
+			window.phantomas.timingLoadStarted = Date.now();
+
+			document.addEventListener("DOMContentLoaded", function() {
+				window.phantomas.timingDOMContentLoaded = Date.now();
+				console.log('onDOMready');
+			}, false);
+
+			window.addEventListener("load", function() {
+				window.phantomas.timingOnLoad = Date.now();
+				console.log('window.onload');
+			}, false);
+		});
+	});
+
+	// called just before report is generated
+	phantomas.on('report', function() {
+		phantomas.setMetricEvaluate('onDOMReadyTime', function() {
+			return window.phantomas.timingDOMContentLoaded - window.phantomas.timingLoadStarted;
+ 		});
+
+		phantomas.setMetricEvaluate('windowOnLoadTime', function() {
+			return window.phantomas.timingOnLoad - window.phantomas.timingLoadStarted;
+ 		});
+	});
+};

data/lib/phantomas/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "phantomas",
+  "version": "0.4.1",
+  "author": "macbre <maciej.brencz@gmail.com> (http://macbre.net)",
+  "description": "PhantomJS-based web performance metrics collector",
+  "main": "./core/phantomas",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/macbre/phantomas.git"
+  },
+  "keywords": [
+    "phantomas",
+    "web performance",
+    "web development",
+    "metrics",
+    "phantomjs"
+  ],
+  "license": "BSD",
+  "engines": {
+    "node": ">=0.6"
+  },
+  "dependencies": {
+    "phantomjs": ">=1.7"
+  },
+  "devDependencies": {},
+  "optionalDependencies": {}
+}

data/lib/phantomas/phantomas.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env phantomjs
+/**
+ * PhantomJS-based web performance metrics collector
+ *
+ * Usage:
+ *  ./phantomas.js
+ *    --url=<page to check>
+ *    [--timeout=5]
+ *    [--format=json|csv|plain]
+ *    [--verbose]
+ *    [--silent]
+ *    [--modules=moduleOne,moduleTwo]
+ *    [--user-agent='Custom user agent']
+ *
+ * @version 0.4
+ */
+
+// parse script arguments
+var args = require('system').args,
+	params = require('./lib/args').parse(args),
+	phantomas = require('./core/phantomas').phantomas,
+	instance;
+
+// run phantomas
+instance = new phantomas(params);
+
+try {
+	instance.run();
+}
+catch(ex) {
+	console.log('phantomas v' + phantomas.version + ' failed with an error:');
+	console.log(ex);
+
+	phantom.exit(1);
+}

data/lib/phantomas/run-multiple.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * This is a helper NodeJS script allowing you to run phantomas multiple times and
+ * get a nice looking table with all the metrics + avg / median / min / max values
+ *
+ * Usage:
+ *  ./run-multiple.js
+ *	--url=<page to check>
+ *	--runs=<number of runs, defaults to 3>
+ *	--timeout=<in seconds (for each run), default to 15>
+ *	[--modules=moduleOne,moduleTwo]
+ *	[--format=plain|json] (plain is default)
+ *	  note: json format, prints only errorrs or the
+ *			  results in json format, no other
+ *			  messaging
+ *
+ * @version 0.1
+ */
+var exec = require('child_process').exec,
+	args = process.argv.slice(2),
+	params = require('./lib/args').parse(args),
+	pads = require('./core/pads'),
+	lpad = pads.lpad,
+	rpad = pads.rpad;
+
+// handle --url and --runs CLI parameters
+var url = params.url,
+	runs = parseInt(params.runs, 10) || 3,
+	format = params.format || 'plain',
+	remainingRuns = runs,
+	metrics = [];
+
+function runPhantomas(params, callback) {
+	var timeMs = Date.now(),
+		cmd = 'phantomjs phantomas.js --format=json --url=' + params.url;
+
+	if (params.timeout > 0) {
+		cmd += ' --timeout=' + params.timeout;
+	}
+
+	if (params.modules) {
+		cmd += ' --modules=' + params.modules;
+	}
+
+	// @see http://nodejs.org/api/child_process.html#child_process_child_process_exec_command_options_callback
+	exec(cmd, function(error, stdout, stderr) {
+		var res = false;
+
+		try {
+			res = JSON.parse(stdout) || false;
+		} catch(e) {
+			console.log("Unable to parse JSON from phantomas!");
+		}
+
+		if (res === false) {
+			console.log(stdout);
+		}
+
+		if (typeof callback === 'function') {
+			callback(res, Date.now() - timeMs);
+		}
+	});
+}
+
+function run() {
+	if (remainingRuns--) {
+		if (format === 'plain') {
+			console.log('Remaining runs: ' + (remainingRuns + 1));
+		}
+
+		runPhantomas(params, function(res, timeMs) {
+			if (res) {
+				metrics.push(res.metrics);
+			}
+
+			if (format === 'plain') {
+				console.log('Run completed in ' + (timeMs/1000).toFixed(2) + ' s');
+			}
+			run();
+		});
+	} else {
+		if (format === 'plain') {
+			console.log('Done');
+		}
+		formatResults(metrics);
+	}
+}
+
+function formatResults(metrics) {
+	var entries = {},
+		entry,
+		metric;
+
+	// prepare entries
+	for(metric in metrics[0]) {
+		entries[metric] = {
+			values: [],
+			sum: 0,
+			min: 0,
+			max: 0,
+			median: 0,
+			average: 0
+		};
+	}
+
+	// process all runs
+	metrics.forEach(function(data) {
+		var metric;
+		for (metric in data) {
+			entries[metric].values.push(data[metric]);
+		}
+	});
+
+	// calculate stats
+	for (metric in entries) {
+		entry = entries[metric];
+
+		entry.values = entry.values.
+			filter(function(element) {
+				return element !== null;
+			}).
+			sort(function (a, b) {
+				return a - b;
+			});
+
+		if (entry.values.length === 0) {
+			continue;
+		}
+
+		entry.min = entry.values.slice(0, 1).pop();
+		entry.max = entry.values.slice(-1).pop();
+
+		for (var i=0, len = entry.values.length++; i<len; i++) {
+			entry.sum += entry.values[i];
+		}
+
+		entry.average = len && (entry.sum / len).toFixed(2);
+		entry.median = ( (len % 2 === 0) ? ((entry.values[len >> 1] + entry.values[len >> 1 + 1])/2) : entry.values[len >> 1] ).toFixed(2);
+	}
+
+	// print out a nice table
+	if (format === 'plain') {
+		console.log("-------------------------------------------------------------------------------------------");
+		console.log("| " + rpad("Report from " + runs + " run(s) for <" + params.url + ">", 87) + " |");
+		console.log("-------------------------------------------------------------------------------------------");
+		console.log("| Metric					  | Min		  | Max		  | Average	  | Median	   |");
+		console.log("-------------------------------------------------------------------------------------------");
+
+		for (metric in entries) {
+			entry = entries[metric];
+
+			console.log("| "+
+				[
+					rpad(metric, 27),
+					lpad(entry.min, 12),
+					lpad(entry.max, 12),
+					lpad(entry.average, 12),
+					lpad(entry.median, 12)
+				].join(" | ") +
+				" |");
+		}
+
+		console.log("-------------------------------------------------------------------------------------------");
+	} else {
+		console.log(JSON.stringify(metrics));
+	}
+}
+
+if (typeof url === 'undefined') {
+	console.log('--url argument must be provided!');
+	process.exit(1);
+}
+
+if (format === 'plain') {
+	console.log('Performing ' + runs + ' phantomas run(s) for <' + params.url + '>...');
+}
+run();