passenger 5.0.21 → 5.0.22

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

@@ -0,0 +1,232 @@
+var util = require('util'),
+    winston = require('../../winston'),
+    http = require('http'),
+    https = require('https'),
+    Stream = require('stream').Stream,
+    Transport = require('./transport').Transport;
+
+//
+// ### function Http (options)
+// #### @options {Object} Options for this instance.
+// Constructor function for the Http transport object responsible
+// for persisting log messages and metadata to a terminal or TTY.
+//
+var Http = exports.Http = function (options) {
+  Transport.call(this, options);
+  options = options || {};
+
+  this.name = 'http';
+  this.ssl = !!options.ssl;
+  this.host = options.host || 'localhost';
+  this.port = options.port;
+  this.auth = options.auth;
+  this.path = options.path || '';
+
+  if (!this.port) {
+    this.port = this.ssl ? 443 : 80;
+  }
+};
+
+util.inherits(Http, winston.Transport);
+
+//
+// Expose the name of this Transport on the prototype
+//
+Http.prototype.name = 'http';
+
+//
+// ### function _request (options, callback)
+// #### @callback {function} Continuation to respond to when complete.
+// Make a request to a winstond server or any http server which can
+// handle json-rpc.
+//
+Http.prototype._request = function (options, callback) {
+  options = options || {};
+
+  var auth = options.auth || this.auth,
+      path = options.path || this.path || '',
+      req;
+
+  delete options.auth;
+  delete options.path;
+
+  // Prepare options for outgoing HTTP request
+  req = (this.ssl ? https : http).request({
+    host: this.host,
+    port: this.port,
+    path: '/' + path.replace(/^\//, ''),
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    auth: (auth) ? auth.username + ':' + auth.password : ''
+  });
+
+  req.on('error', callback);
+  req.on('response', function (res) {
+    res.on('end', function () {
+      callback(null, res);
+    });
+
+    res.resume();
+  });
+
+  req.end(new Buffer(JSON.stringify(options), 'utf8'));
+};
+
+//
+// ### function log (level, msg, [meta], callback)
+// #### @level {string} Level at which to log the message.
+// #### @msg {string} Message to log
+// #### @meta {Object} **Optional** Additional metadata to attach
+// #### @callback {function} Continuation to respond to when complete.
+// Core logging method exposed to Winston. Metadata is optional.
+//
+Http.prototype.log = function (level, msg, meta, callback) {
+  var self = this;
+
+  if (typeof meta === 'function') {
+    callback = meta;
+    meta = {};
+  }
+
+  var options = {
+    method: 'collect',
+    params: {
+      level: level,
+      message: msg,
+      meta: meta
+    }
+  };
+
+  if (meta) {
+    if (meta.path) {
+      options.path = meta.path;
+      delete meta.path;
+    }
+
+    if (meta.auth) {
+      options.auth = meta.auth;
+      delete meta.auth;
+    }
+  }
+
+  this._request(options, function (err, res) {
+    if (res && res.statusCode !== 200) {
+      err = new Error('HTTP Status Code: ' + res.statusCode);
+    }
+
+    if (err) return callback(err);
+
+    // TODO: emit 'logged' correctly,
+    // keep track of pending logs.
+    self.emit('logged');
+
+    if (callback) callback(null, true);
+  });
+};
+
+//
+// ### function query (options, callback)
+// #### @options {Object} Loggly-like query options for this instance.
+// #### @callback {function} Continuation to respond to when complete.
+// Query the transport. Options object is optional.
+//
+Http.prototype.query = function (options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+
+  var self = this,
+      options = this.normalizeQuery(options);
+
+  options = {
+    method: 'query',
+    params: options
+  };
+
+  if (options.params.path) {
+    options.path = options.params.path;
+    delete options.params.path;
+  }
+
+  if (options.params.auth) {
+    options.auth = options.params.auth;
+    delete options.params.auth;
+  }
+
+  this._request(options, function (err, res, body) {
+    if (res && res.statusCode !== 200) {
+      err = new Error('HTTP Status Code: ' + res.statusCode);
+    }
+
+    if (err) return callback(err);
+
+    if (typeof body === 'string') {
+      try {
+        body = JSON.parse(body);
+      } catch (e) {
+        return callback(e);
+      }
+    }
+
+    callback(null, body);
+  });
+};
+
+//
+// ### function stream (options)
+// #### @options {Object} Stream options for this instance.
+// Returns a log stream for this transport. Options object is optional.
+//
+Http.prototype.stream = function (options) {
+  options = options || {};
+  
+  var self = this,
+      stream = new Stream,
+      req,
+      buff;
+
+  stream.destroy = function () {
+    req.destroy();
+  };
+
+  options = {
+    method: 'stream',
+    params: options
+  };
+
+  if (options.params.path) {
+    options.path = options.params.path;
+    delete options.params.path;
+  }
+
+  if (options.params.auth) {
+    options.auth = options.params.auth;
+    delete options.params.auth;
+  }
+
+  req = this._request(options);
+  buff = '';
+
+  req.on('data', function (data) {
+    var data = (buff + data).split(/\n+/),
+        l = data.length - 1,
+        i = 0;
+
+    for (; i < l; i++) {
+      try {
+        stream.emit('log', JSON.parse(data[i]));
+      } catch (e) {
+        stream.emit('error', e);
+      }
+    }
+
+    buff = data[l];
+  });
+
+  req.on('error', function (err) {
+    stream.emit('error', err);
+  });
+
+  return stream;
+};

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

@@ -0,0 +1,89 @@
+var events = require('events'),
+    util = require('util'),
+    common = require('../common'),
+    Transport = require('./transport').Transport;
+
+//
+// ### function Memory (options)
+// #### @options {Object} Options for this instance.
+// Constructor function for the Memory transport object responsible
+// for persisting log messages and metadata to a memory array of messages.
+//
+var Memory = exports.Memory = function (options) {
+  Transport.call(this, options);
+  options = options || {};
+
+  this.errorOutput = [];
+  this.writeOutput = [];
+
+  this.json        = options.json        || false;
+  this.colorize    = options.colorize    || false;
+  this.prettyPrint = options.prettyPrint || false;
+  this.timestamp   = typeof options.timestamp !== 'undefined' ? options.timestamp : false;
+  this.showLevel   = options.showLevel === undefined ? true : options.showLevel;
+  this.label       = options.label       || null;
+  this.depth       = options.depth       || null;
+
+  if (this.json) {
+    this.stringify = options.stringify || function (obj) {
+      return JSON.stringify(obj, null, 2);
+    };
+  }
+};
+
+//
+// Inherit from `winston.Transport`.
+//
+util.inherits(Memory, Transport);
+
+//
+// Expose the name of this Transport on the prototype
+//
+Memory.prototype.name = 'memory';
+
+//
+// ### function log (level, msg, [meta], callback)
+// #### @level {string} Level at which to log the message.
+// #### @msg {string} Message to log
+// #### @meta {Object} **Optional** Additional metadata to attach
+// #### @callback {function} Continuation to respond to when complete.
+// Core logging method exposed to Winston. Metadata is optional.
+//
+Memory.prototype.log = function (level, msg, meta, callback) {
+  if (this.silent) {
+    return callback(null, true);
+  }
+
+  var self = this,
+      output;
+
+  output = common.log({
+    colorize:    this.colorize,
+    json:        this.json,
+    level:       level,
+    message:     msg,
+    meta:        meta,
+    stringify:   this.stringify,
+    timestamp:   this.timestamp,
+    prettyPrint: this.prettyPrint,
+    raw:         this.raw,
+    label:       this.label,
+    depth:       this.depth,
+    formatter:   this.formatter,
+    humanReadableUnhandledException: this.humanReadableUnhandledException
+  });
+
+  if (level === 'error' || level === 'debug') {
+    this.errorOutput.push(output);
+  } else {
+    this.writeOutput.push(output);
+  }
+
+  self.emit('logged');
+  callback(null, true);
+};
+
+Memory.prototype.clearLogs = function () {
+  this.errorOutput = [];
+  this.writeOutput = [];
+};

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

@@ -0,0 +1,135 @@
+/*
+ * transport.js: Base Transport object for all Winston transports.
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
+ *
+ */
+
+var events = require('events'),
+    util = require('util');
+
+//
+// ### function Transport (options)
+// #### @options {Object} Options for this instance.
+// Constructor function for the Tranport object responsible
+// base functionality for all winston transports.
+//
+var Transport = exports.Transport = function (options) {
+  events.EventEmitter.call(this);
+
+  options        = options        || {};
+  this.silent    = options.silent || false;
+  this.raw       = options.raw    || false;
+  this.name      = options.name   || this.name;
+  this.formatter = options.formatter;
+
+  //
+  // Do not set a default level. When `level` is falsey on any
+  // `Transport` instance, any `Logger` instance uses the
+  // configured level (instead of the Transport level)
+  //
+  this.level = options.level;
+
+  this.handleExceptions = options.handleExceptions || false;
+  this.exceptionsLevel  = options.exceptionsLevel || 'error';
+  this.humanReadableUnhandledException = options.humanReadableUnhandledException || false;
+};
+
+//
+// Inherit from `events.EventEmitter`.
+//
+util.inherits(Transport, events.EventEmitter);
+
+//
+// ### function formatQuery (query)
+// #### @query {string|Object} Query to format
+// Formats the specified `query` Object (or string) to conform
+// with the underlying implementation of this transport.
+//
+Transport.prototype.formatQuery = function (query) {
+  return query;
+};
+
+//
+// ### function normalizeQuery (query)
+// #### @options {string|Object} Query to normalize
+// Normalize options for query
+//
+Transport.prototype.normalizeQuery = function (options) {
+  //
+  // Use options similar to loggly.
+  // [See Loggly Search API](http://wiki.loggly.com/retrieve_events#optional)
+  //
+
+  options = options || {};
+
+  // limit
+  options.rows = options.rows || options.limit || 10;
+
+  // starting row offset
+  options.start = options.start || 0;
+
+  // now
+  options.until = options.until || new Date;
+  if (typeof options.until !== 'object') {
+    options.until = new Date(options.until);
+  }
+
+  // now - 24
+  options.from = options.from || (options.until - (24 * 60 * 60 * 1000));
+  if (typeof options.from !== 'object') {
+    options.from = new Date(options.from);
+  }
+
+
+  // 'asc' or 'desc'
+  options.order = options.order || 'desc';
+
+  // which fields to select
+  options.fields = options.fields;
+
+  return options;
+};
+
+//
+// ### function formatResults (results, options)
+// #### @results {Object|Array} Results returned from `.query`.
+// #### @options {Object} **Optional** Formatting options
+// Formats the specified `results` with the given `options` accordinging
+// to the implementation of this transport.
+//
+Transport.prototype.formatResults = function (results, options) {
+  return results;
+};
+
+//
+// ### function logException (msg, meta, callback)
+// #### @msg {string} Message to log
+// #### @meta {Object} **Optional** Additional metadata to attach
+// #### @callback {function} Continuation to respond to when complete.
+// Logs the specified `msg`, `meta` and responds to the callback once the log
+// operation is complete to ensure that the event loop will not exit before
+// all logging has completed.
+//
+Transport.prototype.logException = function (msg, meta, callback) {
+  var self = this,
+      called;
+
+  if (this.silent) {
+    return callback();
+  }
+
+  function onComplete () {
+    if (!called) {
+      called = true;
+      self.removeListener('logged', onComplete);
+      self.removeListener('error', onComplete);
+      callback();
+    }
+  }
+
+  this.once('logged', onComplete);
+  this.once('error', onComplete);
+  this.log(self.exceptionsLevel, msg, meta, function () { });
+};