@trojs/logger 2.0.7 → 2.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@trojs/logger",
   "description": "Winston logger for TroJS",
-  "version": "2.0.7",
+  "version": "2.1.0",
   "author": {
     "name": "Pieter Wigboldus",
     "url": "https://trojs.org/"
@@ -36,7 +36,7 @@
     "@trojs/error": "^5.0.0",
     "@trojs/lint": "^0.4.0",
     "eslint": "^9.15.0",
-    "globals": "^16.0.0",
+    "globals": "^17.0.0",
     "jscpd": "^4.0.0",
     "prettier": "^3.3.3"
   },

package/src/helpers/stackdriver.js

@@ -19,14 +19,18 @@ const levels = {
 }
 
 const stackdriver
-  = ({ level, defaultLevel }) =>
-    (info) => ({
-      ...info,
-      severity: levelToSeverity[level] || levelToSeverity[defaultLevel],
-      level: levels[level] || levels[defaultLevel],
-      time: Date.now(),
-      pid: process.pid,
-      hostname: os.hostname()
-    })
+  = ({ level = 'info', defaultLevel = 'info' } = {}) =>
+    (info) => {
+      const currentLevel = info?.level ?? level ?? defaultLevel ?? 'info'
+
+      return {
+        ...info,
+        severity: levelToSeverity[currentLevel] || levelToSeverity.info,
+        level: levels[currentLevel] || levels.info,
+        time: Date.now(),
+        pid: process.pid,
+        hostname: os.hostname()
+      }
+    }
 
 export default stackdriver

package/src/logger.js

@@ -23,20 +23,114 @@ const levels = {
 }
 
 /**
- * Create the logger
- * @param {object} config
- * @param {LoggerType=} config.loggers
- * @param {string?=} config.level
- * @param {object?=} config.meta
- * @returns {winston.Logger}
+ * Creates a Winston logger instance with custom log levels and transports.
+ * Also attaches global process event handlers for uncaught exceptions, unhandled rejections, and warnings.
+ * @param {object} [options={}] - Logger configuration options.
+ * @param {Array<{[key: string]: string}>} [options.loggers=defaultLoggers] - Array of logger transport configurations.
+ * @param {string} [options.level='info'] - Minimum log level for the logger.
+ * @param {object} [options.meta={}] - Default metadata to include in all log messages.
+ * @returns {LoggerType} Winston logger instance with custom level wrappers.
+ * These handlers will log errors and warnings using the logger, and are only attached once per process.
+ * @example
+ * import createLogger from './logger.js';
+ * const logger = createLogger({ level: 'debug', meta: { service: 'api' } });
+ * logger.info('Service started');
  */
