AlkantarClanX12
Your IP : 216.73.217.128
/*
* 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;
//}
}