zeddemore-logger 1.1.0 → 1.2.1

package/lib/color.js

@@ -6,7 +6,7 @@ const chalk = require('chalk');
 const colorMappings = require('./mappings/color_mappings');
 const enums = require('./enums');
 
-const { chalkLayers: cl, chalkFormats: cs } = enums;
+const { chalkLayers: cl, chalkFormats: cf, hexColors: hc } = enums;
 
 /**
  * @param ansiColor {number}
@@ -24,22 +24,6 @@ function chalkAnsi(ansiColor, layer = cl.FOREGROUND, 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}
@@ -66,11 +50,29 @@ function chalkHttpStatuses(statusCode, string = null) {
     return chalkedMatch;
 }
 
+function chalkLogLevel(logLevel, string = null) {
+    return chalkMatch(logLevel, string, colorMappings.logLevelColors);
+}
+
+function chalkMatch(match, string, colorsMap) {
+    if (!string) string = match;
+    const colorMap = _.find(colorsMap, { match });
+    if (!colorMap || !colorMap.style) return string;
+    return chalkTarget(string, colorMap.style);
+}
+
 function chalkHttpVerbs(verb, string = null, replaceGlobal = false) {
     if (!string) string = verb;
     return chalkViaColorMap(verb, string, colorMappings.httpVerbColors, replaceGlobal);
 }
 
+function chalkPackage(packageName, string = null) {
+    if (!string) string = packageName;
+    const colorMap = _.find(colorMappings.packageColors, { match: packageName });
+    if (!colorMap || !colorMap.style) return chalkTarget(string, { format: cf.HEX, fore: hc.BEARDON_RED, back: null });
+    return chalkTarget(string, colorMap.style);
+}
+
 /**
  * @param redColor {number}
  * @param greenColor {number}
@@ -94,10 +96,9 @@ function chalkTarget(target, style) {
     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));
+        case cf.ANSI: return chalkAnsi(back, cl.BACKGROUND, chalkAnsi(fore, cl.FOREGROUND, target));
+        case cf.HEX: return chalkHex(back, cl.BACKGROUND, chalkHex(fore, cl.FOREGROUND, target));
+        case cf.RGB: return chalkRgb(back.r, back.g, back.b, cl.BACKGROUND, chalkRgb(fore.r, fore.g, fore.b, cl.FOREGROUND, target));
         default: return target;
     }
 }
@@ -178,5 +179,8 @@ function stringToIdempotentHslValues(str, hslOptions) {
 module.exports = {
     chalkHttpStatuses,
     chalkHttpVerbs,
+    chalkLogLevel,
+    chalkPackage,
+    chalkTarget,
     stringToIdempotentHexColor,
 };

package/lib/enums.js

@@ -1,6 +1,11 @@
 // Copyright (c) 2025 by Beardon Services, Inc.
 
-const ansi256Colors = {
+const ansiColors = {
+    HTTP_CLIENT_ERROR: 33, // red
+    HTTP_INFORMATIONAL: 0, // white
+    HTTP_REDIRECTION: 36, // blue
+    HTTP_SERVER_ERROR: 31, // red
+    HTTP_SUCCESSFUL: 32, // green
     LOG_LEVEL_DEBUG: 34, // blue
     LOG_LEVEL_ERROR: 31, // red
     LOG_LEVEL_HTTP: 32, // green
@@ -10,14 +15,6 @@ const ansi256Colors = {
     LOG_LEVEL_WARNING: 33, // yellow
 };
 
-const ansiColors = {
-    HTTP_CLIENT_ERROR: 33, // red
-    HTTP_INFORMATIONAL: 0,
-    HTTP_REDIRECTION: 36, // blue
-    HTTP_SERVER_ERROR: 31, // red
-    HTTP_SUCCESSFUL: 32, // green
-};
-
 const apiLogLevelCaptions = {
     DEFAULT: 'Default',
     ERROR: 'Error',
@@ -42,7 +39,6 @@ const apiLogLevels = {
 
 const chalkFormats = {
     ANSI: 'ansi',
-    ANSI256: 'ansi256',
     HEX: 'hex',
     RGB: 'rgb',
 };
@@ -61,6 +57,7 @@ const databaseOperations = {
 };
 
 const hexColors = {
+    BEARDON_RED: '#951A1D',
     BLACK: '#000000',
     CONSOLE_WHITE: '#ECECEC',
     DB_DELETE: '#F22613',
@@ -77,7 +74,11 @@ const hexColors = {
     HTTP_POST: '#F4DA7A',
     HTTP_PUT: '#74AEF6',
     HTTP_TRACE: '#FFFFFF',
-    OSU_ORANGE: '#FF6600',
+    PACKAGE_EXPRESS: '#F7DF1E',
+    PACKAGE_MYSQL: '#00618A',
+    PACKAGE_NODE_JS: '#689F63',
+    PACKAGE_POSTGRESQL: '#336791',
+    PACKAGE_SEQUELIZE: '#00AFEF',
 };
 
 const httpStatusCodeGroups = {
@@ -145,7 +146,6 @@ const winstonLogLevels = {
 };
 
 module.exports = {
-    ansi256Colors,
     ansiColors,
     apiLogLevelCaptions,
     apiLogLevels,

package/lib/mappings/color_mappings.js

@@ -3,45 +3,52 @@
 const _ = require('lodash');
 const enums = require('../enums');
 
-const { ansi256Colors: a256c, ansiColors: ac, databaseOperations: dbo, chalkFormats: cs, hexColors: hc,
-    httpMethods: http, winstonLogLevels: wll } = enums;
+const { ansiColors: ac, databaseOperations: dbo, chalkFormats: cf, hexColors: hc, httpMethods: http, winstonLogLevels: wll } = enums;
 
 const databaseOperationColors = [
-    { match: dbo.DELETE, style: { format: cs.HEX, fore: hc.DB_DELETE, back: null } },
-    { match: dbo.INSERT, style: { format: cs.HEX, fore: hc.DB_INSERT, back: null } },
-    { match: dbo.SELECT, style: { format: cs.HEX, fore: hc.DB_SELECT, back: null } },
-    { match: dbo.TRUNCATE, style: { format: cs.HEX, fore: hc.DB_TRUNCATE, back: null } },
-    { match: dbo.UPDATE, style: { format: cs.HEX, fore: hc.DB_UPDATE, back: null } },
+    { match: dbo.DELETE, style: { format: cf.HEX, fore: hc.DB_DELETE, back: null } },
+    { match: dbo.INSERT, style: { format: cf.HEX, fore: hc.DB_INSERT, back: null } },
+    { match: dbo.SELECT, style: { format: cf.HEX, fore: hc.DB_SELECT, back: null } },
+    { match: dbo.TRUNCATE, style: { format: cf.HEX, fore: hc.DB_TRUNCATE, back: null } },
+    { match: dbo.UPDATE, style: { format: cf.HEX, fore: hc.DB_UPDATE, back: null } },
 ];
 
 const httpStatusColors = [
-    { range: _.range(500, 600), style: { format: cs.ANSI, fore: ac.HTTP_SERVER_ERROR, back: null } },
-    { range: _.range(400, 500), style: { format: cs.ANSI, fore: ac.HTTP_CLIENT_ERROR, back: null } },
-    { range: _.range(300, 400), style: { format: cs.ANSI, fore: ac.HTTP_REDIRECTION, back: null } },
-    { range: _.range(200, 300), style: { format: cs.ANSI, fore: ac.HTTP_SUCCESSFUL, back: null } },
-    { range: _.range(100, 200), style: { format: cs.ANSI, fore: ac.HTTP_INFORMATIONAL, back: null } },
+    { range: _.range(500, 600), style: { format: cf.ANSI, fore: ac.HTTP_SERVER_ERROR, back: null } },
+    { range: _.range(400, 500), style: { format: cf.ANSI, fore: ac.HTTP_CLIENT_ERROR, back: null } },
+    { range: _.range(300, 400), style: { format: cf.ANSI, fore: ac.HTTP_REDIRECTION, back: null } },
+    { range: _.range(200, 300), style: { format: cf.ANSI, fore: ac.HTTP_SUCCESSFUL, back: null } },
+    { range: _.range(100, 200), style: { format: cf.ANSI, fore: ac.HTTP_INFORMATIONAL, back: null } },
 ];
 
 const httpVerbColors = [
-    { match: http.CONNECT, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_CONNECT } },
-    { match: http.DELETE, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_DELETE } },
-    { match: http.GET, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_GET } },
-    { match: http.HEAD, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_HEAD } },
-    { match: http.OPTIONS, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_OPTIONS } },
-    { match: http.PATCH, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_PATCH } },
-    { match: http.POST, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_POST } },
-    { match: http.PUT, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_PUT } },
-    { match: http.TRACE, style: { format: cs.HEX, fore: hc.BLACK, back: hc.HTTP_TRACE } },
+    { match: http.CONNECT, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_CONNECT } },
+    { match: http.DELETE, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_DELETE } },
+    { match: http.GET, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_GET } },
+    { match: http.HEAD, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_HEAD } },
+    { match: http.OPTIONS, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_OPTIONS } },
+    { match: http.PATCH, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_PATCH } },
+    { match: http.POST, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_POST } },
+    { match: http.PUT, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_PUT } },
+    { match: http.TRACE, style: { format: cf.HEX, fore: hc.BLACK, back: hc.HTTP_TRACE } },
 ];
 
 const logLevelColors = [
-    { match: wll.ERROR, style: { format: cs.ANSI256, fore: a256c.LOG_LEVEL_ERROR, back: null } },
-    { match: wll.WARNING, style: { format: cs.ANSI256, fore: a256c.LOG_LEVEL_WARNING, back: null } },
-    { match: wll.INFO, style: { format: cs.ANSI256, fore: a256c.LOG_LEVEL_INFO, back: null } },
-    { match: wll.HTTP, style: { format: cs.ANSI256, fore: a256c.LOG_LEVEL_HTTP, back: null } },
-    { match: wll.VERBOSE, style: { format: cs.ANSI256, fore: a256c.LOG_LEVEL_VERBOSE, back: null } },
-    { match: wll.DEBUG, style: { format: cs.ANSI256, fore: a256c.LOG_LEVEL_DEBUG, back: null } },
-    { match: wll.SILLY, style: { format: cs.ANSI256, fore: a256c.LOG_LEVEL_SILLY, back: null } },
+    { match: wll.ERROR, style: { format: cf.ANSI, fore: ac.LOG_LEVEL_ERROR, back: null } },
+    { match: wll.WARNING, style: { format: cf.ANSI, fore: ac.LOG_LEVEL_WARNING, back: null } },
+    { match: wll.INFO, style: { format: cf.ANSI, fore: ac.LOG_LEVEL_INFO, back: null } },
+    { match: wll.HTTP, style: { format: cf.ANSI, fore: ac.LOG_LEVEL_HTTP, back: null } },
+    { match: wll.VERBOSE, style: { format: cf.ANSI, fore: ac.LOG_LEVEL_VERBOSE, back: null } },
+    { match: wll.DEBUG, style: { format: cf.ANSI, fore: ac.LOG_LEVEL_DEBUG, back: null } },
+    { match: wll.SILLY, style: { format: cf.ANSI, fore: ac.LOG_LEVEL_SILLY, back: null } },
+];
+
+const packageColors = [
+    { match: 'express', style: { format: cf.HEX, fore: hc.PACKAGE_EXPRESS, back: null } },
+    { match: 'MySQL', style: { format: cf.HEX, fore: hc.PACKAGE_MYSQL, back: null } },
+    { match: 'Node.js', style: { format: cf.HEX, fore: hc.PACKAGE_NODE_JS, back: null } },
+    { match: 'PostgreSQL', style: { format: cf.HEX, fore: hc.PACKAGE_POSTGRESQL, back: null } },
+    { match: 'sequelize', style: { format: cf.HEX, fore: hc.PACKAGE_SEQUELIZE, back: null } },
 ];
 
 module.exports = {
@@ -49,4 +56,5 @@ module.exports = {
     httpStatusColors,
     httpVerbColors,
     logLevelColors,
+    packageColors,
 };

package/lib/zeddemore-logger.js

@@ -2,13 +2,13 @@
 
 const _ = require('lodash');
 const chalk = require('chalk');
-const { createLogger: createWinstonLogger, format, transports } = require('winston');
+const { createLogger: createWinstonLogger, format, Logger, transports } = require('winston');
 const morgan = require('morgan');
 const sizeof = require('object-sizeof');
 const { v4: uuid } = require('uuid');
 
 const { areHeadersSent, isResponseSuccessful } = require('./response');
-const { chalkHttpStatuses, chalkHttpVerbs, stringToIdempotentHexColor } = require('./color');
+const { chalkHttpStatuses, chalkHttpVerbs, chalkLogLevel, chalkPackage, chalkTarget, stringToIdempotentHexColor } = require('./color');
 const { convertBytes } = require('./math');
 const { convertMilliseconds } = require('./date');
 const enums = require('./enums');
@@ -24,12 +24,22 @@ const DEFAULT_REQUEST_ID_ATTRIBUTE = 'requestId';
 const DEFAULT_USER_LOG_LEVEL = -1;
 const WINSTON_CONSOLE_TRANSPORT_NAME = 'console';
 
+/**
+ * Convert a log level to a Winston log level name
+ * @param logLevel {number|string}
+ * @returns {string}
+ */
 function massageLogLevel(logLevel) {
     if (!logLevel) return wlln.VERBOSE;
     if (!_.isInteger(logLevel)) return logLevel;
     return winstonLogLevelIdToName(logLevel);
 }
 
