passenger 6.0.12 → 6.0.13

data/src/nodejs_supportlib/vendor-copy/winston/lib/winston/logger.js

@@ -14,6 +14,8 @@ var events = require('events'),
     exception = require('./exception'),
     Stream = require('stream').Stream;
 
+var formatRegExp = /%[sdj%]/g;
+
 //
 // ### function Logger (options)
 // #### @options {Object} Options for this instance.
@@ -22,10 +24,41 @@ var events = require('events'),
 //
 var Logger = exports.Logger = function (options) {
   events.EventEmitter.call(this);
+  this.configure(options);
+};
+
+//
+// Inherit from `events.EventEmitter`.
+//
+util.inherits(Logger, events.EventEmitter);
+
+//
+// ### function configure (options)
+// This will wholesale reconfigure this instance by:
+// 1. Resetting all transports. Older transports will be removed implicitly.
+// 2. Set all other options including levels, colors, rewriters, filters,
+//    exceptionHandlers, etc.
+//
+Logger.prototype.configure = function (options) {
+  var self = this;
+
+  //
+  // If we have already been setup with transports
+  // then remove them before proceeding.
+  //
+  if (Array.isArray(this._names) && this._names.length) {
+    this.clear();
+  }
+
   options = options || {};
+  this.transports = {};
+  this._names     = [];
 
-  var self = this,
-      handleExceptions = false;
+  if (options.transports) {
+    options.transports.forEach(function (transport) {
+      self.add(transport, null, true);
+    });
+  }
 
   //
   // Set Levels and default logging level
@@ -39,6 +72,7 @@ var Logger = exports.Logger = function (options) {
   //
   // Hoist other options onto this instance.
   //
+  this.id          = options.id || null;
   this.level       = options.level || 'info';
   this.emitErrs    = options.emitErrs || false;
   this.stripColors = options.stripColors || false;
@@ -47,65 +81,21 @@ var Logger = exports.Logger = function (options) {
     : true;
 
   //
-  // Setup other intelligent default settings.
+  // Setup internal state as empty Objects even though it is
+  // defined lazily later to ensure a strong existential API contract.
   //
-  this.transports        = {};
-  this.rewriters         = [];
-  this.filters           = [];
   this.exceptionHandlers = {};
   this.profilers         = {};
-  this._names            = [];
-  this._hnames           = [];
-
-  if (options.transports) {
-    options.transports.forEach(function (transport) {
-      self.add(transport, null, true);
 
-      if (transport.handleExceptions) {
-        handleExceptions = true;
-      }
-    });
-  }
-
-  if (options.rewriters) {
-    options.rewriters.forEach(function (rewriter) {
-      self.addRewriter(rewriter);
-    });
-  }
+  ['rewriters', 'filters'].forEach(function (kind) {
+    self[kind] = Array.isArray(options[kind])
+      ? options[kind]
+      : [];
+  });
 
   if (options.exceptionHandlers) {
-    handleExceptions = true;
-    options.exceptionHandlers.forEach(function (handler) {
-      self._hnames.push(handler.name);
-      self.exceptionHandlers[handler.name] = handler;
-    });
+    this.handleExceptions(options.exceptionHandlers);
   }
-
-  if (options.handleExceptions || handleExceptions) {
-    this.handleExceptions();
-  }
-};
-
-//
-// Inherit from `events.EventEmitter`.
-//
-util.inherits(Logger, events.EventEmitter);
-
-//
-// ### function extend (target)
-// #### @target {Object} Target to extend.
-// Extends the target object with a 'log' method
-// along with a method for each level in this instance.
-//
-Logger.prototype.extend = function (target) {
-  var self = this;
-  ['log', 'profile', 'startTimer'].concat(Object.keys(this.levels)).forEach(function (method) {
-    target[method] = function () {
-      return self[method].apply(self, arguments);
-    };
-  });
-
-  return this;
 };
 
 //
@@ -117,23 +107,28 @@ Logger.prototype.extend = function (target) {
 // Core logging method exposed to Winston. Metadata is optional.
 //
 Logger.prototype.log = function (level) {
-  var self = this,
-      args = Array.prototype.slice.call(arguments, 1);
+  var args = Array.prototype.slice.call(arguments, 1),
+      self = this,
+      transports;
 
-  while(args[args.length - 1] === null) {
+  while (args[args.length - 1] === null) {
     args.pop();
   }
 
-  var callback = typeof args[args.length - 1] === 'function' ? args.pop() : null,
-      meta     = typeof args[args.length - 1] === 'object' && Object.prototype.toString.call(args[args.length - 1]) !== '[object RegExp]' ? args.pop() : {},
-      msg      = util.format.apply(null, args);
-
-  // If we should pad for levels, do so
-  if (this.padLevels) {
-    msg = new Array(this.levelLength - level.length + 1).join(' ') + msg;
-  }
+  //
+  // Determining what is `meta` and what are arguments for string interpolation
+  // turns out to be VERY tricky. e.g. in the cases like this:
+  //
+  //    logger.info('No interpolation symbols', 'ok', 'why', { meta: 'is-this' });
+  //
+  var callback  = typeof args[args.length - 1] === 'function'
+    ? args.pop()
+    : null;
 
-  function onError (err) {
+  //
+  // Handle errors appropriately.
+  //
+  function onError(err) {
     if (callback) {
       callback(err);
     }
@@ -142,20 +137,75 @@ Logger.prototype.log = function (level) {
     }
   }
 
-
-  if (Object.keys(this.transports).length === 0) {
+  if (this._names.length === 0) {
     return onError(new Error('Cannot log with no transports.'));
   }
   else if (typeof self.levels[level] === 'undefined') {
     return onError(new Error('Unknown log level: ' + level));
   }
 
+  //
+  // If there are no transports that match the level
+  // then be eager and return. This could potentially be calculated
+  // during `setLevels` for more performance gains.
+  //
+  var targets = this._names.filter(function (name) {
+    var transport = self.transports[name];
+    return (transport.level && self.levels[transport.level] >= self.levels[level])
+      || (!transport.level && self.levels[self.level] >= self.levels[level]);
+  });
+
+  if (!targets.length) {
+    if (callback) { callback(); }
+    return;
+  }
+
+  //
+  // Determining what is `meta` and what are arguments for string interpolation
+  // turns out to be VERY tricky. e.g. in the cases like this:
+  //
+  //    logger.info('No interpolation symbols', 'ok', 'why', { meta: 'is-this' });
+  //
+  var msg, meta = {}, validMeta = false;
+  var hasFormat = args && args[0] && args[0].match && args[0].match(formatRegExp) !== null;
+  var tokens = (hasFormat) ? args[0].match(formatRegExp) : [];
+  var ptokens = tokens.filter(function(t) { return t === '%%' });
+  if (((args.length - 1) - (tokens.length - ptokens.length)) > 0 || args.length === 1) {
+    // last arg is meta
+    meta = args[args.length - 1] || args;
+    var metaType = Object.prototype.toString.call(meta);
+    validMeta = metaType === '[object Object]' ||
+      metaType === '[object Error]' || metaType === '[object Array]';
+    meta = validMeta ? args.pop() : {};
+  }
+  msg = util.format.apply(null, args);
+
+  //
+  // Respond to the callback.
+  //
+  function finish(err) {
+    if (callback) {
+      if (err) return callback(err);
+      callback(null, level, msg, meta);
+    }
+
+    callback = null;
+    if (!err) {
+      self.emit('logged', level, msg, meta);
+    }
+  }
+
+  // If we should pad for levels, do so
+  if (this.padLevels) {
+    msg = new Array(this.levelLength - level.length + 1).join(' ') + msg;
+  }
+
   this.rewriters.forEach(function (rewriter) {
     meta = rewriter(level, msg, meta, self);
   });
 
   this.filters.forEach(function(filter) {
-    var filtered = filter(msg, meta, level, self);
+    var filtered = filter(level, msg, meta, self);
     if (typeof filtered === 'string')
       msg = filtered;
     else {
@@ -179,40 +229,21 @@ Logger.prototype.log = function (level) {
   //
   // Log for each transport and emit 'logging' event
   //
-  function emit(name, next) {
+  function transportLog(name, next) {
     var transport = self.transports[name];
-    if ((transport.level && self.levels[transport.level] <= self.levels[level])
-      || (!transport.level && self.levels[self.level] <= self.levels[level])) {
-      transport.log(level, msg, meta, function (err) {
-        if (err) {
-          err.transport = transport;
-          cb(err);
-          return next();
-        }
-        self.emit('logging', transport, level, msg, meta);
-        next();
-      });
-    } else {
-      next();
-    }
-  }
+    transport.log(level, msg, meta, function (err) {
+      if (err) {
+        err.transport = transport;
+        finish(err);
+        return next();
+      }
 
-  //
-  // Respond to the callback
-  //
-  function cb(err) {
-    if (callback) {
-      if (err) return callback(err);
-      callback(null, level, msg, meta);
-    }
-    callback = null;
-    if (!err) {
-      self.emit('logged', level, msg, meta);
-    }
+      self.emit('logging', transport, level, msg, meta);
+      next();
+    });
   }
 
-  async.forEach(this._names, emit, cb);
-
+  async.forEach(targets, transportLog, finish);
   return this;
 };
 
@@ -257,7 +288,7 @@ Logger.prototype.query = function (options, callback) {
   // Helper function to accumulate the results from
   // `queryTransport` into the `results`.
   //
-  function addResults (transport, next) {
+  function addResults(transport, next) {
     queryTransport(transport, function (err, result) {
       //
       // queryTransport could potentially invoke the callback
@@ -379,8 +410,9 @@ Logger.prototype.close = function () {
 };
 
 //
-// ### function handleExceptions ()
-// Handles `uncaughtException` events for the current process
+// ### function handleExceptions ([tr0, tr1...] || tr0, tr1, ...)
+// Handles `uncaughtException` events for the current process by
+// ADDING any handlers passed in.
 //
 Logger.prototype.handleExceptions = function () {
   var args = Array.prototype.slice.call(arguments),
@@ -396,6 +428,7 @@ Logger.prototype.handleExceptions = function () {
     }
   });
 
+  this.exceptionHandlers = this.exceptionHandlers || {};
   handlers.forEach(function (handler) {
     self.exceptionHandlers[handler.name] = handler;
   });
@@ -451,7 +484,7 @@ Logger.prototype.add = function (transport, options, created) {
     throw new Error('Unknown transport with no log() method');
   }
   else if (this.transports[instance.name]) {
-    throw new Error('Transport already attached: ' + instance.name);
+    throw new Error('Transport already attached: ' + instance.name + ", assign a different name");
   }
 
   this.transports[instance.name] = instance;
@@ -476,37 +509,14 @@ Logger.prototype.add = function (transport, options, created) {
   return this;
 };
 
-//
-// ### function addRewriter (transport, [options])
-// #### @transport {Transport} Prototype of the Transport object to add.
-// #### @options {Object} **Optional** Options for the Transport to add.
-// #### @instance {Boolean} **Optional** Value indicating if `transport` is already instantiated.
-// Adds a transport of the specified type to this instance.
-//
-Logger.prototype.addRewriter = function (rewriter) {
-  this.rewriters.push(rewriter);
-}
-
-//
-// ### function addFilter (filter)
-// #### @filter {function} Filter function, called with the message and
-// optional metadata as the two arguments.
-// Expected to return either the filtered message or an object with properties:
-//   - msg = the filtered message string
-//   - meta = the filtered metadata object
-//
-Logger.prototype.addFilter = function (filter) {
-  this.filters.push(filter);
-}
-
 //
 // ### function clear ()
 // Remove all transports from this instance
 //
 Logger.prototype.clear = function () {
-  for (var name in this.transports) {
+  Object.keys(this.transports).forEach(function (name) {
     this.remove({ name: name });
-  }
+  }, this);
 };
 
 //
@@ -537,26 +547,19 @@ Logger.prototype.remove = function (transport) {
   return this;
 };
 
-var ProfileHandler = function (logger) {
-  this.logger = logger;
-
-  this.start = Date.now();
-
-  this.done = function (msg) {
-    var args, callback, meta;
-    args     = Array.prototype.slice.call(arguments);
-    callback = typeof args[args.length - 1] === 'function' ? args.pop() : null;
-    meta     = typeof args[args.length - 1] === 'object' ? args.pop() : {};
-
-    meta.durationMs = (Date.now()) - this.start;
-
-    return this.logger.info(msg, meta, callback);
-  }
-}
-
+//
+// ### function startTimer ()
+// Returns an object corresponding to a specific timing. When done
+// is called the timer will finish and log the duration. e.g.:
+//
+//    timer = winston.startTimer()
+//    setTimeout(function(){
+//      timer.done("Logging message");
+//    }, 1000);
+//
 Logger.prototype.startTimer = function () {
   return new ProfileHandler(this);
-}
+};
 
 //
 // ### function profile (id, [msg, meta, callback])
@@ -699,3 +702,28 @@ Logger.prototype._onError = function (transport, err) {
     this.emit('error', err, transport);
   }
 };
+
+//
+// ### @private ProfileHandler
+// Constructor function for the ProfileHandler instance used by
+// `Logger.prototype.startTimer`. When done is called the timer
+// will finish and log the duration.
+//
+function ProfileHandler(logger) {
+  this.logger = logger;
+  this.start = Date.now();
+}
+
+//
+// ### function done (msg)
+// Ends the current timer (i.e. ProfileHandler) instance and
+// logs the `msg` along with the duration since creation.
+//
+ProfileHandler.prototype.done = function (msg) {
+  var args     = Array.prototype.slice.call(arguments),
+      callback = typeof args[args.length - 1] === 'function' ? args.pop() : null,
+      meta     = typeof args[args.length - 1] === 'object' ? args.pop() : {};
+
+  meta.duration = (Date.now()) - this.start + 'ms';
+  return this.logger.info(msg, meta, callback);
+};

data/src/nodejs_supportlib/vendor-copy/winston/lib/winston/transports/console.js

@@ -7,6 +7,7 @@
  */
 
 var events = require('events'),
+    os = require('os'),
     util = require('util'),
     common = require('../common'),
     Transport = require('./transport').Transport;
@@ -31,6 +32,7 @@ var Console = exports.Console = function (options) {
   this.depth        = options.depth       || null;
   this.align        = options.align       || false;
   this.stderrLevels = setStderrLevels(options.stderrLevels, options.debugStdout);
+  this.eol          = options.eol   || os.EOL;
 
   if (this.json) {
     this.stringify = options.stringify || function (obj) {
@@ -114,9 +116,9 @@ Console.prototype.log = function (level, msg, meta, callback) {
   });
 
   if (this.stderrLevels[level]) {
-    process.stderr.write(output + '\n');
+    process.stderr.write(output + this.eol);
   } else {
-    process.stdout.write(output + '\n');
+    process.stdout.write(output + this.eol);
   }
 
   //

data/src/nodejs_supportlib/vendor-copy/winston/lib/winston/transports/file.js

@@ -159,8 +159,11 @@ File.prototype.log = function (level, msg, meta, callback) {
     depth:       this.depth,
     formatter:   this.formatter,
     humanReadableUnhandledException: this.humanReadableUnhandledException
-  }) + this.eol;
+  });
 
+  if (typeof output === 'string') {
+    output += this.eol;
+  }
 
   if (!this.filename) {
     //
@@ -284,7 +287,8 @@ File.prototype.query = function (options, callback) {
   }
 
   function push(log) {
-    if (options.rows && results.length >= options.rows) {
+    if (options.rows && results.length >= options.rows
+        && options.order != 'desc') {
       if (stream.readable) {
         stream.destroy();
       }
@@ -299,6 +303,11 @@ File.prototype.query = function (options, callback) {
       log = obj;
     }
 
+    if (options.order === 'desc') {
+      if (results.length >= options.rows) {
+        results.shift();
+      }
+    }
     results.push(log);
   }
 
@@ -309,7 +318,8 @@ File.prototype.query = function (options, callback) {
 
     var time = new Date(log.timestamp);
     if ((options.from && time < options.from)
-        || (options.until && time > options.until)) {
+        || (options.until && time > options.until)
+        || (options.level && options.level !== log.level)) {
       return;
     }
 
@@ -521,7 +531,7 @@ File.prototype._createStream = function () {
 
         inp.pipe(gzip).pipe(out);
 
-        fs.unlink(String(self._archive));
+        fs.unlink(String(self._archive), function () {});
         self._archive = '';
       }
     }
@@ -668,7 +678,7 @@ File.prototype._lazyDrain = function () {
     this._draining = true;
 
     this._stream.once('drain', function () {
-      this._draining = false;
+      self._draining = false;
       self.emit('logged');
     });
   }

data/src/nodejs_supportlib/vendor-copy/winston/lib/winston/transports/http.js

@@ -21,6 +21,9 @@ var Http = exports.Http = function (options) {
   this.port = options.port;
   this.auth = options.auth;
   this.path = options.path || '';
+  this.agent = options.agent;
+  this.headers = options.headers || {};
+  this.headers['content-type'] = 'application/json';
 
   if (!this.port) {
     this.port = this.ssl ? 443 : 80;
@@ -56,20 +59,27 @@ Http.prototype._request = function (options, callback) {
     port: this.port,
     path: '/' + path.replace(/^\//, ''),
     method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+    headers: this.headers,
+    agent: this.agent,
     auth: (auth) ? auth.username + ':' + auth.password : ''
   });
 
   req.on('error', callback);
   req.on('response', function (res) {
+    var body = '';
+
+    res.on('data', function (chunk) {
+      body += chunk;
+    });
+
     res.on('end', function () {
-      callback(null, res);
+      callback(null, res, body);
     });
 
     res.resume();
   });
 
-  req.end(new Buffer(JSON.stringify(options), 'utf8'));
+  req.end(new Buffer.from(JSON.stringify(options), 'utf8'));
 };
 
 //
@@ -180,7 +190,7 @@ Http.prototype.query = function (options, callback) {
 //
 Http.prototype.stream = function (options) {
   options = options || {};
-  
+
   var self = this,
       stream = new Stream,
       req,

data/src/nodejs_supportlib/vendor-copy/winston/lib/winston/transports.js

@@ -6,29 +6,31 @@
  *
  */
 
-var fs = require('fs'),
-    path = require('path'),
-    common = require('./common');
-
-var transports = exports;
-
-//
-// Setup all transports as lazy-loaded getters.
-//
-fs.readdirSync(path.join(__dirname, 'transports')).forEach(function (file) {
-  var transport = file.replace('.js', ''),
-      name  = common.capitalize(transport);
-
-  if (transport === 'transport') {
-    return;
+Object.defineProperty(exports, 'Console', {
+  configurable: true,
+  enumerable: true,
+  get: function () {
+    return require('./transports/console').Console;
   }
-  else if (~transport.indexOf('-')) {
-    name = transport.split('-').map(function (part) {
-      return common.capitalize(part);
-    }).join('');
+});
+Object.defineProperty(exports, 'File', {
+  configurable: true,
+  enumerable: true,
+  get: function () {
+    return require('./transports/file').File;
   }
-
-  transports.__defineGetter__(name, function () {
-    return require('./transports/' + transport)[name];
-  });
-});
+});
+Object.defineProperty(exports, 'Http', {
+  configurable: true,
+  enumerable: true,
+  get: function () {
+    return require('./transports/http').Http;
+  }
+});
+Object.defineProperty(exports, 'Memory', {
+  configurable: true,
+  enumerable: true,
+  get: function () {
+    return require('./transports/memory').Memory;
+  }
+});

data/src/nodejs_supportlib/vendor-copy/winston/lib/winston.js

@@ -9,9 +9,9 @@
 var winston = exports;
 
 //
-// Expose version using `pkginfo`
+// use require method for webpack bundle
 //
-require('pkginfo')(module, 'version');
+winston.version = require('../package.json').version
 
 //
 // Include transports defined by default by winston
@@ -63,7 +63,7 @@ var defaultLogger = new winston.Logger({
 });
 
 //
-// Pass through the target methods onto `winston.
+// Pass through the target methods onto `winston`.
 //
 var methods = [
   'log',
@@ -78,9 +78,9 @@ var methods = [
   'cli',
   'handleExceptions',
   'unhandleExceptions',
-  'addRewriter',
-  'addFilter'
+  'configure'
 ];
+winston.padLevels = false;
 common.setLevels(winston, null, defaultLogger.levels);
 methods.forEach(function (method) {
   winston[method] = function () {