zeddemore-logger 1.0.6 → 1.1.0

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

@@ -1,5 +1,23 @@
 // Copyright (c) 2025 by Beardon Services, Inc.
 
+const ansi256Colors = {
+    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 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',
@@ -22,6 +40,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',
@@ -30,6 +60,34 @@ const databaseOperations = {
     UPDATE: 'UPDATE',
 };
 
+const hexColors = {
+    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',
+    OSU_ORANGE: '#FF6600',
+};
+
+const httpStatusCodeGroups = {
+    INFORMATIONAL: 1,
+    SUCCESSFUL: 2,
+    REDIRECTION: 3,
+    CLIENT_ERROR: 4,
+    SERVER_ERROR: 5,
+};
+
 const httpMethods = {
     GET: 'GET',
     HEAD: 'HEAD',
@@ -44,9 +102,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 = {
@@ -84,9 +145,15 @@ const winstonLogLevels = {
 };
 
 module.exports = {
+    ansi256Colors,
+    ansiColors,
     apiLogLevelCaptions,
     apiLogLevels,
+    chalkFormats,
+    chalkLayers,
     databaseOperations,
+    hexColors,
+    httpStatusCodeGroups,
     httpMethods,
     httpRequestHeaders,
     httpResponseHeaders,

package/lib/mappings/color_mappings.js

@@ -1,40 +1,52 @@
-// 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 { ansi256Colors: a256c, ansiColors: ac, databaseOperations: dbo, chalkFormats: cs, hexColors: hc,
+    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: 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 } },
 ];
 
 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: 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 } },
 ];
 
 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.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 } },
+];
+
+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 } },
 ];
 
 module.exports = {
     databaseOperationColors,
     httpStatusColors,
     httpVerbColors,
+    logLevelColors,
 };

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

@@ -7,15 +7,17 @@ const morgan = require('morgan');
 const sizeof = require('object-sizeof');
 const { v4: uuid } = require('uuid');
 
-const { areHeadersSent, getRequestResponseTime, parseRequest } = require('./http');
-const { chalkHttpStatus, chalkHttpVerb, stringToIdempotentHexColor } = require('./color');
+const { areHeadersSent, isResponseSuccessful } = require('./response');
+const { chalkHttpStatuses, chalkHttpVerbs, 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, winstonLogLevels: wll } = enums;
+const { morganFormats: mf, httpMethods: http, httpRequestHeaders: rqh, httpResponseHeaders: rsh, winstonLogLevelNames: wlln,
+    winstonLogLevels: wll } = enums;
 
 const COLOR_CONSOLE_WHITE_HEX = '#ECECEC';
 const DEFAULT_REQUEST_ID_ATTRIBUTE = 'requestId';
@@ -35,27 +37,64 @@ function winstonLogLevelIdToName(levelId) {
 
 class ZeddemoreLogger {
 
+    #forceLogLevel = false;
+    #logLevel = wll.INFO;
+
     constructor(options) {
         options = options || { };
-        this.additionalWriteFn = options.additionalWriteFn || null;
+        this.apiCallModel = options.apiCallModel || null;
+        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 || [ ];
         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.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;
     }
 
-    #buildWinstonFormat = (options, additionalFormats = [ ]) =>{
+    get apiCallLoggingEnabled() {
+        return !this.disableApiCallLogging && !!this.apiCallModel;
+    }
+
+    get forceLogLevel() {
+        return this.#forceLogLevel;
+    }
+
+    get logLevel() {
+        return this.#logLevel;
+    }
+
+    get logLevelName() {
+        return winstonLogLevelIdToName(this.#logLevel);
+    }
+
+    get routeLoggingEnabled() {
+        return !this.disableRouteLogging && !!this.routeModel;
+    }
+
+    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 +111,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 +130,7 @@ class ZeddemoreLogger {
 
     #colorizeResponse(message) {
         const verb = message.split(' ')[ 0 ];
-        return chalkHttpVerb(verb, message);
+        return chalkHttpVerbs(verb, message);
     }
 
     #colorizedTemplate = (info) => {
@@ -177,7 +216,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); });
@@ -192,9 +231,20 @@ class ZeddemoreLogger {
         return zeddemoreLogger.createLogger(options);
     }
 
+    #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;
@@ -204,7 +254,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;
@@ -227,6 +277,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)
@@ -237,21 +302,81 @@ 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);
             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();
     }
 
+    #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 || { };
@@ -262,13 +387,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;
@@ -291,13 +416,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.6",
+  "version": "1.1.0",
   "description": "Node.js Express logger using Morgan and Winston for thread and caller info tracking",
   "repository": {
     "type": "git",