zeddemore-logger 1.0.5 → 1.0.7

package/lib/color.js

@@ -1,43 +1,119 @@
-// Copyright (c) 2025 by Beardon Services, Inc.
+// Copyright (c) 2024-2025 by Beardon Services, Inc.
 
 const _ = require('lodash');
 const chalk = require('chalk');
 
 const colorMappings = require('./mappings/color_mappings');
+const enums = require('./enums');
 
-function chalkDatabaseOperation(operation, string = null) {
-    if (!string) string = operation;
-    return chalkViaColorMap(operation, string, colorMappings.databaseOperationColors, true);
+const { chalkLayers: cl, chalkFormats: cs } = enums;
+
+/**
+ * @param ansiColor {number}
+ * @param layer {string}
+ * @param string {string}
+ * @returns {string}
+ */
+function chalkAnsi(ansiColor, layer = cl.FOREGROUND, string) {
+    if (!string) return '';
+    if (!ansiColor) return string;
+    switch (layer) {
+        case cl.BACKGROUND: return `\x1B[${ ansiColor }m${ string }\x1B[49m`;
+        case cl.FOREGROUND: return `\x1B[${ ansiColor }m${ string }\x1B[39m`;
+        default: return string;
+    }
+}
+
+/**
+ * @param ansiColor {number}
+ * @param layer {string}
+ * @param string {string}
+ * @returns {string}
+ */
+function chalkAnsi256(ansiColor, layer = cl.FOREGROUND, string) {
+    if (!string) return '';
+    if (!ansiColor) return string;
+    switch (layer) {
+        case cl.BACKGROUND: return chalk.bgAnsi256(ansiColor)(string);
+        case cl.FOREGROUND: return chalk.ansi256(ansiColor)(string);
+        default: return string;
+    }
+}
+
+/**
+ * @param hexColor {string}
+ * @param layer {string}
+ * @param string {string}
+ * @returns {string}
+ */
+function chalkHex(hexColor, layer = cl.FOREGROUND, string) {
+    if (!string) return '';
+    if (!hexColor) return string;
+    hexColor = (hexColor[ 0 ] === '#') ? hexColor : `#${ hexColor }`;
+    switch (layer) {
+        case cl.BACKGROUND: return chalk.bgHex(hexColor)(string);
+        case cl.FOREGROUND: return chalk.hex(hexColor)(string);
+        default: return string;
+    }
 }
 
-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`;
+function chalkHttpStatuses(statusCode, string = null) {
+    if (!string) string = statusCode;
+    const colorMap = _.find(colorMappings.httpStatusColors, (httpStatusColor) => httpStatusColor.range.includes(string));
+    if (!colorMap || !colorMap.style) return string;
+    let chalkedMatch = string;
+    if (colorMap.style.fore) chalkedMatch = `\x1B[${ colorMap.style.fore }m${ string }\x1B[39m`;
     return chalkedMatch;
 }
 
-function chalkHttpVerb(verb, string = null) {
+function chalkHttpVerbs(verb, string = null, replaceGlobal = false) {
     if (!string) string = verb;
-    return chalkViaColorMap(verb, string, colorMappings.httpVerbColors, false);
+    return chalkViaColorMap(verb, string, colorMappings.httpVerbColors, replaceGlobal);
+}
+
+/**
+ * @param redColor {number}
+ * @param greenColor {number}
+ * @param blueColor {number}
+ * @param layer {string}
+ * @param string {string}
+ * @returns {string}
+ */
+function chalkRgb(redColor, greenColor, blueColor, layer = cl.FOREGROUND, string) {
+    if (!string) return '';
+    if (!redColor || !greenColor || !blueColor) return string;
+    switch (layer) {
+        case cl.BACKGROUND: return chalk.bgRgb(redColor, greenColor, blueColor)(string);
+        case cl.FOREGROUND: return chalk.rgb(redColor, greenColor, blueColor)(string);
+        default: return string;
+    }
+}
+
+function chalkTarget(target, style) {
+    if (!style) return target;
+    const fore = style.fore;
+    const back = style.back;
+    switch (style.format) {
+        case cs.ANSI: return chalkAnsi(back, cl.BACKGROUND, chalkAnsi(fore, cl.FOREGROUND, target));
+        case cs.ANSI256: return chalkAnsi256(back, cl.BACKGROUND, chalkAnsi256(fore, cl.FOREGROUND, target));
+        case cs.HEX: return chalkHex(back, cl.BACKGROUND, chalkHex(fore, cl.FOREGROUND, target));
+        case cs.RGB: return chalkRgb(back.r, back.g, back.b, cl.BACKGROUND, chalkRgb(fore.r, fore.g, fore.b, cl.FOREGROUND, target));
+        default: return target;
+    }
 }
 
-function chalkViaColorMap(match, string, colorMap, useGlobal = true) {
+function chalkViaColorMap(match, target, colorsMap, replaceGlobal = true) {
     function fixPattern(pattern) {
-        return pattern.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1');
+        return _.isString(pattern) ? pattern.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1') : pattern;
     }
-    if (!match || !_.isString(match) || !string || !_.isString(string) || !_.isObject(colorMap)) return string;
+    if (!match || !_.isString(match) || !target || !_.isString(target) || !_.isObject(colorsMap)) return target;
     const cleanMatch = match.replace(/[^A-Z]/g, '');
-    const mapping = _.find(colorMap, { match: cleanMatch });
-    if (!mapping) return string;
-    const flags = useGlobal ? 'g' : '';
+    const colorMap = _.find(colorsMap, { match: cleanMatch });
+    if (!colorMap || !colorMap.style) return target;
+    const flags = replaceGlobal ? '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);
+    if (!target.match(re)) return target;
+    return target.replace(re, chalkTarget(cleanMatch, colorMap.style));
 }
 
 // adapted from https://stackoverflow.com/a/44134328
@@ -100,8 +176,7 @@ function stringToIdempotentHslValues(str, hslOptions) {
 }
 
 module.exports = {
-    chalkDatabaseOperation,
-    chalkHttpStatus,
-    chalkHttpVerb,
+    chalkHttpStatuses,
+    chalkHttpVerbs,
     stringToIdempotentHexColor,
 };

package/lib/enums.js

@@ -22,6 +22,18 @@ const apiLogLevels = {
     SILLY: 6,
 };
 
+const chalkFormats = {
+    ANSI: 'ansi',
+    ANSI256: 'ansi256',
+    HEX: 'hex',
+    RGB: 'rgb',
+};
+
+const chalkLayers = {
+    BACKGROUND: 'bg',
+    FOREGROUND: 'fg',
+};
+
 const databaseOperations = {
     DELETE: 'DELETE',
     INSERT: 'INSERT',
@@ -86,6 +98,8 @@ const winstonLogLevels = {
 module.exports = {
     apiLogLevelCaptions,
     apiLogLevels,
+    chalkFormats,
+    chalkLayers,
     databaseOperations,
     httpMethods,
     httpRequestHeaders,

package/lib/mappings/color_mappings.js

@@ -1,40 +1,51 @@
-// Copyright (c) 2025 by Beardon Services, Inc.
+// Copyright (c) 2024-2025 by Beardon Services, Inc.
 
 const _ = require('lodash');
 const enums = require('../enums');
 
-const { databaseOperations: dbo, httpMethods: http } = enums;
+const { databaseOperations: dbo, chalkFormats: cs, httpMethods: http, winstonLogLevels: wll } = 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 },
+    { match: dbo.DELETE, style: { format: cs.HEX, fore: '#F22613', back: null } },
+    { match: dbo.INSERT, style: { format: cs.HEX, fore: '#00B16A', back: null } },
+    { match: dbo.SELECT, style: { format: cs.HEX, fore: '#1E90FF', back: null } },
+    { match: dbo.TRUNCATE, style: { format: cs.HEX, fore: '#750505', back: null } },
+    { match: dbo.UPDATE, style: { format: cs.HEX, 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 },
+    { range: _.range(500, 600), style: { format: cs.ANSI, fore: 31, back: null } },
+    { range: _.range(400, 500), style: { format: cs.ANSI, fore: 33, back: null } },
+    { range: _.range(300, 400), style: { format: cs.ANSI, fore: 36, back: null } },
+    { range: _.range(200, 300), style: { format: cs.ANSI, fore: 32, back: null } },
+    { range: _.range(100, 200), style: { format: cs.ANSI, fore: 0, back: null } },
 ];
 
 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' },
+    { match: http.GET, style: { format: cs.HEX, fore: '#000000', back: '#67D193' } },
+    { match: http.HEAD, style: { format: cs.HEX, fore: '#000000', back: '#68D696' } },
+    { match: http.POST, style: { format: cs.HEX, fore: '#000000', back: '#F4DA7A' } },
+    { match: http.PUT, style: { format: cs.HEX, fore: '#000000', back: '#74AEF6' } },
+    { match: http.DELETE, style: { format: cs.HEX, fore: '#000000', back: '#EF968A' } },
+    { match: http.CONNECT, style: { format: cs.HEX, fore: '#000000', back: '#FFFFFF' } },
+    { match: http.OPTIONS, style: { format: cs.HEX, fore: '#000000', back: '#E55AA8' } },
+    { match: http.TRACE, style: { format: cs.HEX, fore: '#000000', back: '#FFFFFF' } },
+    { match: http.PATCH, style: { format: cs.HEX, fore: '#000000', back: '#C0A8E1' } },
+];
+
+const logLevelColors = [
+    { match: wll.ERROR, style: { format: cs.ANSI256, fore: 31, back: null } }, // red
+    { match: wll.WARNING, style: { format: cs.ANSI256, fore: 33, back: null } }, // yellow
+    { match: wll.INFO, style: { format: cs.ANSI256, fore: 32, back: null } }, // green
+    { match: wll.HTTP, style: { format: cs.ANSI256, fore: 32, back: null } },
+    { match: wll.VERBOSE, style: { format: cs.ANSI256, fore: 36, back: null } }, // cyan
+    { match: wll.DEBUG, style: { format: cs.ANSI256, fore: 34, back: null } }, // blue
+    { match: wll.SILLY, style: { format: cs.ANSI256, fore: 35, back: null } }, // magenta
 ];
 
 module.exports = {
     databaseOperationColors,
     httpStatusColors,
     httpVerbColors,
+    logLevelColors,
 };

package/lib/zeddemore-logger.js

@@ -8,14 +8,15 @@ const sizeof = require('object-sizeof');
 const { v4: uuid } = require('uuid');
 
 const { areHeadersSent, getRequestResponseTime, parseRequest } = require('./http');
-const { chalkHttpStatus, chalkHttpVerb, stringToIdempotentHexColor } = require('./color');
+const { chalkHttpStatuses, chalkHttpVerbs, 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, winstonLogLevelNames: wlln, winstonLogLevels: wll } = enums;
+const { morganFormats: mf, httpRequestHeaders: rqh, httpResponseHeaders: rsh, winstonLogLevelNames: wlln,
+    winstonLogLevels: wll } = enums;
 
 const COLOR_CONSOLE_WHITE_HEX = '#ECECEC';
 const DEFAULT_REQUEST_ID_ATTRIBUTE = 'requestId';
@@ -35,6 +36,9 @@ function winstonLogLevelIdToName(levelId) {
 
 class ZeddemoreLogger {
 
+    #forceLogLevel = false;
+    #logLevel = wll.INFO;
+
     constructor(options) {
         options = options || { };
         this.additionalWriteFn = options.additionalWriteFn || null;
@@ -45,17 +49,36 @@ class ZeddemoreLogger {
         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.#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 = [ ]) =>{
+    get forceLogLevel() {
+        return this.#forceLogLevel;
+    }
+
+    get logLevel() {
+        return this.#logLevel;
+    }
+
+    get logLevelName() {
+        return winstonLogLevelIdToName(this.#logLevel);
+    }
+
+    set forceLogLevel(doForce) {
+        this.#forceLogLevel = !!doForce;
+    }
+
+    set logLevel(level) {
+        this.#logLevel = massageLogLevel(level);
+    }
+
+    #buildWinstonFormat = (options, additionalFormats = [ ]) => {
         options = options || { };
-        const colorizedTemplate = this.#colorizedTemplate.bind(this);
         const formats = [
             format((info) => {
                 info.id = info.id || options.id || null;
@@ -72,13 +95,13 @@ class ZeddemoreLogger {
         return combine(...additionalFormats.concat(formats));
     }
 
-    #buildWinstonTransport = (logLevel = this.logLevel) => {
-        logLevel = logLevel || this.logLevel;
+    #buildWinstonTransport = (logLevel = this.#logLevel) => {
+        logLevel = logLevel || this.#logLevel;
         const level = winstonLogLevelIdToName(logLevel);
         return new transports.Console({ level, name: WINSTON_CONSOLE_TRANSPORT_NAME });
     }
 
-    #buildWinstonTransports = (logLevel = this.logLevel, additionalTransports = [ ]) => {
+    #buildWinstonTransports = (logLevel = this.#logLevel, additionalTransports = [ ]) => {
         return additionalTransports.concat([ this.#buildWinstonTransport(logLevel) ]);
     }
 
@@ -91,7 +114,7 @@ class ZeddemoreLogger {
 
     #colorizeResponse(message) {
         const verb = message.split(' ')[ 0 ];
-        return chalkHttpVerb(verb, message);
+        return chalkHttpVerbs(verb, message);
     }
 
     #colorizedTemplate = (info) => {
@@ -177,7 +200,7 @@ class ZeddemoreLogger {
         function buildStatusColoredToken(res) {
             const statusCode = areHeadersSent(res) ? res.statusCode : null;
             if (!statusCode) return '-';
-            return chalkHttpStatus(statusCode);
+            return chalkHttpStatuses(statusCode);
         }
         morgan.token('content-length-format', (req, res) => { return buildContentLengthFormatToken(res); });
         morgan.token('response-time-format', (req, res) => { return buildResponseTimeFormatToken(req, res); });
@@ -217,22 +240,25 @@ class ZeddemoreLogger {
 
     requestLoggerMiddleware = (req, res, next) => {
         const requestValues = parseRequest(req);
-        const requestId = uuid();//this.#generateUuid();
+        const requestId = this.#generateUuid();
         req[ this.requestIdAttribute ] = requestId;
         res.header(rqh.REQUEST_ID, requestId);
         const ipAddress = requestValues.ipAddress;
+        res.locals = res.locals || { };
         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;
+        return ((res && res.locals) ? res.locals.user : null)
+            || ((req && req.locals) ? req.locals.user : null)
+            || (req ? req.user : null);
     }
 
     userLoggerMiddleware = (req, res, next) => {
         const requestId = this.#getRequestId(req);
-        const user = res.locals.user || { };
+        const user = this.userGetFn(req, res) || { };
         if (!requestId) return next();
         const username = user.login || null;
         let ipAddress = user.ipAddress || null;
@@ -241,8 +267,9 @@ class ZeddemoreLogger {
             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;
+        if (userLogLevel < 0) userLogLevel = this.#logLevel;
+        const level = this.#forceLogLevel ? this.#logLevel : userLogLevel;
+        res.locals = res.locals || { };
         res.locals.user = res.locals.user || user;
         res.locals.user.logger = this.createUserLogger(requestId, username, level, ipAddress);
         return next();
@@ -258,13 +285,13 @@ class ZeddemoreLogger {
         const logger = options.logger || ZeddemoreLogger.log(options);
         if (!logger) return;
         const _method = _request.method || null;
-        const method = _method ? chalkHttpVerb(_method) : null;
+        const method = _method ? chalkHttpVerbs(_method) : null;
         const _config = _response.config || null;
         const _headers = _response.headers || null;
         const _data = _response.data || null;
         const path = _config ? _config.url : '';
         const prefix = logOptions.prefix ? `[${ logOptions.prefix }]` : null;
-        const status = chalkHttpStatus(_response.status);
+        const status = chalkHttpStatuses(_response.status);
         const _duration = axiosError.duration || _response.duration;
         const duration = _duration ? convertMilliseconds(_duration) : '-';
         let _contentLength = _headers ? _headers[ rsh.CONTENT_LENGTH ] : null;
@@ -287,13 +314,13 @@ class ZeddemoreLogger {
         const logger = options.logger || ZeddemoreLogger.log(options);
         if (!logger) return;
         const _method = _request.method || null;
-        const method = _method ? chalkHttpVerb(_method) : null;
+        const method = _method ? chalkHttpVerbs(_method) : null;
         const _headers = axiosResponse.headers || null;
         const _data = axiosResponse.data || null;
         const path = _request.path || '';
         const prefix = logOptions.prefix ? `[${ logOptions.prefix }]` : null;
         const responseData = (logOptions.response && _.isObject(_data)) ? JSON.stringify(_data) : null;
-        const status = chalkHttpStatus(axiosResponse.status);
+        const status = chalkHttpStatuses(axiosResponse.status);
         const _duration = axiosResponse.duration;
         const duration = _duration ? convertMilliseconds(_duration) : '-';
         let _contentLength = _headers ? _headers[ rsh.CONTENT_LENGTH ] : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeddemore-logger",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Node.js Express logger using Morgan and Winston for thread and caller info tracking",
   "repository": {
     "type": "git",