@rf-logger/logger 0.1.5 → 0.1.6

package/dist/logFormat.js

@@ -5,4 +5,4 @@ var LogFormatEnum;
 (function (LogFormatEnum) {
     LogFormatEnum["Json"] = "json";
     LogFormatEnum["Plain"] = "plain";
-})(LogFormatEnum = exports.LogFormatEnum || (exports.LogFormatEnum = {}));
+})(LogFormatEnum || (exports.LogFormatEnum = LogFormatEnum = {}));

package/dist/logLevel.js

@@ -14,4 +14,4 @@ var LogLevelEnum;
     LogLevelEnum["Verbose"] = "verbose";
     LogLevelEnum["Debug"] = "debug";
     LogLevelEnum["Silly"] = "silly";
-})(LogLevelEnum = exports.LogLevelEnum || (exports.LogLevelEnum = {}));
+})(LogLevelEnum || (exports.LogLevelEnum = LogLevelEnum = {}));

package/dist/logger.js

@@ -3,25 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const winston_1 = require("winston");
 const formats_1 = require("./formats");
+const ExceptionHandlerTransport_1 = require("./transports/ExceptionHandlerTransport");
+const CustomConsoleTransport_1 = require("./transports/CustomConsoleTransport");
 const defaultOptions = {
     silent: false,
     format: "json",
     level: "silly",
+    handleExceptions: true,
+    handleRejections: true,
     handleWarnings: true,
 };
 class Logger {
     constructor(inputOptions) {
         this.init = () => {
-            var _a, _b;
-            const formats = [(0, formats_1.errorFormat)(this.options)];
-            (_a = this.options.plugins) === null || _a === void 0 ? void 0 : _a.forEach((plugin) => {
-                plugin.registerFormats && formats.push(...plugin.registerFormats());
-            });
-            const baseFormat = winston_1.format.combine(...formats);
-            const logger = this.createLogger(baseFormat);
-            (_b = this.options.plugins) === null || _b === void 0 ? void 0 : _b.forEach((plugin) => {
-                plugin.registerInterceptors && plugin.registerInterceptors(logger);
-            });
+            const logger = this.createLogger();
             // displays stacktrace for warnings
             if (this.options.handleWarnings) {
                 process.on("warning", (err) => logger.warn(err));
@@ -30,20 +25,52 @@ class Logger {
         };
         this.options = Object.assign(Object.assign({}, defaultOptions), inputOptions);
     }
-    createLogger(baseFormat) {
-        return (0, winston_1.createLogger)({
+    createLogger() {
+        var _a, _b, _c;
+        // register formats
+        const formats = [(0, formats_1.errorFormat)(this.options)];
+        (_a = this.options.plugins) === null || _a === void 0 ? void 0 : _a.forEach((plugin) => {
+            plugin.registerFormats && formats.push(...plugin.registerFormats());
+        });
+        const baseFormat = winston_1.format.combine(...formats);
+        // register exit handlers
+        let exitHandlers = [];
+        (_b = this.options.plugins) === null || _b === void 0 ? void 0 : _b.forEach((plugin) => {
+            if (!plugin.registerExitHandlers)
+                return;
+            exitHandlers = plugin.registerExitHandlers();
+        });
+        // create logger
+        const logger = (0, winston_1.createLogger)({
             transports: this.options.transports || [
-                new winston_1.transports.Console({
+                new CustomConsoleTransport_1.CustomConsoleTransport({
                     level: this.options.level,
-                    handleExceptions: true,
-                    handleRejections: true,
+                    handleExceptions: this.options.handleExceptions,
+                    handleRejections: this.options.handleRejections,
                 }),
             ],
             silent: this.options.silent,
             format: this.options.format === "json"
                 ? winston_1.format.combine(baseFormat, (0, formats_1.gcpFormat)(), winston_1.format.json())
                 : winston_1.format.combine(baseFormat, winston_1.format.timestamp({ format: "HH:mm:ss.SSS" }), winston_1.format.colorize(), formats_1.simpleFormatWithTimestamp),
+            // execute exit handlers when catching an exception
+            exceptionHandlers: this.options.handleExceptions && [
+                new ExceptionHandlerTransport_1.ExceptionHandlerTransport(exitHandlers),
+            ],
+            // execute exit handlers when catching a rejection
+            rejectionHandlers: this.options.handleRejections && [
+                new ExceptionHandlerTransport_1.ExceptionHandlerTransport(exitHandlers),
+            ],
+        });
+        // execute exit handlers when closing the logger
+        for (const exitHandler of exitHandlers) {
+            logger.on("finish", exitHandler);
+        }
+        // register interceptors
+        (_c = this.options.plugins) === null || _c === void 0 ? void 0 : _c.forEach((plugin) => {
+            plugin.registerInterceptors && plugin.registerInterceptors(logger);
         });
+        return logger;
     }
 }
 exports.Logger = Logger;

package/dist/transports/CustomConsoleTransport.d.ts

@@ -0,0 +1,14 @@
+import { transports } from "winston";
+/**
+ * This is an override of the Console transport that emits a "finish" event
+ * as soon as the transport is closed by the exception handler, see
+ * https://github.com/winstonjs/winston/blob/91ec06961d2cc9a522f65c023cd02871aa6d97b2/lib/winston/exception-handler.js#L215C10-L215C10
+ * Its only goal is to improve the default Console transport in order for the NodeJS process
+ * to not wait the full 3 seconds timeout before exiting, see
+ * https://github.com/winstonjs/winston/blob/91ec06961d2cc9a522f65c023cd02871aa6d97b2/lib/winston/exception-handler.js#L225C10-L225C11
+ */
+export declare class CustomConsoleTransport extends transports.Console {
+    protected _ending: boolean;
+    log(info: any, next: () => void): any;
+    private finishIfEnding;
+}

package/dist/transports/CustomConsoleTransport.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomConsoleTransport = void 0;
+const winston_1 = require("winston");
+/**
+ * This is an override of the Console transport that emits a "finish" event
+ * as soon as the transport is closed by the exception handler, see
+ * https://github.com/winstonjs/winston/blob/91ec06961d2cc9a522f65c023cd02871aa6d97b2/lib/winston/exception-handler.js#L215C10-L215C10
+ * Its only goal is to improve the default Console transport in order for the NodeJS process
+ * to not wait the full 3 seconds timeout before exiting, see
+ * https://github.com/winstonjs/winston/blob/91ec06961d2cc9a522f65c023cd02871aa6d97b2/lib/winston/exception-handler.js#L225C10-L225C11
+ */
+class CustomConsoleTransport extends winston_1.transports.Console {
+    constructor() {
+        super(...arguments);
+        this._ending = false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    log(info, next) {
+        // @ts-expect-error The log function is defined for the Console transport
+        super.log(info, next);
+        this.finishIfEnding();
+    }
+    finishIfEnding() {
+        if (this._ending) {
+            this.emit("finish");
+        }
+    }
+}
+exports.CustomConsoleTransport = CustomConsoleTransport;

package/dist/transports/ExceptionHandlerTransport.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Writable } from "stream";
+import { transports } from "winston";
+import { ExitHandler } from "../types";
+/**
+ * This is a custom winston transport made to act as an exception handler and
+ * to wait for exit handlers to be processed before emitting a finish event.
+ */
+export declare class ExceptionHandlerTransport extends transports.Stream {
+    private exitHandlers;
+    protected _ending: boolean;
+    protected _stream: Writable;
+    constructor(exitHandlers: ExitHandler[], options?: transports.StreamTransportOptions);
+    private finishIfEnding;
+}

package/dist/transports/ExceptionHandlerTransport.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionHandlerTransport = void 0;
+const stream_1 = require("stream");
+const winston_1 = require("winston");
+/**
+ * This is a custom winston transport made to act as an exception handler and
+ * to wait for exit handlers to be processed before emitting a finish event.
+ */
+class ExceptionHandlerTransport extends winston_1.transports.Stream {
+    constructor(exitHandlers, options) {
+        super(Object.assign(Object.assign({}, options), { stream: new stream_1.Writable() }));
+        this.exitHandlers = exitHandlers;
+        this._ending = false;
+        this._stream = new stream_1.Writable();
+        this._stream._write = (chunk, encoding, callback) => {
+            this.finishIfEnding();
+            callback();
+        };
+    }
+    finishIfEnding() {
+        if (this._ending) {
+            this._stream.once("finish", () => this.emit("finish"));
+            void Promise.all(this.exitHandlers.map((h) => h())).then(() => this._stream.end());
+        }
+    }
+}
+exports.ExceptionHandlerTransport = ExceptionHandlerTransport;

package/dist/types.d.ts

@@ -5,6 +5,8 @@ export type Options = {
     format?: LogFormat;
     silent?: boolean;
     level?: LogLevel;
+    handleExceptions?: boolean;
+    handleRejections?: boolean;
     handleWarnings?: boolean;
     plugins?: LoggerPlugin[];
     transports?: transport[];
@@ -16,9 +18,11 @@ export type ErrorMetaDeep = Record<string, string>;
 export type ErrorMeta = Record<string, string | ErrorMetaDeep>;
 export type ErrorMetaGenerator = (error: ErrorLog) => ErrorMeta;
 export type ErrorForwarder = (error: ErrorLog, info: Logform.TransformableInfo, meta: ErrorMeta) => void;
+export type ExitHandler = () => Promise<void>;
 export type LoggerPlugin = {
     registerFormats?: () => Logform.Format[];
     registerInterceptors?: (logger: Logger) => void;
     registerErrorMetaGenerators?: () => ErrorMetaGenerator[];
     registerErrorForwarders?: () => ErrorForwarder[];
+    registerExitHandlers?: () => ExitHandler[];
 };

package/package.json

@@ -21,7 +21,7 @@
   "engines": {
     "node": ">=16.0.0"
   },
-  "version": "0.1.5",
+  "version": "0.1.6",
   "scripts": {
     "test": "jest",
     "version": "pnpm version --no-git-tag-version"