zeddemore-logger 1.0.7 → 1.1.0

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',
@@ -42,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',
@@ -56,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 = {
@@ -96,11 +145,15 @@ const winstonLogLevels = {
 };
 
 module.exports = {
+    ansi256Colors,
+    ansiColors,
     apiLogLevelCaptions,
     apiLogLevels,
     chalkFormats,
     chalkLayers,
     databaseOperations,
+    hexColors,
+    httpStatusCodeGroups,
     httpMethods,
     httpRequestHeaders,
     httpResponseHeaders,

package/lib/mappings/color_mappings.js

@@ -3,44 +3,45 @@
 const _ = require('lodash');
 const enums = require('../enums');
 
-const { databaseOperations: dbo, chalkFormats: cs, httpMethods: http, winstonLogLevels: wll } = enums;
+const { ansi256Colors: a256c, ansiColors: ac, databaseOperations: dbo, chalkFormats: cs, 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: 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), 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: 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, 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: 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: 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: 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 = {

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,16 @@ const morgan = require('morgan');
 const sizeof = require('object-sizeof');
 const { v4: uuid } = require('uuid');
 
-const { areHeadersSent, getRequestResponseTime, parseRequest } = require('./http');
+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,
+const { morganFormats: mf, httpMethods: http, httpRequestHeaders: rqh, httpResponseHeaders: rsh, winstonLogLevelNames: wlln,
     winstonLogLevels: wll } = enums;
 
 const COLOR_CONSOLE_WHITE_HEX = '#ECECEC';
@@ -41,10 +42,14 @@ class ZeddemoreLogger {
 
     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 || [ ];
@@ -52,11 +57,18 @@ 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;
     }
@@ -69,6 +81,10 @@ class ZeddemoreLogger {
         return winstonLogLevelIdToName(this.#logLevel);
     }
 
+    get routeLoggingEnabled() {
+        return !this.disableRouteLogging && !!this.routeModel;
+    }
+
     set forceLogLevel(doForce) {
         this.#forceLogLevel = !!doForce;
     }
@@ -215,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;
@@ -227,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;
@@ -250,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)
@@ -260,7 +302,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 +317,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 || { };

package/package.json

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