@nest-yalc-2/logger 1.0.0

package/src/logger.factory.ts

@@ -0,0 +1,70 @@
+import { ConsoleLogger } from './logger-console.service.js';
+import { PinoLogger } from './logger-pino.service.js';
+import { LogLevel, Logger } from '@nestjs/common';
+import { LoggerTypeEnum, LOG_LEVEL_DEFAULT } from './logger.enum.js';
+import { ImprovedNestLogger } from './logger-nest.service.js';
+import type {
+  IImprovedLoggerOptions,
+  ImprovedLoggerService,
+} from './logger-abstract.service.js';
+import * as _ from 'lodash-es';
+import { getEnvLoggerLevels } from './logger.helper.js';
+
+export const AppLoggerFactory: (
+  context: string,
+  loggerLevels?: LogLevel[],
+  loggerType?: string,
+  options?: IImprovedLoggerOptions,
+) => ImprovedLoggerService = _.memoize(
+  (
+    context: string,
+    loggerLevels: LogLevel[] = LOG_LEVEL_DEFAULT,
+    loggerType?: string,
+    options?: IImprovedLoggerOptions,
+  ): ImprovedLoggerService => {
+    let logger: ImprovedLoggerService;
+    switch (loggerType) {
+      case LoggerTypeEnum.CONSOLE:
+        logger = new ConsoleLogger(context, loggerLevels, options);
+        break;
+      case LoggerTypeEnum.PINO:
+        logger = new PinoLogger(context, loggerLevels, options);
+        break;
+      case LoggerTypeEnum.NEST:
+      default:
+        logger = new ImprovedNestLogger(
+          context,
+          {
+            timestamp: true,
+          },
+          options,
+        );
+        // not available on default NEST logger
+        // ImprovedNestLogger.overrideLogger(loggerLevels);
+        logger.setLogLevels?.(loggerLevels);
+        break;
+    }
+
+    /**
+     * Side effect to be executed as soon as the module is imported
+     */
+    Logger.overrideLogger(getEnvLoggerLevels());
+    /**
+     * We use the system logger here
+     */
+    Logger.debug?.(
+      `Use Logger: ${
+        loggerType ??
+        `not specified, fallback to default (${LoggerTypeEnum.NEST})`
+      }`,
+    );
+
+    return logger;
+  },
+  (
+    context: string,
+    loggerLevels: LogLevel[] | undefined,
+    loggerType: string | undefined,
+    options: IImprovedLoggerOptions | undefined,
+  ): string => `${context}-${loggerLevels?.join('-')}-${loggerType}-${options}`,
+);

package/src/logger.helper.d.ts

@@ -0,0 +1,4 @@
+import { LogLevel } from '@nestjs/common';
+export declare function maskDataInObject(data?: any, paths?: string[], trace?: any): any;
+export declare const getEnvLoggerLevelsByContext: (context: string) => LogLevel[];
+export declare const getEnvLoggerLevels: (context?: string, def?: LogLevel[]) => LogLevel[];

package/src/logger.helper.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvLoggerLevels = exports.getEnvLoggerLevelsByContext = void 0;
+exports.maskDataInObject = maskDataInObject;
+const env_helper_js_1 = require("@nest-yalc-2/utils/env.helper.js");
+const fast_redact_1 = __importDefault(require("fast-redact"));
+const lodash_es_1 = require("lodash-es");
+const logger_enum_js_1 = require("./logger.enum.js");
+function maskDataInObject(data, paths, trace) {
+    if (typeof data === 'string')
+        data = { message: data };
+    if (!paths || !data || (0, lodash_es_1.isEmpty)(paths) || (0, lodash_es_1.isEmpty)(data)) {
+        if (trace)
+            data ? (data.trace = trace) : (data = { trace });
+        return data;
+    }
+    const redact = (0, fast_redact_1.default)({
+        paths,
+    });
+    return { ...JSON.parse(redact(data)), trace };
+}
+const getEnvLoggerLevelsByContext = (context) => {
+    return (0, env_helper_js_1.envToArray)(`NEST_LOGGER_LEVELS_${context.toUpperCase()}`);
+};
+exports.getEnvLoggerLevelsByContext = getEnvLoggerLevelsByContext;
+const getEnvLoggerLevels = (context, def = logger_enum_js_1.LOG_LEVEL_ALL) => {
+    let levels = (0, exports.getEnvLoggerLevelsByContext)(context ?? logger_enum_js_1.LoggerDefContext.NEST_SYSTEM);
+    if (!levels.length)
+        levels = (0, env_helper_js_1.envToArray)('NEST_LOGGER_LEVELS');
+    return levels.length ? levels : def;
+};
+exports.getEnvLoggerLevels = getEnvLoggerLevels;
+//# sourceMappingURL=logger.helper.js.map

