src/utils/Logger.ts

   1 import type { FormatWrap } from 'logform'
   2
   3 import {
   4   createLogger,
   5   format,
   6   type transport,
   7   type Logger as WinstonLogger,
   8   transports as WinstonTransports,
   9 } from 'winston'
  10 import DailyRotateFile from 'winston-daily-rotate-file'
  11
  12 import { ConfigurationSection, type LogConfiguration } from '../types/index.js'
  13 import { Configuration } from './Configuration.js'
  14 import { insertAt, isEmpty, isNotEmptyString } from './Utils.js'
  15
  16 let loggerInstance: undefined | WinstonLogger
  17
  18 const getLoggerInstance = (): WinstonLogger => {
  19   if (loggerInstance !== undefined) {
  20     return loggerInstance
  21   }
  22   const logConfiguration = Configuration.getConfigurationSection<LogConfiguration>(
  23     ConfigurationSection.log
  24   )
  25   const logTransports: transport[] = []
  26   if (logConfiguration.rotate === true) {
  27     const logMaxFiles = logConfiguration.maxFiles
  28     const logMaxSize = logConfiguration.maxSize
  29     if (isNotEmptyString(logConfiguration.errorFile)) {
  30       logTransports.push(
  31         new DailyRotateFile({
  32           filename: insertAt(
  33             logConfiguration.errorFile,
  34             '-%DATE%',
  35             logConfiguration.errorFile.indexOf('.log')
  36           ),
  37           level: 'error',
  38           ...(logMaxFiles != null && { maxFiles: logMaxFiles }),
  39           ...(logMaxSize != null && { maxSize: logMaxSize }),
  40         })
  41       )
  42     }
  43     if (isNotEmptyString(logConfiguration.file)) {
  44       logTransports.push(
  45         new DailyRotateFile({
  46           filename: insertAt(
  47             logConfiguration.file,
  48             '-%DATE%',
  49             logConfiguration.file.indexOf('.log')
  50           ),
  51           ...(logMaxFiles != null && { maxFiles: logMaxFiles }),
  52           ...(logMaxSize != null && { maxSize: logMaxSize }),
  53         })
  54       )
  55     }
  56   } else {
  57     if (isNotEmptyString(logConfiguration.errorFile)) {
  58       logTransports.push(
  59         new WinstonTransports.File({
  60           filename: logConfiguration.errorFile,
  61           level: 'error',
  62         })
  63       )
  64     }
  65     if (isNotEmptyString(logConfiguration.file)) {
  66       logTransports.push(
  67         new WinstonTransports.File({
  68           filename: logConfiguration.file,
  69         })
  70       )
  71     }
  72   }
  73   const logFormat = format.combine(
  74     format.splat(),
  75     (format[(logConfiguration.format ?? 'simple') as keyof FormatWrap] as FormatWrap)()
  76   )
  77   loggerInstance = createLogger({
  78     format: logFormat,
  79     level: logConfiguration.level,
  80     silent:
  81       logConfiguration.enabled === false ||
  82       isEmpty(logTransports) ||
  83       process.env.NODE_ENV === 'test',
  84     transports: logTransports,
  85   })
  86   //
  87   // If enabled, log to the `console` with the format:
  88   // `${info.level}: ${info.message} JSON.stringify({ ...rest }) `
  89   //
  90   if (logConfiguration.console === true) {
  91     loggerInstance.add(
  92       new WinstonTransports.Console({
  93         format: logFormat,
  94       })
  95     )
  96   }
  97   return loggerInstance
  98 }
  99
 100 export const logger = new Proxy({} as WinstonLogger, {
 101   get (target, property, receiver): unknown {
 102     if (Reflect.has(target, property)) {
 103       return Reflect.get(target, property, receiver) as unknown
 104     }
 105     return Reflect.get(getLoggerInstance(), property, receiver) as unknown
 106   },
 107   getOwnPropertyDescriptor (target, property) {
 108     return (
 109       Reflect.getOwnPropertyDescriptor(target, property) ??
 110       Reflect.getOwnPropertyDescriptor(getLoggerInstance(), property)
 111     )
 112   },
 113   getPrototypeOf () {
 114     return Reflect.getPrototypeOf(getLoggerInstance())
 115   },
 116   has (target, property) {
 117     return Reflect.has(target, property) || Reflect.has(getLoggerInstance(), property)
 118   },
 119   set (target, property, value, receiver) {
 120     return Reflect.set(target, property, value, receiver)
 121   },
 122 })