passenger 5.0.21 → 5.0.22

data/src/nginx_module/ConfigurationFields.h

@@ -51,6 +51,8 @@
 
 
 
+	ngx_int_t abort_websockets_on_process_shutdown;
+
 	ngx_array_t *base_uris;
 
 	ngx_int_t debugger;
@@ -59,6 +61,8 @@
 
 	ngx_array_t *env_vars;
 
+	ngx_int_t force_max_concurrent_requests_per_process;
+
 	ngx_int_t friendly_error_pages;
 
 	ngx_uint_t headers_hash_bucket_size;

data/src/nginx_module/CreateLocationConfig.c

@@ -203,4 +203,12 @@ void generated_set_conf_part(passenger_loc_conf_t  *conf) {
 		conf->vary_turbocache_by_cookie.len  = 0;
 	
 
+	
+		conf->abort_websockets_on_process_shutdown = NGX_CONF_UNSET;
+	
+
+	
+		conf->force_max_concurrent_requests_per_process = NGX_CONF_UNSET;
+	
+
 }

data/src/nginx_module/MergeLocationConfig.c

@@ -264,5 +264,17 @@ int generated_merge_part(passenger_loc_conf_t *conf, passenger_loc_conf_t *prev,
 			NULL);
 	
 
+	
+		ngx_conf_merge_value(conf->abort_websockets_on_process_shutdown,
+			prev->abort_websockets_on_process_shutdown,
+			NGX_CONF_UNSET);
+	
+
+	
+		ngx_conf_merge_value(conf->force_max_concurrent_requests_per_process,
+			prev->force_max_concurrent_requests_per_process,
+			NGX_CONF_UNSET);
+	
+
 	return 1;
 }

data/src/nodejs_supportlib/phusion_passenger/log_express.js

@@ -0,0 +1,106 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2015 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+
+var ustReporter = global.phusion_passenger_ustReporter;
+
+var log;
+var express;
+
+var applicationThis;
+
+exports.initPreLoad = function() {
+	log = ustReporter.getPassengerLogger();
+	var appRoot = ustReporter.getApplicationRoot();
+	
+	try {
+		express = require(appRoot + "/node_modules/express");
+	} catch (e) {
+		// express not present, no need to instrument.
+		log.debug("Not instrumenting Express (probably not used): " + e);
+		return;
+	}
+	
+	try {
+		log.info("==== Instrumentation [Express] ==== initialize");
+		log.debug("hook application.init, to be the first in the use() line..");
+
+		express.application.initOrig = express.application.init;
+		express.application.init = function() {
+				log.debug("Express application.init() called, chain and then be the first to use()..");
+				var rval = express.application.initOrig.apply(this, arguments);
+
+				this.use(logRequest);
+				
+				applicationThis = this; // store for initPostLoad use
+				
+				return rval;
+			};
+
+		log.debug("Express tap: application.use, to be as late as possible in the use() line, but before any other error handlers..");
+		express.application.useOrig = express.application.use;
+		express.application.use = function() {
+			// Express recognizes error handlers by #params = 4
+			if (arguments[0].length == 4) {
+				express.application.useOrig.call(this, logException);
+			}
+		
+			express.application.useOrig.apply(this, arguments);
+		} 
+	} catch (e) {
+		log.error("Unable to instrument Express due to error: " + e);
+	}
+}
+
+exports.initPostLoad = function() {
+	if (!express) {
+		return;
+	}
+
+	log.debug("add final error handler..");
+	try {
+		if (applicationThis) {
+			express.application.useOrig.call(applicationThis, logException);
+		}
+	} catch (e) {
+		log.error("Unable to instrument Express error flow due to error: " + e);
+	}
+}
+
+function logRequest(req, res, next) {
+	log.verbose("==== Instrumentation [Express] ==== REQUEST [" + req.method + " " + req.url + "] attach");
+	ustReporter.attachToRequest(req, res, next);
+}
+
+function logException(err, req, res, next) {
+	// We may have multiple exception handlers in the routing chain, ensure only the first one actually logs.
+	if (!res.hasLoggedException) {
+		log.verbose("==== Instrumentation [Express] ==== EXCEPTION + TRACE FOR [" + req.url + "]");
+			
+		ustReporter.logException(err.name, err.message, err.stack);
+
+		res.hasLoggedException = true;
+	}
+	next(err);
+}

