@rf-logger/logger 0.0.9

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

@@ -0,0 +1,11 @@
+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;

package/dist/formats/error.format.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorFormat = void 0;
+const triple_beam_1 = require("triple-beam");
+const uuid_1 = require("uuid");
+const winston_1 = require("winston");
+function generateTraceId(error) {
+    error.traceId = (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) {
+        generateTraceId(error);
+        const meta = errorMetaGenerators.reduce((previousMeta, metaGenerator) => (Object.assign(Object.assign({}, previousMeta), metaGenerator(error))), {});
+        errorForwarders.forEach((forward) => forward(error, info, meta));
+    }
+    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 });
+        }
+        // case where the error is passed down the log context
+        let lastTraceId = null;
+        ["error", "err", "e"].forEach((prop) => {
+            const value = info[prop];
+            if (!(info[prop] instanceof Error))
+                return;
+            forwardError(value, info);
+            lastTraceId = value.traceId;
+            info[prop] = Object.assign(Object.assign({}, value), { message: `${value.name}: ${value.message}`, stack: errorForwarders.length ? undefined : info[prop].stack });
+        });
+        if (lastTraceId) {
+            info.traceId = lastTraceId;
+            return info;
+        }
+        // case where the error is passed down as second argument
+        if (info[triple_beam_1.SPLAT]) {
+            let traceId;
+            info[triple_beam_1.SPLAT].forEach((error) => {
+                if (!(error instanceof Error))
+                    return;
+                forwardError(error, info);
+                traceId = error.traceId;
+            });
+            return Object.assign(Object.assign({}, info), { traceId, stack: errorForwarders.length ? undefined : info.stack });
+        }
+        return info;
+    })();
+};
+exports.errorFormat = errorFormat;

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

@@ -0,0 +1,2 @@
+import winston from "winston";
+export declare const gcpFormat: winston.Logform.FormatWrap;

package/dist/formats/gcp.format.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gcpFormat = void 0;
+const winston_1 = __importDefault(require("winston"));
+// see https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#logseverity
+const mapWinstonLevelToGcpLevel = (level) => {
+    switch (level) {
+        case "warn":
+            return "WARNING";
+        case "http":
+        case "verbose":
+        case "silly":
+            return "DEBUG";
+    }
+    return level.toUpperCase();
+};
+exports.gcpFormat = winston_1.default.format((info) => {
+    info.severity = mapWinstonLevelToGcpLevel(info.level);
+    return info;
+});

package/dist/formats/index.d.ts

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

package/dist/formats/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });
+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");
+Object.defineProperty(exports, "simpleFormatWithTimestamp", { enumerable: true, get: function () { return simple_format_1.simpleFormatWithTimestamp; } });

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

@@ -0,0 +1,6 @@
+import winston from "winston";
+/**
+ * Like the winston.format.simple but with the timestamp in front of it.
+ * see https://github.com/winstonjs/logform/blob/master/simple.js
+ */
+export declare const simpleFormatWithTimestamp: winston.Logform.Format;

package/dist/formats/simple.format.js

@@ -0,0 +1,42 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleFormatWithTimestamp = void 0;
+const chalk_1 = require("chalk");
+const json_colorizer_1 = __importDefault(require("json-colorizer"));
+const safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify"));
+const winston_1 = __importDefault(require("winston"));
+const shift = (string, spaces = 2) => string
+    .split("\n")
+    .map((line) => " ".repeat(spaces) + line)
+    .join("\n");
+/**
+ * Like the winston.format.simple but with the timestamp in front of it.
+ * see https://github.com/winstonjs/logform/blob/master/simple.js
+ */
+exports.simpleFormatWithTimestamp = winston_1.default.format.printf((info) => {
+    const { level, message, timestamp, stack, channel } = info, rest = __rest(info, ["level", "message", "timestamp", "stack", "channel"]);
+    const context = (0, safe_stable_stringify_1.default)(rest, null, 2);
+    const padding = (info.padding && info.padding[info.level]) || "";
+    let log = `[${timestamp}] ${level}:${padding}${(channel && ` [${channel}]`) || ""} ${message}`;
+    if (context !== "{}") {
+        log += shift(`\n> ${(0, chalk_1.underline)("Context")}: ${shift((0, json_colorizer_1.default)(context)).trim()}`, 15);
+    }
+    if (stack) {
+        log += shift(`\n> ${(0, chalk_1.underline)("Stacktrace")}: ${shift(stack).trim()}`, 15);
+    }
+    return log;
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Logger } from "./logger";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+__exportStar(require("./types"), exports);

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+import type { Logger as WinstonLogger } from "winston";
+import { Options } from "./types";
+export declare class Logger {
+    private readonly options;
+    constructor(inputOptions?: Options);
+    private createLogger;
+    init: () => WinstonLogger;
+}

package/dist/logger.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const winston_1 = require("winston");
+const formats_1 = require("./formats");
+const defaultOptions = {
+    silent: false,
+    format: "json",
+    level: "silly",
+    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);
+            });
+            // displays stacktrace for warnings
+            if (this.options.handleWarnings) {
+                process.on("warning", (err) => logger.warn(err));
+            }
+            return logger;
+        };
+        this.options = Object.assign(Object.assign({}, defaultOptions), inputOptions);
+    }
+    createLogger(baseFormat) {
+        return (0, winston_1.createLogger)({
+            transports: this.options.transports || [
+                new winston_1.transports.Console({
+                    level: this.options.level,
+                    handleExceptions: true,
+                    handleRejections: true,
+                }),
+            ],
+            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),
+        });
+    }
+}
+exports.Logger = Logger;

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+import { Logger, Logform } from "winston";
+import TransportStream from "winston-transport";
+export type Options = {
+    format?: "json" | "plain";
+    silent?: boolean;
+    level?: LogLevel;
+    handleWarnings?: boolean;
+    plugins?: LoggerPlugin[];
+    transports?: TransportStream[];
+};
+/**
+ * Default Winston's logging levels,
+ * see https://github.com/winstonjs/winston#logging-levels
+ */
+export type LogLevel = "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly";
+export type ErrorLog = Error & {
+    traceId: 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 LoggerPlugin = {
+    registerFormats?: () => Logform.Format[];
+    registerInterceptors?: (logger: Logger) => void;
+    registerErrorMetaGenerators?: () => ErrorMetaGenerator[];
+    registerErrorForwarders?: () => ErrorForwarder[];
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@rf-logger/logger",
+  "files": [
+    "dist/**"
+  ],
+  "main": "dist/index.js",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "json-colorizer": "^2.2.2",
+    "safe-stable-stringify": "^2.3.1",
+    "triple-beam": "^1.3.0",
+    "uuid": "^8.3.2",
+    "winston": "^3.8.2",
+    "winston-transport": "^4.5.0"
+  },
+  "devDependencies": {
+    "@types/triple-beam": "^1.3.2",
+    "@types/uuid": "^8.3.4",
+    "ts-node": "^10.9.1"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "version": "0.0.9",
+  "scripts": {
+    "test": "jest",
+    "version": "pnpm version --no-git-tag-version"
+  }
+}