package/src/logger.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.helper.js","sourceRoot":"","sources":["logger.helper.ts"],"names":[],"mappings":";;;;;;AAQA,4CAcC;AAtBD,oEAA8D;AAI9D,8DAAqC;AACrC,yCAAoC;AACpC,qDAAmE;AAEnE,SAAgB,gBAAgB,CAAC,IAAU,EAAE,KAAgB,EAAE,KAAW;IACxE,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,IAAI,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAEvD,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,IAAI,IAAA,mBAAO,EAAC,KAAK,CAAC,IAAI,IAAA,mBAAO,EAAC,IAAI,CAAC,EAAE,CAAC;QACvD,IAAI,KAAK;YAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;QAE5D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,MAAM,GAAG,IAAA,qBAAU,EAAC;QACxB,KAAK;KACN,CAAC,CAAC;IAEH,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC;AAChD,CAAC;AAEM,MAAM,2BAA2B,GAAG,CAAC,OAAe,EAAc,EAAE;IACzE,OAAO,IAAA,0BAAU,EAAW,sBAAsB,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;AAC7E,CAAC,CAAC;AAFW,QAAA,2BAA2B,+BAEtC;AAEK,MAAM,kBAAkB,GAAG,CAChC,OAAgB,EAChB,MAAkB,8BAAa,EACnB,EAAE;IACd,IAAI,MAAM,GAAG,IAAA,mCAA2B,EACtC,OAAO,IAAI,iCAAgB,CAAC,WAAW,CACxC,CAAC;IAEF,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,MAAM,GAAG,IAAA,0BAAU,EAAW,oBAAoB,CAAC,CAAC;IAExE,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC;AACtC,CAAC,CAAC;AAXW,QAAA,kBAAkB,sBAW7B"}

package/src/logger.helper.ts

@@ -0,0 +1,40 @@
+import { envToArray } from '@nest-yalc-2/utils/env.helper.js';
+import { LogLevel } from '@nestjs/common';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import fastRedact from 'fast-redact';
+import { isEmpty } from 'lodash-es';
+import { LOG_LEVEL_ALL, LoggerDefContext } from './logger.enum.js';
+
+export function maskDataInObject(data?: any, paths?: string[], trace?: any) {
+  if (typeof data === 'string') data = { message: data };
+
+  if (!paths || !data || isEmpty(paths) || isEmpty(data)) {
+    if (trace) data ? (data.trace = trace) : (data = { trace });
+
+    return data;
+  }
+
+  const redact = fastRedact({
+    paths,
+  });
+
+  return { ...JSON.parse(redact(data)), trace };
+}
+
+export const getEnvLoggerLevelsByContext = (context: string): LogLevel[] => {
+  return envToArray<LogLevel>(`NEST_LOGGER_LEVELS_${context.toUpperCase()}`);
+};
+
+export const getEnvLoggerLevels = (
+  context?: string,
+  def: LogLevel[] = LOG_LEVEL_ALL,
+): LogLevel[] => {
+  let levels = getEnvLoggerLevelsByContext(
+    context ?? LoggerDefContext.NEST_SYSTEM,
+  );
+
+  if (!levels.length) levels = envToArray<LogLevel>('NEST_LOGGER_LEVELS');
+
+  return levels.length ? levels : def;
+};

package/src/logger.service.d.ts

@@ -0,0 +1,3 @@
+import { FactoryProvider } from '@nestjs/common';
+import type { IImprovedLoggerOptions, ImprovedLoggerService } from '@nest-yalc-2/logger/logger-abstract.service.js';
+export declare const LoggerServiceFactory: (appAlias: string, provide: string, context: string, options?: IImprovedLoggerOptions) => FactoryProvider<ImprovedLoggerService>;