data/src/nodejs_supportlib/phusion_passenger/log_mongodb.js

@@ -0,0 +1,203 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2015 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+
+var ustReporter = global.phusion_passenger_ustReporter;
+
+var log;
+var mongodb;
+
+// From http://docs.mongodb.org/manual/reference/method/js-collection/
+var collectionMethods = [
+	"aggregate", "count", "copyTo", "createIndex", "dataSize", "distinct", "drop", "dropIndex", "dropIndexes",
+	"ensureIndex", "explain", "find", "findAndModify", "findOne", "getIndexes", "getShardDistribution", "getShardVersion",
+	"group", "insert", "isCapped", "mapReduce", "reIndex", "remove", "renameCollection", "save", "stats",
+	"storageSize", "totalSize", "totalIndexSize", "update", "validate"
+];
+
+function instrumentCollectionMethod(origParent, functionName, newFn) {
+	var originalFn = origParent[functionName];
+
+	// not used yet (unwrapping N/I)
+	origParent["_passenger_wrapped_" + functionName] = originalFn;
+
+	origParent[functionName] = function() {
+		var databaseName;
+		var collectionName;
+
+		if (this.s) {
+			// Plain driver
+			databaseName = this.s.dbName;
+			collectionName = this.s.name;
+		} else if (this.db) {
+			// Mongoskin 1.4.13
+			databaseName = this.db.databaseName;
+			collectionName = this.collectionName;
+		} else if (this._collection_args) {
+			// Mongoskin driver
+			databaseName = this._skin_db._connect_args[0];
+			collectionName = this._collection_args[0];
+		}
+
+		return newFn.call(this, arguments, databaseName, collectionName, functionName, originalFn);
+	};
+}
+
+function collectionFn(origArguments, databaseName, collectionName, functionName, originalFn) {
+	var friendlyName = databaseName + "." + collectionName + "." + functionName + "(..)";
+	var query = "";
+	for (i = 0; i < origArguments.length; i++) {
+		if (typeof(origArguments[i]) != 'function') { // mongoskin
+			query += (i > 0 ? "," : "") + JSON.stringify(origArguments[i]);
+		}
+	}
+	query = "'" + databaseName + "'.collection['" + collectionName + "']." + functionName + "(" + query + ")";
+
+	var tBegin = ustReporter.nowTimestamp();
+	var rval = originalFn.apply(this, origArguments);
+	var tEnd = ustReporter.nowTimestamp();
+
+	log.verbose("==== Instrumentation [MongoDB] ==== [" + query + "] (attach to txnId " + ustReporter.getCurrentTxnId() + ")");
+	
+	ustReporter.logTimedActivityMongo("mongo: " + query, tBegin, tEnd, query);
+	
+	return rval;
+}
+
+exports.initPreLoad = function() {
+	log = ustReporter.getPassengerLogger();
+	var appRoot = ustReporter.getApplicationRoot();
+	
+	// See if the mongodb driver is used. It can also be used through mongoskin, in which case older mongoskin
+	// versions will have it as part of their own node_modules.
+	try {
+		mongodb = require(appRoot + "/node_modules/mongodb");
+	} catch (e1) {
+		try {
+			mongodb = require(appRoot + "/node_modules/mongoskin/node_modules/mongodb");
+		} catch (e2) {
+			log.verbose("Not instrumenting MongoDB (probably not used): (default) " + e1 + ", (mongoskin) " + e2);
+			return;
+		}
+	}
+
+	log.info("==== Instrumentation [MongoDB] ==== initialize");
+
+	// The 1.4 mongo driver series uses a callback mechanism that breaks continuation-local-storage.
+	wrapRepairCLSMongo14();
+		
+	// Newer mongoskin techniques break continuation-local-storage, so we need to skin the skinner there.
+	wrapRepairCLSMongoskinUtils(appRoot);
+	
+	try {
+		for (i = 0; i < collectionMethods.length; i++) {
+			instrumentCollectionMethod(mongodb.Collection.prototype, collectionMethods[i], collectionFn);
+		}
+	} catch (e) {
+		log.error("Unable to instrument MongoDB due to error: " + e);
+	}
+}
+
+function wrapRepairCLSMongo14() {
+	try {
+		if (!mongodb.Db.prototype._executeQueryCommand || mongodb.Db.prototype._executeInsertCommand) {
+			log.verbose("Not using MongoDB 1.4.x, so don't need MongoDB continuation-local-storage workaround");
+			return;
+		}
+		
+		mongodb.Db.prototype._passenger_wrapped__executeQueryCommand = mongodb.Db.prototype._executeQueryCommand;
+		mongodb.Db.prototype._executeQueryCommand = function() {
+			if (arguments.length > 0 && typeof(arguments[arguments.length - 1]) === 'function') {
+				var callback = ustReporter.getCLSWrappedCallback(arguments[arguments.length - 1]);
+				var newArgs = [];
+				for (var i = 0; i < arguments.length - 1; i++) {
+					newArgs.push(arguments[i]);
+				}
+				newArgs.push(callback);
+				this._passenger_wrapped__executeQueryCommand.apply(this, newArgs);
+			} else {
+				this._passenger_wrapped__executeQueryCommand.apply(this, arguments);
+			}
+		}
+
+		mongodb.Db.prototype._passenger_wrapped__executeInsertCommand = mongodb.Db.prototype._executeInsertCommand;
+		mongodb.Db.prototype._executeInsertCommand = function() {
+			if (arguments.length > 0 && typeof(arguments[arguments.length - 1]) === 'function') {
+				var callback = ustReporter.getCLSWrappedCallback(arguments[arguments.length - 1]);
+				var newArgs = [];
+				for (var i = 0; i < arguments.length - 1; i++) {
+					newArgs.push(arguments[i]);
+				}
+				newArgs.push(callback);
+				this._passenger_wrapped__executeInsertCommand.apply(this, newArgs);
+			} else {
+				this._passenger_wrapped__executeInsertCommand.apply(this, arguments);
+			}
+		}
+		log.verbose("Using MongoDB 1.4.x continuation-local-storage workaround");
+	} catch (e) {
+		log.error("Not using MongoDB continuation-local-storage workaround: " + e);
+	}
+}
+
+// Mongoskin utils creates skin (wrapper) classes and in the process introduce an emitter for supporting
+// delayed open() (e.g. while the driver is still connecting).
+// The emitter breaks continuation-local-storage, but since it is for top-level classes (Db, Collection, etc.)
+// we can't bind it per request, so we need to bind the individual callbacks that get pushed onto it.
+function wrapRepairCLSMongoskinUtils(appRoot) {
+	var mongoskinUtils;
+	try {
+		mongoskinUtils = require(appRoot + "/node_modules/mongoskin/lib/utils");
+	} catch (e) {
+		log.verbose("Not using mongoskin continuation-local-storage workaround (either not used, old version, or new unsupported version): " + e);
+		return;
+	}
+	
+	try {
+		// makeSkinClass is a factory, so need a double wrap: one to get the run-time factory output (skinClass),
+		// and then one that hooks the actual method in that output.
+		mongoskinUtils._passenger_wrapped_makeSkinClass = mongoskinUtils.makeSkinClass;
+		mongoskinUtils.makeSkinClass = function(NativeClass, useNativeConstructor) {
+			var skinClass = mongoskinUtils._passenger_wrapped_makeSkinClass(NativeClass, useNativeConstructor);
+	
+			skinClass.prototype._passenger_wrapped_open = skinClass.prototype.open;
+			skinClass.prototype.open = function(callback) {
+				// Finally we can bind the callback so that when the emitter calls it, the cls is mapped correctly.
+				return skinClass.prototype._passenger_wrapped_open.call(this, ustReporter.getCLSWrappedCallback(callback));
+			}
+	
+			return skinClass;
+		}
+		log.verbose("Using mongoskin continuation-local-storage workaround");
+	} catch (e) {
+		log.error("Not using mongoskin continuation-local-storage workaround (probably an unsupported version): " + e);
+	}
+}
+
+exports.initPostLoad = function() {
+	//if (!mongodb) {
+	//	return;
+	//}
+}
+

