@rf-logger/logger 0.2.1 → 0.3.1

package/dist/formats/error.format.d.ts

@@ -1,11 +1,30 @@
 import { Logform } from "winston";
-import { Options } from "../types";
-/**
- * This format accepts:
- * - errors in the log message --> src.error(new Error("test"))
- * - errors in the second argument --> src.error("Something bad happened", new Error("test"))
- * - errors in the log context --> src.error("Something bad happened", { err })
- * The error message will be added to the log (either in the context, or in the message depending on the situation).
- * The exception be sent to Sentry where the Stacktrace will accessible thanks to its sourcemap.
- */
-export declare const errorFormat: (options: Options) => Logform.Format;
+import { ErrorForwarder, ErrorMetaGenerator, Options } from "../types";
+type ErrorLog = {
+    id: string;
+    parentId?: string;
+    message: string;
+    stack?: string;
+};
+export declare class ErrorFormat {
+    protected readonly format: Logform.Format;
+    protected readonly errorMetaGenerators: ErrorMetaGenerator[];
+    protected readonly errorForwarders: ErrorForwarder[];
+    /**
+     * This format accepts:
+     * - errors in the log message --> src.error(new Error("test"))
+     * - errors in the second argument --> src.error("Something bad happened", new Error("test"))
+     * - errors in the log context --> src.error("Something bad happened", { err })
+     * The error message will be added to the log (either in the context, or in the message depending on the situation).
+     * The exception be sent to Sentry where the Stacktrace will accessible thanks to its sourcemap.
+     */
+    constructor(options: Options);
+    getFormat(): Logform.Format;
+    protected errorToMessage(error: Error): string;
+    protected forwardError(error: Error, errorId: string, info: Logform.TransformableInfo): void;
+    protected formatError(error: Error): ErrorLog;
+    protected handleCauses(error: Error, errorId: string, causes?: ErrorLog[]): ErrorLog[];
+    protected formatMessageWithError(message: string, error: Error, info: Logform.TransformableInfo): Logform.TransformableInfo;
+    protected generateWinstonFormat(): Logform.Format;
+}
+export {};

package/dist/formats/error.format.js

@@ -1,68 +1,97 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorFormat = void 0;
+exports.ErrorFormat = void 0;
 const triple_beam_1 = require("triple-beam");
 const uuid_1 = require("uuid");
 const winston_1 = require("winston");
