serverless-spy 0.0.38 → 0.0.39

package/node_modules/winston/lib/winston/transports/console.js

@@ -0,0 +1,130 @@
+/*
+ * console.js: Transport for outputting to the console
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
+ *
+ */
+
+var events = require('events'),
+    os = require('os'),
+    util = require('util'),
+    common = require('../common'),
+    Transport = require('./transport').Transport;
+
+//
+// ### function Console (options)
+// #### @options {Object} Options for this instance.
+// Constructor function for the Console transport object responsible
+// for persisting log messages and metadata to a terminal or TTY.
+//
+var Console = exports.Console = function (options) {
+  Transport.call(this, options);
+  options = options || {};
+
+  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.logstash     = options.logstash    || false;
+  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) {
+      return JSON.stringify(obj, null, 2);
+    };
+  }
+
+  //
+  // Convert stderrLevels into an Object for faster key-lookup times than an Array.
+  //
+  // For backwards compatibility, stderrLevels defaults to ['error', 'debug']
+  // or ['error'] depending on whether options.debugStdout is true.
+  //
+  function setStderrLevels (levels, debugStdout) {
+    var defaultMsg = 'Cannot have non-string elements in stderrLevels Array';
+    if (debugStdout) {
+      if (levels) {
+        //
+        // Don't allow setting both debugStdout and stderrLevels together,
+        // since this could cause behaviour a programmer might not expect.
+        //
+        throw new Error('Cannot set debugStdout and stderrLevels together');
+      }
+
+      return common.stringArrayToSet(['error'], defaultMsg);
+    }
+
+    if (!levels) {
+      return common.stringArrayToSet(['error', 'debug'], defaultMsg);
+    } else if (!(Array.isArray(levels))) {
+      throw new Error('Cannot set stderrLevels to type other than Array');
+    }
+
+    return common.stringArrayToSet(levels, defaultMsg);
+  };
+};
+
+//
+// Inherit from `winston.Transport`.
+//
+util.inherits(Console, Transport);
+
+//
+// Expose the name of this Transport on the prototype
+//
+Console.prototype.name = 'console';
+
+//
+// ### 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.
+//
+Console.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,
+    showLevel:   this.showLevel,
+    prettyPrint: this.prettyPrint,
+    raw:         this.raw,
+    label:       this.label,
+    logstash:    this.logstash,
+    depth:       this.depth,
+    formatter:   this.formatter,
+    align:       this.align,
+    humanReadableUnhandledException: this.humanReadableUnhandledException
+  });
+
+  if (this.stderrLevels[level]) {
+    process.stderr.write(output + this.eol);
+  } else {
+    process.stdout.write(output + this.eol);
+  }
+
+  //
+  // Emit the `logged` event immediately because the event loop
+  // will not exit until `process.stdout` has drained anyway.
+  //
+  self.emit('logged');
+  callback(null, true);
+};