@trojs/logger 0.5.15 → 0.5.17

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@trojs/logger",
     "description": "Winston logger for TroJS",
-    "version": "0.5.15",
+    "version": "0.5.17",
     "author": {
         "name": "Pieter Wigboldus",
         "url": "https://trojs.org/"

package/src/logger.js

@@ -3,15 +3,9 @@ import makeLoggers from './loggers/index.js'
 
 /**
  * @typedef {import('./models/schemas/logger.js').Logger} LoggerType
- * @typedef {import('./models/enums/level.js').LevelType} LevelType
  */
 
-/** @type {LoggerType[]} */
-const defaultLoggers = [
-  {
-    type: 'console'
-  }
-]
+const defaultLoggers = [{ type: 'console' }]
 
 const levels = {
   fatal: 0,
@@ -23,20 +17,102 @@ 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 info = {
+          level: lvl,
+          message: first.message || first.toString(),
+          error: first,
+          stack: first.stack
+        }
+        if (rest[0] && typeof rest[0] === 'object') {
+          Object.assign(info, rest[0])
+        }
+        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,59 +1,130 @@
 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 jsonFormatter = winston.format.combine(
-    winston.format.errors({ stack: logger?.debug ?? false }),
-    winston.format((info) => {
-      if (!info.message) {
-        if (info instanceof Error) {
-          // Prefer the raw message; fall back to toString
-          info.message = info.message || info.toString()
-        } else {
-          // Avoid {"level":"error"} as a message if level is the only key
-          const clone = { ...info }
-          delete clone.level
-          const keys = Object.keys(clone)
-          info.message = keys.length > 0 ? JSON.stringify(clone) : ''
+  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
         }
-      } else if (info.message instanceof Error) {
-        info.message = info.message.message || info.message.toString()
-      } else if (typeof info.message !== 'string') {
-        info.message = JSON.stringify(info.message)
-      }
-      if (logger?.debug && info.stack) {
-        info.stacktrace = info.stack
+      } catch {
+        info.message = info[SYMBOL_MESSAGE]
       }
-      return info
-    })(),
-    winston.format(
-      stackDriver({ level: logger?.level, defaultLevel })
-    )(),
-    winston.format.json()
-  )
+    }
+  }
 
-  const simpleLoggerWithStack = winston.format.printf(({ level, message, stack }) => {
-    const text = `${level.toUpperCase()}: ${message}`
-    return stack ? `${text}\n${stack}` : text
-  })
+  const attachEmbeddedError = (info) => {
+    const embedded
+      = (info.error instanceof Error && info.error)
+        || (info.exception instanceof Error && info.exception)
 
-  const defaultFormatter = winston.format.combine(
-    winston.format.errors({ stack: logger?.debug ?? false }),
-    winston.format((info) => {
-      if (!info.message && info instanceof Error) {
+    if (info instanceof Error) {
+      if (!info.message || info.message === '') {
         info.message = info.toString()
       }
-      return info
-    })(),
-    simpleLoggerWithStack
+      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(
+    ensureErrorProps(),
+    winston.format.errors({ stack: stackTrace }),
+    normalizeMessage(),
+    winston.format(stackDriver({ level: logger?.level, defaultLevel }))(),
+    winston.format.json()
+  )
+
+  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
   })
 }