zeddemore-logger 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+# zeddemore-logger
+
+Node.js logger using Morgan and Winston.

package/lib/color.js

@@ -0,0 +1,107 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+const _ = require('lodash');
+const chalk = require('chalk');
+
+const colorMappings = require('./mappings/color_mappings');
+
+function chalkDatabaseOperation(operation, string = null) {
+    if (!string) string = operation;
+    return chalkViaColorMap(operation, string, colorMappings.databaseOperationColors, true);
+}
+
+function chalkHttpStatus(statusCode) {
+    const colorMap = _.find(colorMappings.httpStatusColors, (httpStatusColor) => httpStatusColor.range.includes(statusCode));
+    if (!colorMap) return statusCode;
+    let chalkedMatch = statusCode;
+    if (colorMap.ansi) chalkedMatch = `\x1B[${ colorMap.ansi }m${ statusCode }\x1B[39m`;
+    return chalkedMatch;
+}
+
+function chalkHttpVerb(verb, string = null) {
+    if (!string) string = verb;
+    return chalkViaColorMap(verb, string, colorMappings.httpVerbColors, false);
+}
+
+function chalkViaColorMap(match, string, colorMap, useGlobal = true) {
+    function fixPattern(pattern) {
+        return pattern.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1');
+    }
+    if (!match || !_.isString(match) || !string || !_.isString(string) || !_.isObject(colorMap)) return string;
+    const cleanMatch = match.replace(/[^A-Z]/g, '');
+    const mapping = _.find(colorMap, { match: cleanMatch });
+    if (!mapping) return string;
+    const flags = useGlobal ? 'g' : '';
+    const re = new RegExp(fixPattern(match), flags);
+    if (!string.match(re)) return string;
+    let chalkedMatch = cleanMatch;
+    if (mapping.fore) chalkedMatch = chalk.hex(mapping.fore)(chalkedMatch);
+    if (mapping.back) chalkedMatch = chalk.bgHex(mapping.back)(chalkedMatch);
+    return string.replace(re, chalkedMatch);
+}
+
+// adapted from https://stackoverflow.com/a/44134328
+function hslToHex(hue, saturation, lightness) {
+    lightness /= 100;
+    const a = saturation * Math.min(lightness, 1 - lightness) / 100;
+    const convert = (n) => {
+        const k = (n + hue / 30) % 12;
+        const color = lightness - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+        return Math.round(255 * color).toString(16).padStart(2, '0'); // convert to Hex and prefix "0" if needed
+    };
+    return `#${ convert(0) }${ convert(8) }${ convert(4) }`;
+}
+
+// adapted from https://gist.github.com/0x263b/2bdd90886c2036a1ad5bcf06d6e6fb37
+function stringToIdempotentHexColor(str, useHsl = true) {
+    if (useHsl) {
+        const { h, s, l } = stringToIdempotentHslValues(str);
+        return hslToHex(h, s, l);
+    }
+    let hash = 0;
+    if (str.length === 0) return hash;
+    for (let i = 0; i < str.length; i++) {
+        hash = str.charCodeAt(i) + ((hash << 5) - hash);
+        hash = hash & hash;
+    }
+    let hexColor = '#';
+    for (let i = 0; i < 3; i++) {
+        let value = (hash >> (i * 8)) & 255;
+        hexColor += (`00${ value.toString(16) }`).substring(-2);
+    }
+    return hexColor;
+}
+
+// adapted from https://gist.github.com/0x263b/2bdd90886c2036a1ad5bcf06d6e6fb37
+function stringToIdempotentHslValues(str, hslOptions) {
+    function range(hash, min, max) {
+        const diff = max - min;
+        const x = ((hash % diff) + diff) % diff;
+        return x + min;
+    }
+
+    hslOptions = hslOptions || { };
+    const hueRange = hslOptions.hue || [ 0, 360 ];
+    const saturationRange = hslOptions.saturation || [ 75, 100 ];
+    const lightnessRange = hslOptions.lightness || [ 40, 60 ];
+
+    let hash = 0;
+    if (!str || str.length === 0) return hash;
+    for (let i = 0; i < str.length; i++) {
+        hash = str.charCodeAt(i) + ((hash << 5) - hash);
+        hash = hash & hash;
+    }
+
+    const hue = range(hash, hueRange[ 0 ], hueRange[ 1 ]);
+    const saturation = range(hash, saturationRange[ 0 ], saturationRange[ 1 ]);
+    const lightness = range(hash, lightnessRange[ 0 ], lightnessRange[ 1 ]);
+
+    return { h: hue, s: saturation, l: lightness };
+}
+
+module.exports = {
+    chalkDatabaseOperation,
+    chalkHttpStatus,
+    chalkHttpVerb,
+    stringToIdempotentHexColor,
+};

