zeddemore-logger 2.1.2 → 2.2.3

package/README.md

@@ -1,3 +1,3 @@
 # zeddemore-logger
 
-Node.js logger using Morgan and Winston and CLI-Progress.
+Node.js Express logger using Morgan and Winston for thread and caller info tracking.

package/lib/ZeddemoreBase.js

@@ -6,7 +6,7 @@ const { DateTime } = require('luxon');
 
 const { convertFechaDateFormatToLuxon } = require('./date');
 const defaults = require('./defaults');
-const { isValidLogLevel, logLevelToWinstonLogLevelName } = require('./logging');
+const { isWinstonLogLevel, winstonLogLevelName } = require('./logging');
 const { stringToIdempotentHexColor } = require('./color');
 require('./typedef');
 
@@ -107,7 +107,7 @@ class ZeddemoreBase {
     }
 
     set defaultUserLogLevel(level) {
-        if (isValidLogLevel(level)) this.#defaultUserLogLevel = logLevelToWinstonLogLevelName(level);
+        if (isWinstonLogLevel(level)) this.#defaultUserLogLevel = winstonLogLevelName(level);
     }
 
     get forceLogLevel() {
@@ -124,11 +124,11 @@ class ZeddemoreBase {
     }
 
     set logLevel(level) {
-        if (isValidLogLevel(level)) this.#logLevel = logLevelToWinstonLogLevelName(level);
+        if (isWinstonLogLevel(level)) this.#logLevel = winstonLogLevelName(level);
     }
 
     get logLevelName() {
-        return logLevelToWinstonLogLevelName(this.logLevel);
+        return winstonLogLevelName(this.logLevel);
     }
 
     get luxonTimestampFormat() {

package/lib/ZeddemoreLogger.js

@@ -16,17 +16,16 @@ const enums = require('./enums');
 const { extractHttpStatusCode, extractHttpVerb } = require('./http');
 const { extractToken, getRequestResponseTime, isRequestOfMethod, parseRequest } = require('./request');
 const { generateUuid } = require('./uuid');
-const { isMorganFormat, isValidLogLevelId, isWinstonTransportId, logLevelToWinstonLogLevelName, monkeyPatchConsole } = require('./logging');
+const { isMorganFormat, isWinstonFormat, isWinstonLogLevelId, isWinstonTransport, monkeyPatchConsole, transportLogLevelType,
+    winstonLogLevelName } = require('./logging');
 require('./typedef');
 const WinstonEmailTransport = require('./transports/WinstonEmailTransport');
 const ZeddemoreBase = require('./ZeddemoreBase');
 const ZeddemoreLoggerController = require('./ZeddemoreLoggerController');
-const ZeddemoreProgressMultibar = require('./ZeddemoreProgressMultibar');
 
-const { createLogger: createWinstonLogger, format, Logform: Format, transports } = winston;
-const { colorize, combine, label, metadata, printf, timestamp } = format;
-const { httpMethods: http, httpRequestHeaders: rqh, httpResponseHeaders: rsh, morganFormats: mf, morganFormatTokens: mft,
-    winstonLogLevelNames: wlln, winstonLogLevels: wll, winstonTransportIds: wti } = enums;
+const { createLogger: createWinstonLogger, format: winstonFormat, Logform: Format, transports } = winston;
+const { httpMethods: http, httpRequestHeaders: rqh, httpResponseHeaders: rsh, logLevelTypes: llt, morganFormats: mf,
+    morganFormatTokens: mft, winstonFormats: wf, winstonLogLevelNames: wlln, winstonLogLevels: wll, winstonTransports: wt } = enums;
 
 class ZeddemoreLogger extends ZeddemoreBase {
 
@@ -200,7 +199,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
     }
 
     set emailLogLevel(level) {
-        if (isValidLogLevelId(level)) this.#emailLogLevel = level;
+        if (isWinstonLogLevelId(level)) this.#emailLogLevel = level;
     }
 
     get emailLogPassword() {
@@ -260,7 +259,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
     }
 
     get logger() {
-        if (!(this.#logger instanceof ZeddemoreLoggerController)) this.#logger = this.createLogger();
+        if (!(this.#logger instanceof ZeddemoreLoggerController)) this.#logger = this.createLoggerController();
         return this.#logger;
     }
 
@@ -421,46 +420,21 @@ class ZeddemoreLogger extends ZeddemoreBase {
         return (_.compact(_morganTokens)).join(' ');
     }
 
-    /**
-     * Build a ZeddemoreProgressBars info
-     * @param {Object} options
-     * @returns {Object}
-     */
-    #buildProgressInfo = (options) => {
-        options = options || { };
-        const label = options.label || this.defaultLabel;
-        return {
-            ...options,
-            colorize: this.colorize,
-            label,
-            timestampFormat: this.luxonTimestampFormat,
-        };
-    }
-
     /**
      * Build a Winston format
      * @param {Object} options
-     * @param {[Format]} [additionalFormats]
-     * @param {String} [transportId]
+     * @param {[Format|String]} [additionalFormats]
      * @returns {Format}
      */
-    #buildWinstonFormat = (options, additionalFormats = [ ], transportId = null) => {
-        options = options || { };
-        const formats = [
-            format((info) => {
-                if (isWinstonTransportId(transportId) && isWinstonTransportId(info.transport) && (info.transport !== transportId)) return false;
-                info.id = info.id || options.id || null;
-                info.ip = info.ip || options.ip || null;
-                info.user = info.user || options.user || null;
-                return info;
-            })(),
-            colorize(),
-            label({ label: options.label || this.defaultLabel }),
-            timestamp({ format: this.winstonTimestampFormat }),
-            metadata(),
-            printf(this.#buildWinstonTemplate),
-        ];
-        return combine(...additionalFormats.concat(formats));
+    #buildWinstonFormat = (options, additionalFormats = [ ]) => {
+        additionalFormats = _.isArray(additionalFormats) ? additionalFormats : [ additionalFormats ];
+        const formats = this.#getDefaultFormats(options);
+        const _additionalFormats = _.compact(additionalFormats.map((format) => {
+            if (isWinstonFormat(format)) return this.#getBuiltinFormat(format, options);
+            if (_.isFunction(format)) return format;
+            return null;
+        }));
+        return winstonFormat.combine(..._additionalFormats.concat(formats));
     }
 
     /**
@@ -481,30 +455,22 @@ class ZeddemoreLogger extends ZeddemoreBase {
     /**
      * Build a Winston Console transport
      * @param {number|String} [logLevel]
-     * @param {Object} [options]
-     * @param {[Format]} [options.formats]
      * @returns {winston.ConsoleTransportInstance}
      */
-    #buildWinstonConsoleTransport = (logLevel = this.logLevel, options) => {
-        options = options || { };
+    #buildWinstonConsoleTransport = (logLevel = this.logLevel) => {
         logLevel = logLevel || this.logLevel;
-        const level = logLevelToWinstonLogLevelName(logLevel);
-        const format = this.#buildWinstonFormat(options, options.formats, wti.CONSOLE);
-        return new transports.Console({ format, id: wti.CONSOLE, level });
+        const level = winstonLogLevelName(logLevel);
+        return new transports.Console({ id: wt.CONSOLE, level });
     }
 
     /**
      * Build a Winston Email transport
      * @param {number|String} [logLevel]
-     * @param {Object} [options]
-     * @param {[Format]} [options.formats]
      * @returns {WinstonEmailTransport}
      */
-    #buildWinstonEmailTransport = (logLevel = this.emailLogLevel, options) => {
-        options = options || { };
+    #buildWinstonEmailTransport = (logLevel = this.emailLogLevel) => {
         logLevel = logLevel || this.emailLogLevel;
-        const level = logLevelToWinstonLogLevelName(logLevel);
-        const format = this.#buildWinstonFormat(options, options.formats, wti.EMAIL);
+        const level = winstonLogLevelName(logLevel);
         const messageOptions = {
             from: this.emailLogFrom,
             subject: this.emailLogSubject,
@@ -520,22 +486,22 @@ class ZeddemoreLogger extends ZeddemoreBase {
             port: this.emailLogPort,
         };
         const winstonOptions = { level };
-        const _options = { format, id: wti.EMAIL, messageOptions, transportOptions, ...winstonOptions };
+        const _options = { id: wt.EMAIL, messageOptions, transportOptions, ...winstonOptions };
         return new WinstonEmailTransport(_options);
     }
 
     /**
      * Build Winston transports
-     * @param {number|String} [logLevel]
-     * @param {number|String} [emailLogLevel]
-     * @param {[Object]} [additionalTransports]
+     * @param {[Object|String]} [transports]
      * @returns {Object[]}
      */
-    #buildWinstonTransports = (logLevel = this.logLevel, emailLogLevel = this.emailLogLevel, additionalTransports = [ ]) => {
-        additionalTransports = _.isArray(additionalTransports) ? additionalTransports : [ ];
-        if (this.doConsoleLog) additionalTransports = additionalTransports.concat([ this.#buildWinstonConsoleTransport(logLevel) ]);
-        if (this.doEmailLog && this.canEmailLog) additionalTransports = additionalTransports.concat([ this.#buildWinstonEmailTransport(emailLogLevel) ]);
-        return additionalTransports;
+    #buildWinstonTransports = (transports = [ ]) => {
+        transports = _.compact(_.isArray(transports) ? transports : [ transports ]);
+        return _.compact(transports.map((transport) => {
+            if (isWinstonTransport(transport)) return this.#getBuiltinTransport(transport);
+            if (_.isObject(transport)) return transport;
+            return null;
+        }));
     }
 
     #colorizeResponse(message) {
@@ -543,19 +509,31 @@ class ZeddemoreLogger extends ZeddemoreBase {
         return verb ? chalkHttpVerbs(verb, message) : message;
     }
 
+    createLogger = (options) => {
+        return this.createLoggerController(options);
+    }
+
     /**
      * Create a ZeddemoreLoggerController
      * @param {Object} [options]
-     * @param {[Format]} [options.formats]
-     * @param {String} [options.level]
-     * @param {[Object]} [options.transports]
+     * @param {[Format|String]} [options.formats]
+     * @param {[Object|String]} [options.transports]
      * @returns {ZeddemoreLoggerController}
      */
-    createLogger = (options) => {
+    #createLoggerController = (options) => {
         options = options || { };
-        const winstonLogger = this.#createWinstonLogger(options);
-        const multiBar = this.#createZeddemoreProgressMultibar(options);
-        this.#logger = new ZeddemoreLoggerController({ logger: winstonLogger, progress: multiBar });
+        const transports = _.compact(_.isArray(options.winstonTransports) ? options.winstonTransports : [ options.winstonTransports ]);
+        const defaultLoggerTransports = transports.concat(this.#getDefaultTransports());
+        const defaultLogger = this.#createWinstonLogger({ transports: defaultLoggerTransports, ...options });
+        const loggers = { logger: defaultLogger };
+        if (this.doEmailLog && this.canEmailLog) {
+            loggers.emailLogger = this.#createWinstonLogger({ transports: [ wt.EMAIL ], ...options });
+        }
+        return new ZeddemoreLoggerController(loggers);
+    }
+
+    createLoggerController = (options) => {
+        this.#logger = this.#createLoggerController(options);
         return this.#logger;
     }
 
@@ -570,7 +548,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
         /** @type {Object} */
         const loggerOptions = { id: requestId };
         if (ipAddress) loggerOptions.ip = ipAddress;
-        return this.createLogger(loggerOptions);
+        return this.createLoggerController(loggerOptions);
     }
 
     /**
@@ -586,31 +564,21 @@ class ZeddemoreLogger extends ZeddemoreBase {
         logLevel = logLevel || this.defaultUserLogLevel;
         const loggerOptions = { id: requestId, level: logLevel, user: username };
         if (ipAddress) loggerOptions.ip = ipAddress;
-        return this.createLogger(loggerOptions);
+        return this.createLoggerController(loggerOptions);
     }
 
     /**
      * Create a Winston Logger
      * @param {Object} [options]
-     * @param {[Format]} [options.formats]
-     * @param {number|String} [options.level]
-     * @param {number|String} [options.emailLevel]
-     * @param {[Object]} [options.transports]
+     * @param {[Format|string]} [options.formats]
+     * @param {[Object|String]} [options.transports]
      * @returns {winston.Logger}
      */
     #createWinstonLogger = (options) => {
         options = options || { };
-        const transports = this.#buildWinstonTransports(options.level, options.emailLevel, options.transports);
-        return createWinstonLogger({ transports });
-    }
-
-    /**
-     * Create a progress MultiBar
-     * @param {Object} [options]
-     * @returns {ZeddemoreProgressMultibar}
-     */
-    #createZeddemoreProgressMultibar = (options) => {
-        return new ZeddemoreProgressMultibar(this.#buildProgressInfo(options));
+        const format = this.#buildWinstonFormat(options, options.formats);
+        const transports = this.#buildWinstonTransports(options.transports);
+        return createWinstonLogger({ format, transports });
     }
 
     /**
@@ -633,13 +601,66 @@ class ZeddemoreLogger extends ZeddemoreBase {
         monkeyPatchConsole(methodNames, colors, depth, showHidden);
     }
 
+    #formatInfoMutation(options) {
+        return winstonFormat((info) => {
+            info.id = info.id || options.id || null;
+            info.ip = info.ip || options.ip || null;
+            info.user = info.user || options.user || null;
+            return info;
+        });
+    }
+
+    #getBuiltinFormat(format, options) {
+        options = options || { };
+        switch (format) {
+            case wf.COLORIZE: return winstonFormat.colorize();
+            case wf.JSON: return winstonFormat.json();
+            case wf.METADATA: return winstonFormat.metadata();
+            case wf.PRETTY_PRINT: return winstonFormat.prettyPrint();
+            case wf.SIMPLE: return winstonFormat.simple();
+            case wf.SPLAT: return winstonFormat.splat();
+            case wf.TIMESTAMP: return winstonFormat.timestamp();
+            case wf.ZEDDEMORE_INFO_MUTATION: return this.#formatInfoMutation(options)();
+            case wf.ZEDDEMORE_LABEL: return winstonFormat.label({ label: options.label || this.defaultLabel });
+            case wf.ZEDDEMORE_PRINTF: return winstonFormat.printf(this.#buildWinstonTemplate);
+            case wf.ZEDDEMORE_TIMESTAMP: return winstonFormat.timestamp({ format: this.winstonTimestampFormat });
+        }
+    }
+
+    #getBuiltinTransport(transport) {
+        let logLevel = this.logLevel;
+        const logLevelType = transportLogLevelType(transport);
+        switch (logLevelType) {
+            case llt.CONSOLE: logLevel = this.logLevel; break;
+            case llt.EMAIL: logLevel = this.emailLogLevel; break;
+        }
+        switch (transport) {
+            case wt.CONSOLE: return this.#buildWinstonConsoleTransport(logLevel);
+            case wt.EMAIL: return this.#buildWinstonEmailTransport(logLevel);
+        }
+    }
+
+    #getDefaultFormats(options) {
+        return _.compact(defaults.winstonFormats.map((format) => this.#getBuiltinFormat(format, options)));
+    }
+
+    #getDefaultTransports() {
+        return _.compact(defaults.winstonTransports.map((transport) => {
+            switch (transport) {
+                case wt.CONSOLE: return this.doConsoleLog ? wt.CONSOLE : null;
+                case wt.EMAIL: return (this.doEmailLog && this.canEmailLog) ? wt.EMAIL : null;
+                default: return transport;
+            }
+        }));
+    }
+
     /**
-     * Get a Zeddemore Logger wrapper instance
+     * Get a Zeddemore Logger wrapper instance with all transports
      * @param {Object} options
-     * @param {[Format]} [options.formats]
+     * @param {[Format|String]} [options.formats]
      * @param {String} [options.level]
      * @param {ZeddemoreLoggerController} [options.logger]
-     * @param {[Object]} [options.transports]
+     * @param {[Object|String]} [options.transports]
      * @param {Object} [options.user]
      * @returns {ZeddemoreLoggerController}
      */
@@ -647,25 +668,9 @@ class ZeddemoreLogger extends ZeddemoreBase {
         options = options || { };
         /** @type {app} app */
         const logger = options.logger || (options.user ? options.user.logger : null) || ((app && app.locals) ? app.locals.logger : null);
-        if (!!logger) return logger;
+        if (logger instanceof ZeddemoreLoggerController) return logger;
         const zeddemoreLogger = new ZeddemoreLogger(options);
-        return zeddemoreLogger.createLogger(options);
-    }
-
-    /**
-     * Get a Winston Logger instance
-     * @param {Object} options
-     * @param {ZeddemoreProgressBars} [options.progress]
-     * @param {Object} [options.user]
-     * @returns {ZeddemoreProgressBars}
-     */
-    static getProgress(options) {
-        options = options || { };
-        /** @type {app} */
-        const progress = options.progress || (options.user ? options.user.progress : null) || ((app && app.locals) ? app.locals.progress : null);
-        if (!!progress) return progress;
-        const zeddemoreLogger = new ZeddemoreLogger();
-        return zeddemoreLogger.#createZeddemoreProgressMultibar(options);
+        return zeddemoreLogger.createLoggerController(options);
     }
 
     /**
@@ -715,7 +720,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
      */
     log = (logLevel) => {
         logLevel = logLevel || this.logLevel;
-        const logLevelName = logLevelToWinstonLogLevelName(logLevel);
+        const logLevelName = winstonLogLevelName(logLevel);
         return this.logger[ logLevelName ];
     }
 
@@ -776,7 +781,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
             return `${ packageName }@${ _package.version }`;
         }
         const versionParts = _.compact(_.sortBy(packages, (_package) => _package.name.toUpperCase()).map(buildVersionLabel));
-        this.log(logLevel)(`Packages: ${ versionParts.join(' | ') }`);
+        this.log(logLevel)(`Packages: [ ${ versionParts.join(', ') } ]`);
     }
 
     /**
@@ -797,7 +802,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
         const msgParts = [ `${ routes.length } ${ routesLabel } ${ addedLabel }` ];
         if (showCategories) {
             const categories = options.categories || this.apiRouteCategories || [];
-            msgParts.push(`in: ${ categories.sort().join('/') }`);
+            msgParts.push(`in: [ ${ categories.sort().join(', ') } ]`);
         }
         this.log(logLevel)(msgParts.join(', '));
     }
@@ -869,11 +874,12 @@ class ZeddemoreLogger extends ZeddemoreBase {
                         const user = this.userGetFn(req, res);
                         if (user) logOptions.user = user;
                         const response = colorize ? this.#colorizeResponse(message.trim()) : message.trim();
-                        ZeddemoreLogger.getLogger(logOptions).http(response);
-                        if (this.doEmailLog) {
+                        const logger = ZeddemoreLogger.getLogger(logOptions);
+                        logger.http(response);
+                        if (this.doEmailLog && this.canEmailLog) {
                             const statusCode = extractHttpStatusCode(message);
                             if (isResponseFailure(statusCode, [ 404 ])) {
-                                ZeddemoreLogger.getLogger(logOptions).log({ level: wlln.ERROR, message: response, transport: wti.EMAIL });
+                                logger.logEmail({ level: wlln.ERROR, message: response });
                             }
                         }
                     },
@@ -1024,7 +1030,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
         const _request = axiosResponse.request;
         const axiosConfig = logOptions.axios || { };
         const configData = (logOptions.data && _.isObject(axiosConfig.data)) ? JSON.stringify(axiosConfig.data) : null;
-        const logLevel = logLevelToWinstonLogLevelName(logOptions.logLevel);
+        const logLevel = winstonLogLevelName(logOptions.logLevel);
         const logger = options.logger || ZeddemoreLogger.getLogger(options);
         if (!logger) return;
         const _method = _request.method || null;

package/lib/ZeddemoreLoggerController.js

@@ -4,22 +4,35 @@ const _ = require('lodash');
 const winston = require('winston');
 
 const enums = require('./enums');
-const ZeddemoreProgressMultibar = require('./ZeddemoreProgressMultibar');
 
 const { Logger } = winston;
 const { winstonLogLevelNames: wlln } = enums;
 
 class ZeddemoreLoggerController {
 
-    /** @type {ZeddemoreProgressMultibar} */
-    #multiBar = null;
+    /** @type {winston.Logger} */
+    #winstonEmailLogger = null;
     /** @type {winston.Logger} */
     #winstonLogger = null;
 
     constructor(options) {
         options = options || { };
         this.logger = options.logger;
-        this.progress = options.progress;
+        this.emailLogger = options.emailLogger;
+    }
+
+    get emailLogger() {
+        return this.#winstonEmailLogger;
+    }
+
+    set emailLogger(value) {
+        if (value instanceof Logger) {
+            this.#winstonEmailLogger = value;
+        }
+    }
+
+    get hasWinstonEmailLogger() {
+        return (this.#winstonEmailLogger instanceof Logger);
     }
 
     get hasWinstonLogger() {
@@ -33,24 +46,16 @@ class ZeddemoreLoggerController {
     set logger(value) {
         if (value instanceof Logger) {
             this.#winstonLogger = value;
-            this.#buildWinstonLogLevelFunctions();
+            this.#buildWinstonLogLevelFunctions(this.#winstonLogger);
         }
     }
 
-    get progress() {
-        return this.#multiBar;
-    }
-
-    set progress(value) {
-        if (value instanceof ZeddemoreProgressMultibar) this.#multiBar = value;
-    }
-
-    #buildWinstonLogLevelFunctions() {
-        if (!this.hasWinstonLogger) return;
+    #buildWinstonLogLevelFunctions(logger) {
+        if (!(logger instanceof Logger)) return
         for (const levelName of Object.values(wlln)) {
-            if (_.isFunction(this.#winstonLogger[ levelName ])) {
+            if (_.isFunction(logger[ levelName ])) {
                 this[ levelName ] = (...args) => {
-                    this.#winstonLogger[ levelName ](...args);
+                    logger[ levelName ](...args);
                 }
             } else {
                 this[ levelName ] = () => this.#noop();
@@ -68,6 +73,11 @@ class ZeddemoreLoggerController {
         return this.#noop()
     }
 
+    logEmail = (options) => {
+        if (this.hasWinstonEmailLogger) return this.#winstonEmailLogger.log(options);
+        return this.#noop()
+    }
+
     #noop = () => {
         // No operation function, used to prevent errors when logger methods are called but no logger is set.
     }

package/lib/defaults.js

@@ -2,7 +2,8 @@
 
 const enums = require('./enums');
 
-const { hexColors: hc, morganFormats: mf, morganFormatTokens: mft, winstonLogLevelNames: wlln } = enums;
+const { hexColors: hc, logLevelTypes: llt, morganFormats: mf, morganFormatTokens: mft, winstonFormats: wf,
+    winstonLogLevelNames: wlln, winstonTransports: wt } = enums;
 
 module.exports = {
     colorConsoleWhiteHex: hc.CONSOLE_WHITE,
@@ -10,28 +11,18 @@ module.exports = {
     consoleDirExtensionColors: true,
     consoleDirExtensionDepth: null,
     consoleDirExtensionShowHidden: true,
-    consoleTransportName: 'console',
     contentLengthDigits: 2,
     liveMessage: '⚡live⚡',
+    logLevelType: llt.CONSOLE,
     morganFormat: mf.ZEDDEMORE,
     morganFormatTokens: [ mft.METHOD, mft.DECODED_URL, mft.STATUS, mft.RESPONSE_TIME_FORMAT, mft.CONTENT_LENGTH_FORMAT ],
     morganFormatTokensColorized: [ mft.METHOD, mft.DECODED_URL, mft.STATUS_COLORED, mft.RESPONSE_TIME_FORMAT, mft.CONTENT_LENGTH_FORMAT ],
-    progressBarBarFormat: '{bar}',
-    progressBarCompleteCharacter: '█',
-    progressBarDelimiter: '|',
-    progressBarDurationFormat: '{duration}s',
-    progressBarDurationFormattedFormat: '{duration_formatted}',
-    progressBarEtaFormat: '{eta}s',
-    progressBarEtaFormattedFormat: '{eta_formatted}',
-    progressBarIncompleteCharacter: '░',
-    progressBarPercentageFormat: '{percentage}%',
-    progressBarPostfixFormat: '{postfix}',
-    progressBarValueFormat: '{value}',
-    progressBarTotalFormat: '{total}',
     requestIdAttribute: 'requestId',
     requestIdIcon: '🧵',
     responseTimeDigits: 0,
     timestampFormat: 'YYYY-MM-DD HH:mm:ss',
     userLogLevel: -1,
+    winstonFormats: [ wf.ZEDDEMORE_INFO_MUTATION, wf.COLORIZE, wf.ZEDDEMORE_LABEL, wf.ZEDDEMORE_TIMESTAMP, wf.METADATA, wf.ZEDDEMORE_PRINTF ],
+    winstonTransports: [ wt.CONSOLE, wt.EMAIL ],
     winstonLogLevelName: wlln.INFO,
 };