-export default ({ loggers = defaultLoggers, level = 'info', meta = {} }) => {
+export default ({ loggers = defaultLoggers, level = 'info', meta = {} } = {}) => {
   const winstonLoggers = makeLoggers({ winston, loggers })
 
-  return winston.createLogger({
+  const logger = winston.createLogger({
     level,
     levels,
     defaultMeta: meta,
     transports: winstonLoggers
   })
+
+  const wrapLevel = (lvl) => {
+    const orig = logger[lvl].bind(logger)
+    logger[lvl] = (first, ...rest) => {
+      if (first instanceof Error) {
+        const message = typeof first.message === 'string'
+          ? first.message
+          : (() => {
+              try {
+                return JSON.stringify(first)
+              } catch {
+                return String(first)
+              }
+            })()
+
+        const restInfo = Object.assign(
+          {},
+          ...rest.filter((x) => x && typeof x === 'object')
+        )
+        const info = {
+          ...restInfo,
+          level: lvl,
+          message: message,
+          error: first,
+          stack: first.stack
+        }
+        return logger.log(info)
+      }
+      return orig(first, ...rest)
+    }
+  }
+
+  ;['fatal', 'error', 'warn', 'info', 'debug', 'trace'].forEach((lvl) => {
+    if (typeof logger[lvl] === 'function') wrapLevel(lvl)
+  })
+
+  if (!process.__trojsLoggerHandlersAttached) {
+    process.__trojsLoggerHandlersAttached = true
+
+    process.on('uncaughtException', (err) => {
+      try {
+        logger.error(err instanceof Error ? err : new Error(String(err)))
+      } catch {
+        // eslint-disable-next-line no-console
+        console.error('UNCAUGHT_EXCEPTION', err)
+      }
+    })
+
+    process.on('unhandledRejection', (reason) => {
+      let err
+      if (reason instanceof Error) {
+        err = reason
+      } else if (typeof reason === 'string') {
+        err = new Error(reason)
+      } else {
+        try {
+          err = new Error(JSON.stringify(reason))
+        } catch {
+          err = new Error(String(reason))
+        }
+      }
+      try {
+        logger.error(err)
+      } catch {
+        // eslint-disable-next-line no-console
+        console.error('UNHANDLED_REJECTION', err)
+      }
+    })
+
+    process.on('warning', (warning) => {
+      try {
+        logger.warn(
+          warning instanceof Error
+            ? warning
+            : (
+                new Error(
+                  `${warning.name}: ${warning.message}\n${warning.stack || ''}`
+                )
+              )
+        )
+      } catch {
+        // eslint-disable-next-line no-console
+        console.warn('PROCESS_WARNING', warning)
+      }
+    })
+  }
+
+  return logger
 }

package/src/loggers/console.js

@@ -1,25 +1,131 @@
+/* eslint-disable no-param-reassign */
 import stackDriver from '../helpers/stackdriver.js'
 
+const SYMBOL_MESSAGE = Symbol.for('message')
+
 export default ({ winston, logger }) => {
   const defaultLevel = 'trace'
+  const stackTrace = logger?.debug ?? false
+
+  const stackHead = (stack) =>
+    stack ? (stack.split('\n')[0] || '').trim() : ''
+
+  const ensureErrorProps = winston.format((info) => {
+    if (info instanceof Error) {
+      info.message = info.message || info.toString()
+    }
+    return info
+  })
+
+  const extractSymbolMessage = (info) => {
+    if (
+      (!info.message || info.message === '')
+      && info[SYMBOL_MESSAGE]
+      && typeof info[SYMBOL_MESSAGE] === 'string'
+    ) {
+      try {
+        const parsed = JSON.parse(info[SYMBOL_MESSAGE])
+        if (typeof parsed === 'string') {
+          info.message = parsed
+        }
+      } catch {
+        info.message = info[SYMBOL_MESSAGE]
+      }
+    }
+  }
+
+  const attachEmbeddedError = (info) => {
+    const embedded
+      = (info.error instanceof Error && info.error)
+        || (info.exception instanceof Error && info.exception)
+
+    if (info instanceof Error) {
+      if (!info.message || info.message === '') {
+        info.message = info.toString()
+      }
+      return
+    }
+
+    if (info.message instanceof Error) {
+      info.message = info.message.message || info.message.toString()
+      return
+    }
+
+    if (embedded) {
+      info.message = embedded.message || embedded.toString()
+      if (!info.stack && embedded.stack) {
+        info.stack = embedded.stack
+      }
+    }
+  }
+
+  const stringifyNonStringMessage = (info) => {
+    if (info.message && typeof info.message !== 'string') {
+      try {
+        info.message = JSON.stringify(info.message)
+      } catch {
+        info.message = String(info.message)
+      }
+    }
+  }
+
+  const deriveMessageFromStack = (info) => {
+    if (info.stack && (!info.message || info.message === '')) {
+      info.message = stackHead(info.stack)
+    }
+  }
+
+  const finalizeEmptyMessage = (info) => {
+    if (!info.message || info.message === '') {
+      const clone = { ...info }
+      delete clone.level
+      delete clone.stack
+      delete clone.error
+      delete clone.exception
+      delete clone[SYMBOL_MESSAGE]
+      const keys = Object.keys(clone)
+      info.message = keys.length > 0 ? JSON.stringify(clone) : ''
+    }
+  }
+
+  const duplicateStackTraceIfDebug = (info) => {
+    if ((logger?.debug ?? false) && info.stack) {
+      info.stacktrace = info.stack
+    }
+  }
+
+  const normalizeMessage = winston.format((info) => {
+    extractSymbolMessage(info)
+    attachEmbeddedError(info)
+    stringifyNonStringMessage(info)
+    deriveMessageFromStack(info)
+    finalizeEmptyMessage(info)
+    duplicateStackTraceIfDebug(info)
+    return info
+  })
 
   const jsonFormatter = winston.format.combine(
-    winston.format.errors({ stack: logger?.debug ?? false }),
-    winston.format(
-      stackDriver({ level: logger?.level, defaultLevel })
-    )(),
+    ensureErrorProps(),
+    winston.format.errors({ stack: stackTrace }),
+    normalizeMessage(),
+    winston.format(stackDriver({ level: logger?.level, defaultLevel }))(),
     winston.format.json()
   )
 
-  const defaultFormatter = winston.format.combine(
-    winston.format.errors({ stack: logger?.debug ?? false }),
-    winston.format.simple()
+  const simpleFormatter = winston.format.combine(
+    ensureErrorProps(),
+    winston.format.errors({ stack: stackTrace }),
+    normalizeMessage(),
+    winston.format.printf(({ level, message, stack }) => {
+      const base = `${level}: ${message || stackHead(stack)}`
+      return stack && (logger?.debug ?? false) ? `${base}\n${stack}` : base
+    })
   )
+
   return new winston.transports.Console({
     level: logger?.level || defaultLevel,
-    format:
-            logger.format === 'json'
-              ? jsonFormatter
-              : defaultFormatter
+    handleExceptions: true,
+    handleRejections: true,
+    format: logger?.format === 'json' ? jsonFormatter : simpleFormatter
   })
 }