@trojs/logger 1.0.0 → 2.0.0

package/package.json

@@ -1,89 +1,72 @@
 {
-    "name": "@trojs/logger",
-    "description": "Winston logger for TroJS",
-    "version": "1.0.0",
-    "author": {
-        "name": "Pieter Wigboldus",
-        "url": "https://trojs.org/"
-    },
-    "license": "MIT",
-    "scripts": {
-        "lint": "eslint",
-        "lint:report": "eslint src/*.js -f json -o report.json",
-        "lint:fix": "eslint --fix",
-        "test": "c8 node --test",
-        "cpd": "node_modules/jscpd/bin/jscpd src",
-        "vulnerabilities": "npm audit --omit=dev"
-    },
-    "type": "module",
-    "files": [
-        "src/logger.js",
-        "src/models/logger.js",
-        "src/models/schemas/logger.js",
-        "src/models/enums/level.js",
-        "src/models/mutators/logger.js",
-        "src/loggers/index.js",
-        "src/loggers/console.js",
-        "src/loggers/sentry.js",
-        "src/loggers/combined-file.js",
-        "src/loggers/error-file.js",
-        "src/helpers/stackdriver.js"
-    ],
-    "main": "src/logger.js",
-    "devDependencies": {
-        "@eslint/js": "^9.15.0",
-        "@stylistic/eslint-plugin": "^2.11.0",
-        "@stylistic/eslint-plugin-js": "^2.11.0",
-        "@trojs/error": "^4.0.0",
-        "c8": "^10.0.0",
-        "eslint": "^9.15.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-import": "^2.31.0",
-        "eslint-plugin-jsdoc": "^50.5.0",
-        "eslint-plugin-n": "^17.14.0",
-        "eslint-plugin-prettier": "^5.2.1",
-        "eslint-plugin-promise": "^7.1.0",
-        "eslint-plugin-sonarjs": "^2.0.4",
-        "globals": "^15.12.0",
-        "jscpd": "^4.0.0",
-        "prettier": "^3.3.3"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/trojs/logger"
-    },
-    "engines": {
-        "node": ">= 20"
-    },
-    "keywords": [
-        "javascript",
-        "sentry",
-        "logging",
-        "error"
-    ],
-    "dependencies": {
-        "@sentry/node": "^8.0.0",
-        "@trojs/enum": "^4.0.0",
-        "@trojs/mutator": "^1.0.0",
-        "@trojs/objects": "^9.0.1",
-        "compression": "^1.7.4",
-        "cors": "^2.8.5",
-        "dotenv": "^16.0.3",
-        "winston": "^3.13.0",
-        "winston-transport": "^4.5.0",
-        "winston-transport-sentry-node": "^3.0.0"
-    },
-    "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/w3nl"
-    },
-    "overrides": {
-        "eslint-plugin-sonarjs": {
-            "eslint": "^9.15.0",
-            "@typescript-eslint/eslint-plugin": "^8.0.0",
-            "@typescript-eslint/utils": "^8.0.0",
-            "eslint-plugin-import": "^2.31.0",
-            "eslint-plugin-react-hooks": "^5.0.0"
-        }
-    }
+  "name": "@trojs/logger",
+  "description": "Winston logger for TroJS",
+  "version": "2.0.0",
+  "author": {
+    "name": "Pieter Wigboldus",
+    "url": "https://trojs.org/"
+  },
+  "license": "MIT",
+  "scripts": {
+    "lint": "eslint",
+    "lint:report": "eslint src/*.js -f json -o report.json",
+    "lint:fix": "eslint --fix",
+    "test": "node --test --experimental-test-coverage --test-reporter=spec --test-reporter=lcov --test-reporter-destination=stdout --test-reporter-destination=./coverage/lcov.info",
+    "cpd": "node_modules/jscpd/bin/jscpd src",
+    "vulnerabilities": "npm audit --omit=dev"
+  },
+  "type": "module",
+  "files": [
+    "src/logger.js",
+    "src/models/logger.js",
+    "src/models/schemas/logger.js",
+    "src/models/enums/level.js",
+    "src/models/mutators/logger.js",
+    "src/loggers/index.js",
+    "src/loggers/console.js",
+    "src/loggers/sentry.js",
+    "src/loggers/combined-file.js",
+    "src/loggers/error-file.js",
+    "src/loggers/winston-transport-sentry-node.js",
+    "src/helpers/stackdriver.js",
+    "src/helpers/extended-error.js"
+  ],
+  "main": "src/logger.js",
+  "devDependencies": {
+    "@trojs/error": "^4.0.0",
+    "@trojs/lint": "^0.2.13",
+    "eslint": "^9.15.0",
+    "globals": "^16.0.0",
+    "jscpd": "^4.0.0",
+    "prettier": "^3.3.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/trojs/logger"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "keywords": [
+    "javascript",
+    "sentry",
+    "logging",
+    "error"
+  ],
+  "dependencies": {
+    "@sentry/node": "^9.0.0",
+    "@trojs/enum": "^4.0.0",
+    "@trojs/mutator": "^1.0.0",
+    "@trojs/objects": "^9.0.1",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "dotenv": "^16.0.3",
+    "triple-beam": "^1.4.1",
+    "winston": "^3.13.0",
+    "winston-transport": "^4.5.0"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/w3nl"
+  }
 }

