autobench 0.0.1alpha1

data/lib/phantomas/modules/ajaxRequests/ajaxRequests.js

@@ -0,0 +1,15 @@
+/**
+ * Analyzes AJAX requests
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	phantomas.setMetric('ajaxRequests');
+
+	phantomas.on('send', function(entry, res) {
+		if (entry.requestHeaders['X-Requested-With'] === 'XMLHttpRequest') {
+			phantomas.addNotice('AJAX request: ' + entry.url);
+			phantomas.incrMetric('ajaxRequests');
+		}
+	});
+};

data/lib/phantomas/modules/assetsTypes/assetsTypes.js

@@ -0,0 +1,21 @@
+/**
+ * Analyze number of requests and sizes of differet assets types
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	['html', 'css', 'js', 'image', 'base64', 'other'].forEach(function(key) {
+		phantomas.setMetric(key + 'Count');
+		phantomas.setMetric(key + 'Size');
+	});
+
+	phantomas.on('recv', function(entry, res) {
+		phantomas.incrMetric(entry.type + 'Count');
+		phantomas.incrMetric(entry.type + 'Size', entry.bodySize);
+	});
+
+	phantomas.on('base64recv', function(entry, res) {
+		phantomas.incrMetric('base64Count');
+		phantomas.incrMetric('base64Size', entry.bodySize);
+	});
+};

data/lib/phantomas/modules/cacheHits/cacheHits.js

@@ -0,0 +1,28 @@
+/**
+ * Analyzes X-Cache headers from caching servers like Squid or Varnish
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	phantomas.setMetric('cacheHits');
+	phantomas.setMetric('cacheMisses');
+
+	var re = /miss|hit/i;
+	
+	// examples:
+	// X-Cache:HIT, HIT
+	// X-Cache:arsenic miss (0)
+	phantomas.on('recv', function(entry,res) {
+		var header = entry.headers['X-Cache'] || '',
+			isHit;
+
+		if (re.test(header)) {
+			isHit = header.toLowerCase().indexOf('hit') > -1;
+			phantomas.incrMetric(isHit ? 'cacheHits' : 'cacheMisses');
+
+			if (!isHit) {
+				phantomas.addNotice('Cache miss on ' + entry.url + ' (X-Cache: ' + header + ')');
+			}
+		}
+	});
+};

data/lib/phantomas/modules/caching/caching.js

@@ -0,0 +1,66 @@
+/**
+ * Analyzes HTTP caching headers
+ *
+ * @see https://developers.google.com/speed/docs/best-practices/caching
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	var cacheControlRegExp = /max-age=(\d+)/;
+
+	function getCachingTime(headers) {
+		// false means "no caching"
+		var ttl = false,
+			headerName;
+
+		for (headerName in headers) {
+			var value = headers[headerName];
+
+			switch(headerName.toLowerCase()) {
+				// parse max-age=...
+				//
+				// max-age=2592000
+				// public, max-age=300, must-revalidate
+				case 'cache-control':
+					var matches = value.match(cacheControlRegExp);
+
+					if (matches) {
+						ttl = parseInt(matches[1], 10);
+					}
+					break;
+
+				// TODO: parse date
+				case 'expires':
+					break;
+			}
+		}
+
+		//console.log(JSON.stringify(headers)); console.log("TTL: " + ttl + ' s');
+
+		return ttl;
+	}
+
+	phantomas.setMetric('cachingNotSpecified');
+	phantomas.setMetric('cachingTooShort');
+	phantomas.setMetric('cachingDisabled');
+	
+	phantomas.on('recv', function(entry, res) {
+		var ttl = getCachingTime(entry.headers);
+
+		// static assets
+		if (entry.isImage || entry.isJS || entry.isCSS) {
+			if (ttl === false) {
+				phantomas.addNotice("No caching specified for <" + entry.url + ">");
+				phantomas.incrMetric('cachingNotSpecified');
+			}
+			else if (ttl === 0) {
+				phantomas.addNotice("Caching disabled for <" + entry.url + ">");
+				phantomas.incrMetric('cachingDisabled');
+			}
+			else if (ttl < 7 * 86400) {
+				phantomas.addNotice("Caching period is less than a week for <" + entry.url + "> (set to " + ttl + " s)");
+				phantomas.incrMetric('cachingTooShort');
+			}
+		}
+	});
+};

data/lib/phantomas/modules/cookies/cookies.js

@@ -0,0 +1,54 @@
+/**
+ * cookies metrics
+ */
+exports.version = '0.1';
+
+exports.module = function(phantomas) {
+	// monitor cookies in HTTP headers
+	var cookiesSent = 0,
+		cookiesRecv = 0;
+		cookiesDomains = {};
+
+	phantomas.on('send', function(entry, res) {
+		res.headers.forEach(function(header) {
+			switch (header.name) {
+				case 'Cookie':
+					cookiesSent += header.value.length;
+					cookiesDomains[entry.domain] = true;
+					break;
+			}
+		});
+	});
+
+	phantomas.on('recv', function(entry, res) {
+		res.headers.forEach(function(header) {
+			switch (header.name) {
+				case 'Set-Cookie':
+					cookiesRecv += header.value.length;
+					cookiesDomains[entry.domain] = true;
+					break;
+			}
+		});
+	});
+
+	// domain cookies (accessible by the browser)
+	phantomas.on('report', function() {
+		phantomas.setMetric('cookiesSent', cookiesSent);
+		phantomas.setMetric('cookiesRecv', cookiesRecv);
+
+		// domains with cookies
+		var domainsWithCookies = 0;
+		for (var domain in cookiesDomains) {
+			domainsWithCookies++;
+		}
+		phantomas.setMetric('domainsWithCookies', domainsWithCookies);
+
+		phantomas.setMetricEvaluate('documentCookiesLength', function() {
+			return document.cookie.length;
+		});
+
+		phantomas.setMetricEvaluate('documentCookiesCount', function() {
+			return document.cookie.split(';').length;
+		});
+	});
+};