+/**
+ * Convert a log level ID to a Winston log level name
+ * @param levelId {number}
+ * @returns {string}
+ */
 function winstonLogLevelIdToName(levelId) {
     const logLevelEntry =  _.find(logLevelMap, { winstonLevel: levelId });
     return logLevelEntry ? logLevelEntry.winstonName : wlln.HTTP;
@@ -38,11 +48,14 @@ function winstonLogLevelIdToName(levelId) {
 class ZeddemoreLogger {
 
     #forceLogLevel = false;
+    /** @type {Logger} */
+    #logger = null;
     #logLevel = wll.INFO;
 
     constructor(options) {
         options = options || { };
         this.apiCallModel = options.apiCallModel || null;
+        this.apiRouteCategories = options.apiRouteCategories || [ ];
         this.apiRoutes = options.apiRoutes || [ ];
         this.apiVersion = options.apiVersion || null;
         this.defaultLabel = options.defaultLabel || 'zeddemore-logger';
@@ -73,6 +86,11 @@ class ZeddemoreLogger {
         return this.#forceLogLevel;
     }
 
+    get logger() {
+        if (!this.#logger) this.#logger = this.createLogger();
+        return this.#logger;
+    }
+
     get logLevel() {
         return this.#logLevel;
     }
@@ -199,6 +217,14 @@ class ZeddemoreLogger {
         return uuid(null, null, null);
     }
 
+    static getLogger(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);
+    }
+
     #getRequestId = (req) => {
         if (!req) return null;
         return req[ this.requestIdAttribute ];
@@ -223,12 +249,70 @@ class ZeddemoreLogger {
         morgan.token('status-colored', (req, res) => { return buildStatusColoredToken(res); });
     }
 
-    static log(options) {
+    log = (logLevel) => {
+        logLevel = logLevel || this.#logLevel;
+        const logLevelName = massageLogLevel(logLevel);
+        return this.logger[ logLevelName ];
+    }
+
+    #logServerInfo = (options, logLevel = wll.INFO) => {
         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);
+        const showLogLevel = options.hasOwnProperty('showLogLevel') ? options.showLogLevel : true;
+        const logLevelLabel = chalkLogLevel(this.#logLevel, this.logLevelName.toUpperCase());
+        const msgParts = [ `Server is ${ chalk.bold(chalk.yellowBright('⚡live⚡')) }` ];
+        if (showLogLevel) msgParts.push(`with log level ${ logLevelLabel }${ this.#forceLogLevel ? ` (${ chalk.italic('forced') })` : '' }`);
+        if (options.url) msgParts.push(`at ${ chalk.underline(options.url) }`);
+        this.log(logLevel)(msgParts.join(' '));
+    }
+
+    #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 msgParts = [ ];
+        const serverParts = [ serverName ];
+        if (serverEnvironment) serverParts.push(serverEnvironment);
+        if (serverInstance) serverParts.push(serverInstance);
+        msgParts.push(`[${ serverParts.join(':') }]`);
+        msgParts.push(`Node.js Express server listening on port ${ chalk.bold(serverPort) }`);
+        this.log(logLevel)(msgParts.join(' '));
+    }
+
+    #logServerPackagesInfo = (options, packages, logLevel = wll.INFO) => {
+        function buildVersionLabel(_package) {
+            if (!_package || !_package.name || !_package.version) return null;
+            const packageName = _package.style ? chalkTarget(_package.name, _package.style) : chalkPackage(_package.name);
+            return `${ packageName }@${ _package.version }`;
+        }
+        const versionParts = _.compact(_.sortBy(packages, (_package) => _package.name.toUpperCase()).map(buildVersionLabel));
+        this.log(logLevel)(`Packages: ${ versionParts.join(' | ') }`);
+    }
+
+    #logServerRoutesAdded = (options, logLevel = wll.INFO) => {
+        options = options || { };
+        const showCategories = options.hasOwnProperty('showCategories') ? options.showCategories : true;
+        const routes = options.routes || this.apiRoutes || [ ];
+        const routesLabel = (routes.length === 1) ? 'route' : 'routes';
+        const addedLabel = chalk.green('added');
+        const msgParts = [ `${ routes.length } ${ routesLabel } ${ addedLabel }` ];
+        if (showCategories) {
+            const categories = options.categories || this.apiRouteCategories || [];
+            msgParts.push(`in: ${ categories.sort().join('/') }`);
+        }
+        this.log(logLevel)(msgParts.join(', '));
+    }
+
+    logServerStartup = (options, logLevel = wll.INFO) => {
+        options = options || { };
+        const showListening = options.hasOwnProperty('showListening') ? options.showListening : true;
+        const showPackages = options.hasOwnProperty('showPackages') ? options.showPackages : true;
+        const showRoutes = options.hasOwnProperty('showRoutes') ? options.showRoutes : true;
+        const showInfo = options.hasOwnProperty('showInfo') ? options.showInfo : true;
+        if (showListening) this.#logServerListening(options, logLevel);
+        if (showPackages && options.packages) this.#logServerPackagesInfo(options, options.packages, logLevel);
+        if (showRoutes) this.#logServerRoutesAdded(options, logLevel);
+        if (showInfo) this.#logServerInfo(options, logLevel);
     }
 
     #matchPathToRoute = (path) => {
@@ -258,7 +342,7 @@ class ZeddemoreLogger {
                         const logOptions = { };
                         const user = userGetFn ? userGetFn(req, res) : null;
                         if (user) logOptions.user = user;
-                        ZeddemoreLogger.log(logOptions).http(this.#colorizeResponse(message.trim()));
+                        ZeddemoreLogger.getLogger(logOptions).http(this.#colorizeResponse(message.trim()));
                     },
                 },
             })(req, res, next);