package/src/helpers/extended-error.js

@@ -0,0 +1,16 @@
+/**
+ * Extended error class to handle additional error information.
+ */
+export class ExtendedError extends Error {
+  /**
+   * @param {object} info - Error information.
+   */
+  constructor (info) {
+    super(info.message)
+
+    this.name = info.name || 'Error'
+    if (info.stack && typeof info.stack === 'string') {
+      this.stack = info.stack
+    }
+  }
+}

package/src/helpers/stackdriver.js

@@ -1,32 +1,32 @@
 import os from 'node:os'
 
 const levelToSeverity = {
-    trace: 'DEBUG',
-    debug: 'DEBUG',
-    info: 'INFO',
-    warn: 'WARNING',
-    error: 'ERROR',
-    fatal: 'CRITICAL'
+  trace: 'DEBUG',
+  debug: 'DEBUG',
+  info: 'INFO',
+  warn: 'WARNING',
+  error: 'ERROR',
+  fatal: 'CRITICAL'
 }
 
 const levels = {
-    trace: 10,
-    debug: 20,
-    info: 30,
-    warn: 40,
-    error: 50,
-    fatal: 60
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
 }
 
-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()
-        })
+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()
+      })
 
 export default stackdriver

package/src/logger.js

@@ -8,18 +8,18 @@ import makeLoggers from './loggers/index.js'
 
 /** @type {LoggerType[]} */
 const defaultLoggers = [
-    {
-        type: 'console'
-    }
+  {
+    type: 'console'
+  }
 ]
 
 const levels = {
-    fatal: 0,
-    error: 1,
-    warn: 2,
-    info: 3,
-    debug: 4,
-    trace: 5
+  fatal: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4,
+  trace: 5
 }
 
 /**
@@ -31,12 +31,12 @@ const levels = {
  * @returns {winston.Logger}
  */
 export default ({ loggers = defaultLoggers, level = 'info', meta = {} }) => {
-    const winstonLoggers = makeLoggers({ winston, loggers })
+  const winstonLoggers = makeLoggers({ winston, loggers })
 
-    return winston.createLogger({
-        level,
-        levels,
-        defaultMeta: meta,
-        transports: winstonLoggers
-    })
+  return winston.createLogger({
+    level,
+    levels,
+    defaultMeta: meta,
+    transports: winstonLoggers
+  })
 }

package/src/loggers/combined-file.js

@@ -1,4 +1,4 @@
 export default ({ winston, logger }) =>
-    new winston.transports.File({
-        filename: logger?.location || 'combined.log'
-    })
+  new winston.transports.File({
+    filename: logger?.location || 'combined.log'
+  })

package/src/loggers/console.js

