@villedemontreal/logger 6.5.1

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@villedemontreal/logger",
+  "version": "6.5.1",
+  "description": "Logger and logging utilities",
+  "main": "dist/src/index.js",
+  "typings": "dist/src",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "scripts": {
+    "start": "node run test",
+    "test": "node run test",
+    "compile": "node run compile",
+    "lint": "node run lint",
+    "lint-fix": "node run lint-fix",
+    "tslint": "node run tslint",
+    "tslint-fix": "node run tslint-fix",
+    "prettier": "node run prettier",
+    "prettier-fix": "node run prettier-fix",
+    "watch": "node run watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/villedemontreal/node-logger.git"
+  },
+  "homepage": "https://github.com/villedemontreal/node-logger",
+  "keywords": [
+    "montreal",
+    "utils",
+    "utilities",
+    "logging",
+    "log",
+    "logger"
+  ],
+  "author": "Ville de Montréal",
+  "license": "MIT",
+  "dependencies": {
+    "@types/app-root-path": "1.2.4",
+    "@types/lodash": "4.14.178",
+    "@types/pino": "6.3.5",
+    "@types/pino-multi-stream": "5.1.0",
+    "@types/source-map-support": "0.5.4",
+    "@villedemontreal/general-utils": "5.16.0",
+    "app-root-path": "3.0.0",
+    "lodash": "4.17.21",
+    "pino": "6.11.0",
+    "pino-multi-stream": "5.2.0",
+    "pino-pretty": "4.5.0",
+    "rotating-file-stream": "3.0.2",
+    "source-map-support": "0.5.21",
+    "uuid": "8.3.2"
+  },
+  "devDependencies": {
+    "@types/chai": "4.3.0",
+    "@types/fs-extra": "9.0.13",
+    "@types/mocha": "9.0.0",
+    "@villedemontreal/lint-config": "1.7.6",
+    "@villedemontreal/scripting": "1.5.0",
+    "chai": "4.3.4",
+    "fs-extra": "9.1.0",
+    "mocha": "9.1.3",
+    "mocha-jenkins-reporter": "0.4.7",
+    "tslint": "6.1.2",
+    "typescript": "3.9.5"
+  }
+}

package/src/config/configs.ts