@@ -347,7 +431,7 @@ class ZeddemoreLogger {
                 await this.apiCallModel.create(appCallValues);
             } catch (e) {
                 console.error(e);
-                ZeddemoreLogger.log({ user }).error('Api call logging failed, moving on');
+                ZeddemoreLogger.getLogger({ user }).error('Api call logging failed, moving on');
             }
         }
     }
@@ -384,7 +468,7 @@ class ZeddemoreLogger {
         const _response = axiosError.response;
         if (!_response.request) return;
         const _request = _response.request;
-        const logger = options.logger || ZeddemoreLogger.log(options);
+        const logger = options.logger || ZeddemoreLogger.getLogger(options);
         if (!logger) return;
         const _method = _request.method || null;
         const method = _method ? chalkHttpVerbs(_method) : null;
@@ -413,7 +497,7 @@ class ZeddemoreLogger {
         const axiosConfig = logOptions.axios || { };
         const configData = (logOptions.data && _.isObject(axiosConfig.data)) ? JSON.stringify(axiosConfig.data) : null;
         const logLevel = massageLogLevel(logOptions.logLevel);
-        const logger = options.logger || ZeddemoreLogger.log(options);
+        const logger = options.logger || ZeddemoreLogger.getLogger(options);
         if (!logger) return;
         const _method = _request.method || null;
         const method = _method ? chalkHttpVerbs(_method) : null;
@@ -436,7 +520,7 @@ class ZeddemoreLogger {
 }
 
 module.exports = {
-    log: ZeddemoreLogger.log,
+    log: ZeddemoreLogger.getLogger,
     winstonLogLevelIdToName,
     writeAxiosErrorLog: ZeddemoreLogger.writeAxiosErrorLog,
     writeAxiosLog: ZeddemoreLogger.writeAxiosResponseLog, // deprecated

package/package.json

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