zeddemore-logger 2.0.2 → 2.1.0

package/lib/ZeddemoreBase.js

@@ -172,6 +172,24 @@ class ZeddemoreBase {
         if (_.isFunction(fn)) this.#userGetFn = fn;
     }
 
+    get values() {
+        return {
+            contentLengthDigits: this.contentLengthDigits,
+            defaultLabel: this.defaultLabel,
+            displayCaller: this.displayCaller,
+            displayIpAddress: this.displayIpAddress,
+            colorize: this.colorize,
+            customCallerSettings: this.customCallerSettings,
+            defaultUserLogLevel: this.defaultUserLogLevel,
+            forceLogLevel: this.forceLogLevel,
+            logLevel: this.logLevel,
+            requestIdAttribute: this.requestIdAttribute,
+            responseTimeDigits: this.responseTimeDigits,
+            timestampFormat: this.timestampFormat,
+            userGetFn: this.userGetFn,
+        };
+    }
+
     get winstonTimestampFormat() {
         return this.timestampFormat;
     }

package/lib/ZeddemoreLogger.js

@@ -1,29 +1,32 @@
-// Copyright (c) 2025 by Beardon Services, Inc.
+// Copyright (c) 2025-2026 by Beardon Services, Inc.
 
 const _ = require('lodash');
 const chalk = require('chalk');
+const { hostname } = require('node:os');
 const morgan = require('morgan');
 const sizeof = require('object-sizeof');
 const winston = require('winston');
 
-const { areHeadersSent, isResponseSuccessful } = require('./response');
+const { areHeadersSent, isResponseFailure, isResponseSuccessful } = require('./response');
 const { chalkHttpStatuses, chalkHttpVerbs, chalkLogLevel, chalkPackage, chalkTarget } = require('./color');
 const { convertBytes } = require('./math');
 const { convertMilliseconds } = require('./date');
 const defaults = require('./defaults');
 const enums = require('./enums');
+const { extractHttpStatusCode, extractHttpVerb } = require('./http');
 const { extractToken, getRequestResponseTime, isRequestOfMethod, parseRequest } = require('./request');
 const { generateUuid } = require('./uuid');