@@ -1,22 +1,25 @@
 import stackDriver from '../helpers/stackdriver.js'
 
 export default ({ winston, logger }) => {
-    const defaultLevel = 'trace'
+  const defaultLevel = 'trace'
 
-    return new winston.transports.Console({
-        level: logger?.level || defaultLevel,
-        format:
+  const jsonFormatter = winston.format.combine(
+    winston.format.errors({ stack: logger?.debug ?? false }),
+    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()
+  )
+  return new winston.transports.Console({
+    level: logger?.level || defaultLevel,
+    format:
             logger.format === 'json'
-                ? winston.format.combine(
-                    winston.format.errors({ stack: logger?.debug ?? false }),
-                    winston.format(
-                        stackDriver({ level: logger?.level, defaultLevel })
-                    )(),
-                    winston.format.json()
-                )
-                : winston.format.combine(
-                    winston.format.errors({ stack: logger?.debug ?? false }),
-                    winston.format.simple()
-                )
-    })
+              ? jsonFormatter
+              : defaultFormatter
+  })
 }

package/src/loggers/error-file.js

@@ -1,5 +1,5 @@
 export default ({ winston, logger }) =>
-    new winston.transports.File({
-        filename: logger?.location || 'error.log',
-        level: logger?.level || 'error'
-    })
+  new winston.transports.File({
+    filename: logger?.location || 'error.log',
+    level: logger?.level || 'error'
+  })

package/src/loggers/index.js

@@ -6,10 +6,10 @@ import makeConsoleLogger from './console.js'
 import Logger from '../models/logger.js'
 
 const winstonLoggers = {
-    sentry: makeSentryLogger,
-    errorFile: makeErrorFileLogger,
-    combinedFile: makeCombinedFileLogger,
-    console: makeConsoleLogger
+  sentry: makeSentryLogger,
+  errorFile: makeErrorFileLogger,
+  combinedFile: makeCombinedFileLogger,
+  console: makeConsoleLogger
 }
 
 /**
@@ -25,18 +25,18 @@ const winstonLoggers = {
  * @returns {TransportStream[]}
  */
 const makeLoggers = ({ winston, loggers }) =>
-    Logger.createAll(loggers).map((logger) => {
-        const loggerFn = winstonLoggers[logger.type]
-        if (!loggerFn) {
-            throw new Error(`Unknown logger type: ${logger.type}`)
-        }
+  Logger.createAll(loggers).map((logger) => {
+    const loggerFn = winstonLoggers[logger.type]
+    if (!loggerFn) {
+      throw new Error(`Unknown logger type: ${logger.type}`)
+    }
 
-        const opts = {
-            logger,
-            winston
-        }
+    const opts = {
+      logger,
+      winston
+    }
 
-        return loggerFn(opts)
-    })
+    return loggerFn(opts)
+  })
 
 export default makeLoggers

package/src/loggers/sentry.js

@@ -1,20 +1,18 @@
-import SentryPackage from 'winston-transport-sentry-node'
-
-const Sentry = SentryPackage?.default || SentryPackage
+import { SentryTransport } from './winston-transport-sentry-node.js'
 
 export default ({ logger }) => {
-    const options = {
-        sentry: {
-            dsn: logger?.location,
-            environment: logger?.environment || 'production',
-            serverName: logger?.serverName || 'localhost',
-            release: logger?.release || 'unknown',
-            debug: logger?.debug || false,
-            sampleRate: logger?.sampleRate || 1,
-            tracesSampleRate: logger?.tracesSampleRate || 1
-        },
-        level: logger?.level || 'info'
-    }
+  const options = {
+    sentry: {
+      dsn: logger?.location,
+      environment: logger?.environment || 'production',
+      serverName: logger?.serverName || 'localhost',
+      release: logger?.release || 'unknown',
+      debug: logger?.debug || false,
+      sampleRate: logger?.sampleRate || 1,
+      tracesSampleRate: logger?.tracesSampleRate || 1
+    },
+    level: logger?.level || 'info'
+  }
 
-    return new Sentry(options)
+  return new SentryTransport(options)
 }

package/src/loggers/winston-transport-sentry-node.js