data/lib/phantomas/modules/domComplexity/domComplexity.js

@@ -0,0 +1,130 @@
+/**
+ * Analyzes DOM complexity
+ */
+exports.version = '0.2';
+
+exports.module = function(phantomas) {
+
+	// HTML size
+	phantomas.on('report', function() {
+		phantomas.setMetricEvaluate('bodyHTMLSize', function() {
+			return document.body.innerHTML.length;
+		});
+
+		phantomas.evaluate(function() {
+			(function(phantomas) {
+				var runner = new phantomas.nodeRunner(),
+					whitespacesRegExp = /^\s+$/;
+
+				var metrics = {
+					nodes: 0,
+					comments: 0,
+					hiddenContent: 0,
+					whitespaces: 0,
+					maxDepth: 0,
+					nodesWithCSS: 0
+				};
+
+				// include all nodes
+				runner.isSkipped = function(node) {
+					return false;
+				};
+
+				runner.walk(document.body, function(node, depth) {
+					switch (node.nodeType) {
+						case Node.COMMENT_NODE:
+							metrics.comments += node.textContent.length + 7; // '<!--' + '-->'.length
+							break;
+
+						case Node.ELEMENT_NODE:
+							metrics.nodes++;
+							metrics.maxDepth = Math.max(metrics.maxDepth, depth);
+
+							// ignore inline <script> tags
+							if (node.nodeName === 'SCRIPT') {
+								return false;
+							}
+
+							// @see https://developer.mozilla.org/en/DOM%3awindow.getComputedStyle
+							var styles = window.getComputedStyle(node);
+
+							if (styles && styles.getPropertyValue('display') === 'none') {
+								//console.log(node.innerHTML);
+								metrics.hiddenContent += node.innerHTML.length;
+
+								// don't run for child nodes as they're hidden as well
+								return false;
+							}
+
+							// count nodes with inline CSS
+							if (node.hasAttribute('style')) {
+								metrics.nodesWithCSS++;
+							}
+
+							break;
+
+						case Node.TEXT_NODE:
+							if (whitespacesRegExp.test(node.textContent)) {
+								metrics.whitespaces += node.textContent.length;
+							}
+							break;
+					}
+				});
+
+				// store metrics
+				phantomas.DOMmetrics = metrics;
+
+			}(window.phantomas));
+		});
+
+		// total length of HTML comments (including <!-- --> brackets)
+		phantomas.setMetricEvaluate('commentsSize', function() {
+			return window.phantomas.DOMmetrics.comments;
+		});
+
+		// total length of HTML of hidden elements (i.e. display: none)
+		phantomas.setMetricEvaluate('hiddenContentSize', function() {
+			return window.phantomas.DOMmetrics.hiddenContent;
+		});
+
+		// total length of text nodes with whitespaces only (i.e. pretty formatting of HTML)
+		phantomas.setMetricEvaluate('whiteSpacesSize', function() {
+			return window.phantomas.DOMmetrics.whitespaces;
+		});
+
+		// count all tags
+		phantomas.setMetricEvaluate('DOMelementsCount', function() {
+			return window.phantomas.DOMmetrics.nodes;
+		});
+
+		phantomas.setMetricEvaluate('DOMelementMaxDepth', function() {
+			return window.phantomas.DOMmetrics.maxDepth;
+		});
+
+		// count <iframe> tags
+		phantomas.setMetricEvaluate('iframesCount', function() {
+			return document.querySelectorAll('iframe').length;
+		});
+
+		// nodes with inlines CSS (style attribute)
+		phantomas.setMetricEvaluate('nodesWithInlineCSS', function() {
+			return window.phantomas.DOMmetrics.nodesWithCSS;
+		});
+
+		// <img> nodes without dimensions (one of width / height missing)
+		phantomas.setMetricEvaluate('imagesWithoutDimensions', function() {
+			var imgNodes = document.body.querySelectorAll('img'),
+				node,
+				imagesWithoutDimensions = 0;
+
+			for (i=0, len=imgNodes.length; i<len; i++) {
+				node = imgNodes[i];
+				if (!node.hasAttribute('width') || !node.hasAttribute('height')) {
+					imagesWithoutDimensions++;
+				}
+			};
+
+			return imagesWithoutDimensions;
+		});
+	});
+};