package/src/logger.service.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerServiceFactory = void 0;
+const logger_factory_js_1 = require("@nest-yalc-2/logger/logger.factory.js");
+const app_config_service_js_1 = require("@nest-yalc-2/app/app-config.service.js");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const LoggerServiceFactory = (appAlias, provide, context, options = {}) => ({
+    provide: provide,
+    useFactory: (config, eventEmitter) => {
+        const conf = config.values;
+        const loggerType = conf.loggerType;
+        const loggerLevels = options.overrideLoggerLevels ??
+            (conf.logContextLevels?.[context] || conf.logLevels || []);
+        return (0, logger_factory_js_1.AppLoggerFactory)(context, loggerLevels, loggerType, {
+            event: options.event !== false
+                ? {
+                    eventEmitter: options.event?.eventEmitter ?? eventEmitter,
+                }
+                : false,
+        });
+    },
+    inject: [(0, app_config_service_js_1.getAppConfigToken)(appAlias), event_emitter_1.EventEmitter2],
+});
+exports.LoggerServiceFactory = LoggerServiceFactory;
+//# sourceMappingURL=logger.service.js.map

package/src/logger.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.service.js","sourceRoot":"","sources":["logger.service.ts"],"names":[],"mappings":";;;AAAA,6EAAyE;AAOzE,kFAGgD;AAChD,yDAAsD;AAE/C,MAAM,oBAAoB,GAAG,CAClC,QAAgB,EAChB,OAAe,EACf,OAAe,EACf,UAAkC,EAAE,EACI,EAAE,CAAC,CAAC;IAC5C,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,CACV,MAAsC,EACtC,YAA2B,EACJ,EAAE;QACzB,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC;QAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,MAAM,YAAY,GAChB,OAAO,CAAC,oBAAoB;YAC5B,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;QAE7D,OAAO,IAAA,oCAAgB,EAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE;YACzD,KAAK,EACH,OAAO,CAAC,KAAK,KAAK,KAAK;gBACrB,CAAC,CAAC;oBACE,YAAY,EAAE,OAAO,CAAC,KAAK,EAAE,YAAY,IAAI,YAAY;iBAC1D;gBACH,CAAC,CAAC,KAAK;SACZ,CAAC,CAAC;IACL,CAAC;IACD,MAAM,EAAE,CAAC,IAAA,yCAAiB,EAAC,QAAQ,CAAC,EAAE,6BAAa,CAAC;CACrD,CAAC,CAAC;AA3BU,QAAA,oBAAoB,wBA2B9B"}

package/src/logger.service.ts

@@ -0,0 +1,41 @@
+import { AppLoggerFactory } from '@nest-yalc-2/logger/logger.factory.js';
+import { FactoryProvider, LogLevel } from '@nestjs/common';
+import type {
+  IImprovedLoggerOptions,
+  ImprovedLoggerService,
+} from '@nest-yalc-2/logger/logger-abstract.service.js';
+import { IServiceConf } from '@nest-yalc-2/app/conf.type.js';
+import {
+  AppConfigService,
+  getAppConfigToken,
+} from '@nest-yalc-2/app/app-config.service.js';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+
+export const LoggerServiceFactory = (
+  appAlias: string,
+  provide: string,
+  context: string,
+  options: IImprovedLoggerOptions = {},
+): FactoryProvider<ImprovedLoggerService> => ({
+  provide: provide,
+  useFactory: (
+    config: AppConfigService<IServiceConf>,
+    eventEmitter: EventEmitter2,
+  ): ImprovedLoggerService => {
+    const conf = config.values;
+    const loggerType = conf.loggerType;
+    const loggerLevels: LogLevel[] =
+      options.overrideLoggerLevels ??
+      (conf.logContextLevels?.[context] || conf.logLevels || []);
+
+    return AppLoggerFactory(context, loggerLevels, loggerType, {
+      event:
+        options.event !== false
+          ? {
+              eventEmitter: options.event?.eventEmitter ?? eventEmitter,
+            }
+          : false,
+    });
+  },
+  inject: [getAppConfigToken(appAlias), EventEmitter2],
+});

package/src/typeorm-logger.d.ts

@@ -0,0 +1,13 @@
+import { YalcEventService } from '@nest-yalc-2/event-manager/event.service.js';
+import { Logger } from 'typeorm';
+export declare class TypeORMLogger implements Logger {
+    private event;
+    private isLoggerEnabled;
+    constructor(event: YalcEventService);
+    logQuery(query: string, parameters?: any[]): any;
+    logQueryError(error: string | Error, query: string, parameters?: any[]): any;
+    logQuerySlow(time: number, query: string, parameters?: any[]): any;
+    logSchemaBuild(message: string): any;
+    logMigration(message: string): any;
+    log(level: 'log' | 'info' | 'warn', message: any): any;
+}