package/lib/date.js

@@ -0,0 +1,51 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+function convertMilliseconds(milliseconds, options) {
+    options = options || { };
+    const digits = options.digits || 3;
+    const spaced = options.hasOwnProperty('spaced') ? options.spaced : false;
+    let value = milliseconds || 0;
+    let unit = 'ms';
+    if (milliseconds) {
+        const seconds = milliseconds / 1000;
+        if (seconds >= 1) {
+            value = seconds;
+            unit = 's';
+            const minutes = seconds / 60;
+            if (minutes >= 1) {
+                value = minutes;
+                unit = 'm';
+                const hours = minutes / 60;
+                if (hours >= 1) {
+                    value = hours;
+                    unit = 'h';
+                    const days = hours / 24;
+                    if (days >= 1) {
+                        value = days;
+                        unit = 'd';
+                        const weeks = days / 7;
+                        if (weeks >= 1) {
+                            value = weeks;
+                            unit = 'w';
+                            const months = days / 30;
+                            if (months >= 1) {
+                                value = months;
+                                unit = 'M';
+                                const years = days / 365;
+                                if (years >= 1) {
+                                    value = years;
+                                    unit = 'y';
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return `${ value.toFixed(digits) }${ spaced ? ' ' : '' }${ unit }`;
+}
+
+module.exports = {
+    convertMilliseconds,
+};

package/lib/enums.js

@@ -0,0 +1,96 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+const apiLogLevelCaptions = {
+    DEFAULT: 'Default',
+    ERROR: 'Error',
+    WARNING: 'Warning',
+    INFO: 'Info',
+    HTTP: 'HTTP',
+    VERBOSE: 'Verbose',
+    DEBUG: 'Debug',
+    SILLY: 'Silly',
+};
+
+const apiLogLevels = {
+    DEFAULT: -1,
+    ERROR: 0,
+    WARNING: 1,
+    INFO: 2,
+    HTTP: 3,
+    VERBOSE: 4,
+    DEBUG: 5,
+    SILLY: 6,
+};
+
+const databaseOperations = {
+    DELETE: 'DELETE',
+    INSERT: 'INSERT',
+    SELECT: 'SELECT',
+    TRUNCATE: 'TRUNCATE',
+    UPDATE: 'UPDATE',
+};
+
+const httpMethods = {
+    GET: 'GET',
+    HEAD: 'HEAD',
+    POST: 'POST',
+    PUT: 'PUT',
+    DELETE: 'DELETE',
+    CONNECT: 'CONNECT',
+    OPTIONS: 'OPTIONS',
+    TRACE: 'TRACE',
+    PATCH: 'PATCH',
+};
+
+const httpRequestHeaders = {
+    ALLOW: 'Allow',
+    AUTHORIZATION: 'Authorization',
+    BEARER_PREFIX: 'Bearer',
+    REQUEST_ID: 'X-Request-Id',
+};
+
+const httpResponseHeaders = {
+    CONTENT_LENGTH: 'Content-Length',
+};
+
+const morganFormats = {
+    COMBINED: 'combined',
+    COMMON: 'common',
+    DEV: 'dev',
+    DEV_ENHANCED: ':method :url :status-colored :response-time-format :content-length-format',
+    SHORT: 'short',
+    TINY: 'tiny',
+};
+
+const winstonLogLevelNames = {
+    ERROR: 'error',
+    WARNING: 'warn',
+    INFO: 'info',
+    HTTP: 'http',
+    VERBOSE: 'verbose',
+    DEBUG: 'debug',
+    SILLY: 'silly',
+};
+
+// using NPM logging levels
+const winstonLogLevels = {
+    ERROR: 0,
+    WARNING: 1,
+    INFO: 2,
+    HTTP: 3,
+    VERBOSE: 4,
+    DEBUG: 5,
+    SILLY: 6,
+};
+
+module.exports = {
+    apiLogLevelCaptions,
+    apiLogLevels,
+    databaseOperations,
+    httpMethods,
+    httpRequestHeaders,
+    httpResponseHeaders,
+    morganFormats,
+    winstonLogLevelNames,
+    winstonLogLevels,
+};

package/lib/http.js

@@ -0,0 +1,47 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+function areHeadersSent(res) {
+    return typeof (res.headersSent !== 'boolean') ? Boolean(res._header) : res.headersSent;
+}
+
+function getRequestResponseTime(req, res) {
+    if (!req._startAt || !res._startAt) return null;
+    return (res._startAt[ 0 ] - req._startAt[ 0 ]) * 1e3 + (res._startAt[ 1 ] - req._startAt[ 1 ]) * 1e-6;
+}
+
+function parseRequest(req) {
+    if (!req) return { };
+    const body = req.body || { };
+    return {
+        acceptLanguage: parseRequestAcceptLanguage(req),
+        client: body.client || null,
+        clientVersion: body.applicationVersion || null,
+        ipAddress: parseRequestIpAddress(req),
+        sessionAge: body.uptime || 0,
+        sessionId: body.sessionId || null,
+        userAgent: parseRequestUserAgent(req),
+    };
+}
+
+function parseRequestAcceptLanguage(req) {
+    const body = req.body || { };
+    return body.language || req.header('Accept-Language');
+}
+
+function parseRequestIpAddress(req) {
+    const body = req.body || { };
+    const LOCALHOST_IPS = [ '127.0.0.1', '::1' ];
+    const ipAddress = body.ipAddress || req.get('X-Forwarded-For') || req.socket.remoteAddress;
+    return LOCALHOST_IPS.includes(ipAddress) ? 'localhost' : ipAddress;
+}
+
+function parseRequestUserAgent(req) {
+    const body = req.body || { };
+    return body.agent || body.osVersion || req.get('User-Agent');
+}
+
+module.exports = {
+    areHeadersSent,
+    getRequestResponseTime,
+    parseRequest,
+};

package/lib/mappings/color_mappings.js

@@ -0,0 +1,40 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+const _ = require('lodash');
+const enums = require('../enums');
+
+const { databaseOperations: dbo, httpMethods: http } = enums;
+
+const databaseOperationColors = [
+    { match: dbo.DELETE, fore: '#F22613', back: null },
+    { match: dbo.INSERT, fore: '#00B16A', back: null },
+    { match: dbo.SELECT, fore: '#1E90FF', back: null },
+    { match: dbo.TRUNCATE, fore: '#750505', back: null },
+    { match: dbo.UPDATE, fore: '#F9690E', back: null },
+];
+
+const httpStatusColors = [
+    { range: _.range(500, 600), ansi: 31 },
+    { range: _.range(400, 500), ansi: 33 },
+    { range: _.range(300, 400), ansi: 36 },
+    { range: _.range(200, 300), ansi: 32 },
+    { range: _.range(100, 200), ansi: 0 },
+];
+
+const httpVerbColors = [
+    { match: http.GET, fore: '#000000', back: '#67D193' },
+    { match: http.HEAD, fore: '#000000', back: '#68D696' },
+    { match: http.POST, fore: '#000000', back: '#F4DA7A' },
+    { match: http.PUT, fore: '#000000', back: '#74AEF6' },
+    { match: http.DELETE, fore: '#000000', back: '#EF968A' },
+    { match: http.CONNECT, fore: '#000000', back: '#FFFFFF' },
+    { match: http.OPTIONS, fore: '#000000', back: '#E55AA8' },
+    { match: http.TRACE, fore: '#000000', back: '#FFFFFF' },
+    { match: http.PATCH, fore: '#000000', back: '#C0A8E1' },
+];
+
+module.exports = {
+    databaseOperationColors,
+    httpStatusColors,
+    httpVerbColors,
+};

package/lib/mappings/log_mappings.js

@@ -0,0 +1,20 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+const enums = require('../enums');
+
+const { apiLogLevels: all, apiLogLevelCaptions: allc, winstonLogLevelNames: wlln, winstonLogLevels: wll } = enums;
+
+const logLevelMap = [
+    { apiLevel: all.DEFAULT, winstonLevel: null, winstonName: null, caption: allc.DEFAULT },
+    { apiLevel: all.ERROR, winstonLevel: wll.ERROR, winstonName: wlln.ERROR, caption: allc.ERROR },
+    { apiLevel: all.WARNING, winstonLevel: wll.WARNING, winstonName: wlln.WARNING, caption: allc.WARNING },
+    { apiLevel: all.INFO, winstonLevel: wll.INFO, winstonName: wlln.INFO, caption: allc.INFO },
+    { apiLevel: all.HTTP, winstonLevel: wll.HTTP, winstonName: wlln.HTTP, caption: allc.HTTP },
+    { apiLevel: all.VERBOSE, winstonLevel: wll.VERBOSE, winstonName: wlln.VERBOSE, caption: allc.VERBOSE },
+    { apiLevel: all.DEBUG, winstonLevel: wll.DEBUG, winstonName: wlln.DEBUG, caption: allc.DEBUG },
+    { apiLevel: all.SILLY, winstonLevel: wll.SILLY, winstonName: wlln.SILLY, caption: allc.SILLY },
+];
+
+module.exports = {
+    logLevelMap,
+};

package/lib/math.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+const _ = require('lodash');
+
+function convertBytes(bytes, options = { }) {
+    options = options || { };
+    if (!bytes) return null;
+    const useBinaryUnits = options.useBinaryUnits || false;
+    const decimals = options.decimals || 2;
+    const spaced = options.hasOwnProperty('spaced') ? options.spaced : false;
+    const base = useBinaryUnits ? 1024 : 1000;
+    const units = useBinaryUnits
+        ? [ 'B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB' ]
+        : [ 'B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB' ];
+    const i = Math.floor(Math.log(bytes) / Math.log(base));
+    const size = (bytes / Math.pow(base, i)).toFixed(decimals);
+    return `${ size }${ spaced ? ' ' : '' }${ units[ i ] }`;
+}
+
+function round(value, decimals = 2) {
+    if (!_.isNumber(value)) return value;
+    const rounder = Math.pow(10, decimals);
+    return Math.round((value + Number.EPSILON) * rounder) / rounder;
+}
+
+module.exports = {
+    convertBytes,
+    round,
+};

package/lib/zeddemore-logger.js

@@ -0,0 +1,280 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+const _ = require('lodash');
+const chalk = require('chalk');
+const { createLogger: createWinstonLogger, format, transports } = require('winston');
+const morgan = require('morgan');
+const { v4: uuid } = require('uuid');
+
+const { areHeadersSent, getRequestResponseTime, parseRequest } = require('./http');
+const { chalkHttpStatus, chalkHttpVerb, stringToIdempotentHexColor } = require('./color');
+const { convertBytes } = require('./math');
+const { convertMilliseconds } = require('./date');
+const enums = require('./enums');
+const { logLevelMap } = require('./mappings/log_mappings');
+
+const { colorize, combine, label, metadata, printf, timestamp } = format;
+const { morganFormats: mf, httpRequestHeaders: rqh, httpResponseHeaders: rsh, winstonLogLevels: wll, winstonLogLevelNames: wlln } = enums;
+
+const COLOR_CONSOLE_WHITE_HEX = '#ECECEC';
+const DEFAULT_REQUEST_ID_ATTRIBUTE = 'requestId';
+const DEFAULT_USER_LOG_LEVEL = -1;
+const WINSTON_CONSOLE_TRANSPORT_NAME = 'console';
+
+class ZeddemoreLogger {
+
+    constructor(options) {
+        options = options || { };
+        this.additionalWriteFn = options.additionalWriteFn || null;
+        this.defaultLabel = options.defaultLabel || 'zeddemore-logger';
+        this.disableMorganLogging = options.hasOwnProperty('disableMorganLogging') ? options.disableMorganLogging : false;
+        this.displayCaller = options.hasOwnProperty('displayCaller') ? options.displayUsername : true;
+        this.displayIpAddress = options.hasOwnProperty('displayIpAddress') ? options.displayIpAddress : true;
+        this.displayRequestId = options.hasOwnProperty('displayRequestId') ? options.displayRequestId : true;
+        this.customCallerSettings = options.customCallerSettings || [ ];
+        this.defaultUserLogLevel = options.defaultUserLogLevel || DEFAULT_USER_LOG_LEVEL;
+        this.forceLogLevel = options.hasOwnProperty('forceLogLevel') ? options.forceLogLevel : false;
+        this.logLevel = options.hasOwnProperty('logLevel') ? options.logLevel : wll.INFO;
+        this.morganFormat = options.morganFormat || mf.DEV_ENHANCED;
+        this.timestampFormat = options.timestampFormat || 'YYYY-MM-DD HH:mm:ss';
+        this.requestIdAttribute = options.requestIdAttribute || DEFAULT_REQUEST_ID_ATTRIBUTE;
+        this.userGetFn = options.userGetFn || this.#userGetFn;
+    }
+
+    #buildWinstonFormat = (options, additionalFormats = [ ]) =>{
+        options = options || { };
+        const colorizedTemplate = this.#colorizedTemplate.bind(this);
+        const formats = [
+            format((info) => {
+                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.timestampFormat }),
+            metadata(),
+            printf(this.#colorizedTemplate),
+        ];
+        return combine(...additionalFormats.concat(formats));
+    }
+
+    #buildWinstonTransport = (logLevel = this.logLevel) => {
+        logLevel = logLevel || this.logLevel;
+        const level = ZeddemoreLogger.winstonLogLevelIdToName(logLevel);
+        return new transports.Console({ level, name: WINSTON_CONSOLE_TRANSPORT_NAME });
+    }
+
+    #buildWinstonTransports = (logLevel = this.logLevel, additionalTransports = [ ]) => {
+        return additionalTransports.concat([ this.#buildWinstonTransport(logLevel) ]);
+    }
+
+    #callerToHexColor = (caller) => {
+        if (!caller) return COLOR_CONSOLE_WHITE_HEX;
+        const customCallerSetting = _.find(this.customCallerSettings, { caller });
+        if (customCallerSetting && customCallerSetting.color && customCallerSetting.color.fore) return customCallerSetting.color.fore;
+        return stringToIdempotentHexColor(caller, true);
+    }
+
+    #colorizeResponse(message) {
+        const verb = message.split(' ')[ 0 ];
+        return chalkHttpVerb(verb, message);
+    }
+
+    #colorizedTemplate = (info) => {
+        const id = info.metadata.id ? info.metadata.id.substring(0, 8) : null;
+        const subId = info.metadata.subId || null;
+        const caller = info.metadata.caller || info.metadata.user || null;
+        const ipAddress = info.metadata.ip || null;
+        const prefix = info.metadata.prefix || null;
+        const isError = (info.level.indexOf(wlln.ERROR) > -1);
+        const leaveUncompressed = isError || info.metadata.raw;
+        const idHexColor = stringToIdempotentHexColor(id, true);
+        const callerColorSource = caller || ipAddress;
+        const callerHexColor = this.#callerToHexColor(callerColorSource);
+        const parts = [ ];
+        parts.push(info.metadata.timestamp);
+        parts.push(`[${ info.metadata.target || info.metadata.label }]`);
+        parts.push(`${ info.level }:`);
+        const fullId = '🧵' + id + (subId ? `[${ subId }]` : '');
+        if (id && this.displayRequestId) parts.push(chalk.bold.hex(idHexColor)(fullId));
+        const callerParts = [ ];
+        if (caller && this.displayCaller) {
+            const customCallerSettings = _.find(this.customCallerSettings, { caller });
+            const logPrefix = customCallerSettings ? customCallerSettings.logPrefix : null;
+            callerParts.push(logPrefix ? logPrefix + caller : caller);
+        }
+        if (ipAddress && this.displayIpAddress) callerParts.push(ipAddress);
+        const fullCaller = callerParts.join('@');
+        if (fullCaller) parts.push(`<${ chalk.underline.hex(callerHexColor).bold(fullCaller) }>`);
+        if (prefix) parts.push(`[${ prefix }]`);
+        let message = Array.isArray(info.message) ? info.message.join('\n') : info.message;
+        message = _.isObject(message) ? JSON.stringify(message) : message;
+        parts.push(leaveUncompressed ? message : message.replace(/(\n?\s+)/g, ' '));
+        if (info.err) parts.push(info.err);
+        return isError ? chalk.red(parts.join(' ')) : parts.join(' ');
+    }
+
+    /**
+     * Create a Winston Logger
+     * @param options
+     * @returns {Logger}
+     */
+    #createLogger = (options = { }) => {
+        options = options || { };
+        return createWinstonLogger({
+            format: this.#buildWinstonFormat(options, options.formats),
+            transports: this.#buildWinstonTransports(options.level, options.transports),
+        });
+    }
+
+    #getRequestId = (req) => {
+        if (!req) return null;
+        return req[ this.requestIdAttribute ];
+    }
+
+    #initializeMorgan() {
+        function buildContentLengthFormatToken(res) {
+            const contentLength = convertBytes(res.get('content-length'), { digits: 2 });
+            return contentLength ? ` - ${ contentLength }` : '';
+        }
+        function buildResponseTimeFormatToken(req, res) {
+            const responseTime = getRequestResponseTime(req, res);
+            return responseTime ? convertMilliseconds(responseTime, { digits: 0 }) : '-';
+        }
+        function buildStatusColoredToken(res) {
+            const statusCode = areHeadersSent(res) ? res.statusCode : null;
+            if (!statusCode) return '-';
+            return chalkHttpStatus(statusCode);
+        }
+        morgan.token('content-length-format', (req, res) => { return buildContentLengthFormatToken(res); });
+        morgan.token('response-time-format', (req, res) => { return buildResponseTimeFormatToken(req, res); });
+        morgan.token('status-colored', (req, res) => { return buildStatusColoredToken(res); });
+    }
+
+    #createRequestLogger = (requestId = null, ipAddress = null) => {
+        requestId = requestId || this.#generateUuid();
+        const loggerOptions = { id: requestId };
+        if (ipAddress) loggerOptions.ip = ipAddress;
+        return this.#createLogger(loggerOptions);
+    }
+
+    #createUserLogger = (requestId = null, username = null, logLevel = this.defaultUserLogLevel, ipAddress = null) => {
+        requestId = requestId || this.#generateUuid();
+        logLevel = logLevel || this.defaultUserLogLevel;
+        const loggerOptions = { id: requestId, level: logLevel, user: username };
+        if (ipAddress) loggerOptions.ip = ipAddress;
+        return this.#createLogger(loggerOptions);
+    }
+
+    #generateUuid() {
+        return uuid(null, null, null);
+    }
+
+    static log(options) {
+        options = options || { };
+        const logger = options.logger || (options.user ? options.user.logger : null) || ((app && app.locals) ? app.locals.logger : null);
+        if (logger) return logger;
+        const zeddemoreLogger = new ZeddemoreLogger();
+        return zeddemoreLogger.#createLogger(options);
+    }
+
+    morganMiddleware = (options) => {
+        options = options || { };
+        const additionalWriteFn = (_.isFunction(options.additionalWriteFn) ? options.additionalWriteFn : null) || this.additionalWriteFn;
+        const disableMorganLogging = options.hasOwnProperty('disableMorganLogging') ? options.disableMorganLogging : this.disableMorganLogging;
+        const morganFormat = options.morganFormat || this.morganFormat;
+        const userGetFn = (_.isFunction(options.userGetFn) ? options.userGetFn : null) || this.userGetFn;
+        return (req, res, next) => {
+            this.#initializeMorgan();
+            return morgan(morganFormat, {
+                skip: () => disableMorganLogging,
+                stream: {
+                    write: (message) => {
+                        if (additionalWriteFn) additionalWriteFn(req, res);
+                        const logOptions = { };
+                        const user = userGetFn ? userGetFn(req, res) : null;
+                        if (user) logOptions.user = user;
+                        ZeddemoreLogger.log(logOptions).http(this.#colorizeResponse(message.trim()));
+                    },
+                },
+            })(req, res, next);
+        }
+    }
+
+    requestLoggerMiddleware = (req, res, next) => {
+        const requestValues = parseRequest(req);
+        const requestId = uuid();//this.#generateUuid();
+        req[ this.requestIdAttribute ] = requestId;
+        res.header(rqh.REQUEST_ID, requestId);
+        const ipAddress = requestValues.ipAddress;
+        res.locals.user = res.locals.user || { };
+        res.locals.user.logger = this.#createRequestLogger(requestId, ipAddress);
+        return next();
+    }
+
+    #userGetFn(req, res) {
+        return (res.locals ? res.locals.user : null) || (req.locals ? req.locals.user : null) || req.user || null;
+    }
+
+    userLoggerMiddleware = (req, res, next) => {
+        const requestId = this.#getRequestId(req);
+        const user = res.locals.user || { };
+        if (!requestId) return next();
+        const username = user.login || null;
+        let ipAddress = user.ipAddress || null;
+        if (!ipAddress) {
+            const requestValues = parseRequest(req);
+            ipAddress = requestValues.ipAddress;
+        }
+        let userLogLevel = !_.isNil(user.logLevel) ? user.logLevel : this.defaultUserLogLevel;
+        if (userLogLevel < 0) userLogLevel = this.logLevel;
+        const level = this.forceLogLevel ? this.logLevel : userLogLevel;
+        res.locals.user = res.locals.user || user;
+        res.locals.user.logger = this.#createUserLogger(requestId, username, level, ipAddress);
+        return next();
+    }
+
+    static winstonLogLevelIdToName(levelId) {
+        const logLevelEntry =  _.find(logLevelMap, { winstonLevel: levelId });
+        return logLevelEntry ? logLevelEntry.winstonName : wlln.HTTP;
+    }
+
+    static writeAxiosLog(axiosResponse, logOptions, options) {
+        function massageLogLevel(logLevel) {
+            if (!logLevel) return wlln.VERBOSE;
+            if (!_.isInteger(logLevel)) return logLevel;
+            return ZeddemoreLogger.winstonLogLevelIdToName(logLevel);
+        }
+        if (!axiosResponse || !axiosResponse.request) return;
+        logOptions = logOptions || { };
+        options = options || { };
+        const axiosConfig = logOptions.axios || { };
+        const configData = logOptions.data ? JSON.stringify(axiosConfig.data) : null;
+        const logLevel = massageLogLevel(logOptions.logLevel);
+        const logger = options.logger || ZeddemoreLogger.log(options);
+        if (!logger) return;
+        const _method = axiosResponse.request.method || null;
+        const method = _method ? chalkHttpVerb(_method) : null;
+        const path = axiosResponse.request.path || '';
+        const prefix = logOptions.prefix ? `[${ logOptions.prefix }]` : null;
+        const responseData = logOptions.response ? JSON.stringify(axiosResponse.data) : null;
+        const status = chalkHttpStatus(axiosResponse.status);
+        const _duration = axiosResponse.duration;
+        const duration = _duration ? convertMilliseconds(_duration) : '-';
+        const _contentLength = axiosResponse.headers ? axiosResponse.headers[ rsh.CONTENT_LENGTH ] : null;
+        const contentLength = _contentLength ? `- ${ convertBytes(_contentLength) }` : null;
+        const parts = [ prefix, method, path, configData, status, responseData, duration, contentLength ];
+        const message = _.compact(parts).join(' ');
+        logger[ logLevel ](message);
+    }
+
+}
+
+module.exports = {
+    log: ZeddemoreLogger.log,
+    ZeddemoreLogger,
+    winstonLogLevelIdToName: ZeddemoreLogger.winstonLogLevelIdToName,
+    writeAxiosLog: ZeddemoreLogger.writeAxiosLog,
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "zeddemore-logger",
+  "version": "1.0.0",
+  "description": "Node.js Express logger using Morgan and Winston for thread and caller info tracking",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/beardon/zeddemore-logger.git"
+  },
+  "keywords": [
+    "express",
+    "logger",
+    "morgan",
+    "winston"
+  ],
+  "author": "Aaron Bean <aaron.bean@beardon.com> (https://beardon.com)",
+  "license": "UNLICENSED",
+  "bugs": {
+    "url": "https://github.com/beardon/zeddemore-logger/issues"
+  },
+  "homepage": "https://github.com/beardon/zeddemore-logger#readme",
+  "main": "lib/zeddemore-logger.js",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "lodash": "^4.17.21",
+    "morgan": "^1.10.0",
+    "uuid": "^10.0.0",
+    "winston": "^3.17.0"
+  }
+}