data/lib/phantomas/modules/domQueries/domQueries.js

@@ -0,0 +1,148 @@
+/**
+ * Analyzes DOM queries done via native DOM methods & jQuery
+ *
+ */
+exports.version = '0.2';
+
+exports.module = function(phantomas) {
+
+	// fake native DOM functions
+	phantomas.once('init', function() {
+		phantomas.evaluate(function() {
+			(function() {
+				var originalGetElementById = window.document.getElementById,
+					originalGetElementsByClassName = window.document.getElementsByClassName,
+					originalAppendChild = Node.prototype.appendChild,
+					originalInsertBefore = Node.prototype.insertBefore;
+
+				// metrics storage
+				window.phantomas.domQueries = 0;
+				window.phantomas.domInserts = 0;
+				window.phantomas.domInsertsBacktrace = [];
+
+				window.phantomas.jQueryOnDOMReadyFunctions = 0;
+				window.phantomas.jQueryOnDOMReadyFunctionsBacktrace = [];
+	
+				window.phantomas.jQuerySelectors = 0;
+				window.phantomas.jQuerySelectorsBacktrace = [];
+
+				// hook into DOM methods
+				document.getElementById = function(id) {
+					// log calls
+					console.log('document.getElementById("' + id + '")');
+					window.phantomas.domQueries++;
+
+					return originalGetElementById.call(document, id);
+				};
+
+				// count DOM inserts
+				Node.prototype.appendChild = function(child) {
+					var hasParent = typeof this.parentNode !== 'undefined';
+
+					// ignore appending to the node that's not yet added to DOM tree
+					if (!hasParent) {
+						return;
+					}
+
+					var caller = window.phantomas.getCaller();
+
+					window.phantomas.domInserts++;
+					window.phantomas.domInsertsBacktrace.push({
+						url: caller.sourceURL,
+						line: caller.line
+					});
+
+					return originalAppendChild.call(this, child);
+				};
+
+				Node.prototype.insertBefore = function(child) {
+					var hasParent = typeof this.parentNode !== 'undefined';
+
+					// ignore appending to the node that's not yet added to DOM tree
+					if (!hasParent) {
+						return;
+					}
+
+					var caller = window.phantomas.getCaller();
+
+					window.phantomas.domInserts++;
+					window.phantomas.domInsertsBacktrace.push({
+						url: caller.sourceURL,
+						line: caller.line
+					});
+
+					return originalInsertBefore.call(this, child);
+				};
+
+				return;
+
+				// hook into $.fn.init to catch DOM queries
+				// 
+				// TODO: use a better approach here:
+				// @see https://github.com/osteele/jquery-profile
+				var jQuery;
+		
+				window.__defineSetter__('jQuery', function(val) {
+					jQuery = val;
+					console.log('Mocked jQuery v' + val.fn.jquery + ' object');
+				});
+
+				window.__defineGetter__('jQuery', function() {
+					return jQuery;
+				});
+			})();
+		});
+	});
+
+	phantomas.on('loadFinished', function() {
+		phantomas.setMetricEvaluate('DOMqueries', function() {
+			return window.phantomas.domQueries;
+		});
+		
+		phantomas.setMetricEvaluate('DOMinserts', function() {
+			return window.phantomas.domInserts;
+		});
+
+		phantomas.setMetricEvaluate('jQuerySelectors', function() {
+			return window.phantomas.jQuerySelectors;
+		});
+
+		phantomas.setMetricEvaluate('jQueryOnDOMReadyFunctions', function() {
+			return window.phantomas.jQueryOnDOMReadyFunctions;
+		});
+
+		// list all selectors
+		var selectorsBacktrace = phantomas.evaluate(function() {
+			return window.phantomas.jQuerySelectorsBacktrace;
+		});
+/**
+		phantomas.addNotice('jQuery selectors:');
+		selectorsBacktrace.forEach(function(item) {
+			phantomas.addNotice('* $("' + item.selector + '") called from ' + item.url + ' @ ' + item.line);
+		});
+		phantomas.addNotice();
+
+		// list all onDOMReady functions
+		var onDOMReadyBacktrace = phantomas.evaluate(function() {
+			return window.phantomas.jQueryOnDOMReadyFunctionsBacktrace;
+		});
+
+		phantomas.addNotice('jQuery onDOMReady functions (' + onDOMReadyBacktrace.length + '):');
+		onDOMReadyBacktrace.forEach(function(item) {
+			phantomas.addNotice('* bound from ' + item.url + ' @ ' + item.line);
+		});
+		phantomas.addNotice();
+
+		// list all DOM inserts
+		var domInsertsBacktrace = phantomas.evaluate(function() {
+			return window.phantomas.domInsertsBacktrace;
+		});
+
+		phantomas.addNotice('DOM inserts (' + domInsertsBacktrace.length + '):');
+		domInsertsBacktrace.forEach(function(item) {
+			phantomas.addNotice('* from ' + item.url + ' @ ' + item.line);
+		});
+		phantomas.addNotice();
+**/
+	});
+};