@@ -0,0 +1,194 @@
+import * as Sentry from '@sentry/node'
+import TransportStream from 'winston-transport'
+import { LEVEL } from 'triple-beam'
+import { ExtendedError } from '../helpers/extended-error.js'
+
+/**
+ * @enum {string}
+ */
+const SentrySeverity = {
+  Debug: 'debug',
+  Log: 'log',
+  Info: 'info',
+  Warning: 'warning',
+  Error: 'error',
+  Fatal: 'fatal'
+}
+
+/**
+ * @type {{[key: string]: string}}
+ */
+const DEFAULT_LEVELS_MAP = {
+  silly: SentrySeverity.Debug,
+  verbose: SentrySeverity.Debug,
+  info: SentrySeverity.Info,
+  debug: SentrySeverity.Debug,
+  warn: SentrySeverity.Warning,
+  error: SentrySeverity.Error
+}
+
+/**
+ * @typedef {object} SentryTransportOptions
+ * @property {Sentry.NodeOptions} [sentry] - Sentry configuration options.
+ * @property {{[key: string]: string}} [levelsMap] - Custom levels map.
+ * @property {boolean} [skipSentryInit] - Whether to skip Sentry initialization.
+ * @property {boolean} [silent] - Whether to suppress logging.
+ */
+
+/**
+ * @typedef {{[key: string]: string}} SeverityOptions
+ */
+
+/**
+ * Custom Winston transport for Sentry.
+ */
+export class SentryTransport extends TransportStream {
+  /**
+   * @type {boolean}
+   */
+  silent = false
+
+  /**
+   * @type {SeverityOptions}
+   */
+  levelsMap = {}
+
+  /**
+   * @param {SentryTransportOptions} [opts] - Transport options.
+   */
+  constructor (opts) {
+    super(opts)
+
+    this.levelsMap = this.setLevelsMap(opts && opts.levelsMap)
+    this.silent = (opts && opts.silent) || false
+
+    if (!opts || !opts.skipSentryInit) {
+      Sentry.init(SentryTransport.withDefaults((opts && opts.sentry) || {}))
+    }
+  }
+
+  /**
+   * Logs the message to Sentry.
+   * @param {object} info - Log information.
+   * @param {Function} callback - Callback function.
+   * @returns {void}
+   */
+  log (info, callback) {
+    setImmediate(() => {
+      this.emit('logged', info)
+    })
+
+    if (this.silent) return callback()
+
+    const { message, tags, user, ...meta } = info
+    const winstonLevel = info[LEVEL]
+
+    const sentryLevel = this.levelsMap[winstonLevel]
+
+    return Sentry.withScope((scope) => {
+      if (tags !== undefined && SentryTransport.isObject(tags)) {
+        scope.setTags(tags)
+      }
+
+      scope.setExtras(meta)
+
+      if (user !== undefined && SentryTransport.isObject(user)) {
+        scope.setUser(user)
+      }
+
+      // Capturing Errors / Exceptions
+      if (SentryTransport.shouldLogException(sentryLevel)) {
+        const error
+          = Object.values(info).find((value) => value instanceof Error)
+            ?? new ExtendedError(info)
+        Sentry.captureException(error, { tags, level: sentryLevel })
+      } else {
+        // Capturing Messages
+        Sentry.captureMessage(message, sentryLevel)
+      }
+    })
+  }
+
+  /**
+   * Ends the transport and flushes Sentry.
+   * @param {...any} args - Arguments.
+   * @returns {this}
+   */
+  end (...args) {
+    // eslint-disable-next-line promise/catch-or-return
+    Sentry.flush().then(() => super.end(...args))
+    return this
+  }
+
+  /**
+   * @returns {typeof Sentry}
+   */
+  get sentry () {
+    return Sentry
+  }
+
+  /**
+   * Sets the levels map.
+   * @param {SeverityOptions} [options] - Custom levels map.
+   * @returns {SeverityOptions}
+   */
+  setLevelsMap (options) {
+    if (!options) {
+      return DEFAULT_LEVELS_MAP
+    }
+
+    const customLevelsMap = Object.keys(options).reduce(
+      (acc, winstonSeverity) => {
+        acc[winstonSeverity] = options[winstonSeverity]
+        return acc
+      },
+      {}
+    )
+
+    return {
+      ...DEFAULT_LEVELS_MAP,
+      ...customLevelsMap
+    }
+  }
+
+  /**
+   * Merges default Sentry options with user-provided options.
+   * @param {Sentry.NodeOptions} options - Sentry options.
+   * @returns {Sentry.NodeOptions}
+   */
+  static withDefaults (options) {
+    return {
+      ...options,
+      dsn: (options && options.dsn) || process.env.SENTRY_DSN || '',
+      serverName:
+        (options && options.serverName) || 'winston-transport-sentry-node',
+      environment:
+        (options && options.environment)
+        || process.env.SENTRY_ENVIRONMENT
+        || process.env.NODE_ENV
+        || 'production',
+      debug: (options && options.debug) || !!process.env.SENTRY_DEBUG || false,
+      sampleRate: (options && options.sampleRate) || 1.0,
+      maxBreadcrumbs: (options && options.maxBreadcrumbs) || 100
+    }
+  }
+
+  /**
+   * Checks if the given object is an object or function.
+   * @param {any} obj - Object to check.
+   * @returns {boolean}
+   */
+  static isObject (obj) {
+    const type = typeof obj
+    return type === 'function' || (type === 'object' && !!obj)
+  }
+
+  /**
+   * Determines if the given level should log an exception.
+   * @param {string} level - Sentry severity level.
+   * @returns {boolean}
+   */
+  static shouldLogException (level) {
+    return level === SentrySeverity.Fatal || level === SentrySeverity.Error
+  }
+}