-const { isMorganFormat, logLevelToWinstonLogLevelName, monkeyPatchConsole } = require('./logging');
+const { isMorganFormat, isValidLogLevelId, isWinstonTransportId, logLevelToWinstonLogLevelName, monkeyPatchConsole } = 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 { morganFormats: mf, morganFormatTokens: mft, httpMethods: http, httpRequestHeaders: rqh, httpResponseHeaders: rsh,
-    winstonLogLevelNames: wlln, winstonLogLevels: wll } = enums;
+const { httpMethods: http, httpRequestHeaders: rqh, httpResponseHeaders: rsh, morganFormats: mf, morganFormatTokens: mft,
+    winstonLogLevelNames: wlln, winstonLogLevels: wll, winstonTransportIds: wti } = enums;
 
 class ZeddemoreLogger extends ZeddemoreBase {
 
@@ -34,6 +37,18 @@ class ZeddemoreLogger extends ZeddemoreBase {
     #apiRoutes = [ ];
     #apiVersion = null;
     #decodeUrls = true;
+    #doConsoleLog = true;
+    #doEmailLog = false;
+    #emailLogDebug = false;
+    #emailLogFrom = null;
+    #emailLogHost = null;
+    #emailLogLevel = wll.ERROR;
+    #emailLogPassword = null;
+    #emailLogPort = null;
+    #emailLogSubject = 'Zeddemore Log ({{ level }}) - {{ message }}';
+    #emailLogTo = null;
+    #emailLogUseHtml = false;
+    #emailLogUsername = null;
     #httpRequestLogging = true;
     /** @type {ZeddemoreLoggerController} */
     #logger = null;
@@ -41,6 +56,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
     #routeSequelizeLogging = false;
     /** @type {SequelizeModel} */
     #routeSequelizeModel = null;
+    #serverUrl = null;
     #suppressNonMutatingRequestApiCallLogging = false;
     #suppressSuccessfulRequestApiCallLogging = false;
 
@@ -55,6 +71,18 @@ class ZeddemoreLogger extends ZeddemoreBase {
         this.apiRoutes = options.apiRoutes;
         this.apiVersion = options.apiVersion;
         this.decodeUrls = options.decodeUrls;
+        this.doConsoleLog = options.doConsoleLog;
+        this.doEmailLog = options.doEmailLog;
+        this.emailLogDebug = options.emailLogDebug;
+        this.emailLogFrom = options.emailLogFrom;
+        this.emailLogHost = options.emailLogHost;
+        this.emailLogLevel = options.emailLogLevel;
+        this.emailLogPassword = options.emailLogPassword;
+        this.emailLogPort = options.emailLogPort;
+        this.emailLogSubject = options.emailLogSubject;
+        this.emailLogTo = options.emailLogTo;
+        this.emailLogUseHtml = options.emailLogUseHtml;
+        this.emailLogUsername = options.emailLogUsername;
         this.httpRequestLogging = options.httpRequestLogging;
         if (_.isBoolean(options.disableMorganLogging )) this.httpRequestLogging = !options.disableMorganLogging; // backwards compatibility
         this.morganFormat = options.morganFormat;
@@ -62,6 +90,7 @@ class ZeddemoreLogger extends ZeddemoreBase {
         if (_.isBoolean(options.disableRouteLogging)) this.routeSequelizeLogging = !options.disableRouteLogging; // backwards compatibility
         this.routeSequelizeModel = options.routeSequelizeModel;
         if (this.#isSequelizeModel(options.routeModel)) this.routeSequelizeModel = options.routeModel; // backwards compatibility
+        this.serverUrl = options.serverUrl;
         this.suppressNonMutatingRequestApiCallLogging = options.suppressNonMutatingRequestApiCallLogging;
         this.suppressSuccessfulRequestApiCallLogging = options.suppressSuccessfulRequestApiCallLogging;
     }
@@ -106,6 +135,10 @@ class ZeddemoreLogger extends ZeddemoreBase {
         if (_.isString(version) && !!version.length) this.#apiVersion = version;
     }
 
+    get canEmailLog() {
+        return this.doEmailLog && !!this.emailLogFrom && !!this.emailLogHost && !!this.emailLogPassword && !!this.emailLogPort && !!this.emailLogUsername && !!this.emailLogTo;
+    }
+
     get canSequelizeLogApiCall() {
         return this.apiCallSequelizeLogging && !!this.apiCallSequelizeModel;
     }
@@ -122,6 +155,102 @@ class ZeddemoreLogger extends ZeddemoreBase {
         if (_.isBoolean(doDecode)) this.#decodeUrls = doDecode;
     }
 
+    get doConsoleLog() {
+        return this.#doConsoleLog;
+    }
+
+    set doConsoleLog(doLog) {
+        if (_.isBoolean(doLog)) this.#doConsoleLog = doLog;
+    }
+
+    get doEmailLog() {
+        return this.#doEmailLog;
+    }
+
+    set doEmailLog(doLog) {
+        if (_.isBoolean(doLog)) this.#doEmailLog = doLog;
+    }
+
+    get emailLogDebug() {
+        return this.#emailLogDebug;
+    }
+
+    set emailLogDebug(debug) {
+        if (_.isBoolean(debug)) this.#emailLogDebug = debug;
+    }
+
+    get emailLogFrom() {
+        return this.#emailLogFrom || this.#buildEmailLogFrom();
+    }
+
+    set emailLogFrom(from) {
+        if (_.isString(from) && !!from.length) this.#emailLogFrom = from;
+    }
+
+    get emailLogHost() {
+        return this.#emailLogHost;
+    }
+
+    set emailLogHost(host) {
+        if (_.isString(host) && !!host.length) this.#emailLogHost = host;
+    }
+
+    get emailLogLevel() {
+        return this.#emailLogLevel;
+    }
+
+    set emailLogLevel(level) {
+        if (isValidLogLevelId(level)) this.#emailLogLevel = level;
+    }
+
+    get emailLogPassword() {
+        return this.#emailLogPassword;
+    }
+
+    set emailLogPassword(password) {
+        if (_.isString(password) && !!password.length) this.#emailLogPassword = password;
+    }
+
+    get emailLogPort() {
+        return this.#emailLogPort;
+    }
+
+    set emailLogPort(port) {
+        if (_.isInteger(port)) this.#emailLogPort = port;
+    }
+
+    get emailLogSubject() {
+        return this.#emailLogSubject;
+    }
+
+    set emailLogSubject(subject) {
+        if (_.isString(subject) && !!subject.length) this.#emailLogSubject = subject;
+    }
+
+    get emailLogTo() {
+        return this.#emailLogTo;
+    }
+
+    set emailLogTo(to) {
+        if (_.isString(to) && !!to.length) this.#emailLogTo = to;
+    }
+
+    get emailLogUseHtml() {
+        return this.#emailLogUseHtml;
+    }
+
+    set emailLogUseHtml(useHtml) {
+        if (_.isBoolean(useHtml)) this.#emailLogUseHtml = useHtml;
+    }
+
+    get emailLogUsername() {
+        return this.#emailLogUsername;
+    }
+
+    set emailLogUsername(username) {
+        if (_.isString(username) && !!username.length) this.#emailLogUsername = username;
+    }
+
     get httpRequestLogging() {
         return this.#httpRequestLogging;
     }
@@ -159,6 +288,30 @@ class ZeddemoreLogger extends ZeddemoreBase {
         if (this.#isSequelizeModel(model)) this.#routeSequelizeModel = model;
     }
 
+    get serverEnvironment() {
+        return process.env.NODE_ENV || 'development';
+    }
+
+    get serverInstance() {
+        return (process.env.NODE_APP_INSTANCE && (process.env.NODE_APP_INSTANCE.length > 1)) ? process.env.NODE_APP_INSTANCE : null; // handles goofy PM2 NODE_APP_INSTANCE of '0'
+    }
+
+    get serverName() {
+        return this.defaultLabel;
+    }
+
+    get serverPort() {
+        return process.env.PORT || 3000;
+    }
+
+    get serverUrl() {
+        return this.#serverUrl || hostname();
+    }
+
+    set serverUrl(url) {
+        if (_.isString(url) && !!url.length) this.#serverUrl = url;
+    }
+
     get suppressNonMutatingRequestApiCallLogging() {
         return this.#suppressNonMutatingRequestApiCallLogging;
     }
@@ -175,6 +328,45 @@ class ZeddemoreLogger extends ZeddemoreBase {
         if (_.isBoolean(suppress)) this.#suppressSuccessfulRequestApiCallLogging = suppress;
     }
 
+    get values() {
+        return {
+            ...super.values,
+            apiCallSequelizeLogging: this.apiCallSequelizeLogging,
+            apiCallSequelizeModel: this.apiCallSequelizeModel,
+            apiRouteCategories: this.apiRouteCategories,
+            apiRoutes: this.routeSequelizeLogging,
+            apiVersion: this.apiVersion,
+            decodeUrls: this.decodeUrls,
+            doConsoleLog: this.doConsoleLog,
+            doEmailLog: this.doEmailLog,
+            emailLogDebug: this.emailLogDebug,
+            emailLogFrom: this.emailLogFrom,
+            emailLogHost: this.emailLogHost,
+            emailLogLevel: this.emailLogLevel,
+            emailLogPort: this.emailLogPort,
+            emailLogSubject: this.emailLogSubject,
+            emailLogTo: this.emailLogTo,
+            emailLogUseHtml: this.emailLogUseHtml,
+            httpRequestLogging: this.httpRequestLogging,
+            logger: this.logger,
+            morganFormat: this.morganFormat,
+            routeSequelizeLogging: this.routeSequelizeLogging,
+            routeSequelizeModel: this.routeSequelizeModel,
+            serverUrl: this.serverUrl,
+            suppressNonMutatingRequestApiCallLogging: this.suppressNonMutatingRequestApiCallLogging,
+            suppressSuccessfulRequestApiCallLogging: this.suppressSuccessfulRequestApiCallLogging,
+        };
+    }
+
+    #buildEmailLogFrom() {
+        if (_.isString(this.#emailLogFrom) && !!this.#emailLogFrom) return this.#emailLogFrom;
+        const localParts = [ 'zeddemore' ]
+        if (!!this.serverName) localParts.push(this.serverName);
+        if (!!this.serverInstance) localParts.push(this.serverInstance);
+        if (!!this.serverEnvironment) localParts.push(this.serverEnvironment);
+        return `${ localParts.join('_') }@${ hostname() }`;
+    }
+
     /**
      * Build log message
      * @param {String|[String]|Object} [message]
@@ -249,12 +441,14 @@ class ZeddemoreLogger extends ZeddemoreBase {
      * Build a Winston format
      * @param {Object} options
      * @param {[Format]} [additionalFormats]
+     * @param {String} [transportId]
      * @returns {Format}
      */
-    #buildWinstonFormat = (options, additionalFormats = [ ]) => {
+    #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;
@@ -287,30 +481,66 @@ class ZeddemoreLogger extends ZeddemoreBase {
     /**
      * Build a Winston Console transport
      * @param {number|String} [logLevel]
+     * @param {Object} [options]
+     * @param {[Format]} [options.formats]
      * @returns {winston.ConsoleTransportInstance}
      */
-    #buildWinstonTransport = (logLevel = this.logLevel) => {
+    #buildWinstonConsoleTransport = (logLevel = this.logLevel, options) => {
+        options = options || { };
         logLevel = logLevel || this.logLevel;
         const level = logLevelToWinstonLogLevelName(logLevel);
-        return new transports.Console({ level });
+        const format = this.#buildWinstonFormat(options, options.formats, wti.CONSOLE);
+        return new transports.Console({ format, id: wti.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 || { };
+        logLevel = logLevel || this.emailLogLevel;
+        const level = logLevelToWinstonLogLevelName(logLevel);
+        const format = this.#buildWinstonFormat(options, options.formats, wti.EMAIL);
+        const messageOptions = {
+            from: this.emailLogFrom,
+            subject: this.emailLogSubject,
+            to: this.emailLogTo,
+        };
+        const transportOptions = {
+            auth: {
+                user: this.emailLogUsername,
+                pass: this.emailLogPassword,
+            },
+            debug: this.emailLogDebug,
+            host: this.emailLogHost,
+            port: this.emailLogPort,
+        };
+        const winstonOptions = { level };
+        const _options = { format, id: wti.EMAIL, messageOptions, transportOptions, ...winstonOptions };
+        return new WinstonEmailTransport(_options);
     }
 
     /**
      * Build Winston transports
      * @param {number|String} [logLevel]
+     * @param {number|String} [emailLogLevel]
      * @param {[Object]} [additionalTransports]
      * @returns {Object[]}
      */
-    #buildWinstonTransports = (logLevel = this.logLevel, additionalTransports = [ ]) => {
-        return additionalTransports.concat([ this.#buildWinstonTransport(logLevel) ]);
+    #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;
     }
 
     #colorizeResponse(message) {
-        if (!_.isString(message) || !message.length) return message;
-        const splitMessage = message.split(' ');
-        if (splitMessage.length < 2) return message;
-        const verb = message.split(' ')[ 0 ];
-        return chalkHttpVerbs(verb, message);
+        const verb = extractHttpVerb(message);
+        return verb ? chalkHttpVerbs(verb, message) : message;
     }
 
     /**
@@ -363,16 +593,15 @@ class ZeddemoreLogger extends ZeddemoreBase {
      * Create a Winston Logger
      * @param {Object} [options]
      * @param {[Format]} [options.formats]
-     * @param {String} [options.level]
+     * @param {number|String} [options.level]
+     * @param {number|String} [options.emailLevel]
      * @param {[Object]} [options.transports]
      * @returns {winston.Logger}
      */
     #createWinstonLogger = (options) => {
         options = options || { };
-        return createWinstonLogger({
-            format: this.#buildWinstonFormat(options, options.formats),
-            transports: this.#buildWinstonTransports(options.level, options.transports),
-        });
+        const transports = this.#buildWinstonTransports(options.level, options.emailLevel, options.transports);
+        return createWinstonLogger({ transports });
     }
 
     /**
@@ -500,11 +729,13 @@ class ZeddemoreLogger extends ZeddemoreBase {
      */
     #logServerInfo = (options, logLevel = wll.INFO) => {
         options = options || { };
+        const serverUrl = options.url || this.serverUrl;
         const showLogLevel = _.isBoolean(options.showLogLevel) ? options.showLogLevel : true;
+        const showUrl = _.isBoolean(options.showUrl) ? options.showUrl : true;
         const logLevelLabel = chalkLogLevel(this.logLevel, this.logLevelName.toUpperCase());
         const msgParts = [ `Server is ${ chalk.bold(chalk.yellowBright(defaults.liveMessage)) }` ];
         if (showLogLevel) msgParts.push(`with log level ${ logLevelLabel }${ this.forceLogLevel ? ` (${ chalk.italic('forced') })` : '' }`);
-        if (options.url) msgParts.push(`at ${ chalk.underline(options.url) }`);
+        if (showUrl) msgParts.push(`at ${ chalk.underline(serverUrl) }`);
         this.log(logLevel)(msgParts.join(' '));
     }
 
@@ -519,10 +750,10 @@ class ZeddemoreLogger extends ZeddemoreBase {
      * @returns {void}
      */
     #logServerListening = (options, logLevel = wll.INFO) => {
-        const serverEnvironment = options.environment || process.env.NODE_ENV || 'development';
-        const serverInstance = options.instance || (process.env.NODE_APP_INSTANCE && (process.env.NODE_APP_INSTANCE.length > 1)) ? process.env.NODE_APP_INSTANCE : null; // handles goofy PM2 NODE_APP_INSTANCE of '0'
-        const serverName = options.name || this.defaultLabel;
-        const serverPort = options.port || process.env.PORT || 3000;
+        const serverEnvironment = options.environment || this.serverEnvironment;
+        const serverInstance = options.instance || this.serverInstance;
+        const serverName = options.name || this.serverName;
+        const serverPort = options.port || this.serverPort;
         const msgParts = [ ];
         const serverParts = [ serverName ];
         if (serverEnvironment) serverParts.push(serverEnvironment);
@@ -639,6 +870,12 @@ class ZeddemoreLogger extends ZeddemoreBase {
                         if (user) logOptions.user = user;
                         const response = colorize ? this.#colorizeResponse(message.trim()) : message.trim();
                         ZeddemoreLogger.getLogger(logOptions).http(response);
+                        if (this.doEmailLog) {
+                            const statusCode = extractHttpStatusCode(message);
+                            if (isResponseFailure(statusCode, [ 404 ])) {
+                                ZeddemoreLogger.getLogger(logOptions).log({ level: wlln.ERROR, message: response, transport: wti.EMAIL });
+                            }
+                        }
                     },
                 },
             })(req, res, next);

package/lib/enums.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2025 by Beardon Services, Inc.
+// Copyright (c) 2025-2026 by Beardon Services, Inc.
 
 function doesEnumInclude(set, value) {
     for (const key in set) {
@@ -178,6 +178,11 @@ const winstonLogLevels = {
     SILLY: 6,
 };
 
+const winstonTransportIds = {
+    CONSOLE: 'console',
+    EMAIL: 'email',
+};
+
 module.exports = {
     doesEnumInclude,
     ansiColors,
@@ -196,4 +201,5 @@ module.exports = {
     progressBarAlignments,
     winstonLogLevelNames,
     winstonLogLevels,
+    winstonTransportIds,
 };

package/lib/http.js

@@ -0,0 +1,26 @@
+// Copyright (c) 2026 by Beardon Services, Inc.
+
+const _ = require('lodash');
+
+function extractHttpStatusCode(message) {
+    if (!_.isString(message) || !message.length) return null;
+    // Regex breakdown:
+    // \b      : Word boundary (ensures we don't grab "12345")
+    // [1-5]   : Starts with 1 (Info), 2 (Success), 3 (Redirect), 4 (Client Error), or 5 (Server Error)
+    // [0-9]{2}: Followed by exactly two digits
+    // \b      : Ending word boundary
+    const match = message.match(/\b[1-5][0-9]{2}\b/);
+    return match ? +match[ 0 ] : null;
+}
+
+function extractHttpVerb(message) {
+    if (!_.isString(message) || !message.length) return null;
+    const splitMessage = message.split(' ');
+    if (splitMessage.length < 2) return null;
+    return message.split(' ')[ 0 ];
+}
+
+module.exports = {
+    extractHttpStatusCode,
+    extractHttpVerb,
+}

package/lib/logging.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2025 by Beardon Services, Inc.
+// Copyright (c) 2025-2026 by Beardon Services, Inc.
 
 const _ = require('lodash');
 
@@ -13,7 +13,7 @@ function isMorganFormat(format) {
 }
 
 function isValidLogLevel(logLevel) {
-    if (!logLevel) return false;
+    if (!_.isInteger(logLevel) && (!_.isString(logLevel) || !logLevel.length)) return false;
     if (_.isInteger(logLevel)) return isValidLogLevelId(logLevel);
     if (_.isString(logLevel)) return isValidLogLevelName(logLevel);
     return false;
@@ -29,6 +29,10 @@ function isValidLogLevelName(logLevelName) {
     return !!(_.find(logLevelMap, { winstonName: logLevelName }))
 }
 
+function isWinstonTransportId(winstonTransportId) {
+    return doesEnumInclude(enums.winstonTransportIds, winstonTransportId);
+}
+
 /**
  * Convert a log level ID to a Winston log level name
  * @param levelId {number}
@@ -70,6 +74,8 @@ function monkeyPatchConsole(methodNames = [ defaults.consoleDirExtensionMethodNa
 module.exports = {
     isMorganFormat,
     isValidLogLevel,
+    isValidLogLevelId,
+    isWinstonTransportId,
     logLevelIdToWinstonLogLevelName,
     logLevelToWinstonLogLevelName,
     monkeyPatchConsole,

package/lib/response.js

@@ -11,6 +11,19 @@ function areHeadersSent(res) {
     return typeof (res.headersSent !== 'boolean') ? Boolean(res._header) : res.headersSent;
 }
 
+function isResponseFailure(statusCode, disregardStatusCodes = [ ]) {
+    if (_.isArray(disregardStatusCodes) && disregardStatusCodes.includes(statusCode)) return false;
+    return isResponseStatusCodeClientError(statusCode) || isResponseStatusCodeServerError(statusCode);
+}
+
+function isResponseStatusCodeClientError(statusCode) {
+    return isResponseStatusCodeInGroup(statusCode, hscg.CLIENT_ERROR);
+}
+
+function isResponseStatusCodeInformational(statusCode) {
+    return isResponseStatusCodeInGroup(statusCode, hscg.INFORMATIONAL);
+}
+
 function isResponseStatusCodeInGroup(statusCode, group) {
     if (!statusCode || !group) return false;
     const httpStatusCodeGroupMapEntry = _.find(httpStatusCodeGroupMap, { group });
@@ -22,15 +35,20 @@ function isResponseStatusCodeRedirection(statusCode) {
     return isResponseStatusCodeInGroup(statusCode, hscg.REDIRECTION);
 }
 
+function isResponseStatusCodeServerError(statusCode) {
+    return isResponseStatusCodeInGroup(statusCode, hscg.SERVER_ERROR);
+}
+
 function isResponseStatusCodeSuccessful(statusCode) {
     return isResponseStatusCodeInGroup(statusCode, hscg.SUCCESSFUL);
 }
 
 function isResponseSuccessful(statusCode) {
-    return isResponseStatusCodeSuccessful(statusCode) || isResponseStatusCodeRedirection(statusCode);
+    return isResponseStatusCodeSuccessful(statusCode) || isResponseStatusCodeRedirection(statusCode) || isResponseStatusCodeInformational(statusCode);
 }
 
 module.exports = {
     areHeadersSent,
+    isResponseFailure,
     isResponseSuccessful,
 };

package/lib/transports/WinstonEmailTransport.js

@@ -0,0 +1,127 @@
+// Copyright (c) 2026 by Beardon Services, Inc.
+
+const _ = require('lodash');
+const ansiHTML = require('ansi-html');
+const { createTransport } = require('nodemailer');
+const { hostname } = require('node:os');
+const { stripVTControlCharacters } = require('node:util');
+const Transport = require('winston-transport');
+
+/**
+ * @class
+ * @extends Transport
+ */
+class WinstonEmailTransport extends Transport {
+
+    _messageOptions = { };
+    #useHtml = false;
+
+    /**
+     * @callback FilterFunction
+     * @param {Object} info
+     * @param {string} info.level
+     * @param {string} info.message
+     * @returns {boolean}
+     *
+     * @param {Object} [options={}] Options for this instance
+     * @param {Object} [options.transportOptions]
+     * @param {Object} [options.messageOptions]
+     * @param {string} [options.messageOptions.to]
+     * @param {string} [options.messageOptions.from]
+     * @param {string} [options.messageOptions.subject]
+     * @param {FilterFunction} [options.messageOptions.filter]
+     * @throws {Error} if options.messageOptions.to is empty or not set
+     */
+    constructor(options) {
+        options = options || { };
+        const { messageOptions = { }, transportOptions = { }, ...winstonOptions } = options;
+        super(winstonOptions);
+        if (!_.isString(messageOptions.to) || !messageOptions.to.length) {
+            throw new Error('WinstonEmailTransport requires \'to\' property');
+        }
+        /**
+         * @member {Object} _messageOptions
+         * @member {string} _messageOptions.to
+         * @member {string} _messageOptions.from
+         * @member {string} _messageOptions.subject
+         * @member {FilterFunction} _messageOptions.filter
+         * @private
+         */
+        this._messageOptions = {
+            ...messageOptions,
+            from: messageOptions.from ?? `winston@${ hostname() }`,
+            subject: messageOptions.subject ?? 'Winston Log',
+            filter: messageOptions.filter ?? (() => true),
+        };
+        this.name = 'WinstonEmailTransport';
+        /**
+         * @member {object}
+         * @private
+         */
+        this._transportOptions = transportOptions;
+        this.useHtml = winstonOptions.useHtml;
+    }
+
+    get useHtml() {
+        return this.#useHtml;
+    }
+
+    set useHtml(useHtml) {
+        if (_.isBoolean(useHtml)) this.#useHtml = useHtml;
+    }
+
+    /**
+     * Core logging method exposed to Winston
+     *
+     * @callback NextFunction
+     * @returns {void}
+     *
+     * @param {Object} info
+     * @param {string} info.level
+     * @param {string} info.message
+     * @param {NextFunction} callback
+     */
+    log(info, callback) {
+        try {
+            if (!this._messageOptions.filter(info)) {
+                setImmediate(callback);
+                return;
+            }
+            const { level, message, ...meta } = info;
+            const _level = stripVTControlCharacters(level);
+            const _message = stripVTControlCharacters(message);
+            /** @type {Object.<string,*>} messageOptions */
+            const { filter, ...messageOptions } = { ...this._messageOptions }
+            const subject = messageOptions.subject.replace(/{{\s*level\s*}}/g, _level).replace(/{{\s*message\s*}}/g, `${ _message }`.split('\n')[ 0 ]);
+            const content = meta[ Symbol.for('message') ];
+            const html = ansiHTML(content);
+            const text = stripVTControlCharacters(content);
+            messageOptions.subject = subject;
+            if (this.useHtml) messageOptions.html = html;
+            messageOptions.text = text;
+            const transporter = createTransport(this._transportOptions);
+            transporter.sendMail(
+                messageOptions,
+                /**
+                 * @fires WinstonEmailTransport#error
+                 * @fires WinstonEmailTransport#logged
+                 * @param {?Error} err
+                 * @param {Object} info
+                 */
+                (err, info) => {
+                    setImmediate(callback);
+                    if (err) {
+                        this.emit('error', err);
+                    } else {
+                        this.emit('logged', info);
+                    }
+                }
+            );
+        } catch (e) {
+            console.error(e);
+            console.error('Email logging failed, moving on');
+        }
+    }
+}
+
+module.exports = WinstonEmailTransport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeddemore-logger",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Node.js Express logger using Morgan and Winston for thread and caller info tracking",
   "repository": {
     "type": "git",
@@ -20,13 +20,16 @@
   "homepage": "https://github.com/beardon/zeddemore-logger#readme",
   "main": "lib/zeddemore-logger.js",
   "dependencies": {
+    "ansi-html": "^0.0.9",
     "chalk": "^4.1.2",
     "cli-progress": "^3.12.0",
-    "lodash": "^4.17.23",
+    "lodash": "^4.18.1",
     "luxon": "^3.7.1",
     "morgan": "^1.10.1",
+    "nodemailer": "^8.0.4",
     "object-sizeof": "^2.6.5",
     "uuid": "^10.0.0",
-    "winston": "^3.17.0"
+    "winston": "^3.17.0",
+    "winston-transport": "^4.9.0"
   }
 }