Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:53
📄 common.js /* * 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 () {}	13.42 KB	2025-11-20 11:36
📁 config	-	2026-03-21 15:53
📄 config.js /* * config.js: Default settings for all levels that winston knows about * * (C) 2010 Charlie Robbins * MIT LICENCE * */ var colors = require('colors/safe'); // Fix colors not appearing in non-tty environments colors.enabled = true; var config = exports, allColors = exports.allColors = {}; config.addColors = function (colors) { mixin(allColors, colors); }; config.colorize = function (level, message) { if (typeof message === 'undefined') message = level; var colorized = message; if (allColors[level] instanceof Array) { for (var i = 0, l = allColors[level].length; i < l; ++i) { colorized = colors[allColors[level][i]](colorized); } } else if (allColors[level].match(/\s/)) { var colorArr = allColors[level].split(/\s+/); for (var i = 0; i < colorArr.length; ++i) { colorized = colors[colorArr[i]](colorized); } allColors[level] = colorArr; } else { colorized = colors[allColors[level]](colorized); } return colorized; }; // // Export config sets // config.cli = require('./config/cli-config'); config.npm = require('./config/npm-config'); config.syslog = require('./config/syslog-config'); // // Add colors for pre-defined config sets // config.addColors(config.cli.colors); config.addColors(config.npm.colors); config.addColors(config.syslog.colors); function mixin (target) { var args = Array.prototype.slice.call(arguments, 1); args.forEach(function (a) { var keys = Object.keys(a); for (var i = 0; i < keys.length; i++) { target[keys[i]] = a[keys[i]]; } }); return target; };	1.56 KB	2025-11-20 11:36
📄 container.js /* * container.js: Inversion of control container for winston logger instances * * (C) 2010 Charlie Robbins * MIT LICENCE * / var common = require('./common'), winston = require('../winston'), extend = require('util')._extend; // // ### function Container (options) // #### @options {Object} Default pass-thru options for Loggers // Constructor function for the Container object responsible for managing // a set of `winston.Logger` instances based on string ids. // var Container = exports.Container = function (options) { this.loggers = {}; this.options = options \|\| {}; this.default = { transports: [ new winston.transports.Console({ level: 'silly', colorize: false }) ] } }; // // ### function get / add (id, options) // #### @id {string} Id of the Logger to get // #### @options {Object} Optional* Options for the Logger instance // Retreives a `winston.Logger` instance for the specified `id`. If // an instance does not exist, one is created. // Container.prototype.get = Container.prototype.add = function (id, options) { var self = this, existing; if (!this.loggers[id]) { // // Remark: Simple shallow clone for configuration options in case we pass in // instantiated protoypal objects // options = extend({}, options \|\| this.options \|\| this.default); existing = options.transports \|\| this.options.transports; // // Remark: Make sure if we have an array of transports we slice it to make copies // of those references. // options.transports = existing ? existing.slice() : []; if (options.transports.length === 0 && (!options \|\| !options['console'])) { options.transports.push(this.default.transports[0]); } Object.keys(options).forEach(function (key) { if (key === 'transports' \|\| key === 'filters' \|\| key === 'rewriters') { return; } var name = common.capitalize(key); if (!winston.transports[name]) { throw new Error('Cannot add unknown transport: ' + name); } var namedOptions = options[key]; namedOptions.id = id; options.transports.push(new (winston.transports[name])(namedOptions)); }); options.id = id; this.loggers[id] = new winston.Logger(options); this.loggers[id].on('close', function () { self._delete(id); }); } return this.loggers[id]; }; // // ### function close (id) // #### @id {string} Optional Id of the Logger instance to find // Returns a boolean value indicating if this instance // has a logger with the specified `id`. // Container.prototype.has = function (id) { return !!this.loggers[id]; }; // // ### function close (id) // #### @id {string} Optional Id of the Logger instance to close // Closes a `Logger` instance with the specified `id` if it exists. // If no `id` is supplied then all Loggers are closed. // Container.prototype.close = function (id) { var self = this; function _close (id) { if (!self.loggers[id]) { return; } self.loggers[id].close(); self._delete(id); } return id ? _close(id) : Object.keys(this.loggers).forEach(function (id) { _close(id); }); }; // // ### @private function _delete (id) // #### @id {string} Id of the Logger instance to delete from container // Deletes a `Logger` instance with the specified `id`. // Container.prototype._delete = function (id) { delete this.loggers[id]; }	3.37 KB	2025-11-20 11:36
📄 exception.js /* * exception.js: Utility methods for gathing information about uncaughtExceptions. * * (C) 2010 Charlie Robbins * MIT LICENCE * */ var os = require('os'), stackTrace = require('stack-trace'); var exception = exports; exception.getAllInfo = function (err) { return { date: new Date().toString(), process: exception.getProcessInfo(), os: exception.getOsInfo(), trace: exception.getTrace(err), stack: err.stack && err.stack.split('\n') }; }; exception.getProcessInfo = function () { return { pid: process.pid, uid: process.getuid ? process.getuid() : null, gid: process.getgid ? process.getgid() : null, cwd: process.cwd(), execPath: process.execPath, version: process.version, argv: process.argv, memoryUsage: process.memoryUsage() }; }; exception.getOsInfo = function () { return { loadavg: os.loadavg(), uptime: os.uptime() }; }; exception.getTrace = function (err) { var trace = err ? stackTrace.parse(err) : stackTrace.get(); return trace.map(function (site) { return { column: site.getColumnNumber(), file: site.getFileName(), function: site.getFunctionName(), line: site.getLineNumber(), method: site.getMethodName(), native: site.isNative(), } }); };	1.34 KB	2025-11-20 11:36
📄 logger.js /* * logger.js: Core logger object used by winston. * * (C) 2010 Charlie Robbins * MIT LICENCE * / var events = require('events'), util = require('util'), async = require('async'), config = require('./config'), common = require('./common'), exception = require('./exception'), Stream = require('stream').Stream; var formatRegExp = /%[sdj%]/g; // // ### function Logger (options) // #### @options {Object} Options for this instance. // Constructor function for the Logger object responsible // for persisting log messages and metadata to one or more transports. // 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 = []; if (options.transports) { options.transports.forEach(function (transport) { self.add(transport, null, true); }); } // // Set Levels and default logging level // this.padLevels = options.padLevels \|\| false; this.setLevels(options.levels); if (options.colors) { config.addColors(options.colors); } // // 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; this.exitOnError = typeof options.exitOnError !== 'undefined' ? options.exitOnError : true; // // Setup internal state as empty Objects even though it is // defined lazily later to ensure a strong existential API contract. // this.exceptionHandlers = {}; this.profilers = {}; ['rewriters', 'filters'].forEach(function (kind) { self[kind] = Array.isArray(options[kind]) ? options[kind] : []; }); if (options.exceptionHandlers) { this.handleExceptions(options.exceptionHandlers); } }; // // ### 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. // Logger.prototype.log = function (level) { var args = Array.prototype.slice.call(arguments, 1), self = this, transports; while (args[args.length - 1] === null) { args.pop(); } // // 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; // // Handle errors appropriately. // function onError(err) { if (callback) { callback(err); } else if (self.emitErrs) { self.emit('error', err); } } 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(level, msg, meta, self); if (typeof filtered === 'string') msg = filtered; else { msg = filtered.msg; meta = filtered.meta; } }); // // For consideration of terminal 'color" programs like colors.js, // which can add ANSI escape color codes to strings, we destyle the // ANSI color escape codes when `this.stripColors` is set. // // see: http://en.wikipedia.org/wiki/ANSI_escape_code // if (this.stripColors) { var code = /\u001b\[(\d+(;\d+))?m/g; msg = ('' + msg).replace(code, ''); } // // Log for each transport and emit 'logging' event // function transportLog(name, next) { var transport = self.transports[name]; transport.log(level, msg, meta, function (err) { if (err) { err.transport = transport; finish(err); return next(); } self.emit('logging', transport, level, msg, meta); next(); }); } async.forEach(targets, transportLog, finish); return this; }; // // ### function query (options, callback) // #### @options {Object} Query options for this instance. // #### @callback {function} Continuation to respond to when complete. // Queries the all transports for this instance with the specified `options`. // This will aggregate each transport's results into one object containing // a property per transport. // Logger.prototype.query = function (options, callback) { if (typeof options === 'function') { callback = options; options = {}; } var self = this, options = options \|\| {}, results = {}, query = common.clone(options.query) \|\| {}, transports; // // Helper function to query a single transport // function queryTransport(transport, next) { if (options.query) { options.query = transport.formatQuery(query); } transport.query(options, function (err, results) { if (err) { return next(err); } next(null, transport.formatResults(results, options.format)); }); } // // Helper function to accumulate the results from // `queryTransport` into the `results`. // function addResults(transport, next) { queryTransport(transport, function (err, result) { // // queryTransport could potentially invoke the callback // multiple times since Transport code can be unpredictable. // if (next) { result = err \|\| result; if (result) { results[transport.name] = result; } next(); } next = null; }); } // // If an explicit transport is being queried then // respond with the results from only that transport // if (options.transport) { options.transport = options.transport.toLowerCase(); return queryTransport(this.transports[options.transport], callback); } // // Create a list of all transports for this instance. // transports = this._names.map(function (name) { return self.transports[name]; }).filter(function (transport) { return !!transport.query; }); // // Iterate over the transports in parallel setting the // appropriate key in the `results` // async.forEach(transports, addResults, function () { callback(null, results); }); }; // // ### function stream (options) // #### @options {Object} Stream options for this instance. // Returns a log stream for all transports. Options object is optional. // Logger.prototype.stream = function (options) { var self = this, options = options \|\| {}, out = new Stream, streams = [], transports; if (options.transport) { var transport = this.transports[options.transport]; delete options.transport; if (transport && transport.stream) { return transport.stream(options); } } out._streams = streams; out.destroy = function () { var i = streams.length; while (i--) streams[i].destroy(); }; // // Create a list of all transports for this instance. // transports = this._names.map(function (name) { return self.transports[name]; }).filter(function (transport) { return !!transport.stream; }); transports.forEach(function (transport) { var stream = transport.stream(options); if (!stream) return; streams.push(stream); stream.on('log', function (log) { log.transport = log.transport \|\| []; log.transport.push(transport.name); out.emit('log', log); }); stream.on('error', function (err) { err.transport = err.transport \|\| []; err.transport.push(transport.name); out.emit('error', err); }); }); return out; }; // // ### function close () // Cleans up resources (streams, event listeners) for all // transports associated with this instance (if necessary). // Logger.prototype.close = function () { var self = this; this._names.forEach(function (name) { var transport = self.transports[name]; if (transport && transport.close) { transport.close(); } }); this.emit('close'); }; // // ### 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), handlers = [], self = this; args.forEach(function (a) { if (Array.isArray(a)) { handlers = handlers.concat(a); } else { handlers.push(a); } }); this.exceptionHandlers = this.exceptionHandlers \|\| {}; handlers.forEach(function (handler) { self.exceptionHandlers[handler.name] = handler; }); this._hnames = Object.keys(self.exceptionHandlers); if (!this.catchExceptions) { this.catchExceptions = this._uncaughtException.bind(this); process.on('uncaughtException', this.catchExceptions); } }; // // ### function unhandleExceptions () // Removes any handlers to `uncaughtException` events // for the current process // Logger.prototype.unhandleExceptions = function () { var self = this; if (this.catchExceptions) { Object.keys(this.exceptionHandlers).forEach(function (name) { var handler = self.exceptionHandlers[name]; if (handler.close) { handler.close(); } }); this.exceptionHandlers = {}; Object.keys(this.transports).forEach(function (name) { var transport = self.transports[name]; if (transport.handleExceptions) { transport.handleExceptions = false; } }) process.removeListener('uncaughtException', this.catchExceptions); this.catchExceptions = false; } }; // // ### function add (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.add = function (transport, options, created) { var instance = created ? transport : (new (transport)(options)); if (!instance.name && !instance.log) { throw new Error('Unknown transport with no log() method'); } else if (this.transports[instance.name]) { throw new Error('Transport already attached: ' + instance.name + ", assign a different name"); } this.transports[instance.name] = instance; this._names = Object.keys(this.transports); // // Listen for the `error` event on the new Transport // instance._onError = this._onError.bind(this, instance) if (!created) { instance.on('error', instance._onError); } // // If this transport has `handleExceptions` set to `true` // and we are not already handling exceptions, do so. // if (instance.handleExceptions && !this.catchExceptions) { this.handleExceptions(); } return this; }; // // ### function clear () // Remove all transports from this instance // Logger.prototype.clear = function () { Object.keys(this.transports).forEach(function (name) { this.remove({ name: name }); }, this); }; // // ### function remove (transport) // #### @transport {Transport\|String} Transport or Name to remove. // Removes a transport of the specified type from this instance. // Logger.prototype.remove = function (transport) { var name = typeof transport !== 'string' ? transport.name \|\| transport.prototype.name : transport; if (!this.transports[name]) { throw new Error('Transport ' + name + ' not attached to this instance'); } var instance = this.transports[name]; delete this.transports[name]; this._names = Object.keys(this.transports); if (instance.close) { instance.close(); } if (instance._onError) { instance.removeListener('error', instance._onError); } return this; }; // // ### 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]) // #### @id {string} Unique id of the profiler // #### @msg {string} Optional Message to log // #### @meta {Object} Optional Additional metadata to attach // #### @callback {function} Optional Continuation to respond to when complete. // Tracks the time inbetween subsequent calls to this method // with the same `id` parameter. The second call to this method // will log the difference in milliseconds along with the message. // Logger.prototype.profile = function (id) { var now = Date.now(), then, args, msg, meta, callback; if (this.profilers[id]) { then = this.profilers[id]; delete this.profilers[id]; // Support variable arguments: msg, meta, callback 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() : {}; msg = args.length === 2 ? args[1] : id; // Set the duration property of the metadata meta.durationMs = now - then; return this.info(msg, meta, callback); } else { this.profilers[id] = now; } return this; }; // // ### function setLevels (target) // #### @target {Object} Target levels to use on this instance // Sets the `target` levels specified on this instance. // Logger.prototype.setLevels = function (target) { return common.setLevels(this, this.levels, target); }; // // ### function cli () // Configures this instance to have the default // settings for command-line interfaces: no timestamp, // colors enabled, padded output, and additional levels. // Logger.prototype.cli = function () { this.padLevels = true; this.setLevels(config.cli.levels); config.addColors(config.cli.colors); if (this.transports.console) { this.transports.console.colorize = this.transports.console.colorize \|\| true; this.transports.console.timestamp = this.transports.console.timestamp \|\| false; } return this; }; // // ### @private function _uncaughtException (err) // #### @err {Error} Error to handle // Logs all relevant information around the `err` and // exits the current process. // Logger.prototype._uncaughtException = function (err) { var self = this, responded = false, info = exception.getAllInfo(err), handlers = this._getExceptionHandlers(), timeout, doExit; // // Calculate if we should exit on this error // doExit = typeof this.exitOnError === 'function' ? this.exitOnError(err) : this.exitOnError; function logAndWait(transport, next) { transport.logException('uncaughtException: ' + (err.message \|\| err), info, next, err); } function gracefulExit() { if (doExit && !responded) { // // Remark: Currently ignoring any exceptions from transports // when catching uncaught exceptions. // clearTimeout(timeout); responded = true; process.exit(1); } } if (!handlers \|\| handlers.length === 0) { return gracefulExit(); } // // Log to all transports and allow the operation to take // only up to `3000ms`. // async.forEach(handlers, logAndWait, gracefulExit); if (doExit) { timeout = setTimeout(gracefulExit, 3000); } }; // // ### @private function _getExceptionHandlers () // Returns the list of transports and exceptionHandlers // for this instance. // Logger.prototype._getExceptionHandlers = function () { var self = this; return this._hnames.map(function (name) { return self.exceptionHandlers[name]; }).concat(this._names.map(function (name) { return self.transports[name].handleExceptions && self.transports[name]; })).filter(Boolean); }; // // ### @private function _onError (transport, err) // #### @transport {Object} Transport on which the error occured // #### @err {Error} Error that occurred on the transport // Bubbles the error, `err`, that occured on the specified `transport` // up from this instance if `emitErrs` has been set. // Logger.prototype._onError = function (transport, err) { if (this.emitErrs) { 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); };	19.54 KB	2025-11-20 11:36
📁 transports	-	2026-03-21 15:53
📄 transports.js /* * transports.js: Set of all transports Winston knows about * * (C) 2010 Charlie Robbins * MIT LICENCE * */ Object.defineProperty(exports, 'Console', { configurable: true, enumerable: true, get: function () { return require('./transports/console').Console; } }); Object.defineProperty(exports, 'File', { configurable: true, enumerable: true, get: function () { return require('./transports/file').File; } }); 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; } });	764 B	2025-11-20 11:36

Terminal