package/src/models/enums/level.js

@@ -19,17 +19,17 @@ import { Enum } from '@trojs/enum'
  * @enum { LevelType }
  */
 class Level extends Enum {
-    static info = 'info'
+  static info = 'info'
 
-    static fatal = 'fatal'
+  static fatal = 'fatal'
 
-    static error = 'error'
+  static error = 'error'
 
-    static warn = 'warn'
+  static warn = 'warn'
 
-    static debug = 'debug'
+  static debug = 'debug'
 
-    static trace = 'trace'
+  static trace = 'trace'
 }
 
 export default Level

package/src/models/logger.js

@@ -9,26 +9,26 @@ import LoggerMutator from './mutators/logger.js'
 const LoggerObject = Obj({ schema: loggerSchema })
 
 export default class Logger {
-    /**
-     * Create a logger object
-     * @param {LoggerType} data
-     * @returns {LoggerType}
-     */
-    static create(data) {
-        const logger = LoggerMutator.create(data)
-        return LoggerObject.create(logger)
-    }
-
-    /**
-     * Create logger objects
-     * @param {LoggerType[]} data
-     * @returns {LoggerType[]}
-     */
-    static createAll(data) {
-        if (!data || data.length === 0) {
-            return []
-        }
+  /**
+   * Create a logger object
+   * @param {LoggerType} data
+   * @returns {LoggerType}
+   */
+  static create (data) {
+    const logger = LoggerMutator.create(data)
+    return LoggerObject.create(logger)
+  }
 
-        return data.map((loggerData) => Logger.create(loggerData))
+  /**
+   * Create logger objects
+   * @param {LoggerType[]} data
+   * @returns {LoggerType[]}
+   */
+  static createAll (data) {
+    if (!data || data.length === 0) {
+      return []
     }
+
+    return data.map((loggerData) => Logger.create(loggerData))
+  }
 }

package/src/models/mutators/logger.js

@@ -6,9 +6,9 @@ import LevelEnum from '../enums/level.js'
  * @augments DefaultMutator
  */
 class Logger extends DefaultMutator {
-    setLevelAttribute(level) {
-        return LevelEnum.fromKey(level)
-    }
+  setLevelAttribute (level) {
+    return LevelEnum.fromKey(level)
+  }
 }
 
 export default Logger

package/src/models/schemas/logger.js

@@ -22,16 +22,16 @@ import Level from '../enums/level.js'
  */
 
 export default {
-    type: String,
-    'location?': String,
-    'level?': Level,
-    'key?': String,
-    'credentials?': Object,
-    'environment?': String,
-    'serverName?': String,
-    'release?': String,
-    'debug?': Boolean,
-    'sampleRate?': Number,
-    'tracesSampleRate?': Number,
-    'format?': String
+  type: String,
+  'location?': String,
+  'level?': Level,
+  'key?': String,
+  'credentials?': Object,
+  'environment?': String,
+  'serverName?': String,
+  'release?': String,
+  'debug?': Boolean,
+  'sampleRate?': Number,
+  'tracesSampleRate?': Number,
+  'format?': String
 }