@@ -0,0 +1,195 @@
+import { globalConstants } from '@villedemontreal/general-utils';
+import { LogLevel } from '../logger';
+
+/**
+ * Logger Config
+ */
+export class LoggerConfigs {
+  /**
+   * The correlation id provider.
+   * To set this is required.
+   */
+  private correlationIdProvider: () => string = null;
+
+  /**
+   * Enable logging to a file.
+   * Default to false.
+   */
+  private logToFile: boolean = false;
+
+  /**
+   * The directory where the potential
+   * log file will be written.
+   * Default to "./log".
+   */
+  private logDir: string = './log';
+
+  /**
+   * Log rotation file nb
+   */
+  private logRotateFilesNbr: number = 30;
+
+  /**
+   * Log rotation threshhold in MB
+   */
+  private logRotateThresholdMB: number = 100;
+
+  /**
+   * Log maximum total size in MB
+   */
+  private logRotateMaxTotalSizeMB: number = 1000;
+
+  /**
+   * Logging level (info, debug, warning, error)
+   *
+   * Default value : DEBUG in DEV or WARNING otherwise.
+   */
+  private logLevel: LogLevel =
+    process.env.NODE_ENV === globalConstants.Environments.DEV ? LogLevel.DEBUG : LogLevel.WARNING;
+
+  /**
+   * Log in human readable form in the console.
+   */
+  private logHumanReadableinConsole: boolean = false;
+
+  /**
+   * Add the stack trace to the error log in development
+   */
+  private addStackTraceToErrorMessagesInDev: boolean =
+    process.env.NODE_ENV === globalConstants.Environments.DEV ? true : false;
+
+  /**
+   * Log the source of the error in the log message
+   */
+  private logSource: boolean = true;
+
+  /**
+   * The Correlation Id provider is required.
+   */
+  constructor(correlationIdProvider: () => string) {
+    if (!correlationIdProvider) {
+      throw new Error(`The Correlation Id provider is required.`);
+    }
+
+    this.correlationIdProvider = correlationIdProvider;
+  }
+
+  /**
+   * The current Correlation Id.
+   */
+  get correlationId() {
+    return this.correlationIdProvider();
+  }
+
+  /**
+   * Logging to a file?
+   */
+  public isLogToFile() {
+    return this.logToFile;
+  }
+
+  /**
+   * Get the directory where the log files should be written
+   */
+  public getLogDirectory() {
+    return this.logDir;
+  }
+
+  /**
+   * Get the current logging level
+   */
+  public getLogLevel() {
+    return this.logLevel;
+  }
+
+  public isLogHumanReadableinConsole() {
+    return this.logHumanReadableinConsole;
+  }
+
+  public isAddStackTraceToErrorMessagesInDev() {
+    return this.addStackTraceToErrorMessagesInDev;
+  }
+
+  public isLogSource() {
+    return this.logSource;
+  }
+
+  public getLogRotateFilesNbr() {
+    return this.logRotateFilesNbr;
+  }
+
+  public getLogRotateThresholdMB() {
+    return this.logRotateThresholdMB;
+  }
+
+  public getLogRotateMaxTotalSizeMB() {
+    return this.logRotateMaxTotalSizeMB;
+  }
+
+  /**
+   * Enable logging to a file in addition to
+   * logging to the standard output.
+   * This should probably be let to FALSE in our
+   * current network where Graylog is used : no
+   * log files are indeed required!
+   */
+  public setSlowerLogToFileToo(logToFile: boolean) {
+    this.logToFile = logToFile;
+  }
+
+  /**
+   * Set the directory where the log files should be written
+   */
+  public setLogDirectory(logDir: string) {
+    this.logDir = logDir;
+  }
+
+  /**
+   * Set the logging level
+   */
+  public setLogLevel(loglevel: LogLevel) {
+    this.logLevel = loglevel;
+  }
+
+  /**
+   * Set the logs in the console to be human readable
+   */
+  public setLogHumanReadableinConsole(logHumanReadableinConsole: boolean) {
+    this.logHumanReadableinConsole = logHumanReadableinConsole;
+  }
+
+  /**
+   * Set the stack trace to be logged in development environment
+   */
+  public setAddStackTraceToErrorMessagesInDev(addStackTraceToErrorMessagesInDev: boolean) {
+    this.addStackTraceToErrorMessagesInDev = addStackTraceToErrorMessagesInDev;
+  }
+
+  /**
+   * Set if the source of the error should be logged
+   */
+  public setLogSource(logSource: boolean) {
+    this.logSource = logSource;
+  }
+
+  /**
+   * Set the number of log files to rotate
+   */
+  public setLogRotateFilesNbr(logRotateFilesNb: number) {
+    this.logRotateFilesNbr = logRotateFilesNb;
+  }
+
+  /**
+   * Set the log rotation threshhold.
+   */
+  public setLogRotateThresholdMB(logRotateThresholdMB: number) {
+    this.logRotateThresholdMB = logRotateThresholdMB;
+  }
+
+  /**
+   * Set the maximum total size of the logfile
+   */
+  public setLogRotateMaxTotalSizeMB(logRotateMaxTotalSizeMB: number) {
+    this.logRotateMaxTotalSizeMB = logRotateMaxTotalSizeMB;
+  }
+}

package/src/config/constants.ts