-function generateErrorId(error) {
-    error.errorId = (0, uuid_1.v4)();
-}
-/**
- * This format accepts:
- * - errors in the log message --> src.error(new Error("test"))
- * - errors in the second argument --> src.error("Something bad happened", new Error("test"))
- * - errors in the log context --> src.error("Something bad happened", { err })
- * The error message will be added to the log (either in the context, or in the message depending on the situation).
- * The exception be sent to Sentry where the Stacktrace will accessible thanks to its sourcemap.
- */
-const errorFormat = (options) => {
-    var _a;
-    const errorMetaGenerators = [];
-    const errorForwarders = [];
-    (_a = options.plugins) === null || _a === void 0 ? void 0 : _a.forEach((plugin) => {
-        plugin.registerErrorMetaGenerators &&
-            errorMetaGenerators.push(...plugin.registerErrorMetaGenerators());
-        plugin.registerErrorForwarders &&
-            errorForwarders.push(...plugin.registerErrorForwarders());
-    });
-    function forwardError(error, info) {
-        generateErrorId(error);
-        const meta = errorMetaGenerators.reduce((previousMeta, metaGenerator) => (Object.assign(Object.assign({}, previousMeta), metaGenerator(error))), {});
-        errorForwarders.forEach((forward) => forward(error, info, meta));
+class ErrorFormat {
+    format;
+    errorMetaGenerators = [];
+    errorForwarders = [];
+    /**
+     * This format accepts:
+     * - errors in the log message --> src.error(new Error("test"))
+     * - errors in the second argument --> src.error("Something bad happened", new Error("test"))
+     * - errors in the log context --> src.error("Something bad happened", { err })
+     * The error message will be added to the log (either in the context, or in the message depending on the situation).
+     * The exception be sent to Sentry where the Stacktrace will accessible thanks to its sourcemap.
+     */
+    constructor(options) {
+        options.plugins?.forEach((plugin) => {
+            plugin.registerErrorMetaGenerators &&
+                this.errorMetaGenerators.push(...plugin.registerErrorMetaGenerators());
+            plugin.registerErrorForwarders &&
+                this.errorForwarders.push(...plugin.registerErrorForwarders());
+        });
+        this.format = this.generateWinstonFormat();
+    }
+    getFormat() {
+        return this.format;
+    }
+    errorToMessage(error) {
+        return `${error.name}: ${error.message}`;
     }
-    return (0, winston_1.format)((info) => {
-        if (info instanceof Error) {
-            forwardError(info, info);
-            const message = `${info.name}: ${info.message}`;
-            return Object.assign(Object.assign({}, info), { level: info.level, [triple_beam_1.LEVEL]: info.level, message, [triple_beam_1.MESSAGE]: message, stack: errorForwarders.length ? undefined : info.stack });
+    forwardError(error, errorId, info) {
+        const meta = this.errorMetaGenerators.reduce((previousMeta, metaGenerator) => ({
+            ...previousMeta,
+            ...metaGenerator(error),
+        }), {});
+        this.errorForwarders.forEach((forward) => forward(error, errorId, info, meta));
+    }
+    formatError(error) {
+        const errorId = (0, uuid_1.v4)();
+        return {
+            id: errorId,
+            message: this.errorToMessage(error),
+            stack: this.errorForwarders.length ? undefined : error.stack,
+        };
+    }
+    handleCauses(error, errorId, causes = []) {
+        if (error.cause && error.cause instanceof Error && causes.length < 10) {
+            const causeInfo = this.formatError(error.cause);
+            causeInfo.parentId = errorId;
+            causes.push(causeInfo);
+            return this.handleCauses(error.cause, causeInfo.id, causes);
         }
-        // case where the error is passed down the log context
-        let lastErrorId = null;
-        ["error", "err", "e"].forEach((prop) => {
-            const value = info[prop];
-            if (!(info[prop] instanceof Error))
-                return;
-            forwardError(value, info);
-            lastErrorId = value.errorId;
-            info[prop] = Object.assign(Object.assign({}, value), { message: `${value.name}: ${value.message}`, stack: errorForwarders.length ? undefined : info[prop].stack });
-        });
-        if (lastErrorId) {
-            info.errorId = lastErrorId;
+        return causes;
+    }
+    formatMessageWithError(message, error, info) {
+        const errorInfo = this.formatError(error);
+        this.forwardError(error, errorInfo.id, info);
+        const causes = this.handleCauses(error, errorInfo.id);
+        return {
+            ...info,
+            level: info.level,
+            [triple_beam_1.LEVEL]: info.level,
+            message,
+            [triple_beam_1.MESSAGE]: message,
+            e: undefined,
+            err: undefined,
+            error: {
+                ...errorInfo,
+                causes: causes.length ? causes : undefined,
+            },
+        };
+    }
+    generateWinstonFormat() {
+        return (0, winston_1.format)((info) => {
+            if (info instanceof Error) {
+                return this.formatMessageWithError(this.errorToMessage(info), info, info);
+            }
+            // case where the error is passed down the log context
+            const errorFromContext = info.error || info.err || info.e;
+            if (errorFromContext instanceof Error) {
+                return this.formatMessageWithError(info.message, errorFromContext, info);
+            }
+            // case where the error is passed down as second argument
+            if (info[triple_beam_1.SPLAT]) {
+                const errorFromSplat = info[triple_beam_1.SPLAT]?.find((key) => key instanceof Error);
+                if (errorFromSplat) {
+                    return this.formatMessageWithError(info.message, errorFromSplat, info);
+                }
+            }
             return info;
-        }
-        // case where the error is passed down as second argument
-        if (info[triple_beam_1.SPLAT]) {
-            info[triple_beam_1.SPLAT].forEach((error) => {
-                if (!(error instanceof Error))
-                    return;
-                forwardError(error, info);
-                lastErrorId = error.errorId;
-            });
-            if (!lastErrorId)
-                return info;
-            return Object.assign(Object.assign({}, info), { errorId: lastErrorId, stack: errorForwarders.length ? undefined : info.stack });
-        }
-        return info;
-    })();
-};
-exports.errorFormat = errorFormat;
+        })();
+    }
+}
+exports.ErrorFormat = ErrorFormat;

package/dist/formats/index.d.ts

@@ -1,3 +1,3 @@
-export { errorFormat } from "./error.format";
+export { ErrorFormat } from "./error.format";
 export { gcpFormat } from "./gcp.format";
 export { simpleFormatWithTimestamp } from "./simple.format";

package/dist/formats/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.simpleFormatWithTimestamp = exports.gcpFormat = exports.errorFormat = void 0;
+exports.simpleFormatWithTimestamp = exports.gcpFormat = exports.ErrorFormat = void 0;
 var error_format_1 = require("./error.format");
-Object.defineProperty(exports, "errorFormat", { enumerable: true, get: function () { return error_format_1.errorFormat; } });
+Object.defineProperty(exports, "ErrorFormat", { enumerable: true, get: function () { return error_format_1.ErrorFormat; } });
 var gcp_format_1 = require("./gcp.format");
 Object.defineProperty(exports, "gcpFormat", { enumerable: true, get: function () { return gcp_format_1.gcpFormat; } });
 var simple_format_1 = require("./simple.format");

package/dist/formats/simple.format.js

@@ -1,15 +1,4 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -29,7 +18,7 @@ const shift = (string, spaces = 2) => string
  * see https://github.com/winstonjs/logform/blob/master/simple.js
  */
 exports.simpleFormatWithTimestamp = winston_1.default.format.printf((info) => {
-    const { level, message, timestamp, stack, channel, nestContext } = info, rest = __rest(info, ["level", "message", "timestamp", "stack", "channel", "nestContext"]);
+    const { level, message, timestamp, stack, channel, nestContext, ...rest } = info;
     const context = (0, safe_stable_stringify_1.default)(rest, null, 2);
     let log = `[${timestamp}] ${level}:`;
     if (info.padding)

package/dist/logger.js

@@ -14,28 +14,24 @@ const defaultOptions = {
     handleWarnings: true,
 };
 class Logger {
+    options;
     constructor(inputOptions) {
-        this.init = () => {
-            const logger = this.createLogger();
-            // displays stacktrace for warnings
-            if (this.options.handleWarnings) {
-                process.on("warning", (err) => logger.warn(err));
-            }
-            return logger;
+        this.options = {
+            ...defaultOptions,
+            ...inputOptions,
         };
-        this.options = Object.assign(Object.assign({}, defaultOptions), inputOptions);
     }
     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) => {
+        const errorFormat = new formats_1.ErrorFormat(this.options);
+        const formats = [errorFormat.getFormat()];
+        this.options.plugins?.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) => {
+        this.options.plugins?.forEach((plugin) => {
             if (!plugin.registerExitHandlers)
                 return;
             exitHandlers = plugin.registerExitHandlers();
@@ -67,10 +63,18 @@ class Logger {
             logger.on("finish", exitHandler);
         }
         // register interceptors
-        (_c = this.options.plugins) === null || _c === void 0 ? void 0 : _c.forEach((plugin) => {
+        this.options.plugins?.forEach((plugin) => {
             plugin.registerInterceptors && plugin.registerInterceptors(logger);
         });
         return logger;
     }
+    init = () => {
+        const logger = this.createLogger();
+        // displays stacktrace for warnings
+        if (this.options.handleWarnings) {
+            process.on("warning", (err) => logger.warn(err));
+        }
+        return logger;
+    };
 }
 exports.Logger = Logger;

package/dist/transports/CustomConsoleTransport.js

@@ -11,10 +11,7 @@ const winston_1 = require("winston");
  * 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;
-    }
+    _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

package/dist/transports/ExceptionHandlerTransport.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Writable } from "stream";
 import { transports } from "winston";
 import { ExitHandler } from "../types";

package/dist/transports/ExceptionHandlerTransport.js

@@ -8,11 +8,12 @@ const winston_1 = require("winston");
  * to wait for exit handlers to be processed before emitting a finish event.
  */
 class ExceptionHandlerTransport extends winston_1.transports.Stream {
+    exitHandlers;
+    _ending = false;
+    _stream = new stream_1.Writable();
     constructor(exitHandlers, options) {
-        super(Object.assign(Object.assign({}, options), { stream: new stream_1.Writable() }));
+        super({ ...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();

package/dist/types.d.ts

@@ -11,13 +11,10 @@ export type Options = {
     plugins?: LoggerPlugin[];
     transports?: transport[];
 };
-export type ErrorLog = Error & {
-    errorId: string;
-};
 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 ErrorMetaGenerator = (error: Error) => ErrorMeta;
+export type ErrorForwarder = (error: Error, errorId: string, info: Logform.TransformableInfo, meta: ErrorMeta) => void;
 export type ExitHandler = () => Promise<void>;
 export type LoggerPlugin = {
     registerFormats?: () => Logform.Format[];

package/package.json

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