%PDF-
%PDF-
Mini Shell
Mini Shell
/*
* common.js: Internal helper and utility functions for winston
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*
*/
var util = require('util'),
crypto = require('crypto'),
cycle = require('cycle'),
fs = require('fs'),
StringDecoder = require('string_decoder').StringDecoder,
Stream = require('stream').Stream,
config = require('./config');
//
// ### function setLevels (target, past, current)
// #### @target {Object} Object on which to set levels.
// #### @past {Object} Previous levels set on target.
// #### @current {Object} Current levels to set on target.
// Create functions on the target objects for each level
// in current.levels. If past is defined, remove functions
// for each of those levels.
//
exports.setLevels = function (target, past, current, isDefault) {
var self = this;
if (past) {
Object.keys(past).forEach(function (level) {
delete target[level];
});
}
target.levels = current || config.npm.levels;
if (target.hasOwnProperty('padLevels') && target.padLevels) {
target.levelLength = exports.longestElement(Object.keys(target.levels));
}
//
// Define prototype methods for each log level
// e.g. target.log('info', msg) <=> target.info(msg)
//
Object.keys(target.levels).forEach(function (level) {
// TODO Refactor logging methods into a different object to avoid name clashes
if (level === 'log') {
console.warn('Log level named "log" will clash with the method "log". Consider using a different name.');
return;
}
target[level] = function (msg) {
// build argument list (level, msg, ... [string interpolate], [{metadata}], [callback])
var args = [level].concat(Array.prototype.slice.call(arguments));
target.log.apply(target, args);
};
});
return target;
};
//
// ### function longestElement
// #### @xs {Array} Array to calculate against
// Returns the longest element in the `xs` array.
//
exports.longestElement = function (xs) {
return Math.max.apply(
null,
xs.map(function (x) { return x.length; })
);
};
//
// ### function clone (obj)
// #### @obj {Object} Object to clone.
// Helper method for deep cloning pure JSON objects
// i.e. JSON objects that are either literals or objects (no Arrays, etc)
//
exports.clone = function (obj) {
if (obj instanceof Error) {
// With potential custom Error objects, this might not be exactly correct,
// but probably close-enough for purposes of this lib.
var copy = { message: obj.message };
Object.getOwnPropertyNames(obj).forEach(function (key) {
copy[key] = obj[key];
});
return cycle.decycle(copy);
}
else if (!(obj instanceof Object)) {
return obj;
}
else if (obj instanceof Date) {
return new Date(obj.getTime());
}
return clone(cycle.decycle(obj));
};
function clone(obj) {
//
// We only need to clone reference types (Object)
//
var copy = Array.isArray(obj) ? [] : {};
for (var i in obj) {
if (obj.hasOwnProperty(i)) {
if (Array.isArray(obj[i])) {
copy[i] = obj[i].slice(0);
}
else if (obj[i] instanceof Buffer) {
copy[i] = obj[i].slice(0);
}
else if (typeof obj[i] != 'function') {
copy[i] = obj[i] instanceof Object ? exports.clone(obj[i]) : obj[i];
}
else if (typeof obj[i] === 'function') {
copy[i] = obj[i];
}
}
}
return copy;
}
//
// ### function log (options)
// #### @options {Object} All information about the log serialization.
// Generic logging function for returning timestamped strings
// with the following options:
//
// {
// level: 'level to add to serialized message',
// message: 'message to serialize',
// meta: 'additional logging metadata to serialize',
// colorize: false, // Colorizes output (only if `.json` is false)
// align: false // Align message level.
// timestamp: true // Adds a timestamp to the serialized message
// label: 'label to prepend the message'
// }
//
exports.log = function (options) {
var timestampFn = typeof options.timestamp === 'function'
? options.timestamp
: exports.timestamp,
timestamp = options.timestamp ? timestampFn() : null,
showLevel = options.showLevel === undefined ? true : options.showLevel,
meta = options.meta !== null && options.meta !== undefined
? exports.clone(options.meta)
: options.meta || null,
output;
//
// raw mode is intended for outputing winston as streaming JSON to STDOUT
//
if (options.raw) {
if (typeof meta !== 'object' && meta != null) {
meta = { meta: meta };
}
output = exports.clone(meta) || {};
output.level = options.level;
//
// Remark (jcrugzz): This used to be output.message = options.message.stripColors.
// I do not know why this is, it does not make sense but im handling that
// case here as well as handling the case that does make sense which is to
// make the `output.message = options.message`
//
output.message = options.message.stripColors
? options.message.stripColors
: options.message;
return JSON.stringify(output);
}
//
// json mode is intended for pretty printing multi-line json to the terminal
//
if (options.json || true === options.logstash) {
if (typeof meta !== 'object' && meta != null) {
meta = { meta: meta };
}
output = exports.clone(meta) || {};
output.level = options.level;
output.message = output.message || '';
if (options.label) { output.label = options.label; }
if (options.message) { output.message = options.message; }
if (timestamp) { output.timestamp = timestamp; }
if (options.logstash === true) {
// use logstash format
var logstashOutput = {};
if (output.message !== undefined) {
logstashOutput['@message'] = output.message;
delete output.message;
}
if (output.timestamp !== undefined) {
logstashOutput['@timestamp'] = output.timestamp;
delete output.timestamp;
}
logstashOutput['@fields'] = exports.clone(output);
output = logstashOutput;
}
if (typeof options.stringify === 'function') {
return options.stringify(output);
}
return JSON.stringify(output, function (key, value) {
return value instanceof Buffer
? value.toString('base64')
: value;
});
}
//
// Remark: this should really be a call to `util.format`.
//
if (typeof options.formatter == 'function') {
options.meta = meta || options.meta;
if (options.meta instanceof Error) {
// Force converting the Error to an plain object now so it
// will not be messed up by decycle() when cloning options
options.meta = exports.clone(options.meta);
}
return String(options.formatter(exports.clone(options)));
}
output = timestamp ? timestamp + ' - ' : '';
if (showLevel) {
output += options.colorize === 'all' || options.colorize === 'level' || options.colorize === true
? config.colorize(options.level)
: options.level;
}
output += (options.align) ? '\t' : '';
output += (timestamp || showLevel) ? ': ' : '';
output += options.label ? ('[' + options.label + '] ') : '';
output += options.colorize === 'all' || options.colorize === 'message'
? config.colorize(options.level, options.message)
: options.message;
if (meta !== null && meta !== undefined) {
if (typeof meta !== 'object') {
output += ' ' + meta;
}
else if (Object.keys(meta).length > 0) {
if (typeof options.prettyPrint === 'function') {
output += ' ' + options.prettyPrint(meta);
} else if (options.prettyPrint) {
output += ' ' + '\n' + util.inspect(meta, false, options.depth || null, options.colorize);
} else if (
options.humanReadableUnhandledException
&& Object.keys(meta).length >= 5
&& meta.hasOwnProperty('date')
&& meta.hasOwnProperty('process')
&& meta.hasOwnProperty('os')
&& meta.hasOwnProperty('trace')
&& meta.hasOwnProperty('stack')) {
//
// If meta carries unhandled exception data serialize the stack nicely
//
var stack = meta.stack;
delete meta.stack;
delete meta.trace;
output += ' ' + exports.serialize(meta);
if (stack) {
output += '\n' + stack.join('\n');
}
} else {
output += ' ' + exports.serialize(meta);
}
}
}
return output;
};
exports.capitalize = function (str) {
return str && str[0].toUpperCase() + str.slice(1);
};
//
// ### function hash (str)
// #### @str {string} String to hash.
// Utility function for creating unique ids
// e.g. Profiling incoming HTTP requests on the same tick
//
exports.hash = function (str) {
return crypto.createHash('sha1').update(str).digest('hex');
};
//
// ### function pad (n)
// Returns a padded string if `n < 10`.
//
exports.pad = function (n) {
return n < 10 ? '0' + n.toString(10) : n.toString(10);
};
//
// ### function timestamp ()
// Returns a timestamp string for the current time.
//
exports.timestamp = function () {
return new Date().toISOString();
};
//
// ### function serialize (obj, key)
// #### @obj {Object|literal} Object to serialize
// #### @key {string} **Optional** Optional key represented by obj in a larger object
// Performs simple comma-separated, `key=value` serialization for Loggly when
// logging to non-JSON inputs.
//
exports.serialize = function (obj, key) {
// symbols cannot be directly casted to strings
if (typeof key === 'symbol') {
key = key.toString()
}
if (typeof obj === 'symbol') {
obj = obj.toString()
}
if (obj === null) {
obj = 'null';
}
else if (obj === undefined) {
obj = 'undefined';
}
else if (obj === false) {
obj = 'false';
}
if (typeof obj !== 'object') {
return key ? key + '=' + obj : obj;
}
if (obj instanceof Buffer) {
return key ? key + '=' + obj.toString('base64') : obj.toString('base64');
}
var msg = '',
keys = Object.keys(obj),
length = keys.length;
for (var i = 0; i < length; i++) {
if (Array.isArray(obj[keys[i]])) {
msg += keys[i] + '=[';
for (var j = 0, l = obj[keys[i]].length; j < l; j++) {
msg += exports.serialize(obj[keys[i]][j]);
if (j < l - 1) {
msg += ', ';
}
}
msg += ']';
}
else if (obj[keys[i]] instanceof Date) {
msg += keys[i] + '=' + obj[keys[i]];
}
else {
msg += exports.serialize(obj[keys[i]], keys[i]);
}
if (i < length - 1) {
msg += ', ';
}
}
return msg;
};
//
// ### function tailFile (options, callback)
// #### @options {Object} Options for tail.
// #### @callback {function} Callback to execute on every line.
// `tail -f` a file. Options must include file.
//
exports.tailFile = function(options, callback) {
var buffer = Buffer.alloc(64 * 1024)
, decode = new StringDecoder('utf8')
, stream = new Stream
, buff = ''
, pos = 0
, row = 0;
if (options.start === -1) {
delete options.start;
}
stream.readable = true;
stream.destroy = function() {
stream.destroyed = true;
stream.emit('end');
stream.emit('close');
};
fs.open(options.file, 'a+', '0644', function(err, fd) {
if (err) {
if (!callback) {
stream.emit('error', err);
} else {
callback(err);
}
stream.destroy();
return;
}
(function read() {
if (stream.destroyed) {
fs.close(fd, nop);
return;
}
return fs.read(fd, buffer, 0, buffer.length, pos, function(err, bytes) {
if (err) {
if (!callback) {
stream.emit('error', err);
} else {
callback(err);
}
stream.destroy();
return;
}
if (!bytes) {
if (buff) {
if (options.start == null || row > options.start) {
if (!callback) {
stream.emit('line', buff);
} else {
callback(null, buff);
}
}
row++;
buff = '';
}
return setTimeout(read, 1000);
}
var data = decode.write(buffer.slice(0, bytes));
if (!callback) {
stream.emit('data', data);
}
var data = (buff + data).split(/\n+/)
, l = data.length - 1
, i = 0;
for (; i < l; i++) {
if (options.start == null || row > options.start) {
if (!callback) {
stream.emit('line', data[i]);
} else {
callback(null, data[i]);
}
}
row++;
}
buff = data[l];
pos += bytes;
return read();
});
})();
});
if (!callback) {
return stream;
}
return stream.destroy;
};
//
// ### function stringArrayToSet (array)
// #### @strArray {Array} Array of Set-elements as strings.
// #### @errMsg {string} **Optional** Custom error message thrown on invalid input.
// Returns a Set-like object with strArray's elements as keys (each with the value true).
//
exports.stringArrayToSet = function (strArray, errMsg) {
if (typeof errMsg === 'undefined') {
errMsg = 'Cannot make set from Array with non-string elements';
}
return strArray.reduce(function (set, el) {
if (!(typeof el === 'string' || el instanceof String)) {
throw new Error(errMsg);
}
set[el] = true;
return set;
}, Object.create(null));
};
function nop () {}
Zerion Mini Shell 1.0