data/src/nodejs_supportlib/phusion_passenger/ustreporter.js

@@ -0,0 +1,227 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2015 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+
+var codify = require('vendor-copy/codify');
+
+var reqNamespace = require('vendor-copy/continuation-local-storage').getNamespace('passenger-request-ctx');
+
+// Assigned by init()
+var ustLog;
+var log;
+var appRoot;
+
+/**
+ * @return logger set to Passenger's loglevel. For example, log.error("") maps to Passenger loglevel 1. All mappings:
+ * 1: error
+ * 2: warn
+ * 3: notice
+ * 4: info
+ * 5: verbose
+ * 6: debug
+ * 7: silly
+ * (other levels are mapped to critical)
+ */
+exports.getPassengerLogger = function() {
+	return log;
+}
+
+/**
+ * @return the application root path, needed for instrumenting an application's node modules.
+ */
+exports.getApplicationRoot = function() {
+	return appRoot;
+}
+
+/**
+ * @return timestamp in microseconds to be used as the start or end timestamp for timed logging (monotonic clock, not wall clock).
+ */
+exports.nowTimestamp = function() {
+	var secAndUsec = process.hrtime();
+	return (secAndUsec[0] * 1e6) + (secAndUsec[1] / 1e3);
+}
+
+/**
+ * All Activity logs will be dropped unless they are done after this method, from within an execution chain starting with the callback. So it is
+ * essential to call this function whenever you intercept a request, before code that might want to log can be reached. The function adds context
+ * to the execution chain such that future logs can be correctly appended to the currently open request log, also for modules that don't 
+ * have access to the request object (such as database drivers).
+ *
+ * @param callback
+ *			The "next" handler in line for processing the request. Logging will only work from this handler or within the same execution chain!
+ */
+exports.attachToRequest = function(request, response, callback) {
+	try {
+		log.debug("ustReporter: attachToRequest(" + request.method + " " + request.url + ")");
+		var attachToTxnId = request.headers['!~passenger-txn-id'];
+		if (!attachToTxnId) {
+			log.warn("Dropping Union Station request log due to lack of txnId from Passenger Core (probably a temporary UstRouter failure)");
+			return callback();
+		}
+
+		reqNamespace.bindEmitter(request);
+		reqNamespace.bindEmitter(response);
+
+		// The Passenger core has an open transaction associated with the request, to which we can attach info from node instrumentation.
+		// However, logToUstTransaction() communicates async with the ustrouter, and is not guaranteed to deliver before the application response arrives 
+		// back to the core (at which point the core will close the transaction and later additions will not be taken into account).
+		// That's why we intercept response.end() (from the doc: the method, response.end(), MUST be called on each response), so we can defer it
+		// until we are sure the ustrouter is aware of any attachments generated during the request handling.
+		response._passenger_wrapped_end = response.end;
+		response.end = function() {
+			return ustLog.deferIfPendingTxns(attachToTxnId, this, response._passenger_wrapped_end, arguments);
+		};
+	
+		// Make request transaction ID available for other instrumentation modules, e.g. mongo doesn't know about requests (which is how the core passes
+		// txn ID).
+		reqNamespace.run(function() {
+			reqNamespace.set("attachToTxnId", attachToTxnId);
+			callback();
+		});
+	} catch (e) {
+		log.error("Dropping Union Station request log due to error:\n" + e.stack);
+	}
+}
+
+/**
+ * Log a timed block, described by activityName, with an optional message to display (e.g. in a mouseover).
+ */
+exports.logTimedActivityGeneric = function(activityName, tBegin, tEnd, message) {
+	logTimedActivity(activityName, tBegin, tEnd, "generic", message ? { "message": message } : undefined);
+}
+
+/**
+ * Log a timed mongo database interaction block, described by activityName, with an optional query to display (e.g. in a mouseover).
+ */
+exports.logTimedActivityMongo = function(activityName, tBegin, tEnd, query) {
+	logTimedActivity(activityName, tBegin, tEnd, "mongo", query ? { "query": query } : undefined);
+}
+
+/**
+ * Log a timed SQL database interaction block, described by activityName, with an optional query to display (e.g. in a mouseover).
+ */
+exports.logTimedActivitySQL = function(activityName, tBegin, tEnd, query) {
+	logTimedActivity(activityName, tBegin, tEnd, "sql", query ? { "query": query } : undefined);
+}
+
+/**
+ * Internal, base for the public logTimedActivity...()
+ * @param activityName
+ *			the name to display for this activity
+ * @param tBegin
+ *			activity start timestamp, acquired using .nowTimestamp()
+ * @param tEnd
+ *			activity end timestamp, acquired using .nowTimestamp()
+ * @param dataType
+ *			the type of this activity, and the data in the dataObj; assumed to be one of "generic", "sql", "mongo", "view"
+ * @param dataObj
+ *			optional; usually content for a mouseover
+ */
+function logTimedActivity(activityName, tBegin, tEnd, dataType, dataObj) {
+	try {
+		log.debug("ustReporter: logTimedActivity(activityName: " + activityName + ")");
+		if (!activityName || !tBegin || !tEnd) {
+			log.error("ustReporter: logTimedActivity is missing name or begin/end timestamp, dropping.");
+			return;
+		}
+		
+		var attachToTxnId = getCurrentTxnId();
+		if (!attachToTxnId) {
+			log.warn("Dropping Union Station timed action log due to lack of txnId to attach to " +
+				"(either request was not intercepted, cls context lost, or temporary UstRouter failure).\nCall stack: " + (new Error().stack));
+			return;
+		}
+
+		var uniqueTag = codify.toCode(tBegin);
+		var extraInfo;
+		if (!dataType) {
+			extraInfo = JSON.stringify({ "name": activityName });
+		} else {
+			extraInfo = JSON.stringify({ "name": activityName, "data_type": dataType, "data": dataObj });
+		}
+		var logBuf = [];
+		logBuf.push("BEGIN: " + uniqueTag + " (" + codify.toCode(tBegin) + ") " + new Buffer(extraInfo).toString('base64'));
+		logBuf.push("END: " + uniqueTag + " (" + codify.toCode(tEnd) + ")");
+		ustLog.logToUstTransaction("requests", logBuf, attachToTxnId);
+	} catch (e) {
+		log.error("Dropping Union Station timed action log due to error:\n" + e.stack);
+	}
+}
+
+/**
+ * For logging intercepted exceptions. If the exception occurred in relation to a request (i.e. within an execution chain from the attachToRequest 
+ * callback), the exception will be associated with that request, otherwise it's sent as a standalone.
+ *
+ * @param name
+ *			E.g. "NameError"
+ * @param message
+ *			E.g. "undefined local variable or method for .."
+ * @param trace
+ *			Backtrace
+ */
+exports.logException = function(name, message, trace) {
+	try {
+		log.debug("ustReporter: logException(name: " + name + ", message: " + message + ")");
+		var logBuf = [];
+		
+		var requestTxnId = getCurrentTxnId();
+		if (requestTxnId) {
+			logBuf.push("Request transaction ID: " + requestTxnId);
+		}
+		
+		logBuf.push("Message: " + new Buffer(message).toString('base64'));
+		logBuf.push("Class: " + name);
+		logBuf.push("Backtrace: " + new Buffer(trace).toString('base64'));
+
+		ustLog.logToUstTransaction("exceptions", logBuf);
+	} catch (e) {
+		log.error("Dropping Union Station exception log due to error:\n" + e.stack);
+	}
+}
+
+/**
+ * Get the current request transaction id necessary to append logs to it. This is normally done automatically, but some modules break automatic attachment
+ * in the execution chain (implemented by continuation-local-storage). This method can be used to trace until at what point the transaction id gets
+ * lost, and patch that place with .getCLSWrappedCallback().
+ */
+function getCurrentTxnId() {
+	return reqNamespace.get("attachToTxnId");
+}
+exports.getCurrentTxnId = getCurrentTxnId;
+
+/**
+ * For patching callback systems that are incompatible with continuation-local-storage.
+ */
+exports.getCLSWrappedCallback = function(origCallback) {
+	return reqNamespace.bind(origCallback);
+}
+
+/**
+ * For internal use. Called by Passenger loader, no need to call from anywhere else.
+ */
+exports.init = function(logger, applicationRoot, ustLogger) {
+	log = logger;
+	appRoot = applicationRoot;
+	ustLog = ustLogger;
+}