@@ -0,0 +1,78 @@
+import { path as appRoot } from 'app-root-path';
+import * as path from 'path';
+
+/**
+ * Library constants
+ */
+export class Constants {
+  /**
+   * The library root. When this library is used
+   * as a dependency in a project, the "libRoot"
+   * will be the path to the dependency folder,
+   * inside the "node_modules".
+   */
+  public libRoot: string;
+
+  /**
+   * The app root. When this library is used
+   * as a dependency in a project, the "appRoot"
+   * will be the path to the root project!
+   */
+  public appRoot: string;
+
+  constructor() {
+    // From the "dist/src/config" folder
+    this.libRoot = path.normalize(__dirname + '/../../..');
+    this.appRoot = appRoot;
+  }
+
+  /**
+   * Logging constants
+   */
+  get logging() {
+    return {
+      /**
+       * The properties that can be added to a log entry.
+       */
+      properties: {
+        /**
+         * The type of log. Those types are specified in
+         * the following "logType" section.
+         */
+        LOG_TYPE: 'logType',
+
+        /**
+         * The version of the log type.
+         */
+        LOG_TYPE_VERSION: 'logTypeVersion',
+
+        /**
+         * "Nom du composant logiciel"
+         */
+        APP_NAME: 'app',
+
+        /**
+         * "Version du composant logiciel"
+         */
+        APP_VERSION: 'version',
+
+        /**
+         * Correlation id
+         */
+        CORRELATION_ID: 'cid'
+      },
+
+      /**
+       * The types of logs
+       */
+      logType: {
+        /**
+         * The type for our Ville de Montréal logs.
+         */
+        MONTREAL: 'mtl'
+      }
+    };
+  }
+}
+
+export let constants: Constants = new Constants();

package/src/consoleStream.ts

@@ -0,0 +1,29 @@
+import { Stream } from 'stream';
+const prettyStream = require('bunyan-prettystream-circularsafe');
+
+export class ConsoleStream extends Stream {
+  private prettyStdOut: any;
+  private isLogHumanReadableinConsole: boolean;
+
+  constructor(isLogHumanReadableinConsole: boolean) {
+    super();
+    this.isLogHumanReadableinConsole = isLogHumanReadableinConsole;
+    this.prettyStdOut = new prettyStream();
+    this.prettyStdOut.pipe(process.stdout);
+  }
+
+  public write(data: any): void {
+    // Using human readable format?
+    if (this.isLogHumanReadableinConsole) {
+      this.prettyStdOut.write(data);
+    } else {
+      let dataClean = data;
+      if (typeof dataClean !== 'string') {
+        dataClean = JSON.stringify(dataClean);
+      }
+      dataClean += '\n';
+
+      process.stdout.write(dataClean);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './config/configs';
+export * from './logger';
+export * from './lazyLogger';

package/src/lazyLogger.ts

@@ -0,0 +1,50 @@
+import { ILogger, LogLevel } from './logger';
+
+/**
+ * A Logger wrapper that allows to lazyly create a
+ * real Logger.
+ *
+ * The first time a log is perform, the
+ * "loggerCreator" will be called to create
+ * the actual Logger.
+ */
+export class LazyLogger implements ILogger {
+  private realLogger: ILogger;
+  private name: string;
+  private loggerCreator: (name: string) => ILogger;
+
+  constructor(name: string, loggerCreator: (name: string) => ILogger) {
+    this.name = name;
+
+    if (!loggerCreator) {
+      throw new Error(`The Logger Creator is required!`);
+    }
+    this.loggerCreator = loggerCreator;
+  }
+
+  public debug(messageObj: any, txtMsg?: string): void {
+    return this.getRealLogger().debug(messageObj, txtMsg);
+  }
+  public info(messageObj: any, txtMsg?: string): void {
+    return this.getRealLogger().info(messageObj, txtMsg);
+  }
+  public warning(messageObj: any, txtMsg?: string): void {
+    return this.getRealLogger().warning(messageObj, txtMsg);
+  }
+  public error(messageObj: any, txtMsg?: string): void {
+    return this.getRealLogger().error(messageObj, txtMsg);
+  }
+  public log(level: LogLevel, messageObj: any, txtMsg?: string): void {
+    return this.getRealLogger().log(level, messageObj, txtMsg);
+  }
+
+  protected getRealLogger(): ILogger {
+    if (!this.realLogger) {
+      this.realLogger = this.loggerCreator(this.name);
+      if (!this.realLogger) {
+        throw new Error(`The Logger Creator must create a valid Logger!`);
+      }
+    }
+    return this.realLogger;
+  }
+}