package/src/typeorm-logger.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMLogger = void 0;
+const utils_1 = require("@nest-yalc-2/utils");
+const logger_event_js_1 = require("./logger.event.js");
+class TypeORMLogger {
+    constructor(event) {
+        this.event = event;
+        this.isLoggerEnabled = false;
+        this.isLoggerEnabled = (0, utils_1.envIsTrue)(process.env.TYPEORM_LOGGING || 'false');
+    }
+    logQuery(query, parameters) {
+        if (!this.isLoggerEnabled)
+            return;
+        this.event.debug?.(logger_event_js_1.LoggerEvent.QUERY_LOG, {
+            data: {
+                query,
+                parameters,
+            },
+        });
+    }
+    logQueryError(error, query, parameters) {
+        if (!this.isLoggerEnabled)
+            return;
+        this.event.error?.(logger_event_js_1.LoggerEvent.QUERY_ERROR, {
+            data: {
+                error,
+                query,
+                parameters,
+            },
+        });
+    }
+    logQuerySlow(time, query, parameters) {
+        if (!this.isLoggerEnabled)
+            return;
+        this.event.warn?.(logger_event_js_1.LoggerEvent.QUERY_SLOW, {
+            message: `SLOW QUERY!!!!`,
+            data: {
+                time,
+                query,
+                parameters,
+            },
+        });
+    }
+    logSchemaBuild(message) {
+        if (!this.isLoggerEnabled)
+            return;
+        this.event.debug?.(logger_event_js_1.LoggerEvent.SCHEMA_BUILD, {
+            message,
+        });
+    }
+    logMigration(message) {
+        if (!this.isLoggerEnabled)
+            return;
+        this.event.debug?.(logger_event_js_1.LoggerEvent.DEBUG, {
+            message,
+        });
+    }
+    log(level, message) {
+        if (!this.isLoggerEnabled)
+            return;
+        switch (level) {
+            case 'log':
+                this.event.log?.(logger_event_js_1.LoggerEvent.LOG, {
+                    message,
+                });
+                break;
+            case 'info':
+                this.event.verbose?.(logger_event_js_1.LoggerEvent.INFO, {
+                    message,
+                });
+                break;
+            case 'warn':
+                this.event.warn?.(logger_event_js_1.LoggerEvent.WARN, {
+                    message,
+                });
+                break;
+        }
+    }
+}
+exports.TypeORMLogger = TypeORMLogger;
+//# sourceMappingURL=typeorm-logger.js.map

package/src/typeorm-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm-logger.js","sourceRoot":"","sources":["typeorm-logger.ts"],"names":[],"mappings":";;;AACA,8CAA+C;AAE/C,uDAAgD;AAEhD,MAAa,aAAa;IAGxB,YAAoB,KAAuB;QAAvB,UAAK,GAAL,KAAK,CAAkB;QAFnC,oBAAe,GAAG,KAAK,CAAC;QAG9B,IAAI,CAAC,eAAe,GAAG,IAAA,iBAAS,EAAC,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,OAAO,CAAC,CAAC;IAC3E,CAAC;IAKD,QAAQ,CACN,KAAa,EACb,UAAkB;QAElB,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO;QAGlC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,6BAAW,CAAC,SAAS,EAAE;YACxC,IAAI,EAAE;gBACJ,KAAK;gBACL,UAAU;aACX;SACF,CAAC,CAAC;IACL,CAAC;IAID,aAAa,CACX,KAAqB,EACrB,KAAa,EACb,UAAkB;QAGlB,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO;QAGlC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,6BAAW,CAAC,WAAW,EAAE;YAC1C,IAAI,EAAE;gBACJ,KAAK;gBACL,KAAK;gBACL,UAAU;aACX;SACF,CAAC,CAAC;IACL,CAAC;IAID,YAAY,CACV,IAAY,EACZ,KAAa,EACb,UAAkB;QAGlB,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO;QAGlC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,6BAAW,CAAC,UAAU,EAAE;YACxC,OAAO,EAAE,gBAAgB;YACzB,IAAI,EAAE;gBACJ,IAAI;gBACJ,KAAK;gBACL,UAAU;aACX;SACF,CAAC,CAAC;IACL,CAAC;IAID,cAAc,CAAC,OAAe;QAC5B,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO;QAGlC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,6BAAW,CAAC,YAAY,EAAE;YAC3C,OAAO;SACR,CAAC,CAAC;IACL,CAAC;IAID,YAAY,CAAC,OAAe;QAC1B,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO;QAGlC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,6BAAW,CAAC,KAAK,EAAE;YACpC,OAAO;SACR,CAAC,CAAC;IACL,CAAC;IAKD,GAAG,CACD,KAA8B,EAC9B,OAAY;QAGZ,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO;QAElC,QAAQ,KAAK,EAAE,CAAC;YACd,KAAK,KAAK;gBAER,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,6BAAW,CAAC,GAAG,EAAE;oBAChC,OAAO;iBACR,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,MAAM;gBAET,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,6BAAW,CAAC,IAAI,EAAE;oBACrC,OAAO;iBACR,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,MAAM;gBAET,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,6BAAW,CAAC,IAAI,EAAE;oBAClC,OAAO;iBACR,CAAC,CAAC;gBACH,MAAM;QACV,CAAC;IACH,CAAC;CACF;AAvHD,sCAuHC"}

