zeddemore-logger 1.0.7 → 1.2.0

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,5 +1,20 @@
 // Copyright (c) 2025 by Beardon Services, Inc.
 
+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
+    LOG_LEVEL_INFO: 32, // green
+    LOG_LEVEL_SILLY: 35, // magenta
+    LOG_LEVEL_VERBOSE: 36, // cyan
+    LOG_LEVEL_WARNING: 33, // yellow
+};
+
 const apiLogLevelCaptions = {
     DEFAULT: 'Default',
     ERROR: 'Error',
@@ -24,7 +39,6 @@ const apiLogLevels = {
 
 const chalkFormats = {
     ANSI: 'ansi',
-    ANSI256: 'ansi256',
     HEX: 'hex',
     RGB: 'rgb',
 };
@@ -42,6 +56,39 @@ const databaseOperations = {
     UPDATE: 'UPDATE',
 };
 
+const hexColors = {
+    BEARDON_RED: '#951A1D',
+    BLACK: '#000000',
+    CONSOLE_WHITE: '#ECECEC',
+    DB_DELETE: '#F22613',
+    DB_INSERT: '#00B16A',
+    DB_SELECT: '#1E90FF',
+    DB_TRUNCATE: '#750505',
+    DB_UPDATE: '#F9690E',
+    HTTP_CONNECT: '#FFFFFF',
+    HTTP_DELETE: '#EF968A',
+    HTTP_GET: '#67D193',
+    HTTP_HEAD: '#68D696',
+    HTTP_OPTIONS: '#E55AA8',
+    HTTP_PATCH: '#C0A8E1',
+    HTTP_POST: '#F4DA7A',
+    HTTP_PUT: '#74AEF6',
+    HTTP_TRACE: '#FFFFFF',
+    PACKAGE_EXPRESS: '#F7DF1E',
+    PACKAGE_MYSQL: '#00618A',
+    PACKAGE_NODE_JS: '#689F63',
+    PACKAGE_POSTGRESQL: '#336791',
+    PACKAGE_SEQUELIZE: '#00AFEF',
+};
+
+const httpStatusCodeGroups = {
+    INFORMATIONAL: 1,
+    SUCCESSFUL: 2,
+    REDIRECTION: 3,
+    CLIENT_ERROR: 4,
+    SERVER_ERROR: 5,
+};
+
 const httpMethods = {
     GET: 'GET',
     HEAD: 'HEAD',
@@ -56,9 +103,12 @@ const httpMethods = {
 
 const httpRequestHeaders = {
     ALLOW: 'Allow',
+    APP_VERSION: 'App-Version',
     AUTHORIZATION: 'Authorization',
     BEARER_PREFIX: 'Bearer',
+    FORWARDED_FOR: 'X-Forwarded-For',
     REQUEST_ID: 'X-Request-Id',
+    USER_AGENT: 'User-Agent',
 };
 
 const httpResponseHeaders = {
@@ -96,11 +146,14 @@ const winstonLogLevels = {
 };
 
 module.exports = {
+    ansiColors,
     apiLogLevelCaptions,
     apiLogLevels,
     chalkFormats,
     chalkLayers,
     databaseOperations,
+    hexColors,
+    httpStatusCodeGroups,
     httpMethods,
     httpRequestHeaders,
     httpResponseHeaders,

package/lib/mappings/color_mappings.js

@@ -3,44 +3,52 @@
 const _ = require('lodash');
 const enums = require('../enums');
 
-const { databaseOperations: dbo, chalkFormats: cs, 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: '#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 } },
+    { 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: 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 } },
+    { 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.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' } },
+    { 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: 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
+    { 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 = {
@@ -48,4 +56,5 @@ module.exports = {
     httpStatusColors,
     httpVerbColors,
     logLevelColors,
+    packageColors,
 };

package/lib/mappings/http_mappings.js

@@ -0,0 +1,18 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+const _ = require('lodash');
+const enums = require('../enums');
+
+const { httpStatusCodeGroups: hscg } = enums;
+
+const httpStatusCodeGroupMap = [
+    { group: hscg.INFORMATIONAL, range: _.range(100, 200) },
+    { group: hscg.SUCCESSFUL, range: _.range(200, 300) },
+    { group: hscg.REDIRECTION, range: _.range(300, 400) },
+    { group: hscg.CLIENT_ERROR, range: _.range(400, 500) },
+    { group: hscg.SERVER_ERROR, range: _.range(500, 600) },
+];
+
+module.exports = {
+    httpStatusCodeGroupMap,
+};

package/lib/{http.js → request.js}

@@ -1,7 +1,20 @@
 // Copyright (c) 2025 by Beardon Services, Inc.
 
-function areHeadersSent(res) {
-    return typeof (res.headersSent !== 'boolean') ? Boolean(res._header) : res.headersSent;
+const _ = require('lodash');
+
+const enums = require('./enums');
+
+const { httpRequestHeaders: rqh } = enums;
+
+function extractToken(req) {
+    let token;
+    const authHeader = req.header(rqh.AUTHORIZATION);
+    if (authHeader && authHeader.startsWith(`${ rqh.BEARER_PREFIX } `)) {
+        token = req.header(rqh.AUTHORIZATION).split(' ')[ 1 ];
+    } else if (req.query && req.query.token) {
+        token = req.query.token;
+    }
+    return token;
 }
 
 function getRequestResponseTime(req, res) {
@@ -9,6 +22,12 @@ function getRequestResponseTime(req, res) {
     return (res._startAt[ 0 ] - req._startAt[ 0 ]) * 1e3 + (res._startAt[ 1 ] - req._startAt[ 1 ]) * 1e-6;
 }
 
+function isRequestOfMethod(req, method) {
+    const methods = Array.isArray(method) ? method : [ method ];
+    if (!req || !req.method || _.isEmpty(methods)) return false;
+    return methods.includes(req.method);
+}
+
 function parseRequest(req) {
     if (!req) return { };
     const body = req.body || { };
@@ -41,7 +60,8 @@ function parseRequestUserAgent(req) {
 }
 
 module.exports = {
-    areHeadersSent,
+    extractToken,
     getRequestResponseTime,
+    isRequestOfMethod,
     parseRequest,
 };

package/lib/response.js

@@ -0,0 +1,36 @@
+// Copyright (c) 2025 by Beardon Services, Inc.
+
+const _ = require('lodash');
+
+const enums = require('./enums');
+const { httpStatusCodeGroupMap } = require('./mappings/http_mappings');
+
+const { httpStatusCodeGroups: hscg } = enums;
+
+function areHeadersSent(res) {
+    return typeof (res.headersSent !== 'boolean') ? Boolean(res._header) : res.headersSent;
+}
+
+function isResponseStatusCodeInGroup(statusCode, group) {
+    if (!statusCode || !group) return false;
+    const httpStatusCodeGroupMapEntry = _.find(httpStatusCodeGroupMap, { group });
+    if (!httpStatusCodeGroupMapEntry) return false;
+    return httpStatusCodeGroupMapEntry.range.includes(+statusCode);
+}
+
+function isResponseStatusCodeRedirection(statusCode) {
+    return isResponseStatusCodeInGroup(statusCode, hscg.REDIRECTION);
+}
+
+function isResponseStatusCodeSuccessful(statusCode) {
+    return isResponseStatusCodeInGroup(statusCode, hscg.SUCCESSFUL);
+}
+
+function isResponseSuccessful(statusCode) {
+    return isResponseStatusCodeSuccessful(statusCode) || isResponseStatusCodeRedirection(statusCode);
+}
+
+module.exports = {
+    areHeadersSent,
+    isResponseSuccessful,
+};

package/lib/zeddemore-logger.js

@@ -2,20 +2,21 @@
 
 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, getRequestResponseTime, parseRequest } = require('./http');
-const { chalkHttpStatuses, chalkHttpVerbs, stringToIdempotentHexColor } = require('./color');
+const { areHeadersSent, isResponseSuccessful } = require('./response');
+const { chalkHttpStatuses, chalkHttpVerbs, chalkLogLevel, chalkPackage, chalkTarget, stringToIdempotentHexColor } = require('./color');
 const { convertBytes } = require('./math');
 const { convertMilliseconds } = require('./date');
 const enums = require('./enums');
+const { extractToken, getRequestResponseTime, isRequestOfMethod, parseRequest } = require('./request');
 const { logLevelMap } = require('./mappings/log_mappings');
 
 const { colorize, combine, label, metadata, printf, timestamp } = format;
-const { morganFormats: mf, httpRequestHeaders: rqh, httpResponseHeaders: rsh, winstonLogLevelNames: wlln,
+const { morganFormats: mf, httpMethods: http, httpRequestHeaders: rqh, httpResponseHeaders: rsh, winstonLogLevelNames: wlln,
     winstonLogLevels: wll } = enums;
 
 const COLOR_CONSOLE_WHITE_HEX = '#ECECEC';
@@ -23,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;
@@ -37,14 +48,21 @@ function winstonLogLevelIdToName(levelId) {
 class ZeddemoreLogger {
 
     #forceLogLevel = false;
+    /** @type {Logger} */
+    #logger = null;
     #logLevel = wll.INFO;
 
     constructor(options) {
         options = options || { };
-        this.additionalWriteFn = options.additionalWriteFn || null;
+        this.apiCallModel = options.apiCallModel || null;
+        this.apiRouteCategories = options.apiRouteCategories || [ ];
+        this.apiRoutes = options.apiRoutes || [ ];
+        this.apiVersion = options.apiVersion || null;
         this.defaultLabel = options.defaultLabel || 'zeddemore-logger';
+        this.disableApiCallLogging = options.hasOwnProperty('disableApiCallLogging') ? options.disableApiCallLogging : false;
+        this.disableRouteLogging = options.hasOwnProperty('disableRouteLogging') ? options.disableRouteLogging : false;
         this.disableMorganLogging = options.hasOwnProperty('disableMorganLogging') ? options.disableMorganLogging : false;
-        this.displayCaller = options.hasOwnProperty('displayCaller') ? options.displayUsername : true;
+        this.displayCaller = options.hasOwnProperty('displayCaller') ? options.displayCaller : true;
         this.displayIpAddress = options.hasOwnProperty('displayIpAddress') ? options.displayIpAddress : true;
         this.displayRequestId = options.hasOwnProperty('displayRequestId') ? options.displayRequestId : true;
         this.customCallerSettings = options.customCallerSettings || [ ];
@@ -52,15 +70,27 @@ class ZeddemoreLogger {
         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.routeModel = options.routeModel || null;
+        this.suppressNonMutatingRequestApiCallLogging = options.hasOwnProperty('suppressNonMutatingRequestApiCallLogging') ? options.suppressNonMutatingRequestApiCallLogging : false;
+        this.suppressSuccessfulRequestApiCallLogging = options.hasOwnProperty('suppressSuccessfulRequestApiCallLogging') ? options.suppressSuccessfulRequestApiCallLogging : false;
         this.timestampFormat = options.timestampFormat || 'YYYY-MM-DD HH:mm:ss';
         this.requestIdAttribute = options.requestIdAttribute || DEFAULT_REQUEST_ID_ATTRIBUTE;
         this.userGetFn = options.userGetFn || this.#userGetFn;
     }
 
+    get apiCallLoggingEnabled() {
+        return !this.disableApiCallLogging && !!this.apiCallModel;
+    }
+
     get forceLogLevel() {
         return this.#forceLogLevel;
     }
 
+    get logger() {
+        if (!this.#logger) this.#logger = this.createLogger();
+        return this.#logger;
+    }
+
     get logLevel() {
         return this.#logLevel;
     }
@@ -69,6 +99,10 @@ class ZeddemoreLogger {
         return winstonLogLevelIdToName(this.#logLevel);
     }
 
+    get routeLoggingEnabled() {
+        return !this.disableRouteLogging && !!this.routeModel;
+    }
+
     set forceLogLevel(doForce) {
         this.#forceLogLevel = !!doForce;
     }
@@ -183,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 ];
@@ -207,17 +249,86 @@ 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) => {
+        if (!path) return null;
+        let matchedRoute = null;
+        for (const route of this.apiRoutes) {
+            if (path.match(route.regexp)) {
+                matchedRoute = route.path;
+                break;
+            }
+        }
+        return matchedRoute;
     }
 
     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;
@@ -227,7 +338,7 @@ class ZeddemoreLogger {
                 skip: () => disableMorganLogging,
                 stream: {
                     write: (message) => {
-                        if (additionalWriteFn) additionalWriteFn(req, res);
+                        if (this.apiCallLoggingEnabled) this.#writeApiCallToDatabase(req, res, options);
                         const logOptions = { };
                         const user = userGetFn ? userGetFn(req, res) : null;
                         if (user) logOptions.user = user;
@@ -250,6 +361,21 @@ class ZeddemoreLogger {
         return next();
     }
 
+    routeLoggingMiddleware = (req, res, next) => {
+        if (!this.routeLoggingEnabled) return next();
+        try {
+            const routeValues = {
+                route: req.path,
+                method: req.method,
+                lastCalled: new Date().toISOString(),
+            };
+            this.#writeRouteToDatabase(routeValues);
+        } catch (e) {
+        } finally {
+            next();
+        }
+    }
+
     #userGetFn(req, res) {
         return ((res && res.locals) ? res.locals.user : null)
             || ((req && req.locals) ? req.locals.user : null)
@@ -260,7 +386,7 @@ class ZeddemoreLogger {
         const requestId = this.#getRequestId(req);
         const user = this.userGetFn(req, res) || { };
         if (!requestId) return next();
-        const username = user.login || null;
+        const username = user.login || user.username || null;
         let ipAddress = user.ipAddress || null;
         if (!ipAddress) {
             const requestValues = parseRequest(req);
@@ -275,6 +401,66 @@ class ZeddemoreLogger {
         return next();
     }
 
+    #writeApiCallToDatabase = async (req, res, options) => {
+        options = options || { };
+        if (!req) return;
+        const user = this.userGetFn ? this.userGetFn(req, res) : null;
+        const statusCode = options.statusCode || (res ? res.statusCode : null);
+        if (isResponseSuccessful(statusCode) && this.suppressSuccessfulRequestApiCallLogging) return;
+        if (!isRequestOfMethod(req, [ http.DELETE, http.PUT ]) && this.suppressNonMutatingRequestApiCallLogging) return;
+        const matchedRoute = this.#matchPathToRoute(req.path);
+        let metadataDefaults = Object.assign({ }, user);
+        delete(metadataDefaults.id);
+        delete(metadataDefaults.logger);
+        const _metadata = _.defaults({ }, (options.metadata || { }), metadataDefaults);
+        if (matchedRoute) {
+            try {
+                const appCallValues = {
+                    apiVersion: this.apiVersion,
+                    client: user ? user.clientId : null,
+                    clientVersion: req.header(rqh.APP_VERSION),
+                    httpStatusCode: statusCode,
+                    ipAddress: req.header(rqh.FORWARDED_FOR) || req.socket.remoteAddress,
+                    metadata: _metadata,
+                    method: req.method,
+                    route: matchedRoute,
+                    token: extractToken(req),
+                    userAgent: req.header(rqh.USER_AGENT),
+                    userId: user ? user.id : null,
+                };
+                await this.apiCallModel.create(appCallValues);
+            } catch (e) {
+                console.error(e);
+                ZeddemoreLogger.log({ user }).error('Api call logging failed, moving on');
+            }
+        }
+    }
+
+    #writeRouteToDatabase = async (routeValues) => {
+        if (!this.routeLoggingEnabled || !routeValues) return;
+        const matchedRoute = this.#matchPathToRoute(routeValues.route);
+        if (matchedRoute) {
+            try {
+                const route = await this.routeModel.findOne({ where: { route: matchedRoute }, logging: false });
+                if (route) {
+                    route.count++;
+                    route.lastCalledAt = new Date();
+                    route.save();
+                } else {
+                    this.routeModel.create({
+                        count: 1,
+                        lastCalledAt: new Date(),
+                        method: routeValues.method,
+                        route: matchedRoute,
+                    });
+                }
+            } catch (e) {
+                console.error(e);
+                console.error('Route logging failed, moving on');
+            }
+        }
+    }
+
     static writeAxiosErrorLog(axiosError, logOptions, options) {
         logOptions = logOptions || { };
         options = options || { };
@@ -334,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.0.7",
+  "version": "1.2.0",
   "description": "Node.js Express logger using Morgan and Winston for thread and caller info tracking",
   "repository": {
     "type": "git",