package/src/typeorm-logger.ts

@@ -0,0 +1,125 @@
+import { YalcEventService } from '@nest-yalc-2/event-manager/event.service.js';
+import { envIsTrue } from '@nest-yalc-2/utils';
+import { Logger } from 'typeorm';
+import { LoggerEvent } from './logger.event.js';
+
+export class TypeORMLogger implements Logger {
+  private isLoggerEnabled = false;
+
+  constructor(private event: YalcEventService) {
+    this.isLoggerEnabled = envIsTrue(process.env.TYPEORM_LOGGING || 'false');
+  }
+
+  /**
+   * Logs query and parameters used in it.
+   */
+  logQuery(
+    query: string,
+    parameters?: any[] /*, queryRunner?: QueryRunner*/,
+  ): any {
+    if (!this.isLoggerEnabled) return;
+
+    /* istanbul ignore next */
+    this.event.debug?.(LoggerEvent.QUERY_LOG, {
+      data: {
+        query,
+        parameters,
+      },
+    });
+  }
+  /**
+   * Logs query that is failed.
+   */
+  logQueryError(
+    error: string | Error,
+    query: string,
+    parameters?: any[],
+    // queryRunner?: QueryRunner,
+  ): any {
+    if (!this.isLoggerEnabled) return;
+
+    /* istanbul ignore next */
+    this.event.error?.(LoggerEvent.QUERY_ERROR, {
+      data: {
+        error,
+        query,
+        parameters,
+      },
+    });
+  }
+  /**
+   * Logs query that is slow.
+   */
+  logQuerySlow(
+    time: number,
+    query: string,
+    parameters?: any[],
+    // queryRunner?: QueryRunner,
+  ): any {
+    if (!this.isLoggerEnabled) return;
+
+    /* istanbul ignore next */
+    this.event.warn?.(LoggerEvent.QUERY_SLOW, {
+      message: `SLOW QUERY!!!!`,
+      data: {
+        time,
+        query,
+        parameters,
+      },
+    });
+  }
+  /**
+   * Logs events from the schema build process.
+   */
+  logSchemaBuild(message: string /* , queryRunner?: QueryRunner */): any {
+    if (!this.isLoggerEnabled) return;
+
+    /* istanbul ignore next */
+    this.event.debug?.(LoggerEvent.SCHEMA_BUILD, {
+      message,
+    });
+  }
+  /**
+   * Logs events from the migrations run process.
+   */
+  logMigration(message: string /* , queryRunner?: QueryRunner */): any {
+    if (!this.isLoggerEnabled) return;
+
+    /* istanbul ignore next */
+    this.event.debug?.(LoggerEvent.DEBUG, {
+      message,
+    });
+  }
+  /**
+   * Perform logging using given logger, or by default to the console.
+   * Log has its own level and message.
+   */
+  log(
+    level: 'log' | 'info' | 'warn',
+    message: any,
+    // queryRunner?: QueryRunner,
+  ): any {
+    if (!this.isLoggerEnabled) return;
+
+    switch (level) {
+      case 'log':
+        /* istanbul ignore next */
+        this.event.log?.(LoggerEvent.LOG, {
+          message,
+        });
+        break;
+      case 'info':
+        /* istanbul ignore next */
+        this.event.verbose?.(LoggerEvent.INFO, {
+          message,
+        });
+        break;
+      case 'warn':
+        /* istanbul ignore next */
+        this.event.warn?.(LoggerEvent.WARN, {
+          message,
+        });
+        break;
+    }
+  }
+}