@factorypure/logger 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { AsyncLocalStorage } from "async_hooks";
+import { CloudWatchLogs } from "../node_modules/@aws-sdk/client-cloudwatch-logs/dist-types/CloudWatchLogs";
+import Notify from "../node_modules/fpnotifications-client/dist/index";
+import { NextFunction, Request, Response } from "express";
+declare class LogStream {
+    #private;
+    logStreamName: string;
+    initialized: boolean;
+    logger: LoggerClient;
+    constructor(logger: LoggerClient, logStreamName: string);
+    info: (...messages: any[]) => void;
+    warn: (...messages: any[]) => void;
+    error: (...errors: any[]) => void;
+    fatal: (error: Error, failureDescription?: string) => void;
+}
+export default class LoggerClient {
+    #private;
+    logGroupName: string;
+    initialized: boolean;
+    cloudWatchClient?: CloudWatchLogs;
+    asyncLocalStorage?: AsyncLocalStorage<string>;
+    notifyClient?: Notify;
+    fatalErrorSlackChannel: string;
+    constructor({ logGroupName, cloudWatchClient, asyncLocalStorage, notifyClient, fatalErrorSlackChannel }: LoggerOptions);
+    createLogStream(logStreamName: string): LogStream;
+}
+type LoggerOptions = {
+    logGroupName: string;
+    cloudWatchClient: CloudWatchLogs;
+    asyncLocalStorage?: AsyncLocalStorage<any>;
+    notifyClient?: Notify;
+    fatalErrorSlackChannel: string;
+};
+export declare const attachRequestId: (asyncLocalStorage: AsyncLocalStorage<any>) => (req: Request, _res: Response, next: NextFunction) => void;
+export declare const logCrashes: () => void;
+export declare const reportCrashes: (logger: LogStream) => void;
+export {};

package/dist/index.js

@@ -0,0 +1,197 @@
+import fs from "fs";
+class LogStream {
+    logStreamName;
+    initialized;
+    logger;
+    constructor(logger, logStreamName) {
+        this.logger = logger;
+        this.logStreamName = logStreamName;
+        this.initialized = false;
+    }
+    async #init() {
+        await this.#createLogStream();
+        this.initialized = true;
+    }
+    async #createLogStream() {
+        let failed = false;
+        await this.logger.cloudWatchClient?.createLogStream({
+            logGroupName: this.logger.logGroupName,
+            logStreamName: this.logStreamName,
+        }).catch((err) => {
+            if (err.__type !== 'ResourceAlreadyExistsException') {
+                console.error(err);
+                failed = true;
+            }
+        });
+        if (!failed) {
+            this.initialized = true;
+        }
+    }
+    info = (...messages) => {
+        const requestId = this.logger.asyncLocalStorage?.getStore();
+        if (!this.initialized) {
+            this.#init().then(() => this.info(...messages)).catch(console.error);
+            return;
+        }
+        for (const message of messages) {
+            const formattedMessage = `[INFO]${requestId ? ` (${requestId})` : ''} ${this.#stringify(message)}`;
+            console.log(new Date().toISOString(), formattedMessage);
+            this.#putEvent(formattedMessage);
+        }
+    };
+    warn = (...messages) => {
+        const requestId = this.logger.asyncLocalStorage?.getStore();
+        if (!this.initialized) {
+            this.#init().then(() => this.info(...messages)).catch(console.error);
+            return;
+        }
+        for (const message of messages) {
+            const formattedMessage = `[WARNING]${requestId ? ` (${requestId})` : ''} ${this.#stringify(message)}`;
+            console.warn(new Date().toISOString(), formattedMessage);
+            this.#putEvent(formattedMessage);
+        }
+    };
+    error = (...errors) => {
+        const requestId = this.logger.asyncLocalStorage?.getStore();
+        if (!this.initialized) {
+            this.#init().then(() => this.error(...errors)).catch(console.error);
+            return;
+        }
+        for (const error of errors) {
+            const formattedError = typeof error === 'string' ? { message: error, stack: 'No stack provided.' } : error;
+            const formattedMessage = `[ERROR]${requestId ? ` (${requestId})` : ''} ${formattedError.message}\n${formattedError.stack}`;
+            console.error(new Date().toISOString(), formattedMessage);
+            this.#putEvent(formattedMessage);
+        }
+    };
+    fatal = (error, failureDescription) => {
+        const requestId = this.logger.asyncLocalStorage?.getStore();
+        if (failureDescription) {
+            error.message = `${failureDescription}\n${error.message}`;
+        }
+        this.error(error);
+        this.#sendNotifications({
+            channels: [this.logger.fatalErrorSlackChannel],
+            text: `[${this.logger.logGroupName}]${requestId ? ` (${requestId})` : ''} ${error.message}\n${error.stack}`,
+            mrkdwn: '',
+            store_id: 1,
+        });
+    };
+    async #putEvent(message) {
+        if (this.logger.cloudWatchClient) {
+            return this.logger.cloudWatchClient.putLogEvents({
+                logGroupName: this.logger.logGroupName,
+                logStreamName: this.logStreamName,
+                logEvents: [
+                    {
+                        message,
+                        timestamp: Date.now(),
+                    },
+                ],
+            }).catch(console.error);
+        }
+    }
+    async #sendNotifications(options) {
+        if (this.logger.notifyClient) {
+            this.logger.notifyClient.slack.dm(options);
+        }
+    }
+    #stringify(item) {
+        if (typeof item === 'object') {
+            return JSON.stringify(item, null, 2);
+        }
+        return item;
+    }
+}
+export default class LoggerClient {
+    logGroupName;
+    initialized;
+    cloudWatchClient;
+    asyncLocalStorage;
+    notifyClient;
+    fatalErrorSlackChannel;
+    constructor({ logGroupName, cloudWatchClient, asyncLocalStorage, notifyClient, fatalErrorSlackChannel = 'fatal-error-log' }) {
+        this.logGroupName = logGroupName;
+        this.initialized = false;
+        this.cloudWatchClient = cloudWatchClient;
+        this.asyncLocalStorage = asyncLocalStorage;
+        this.notifyClient = notifyClient;
+        this.fatalErrorSlackChannel = fatalErrorSlackChannel;
+        this.#init();
+        return this;
+    }
+    async #init() {
+        await this.#createLogGroup();
+        this.initialized = true;
+    }
+    createLogStream(logStreamName) {
+        return new LogStream(this, logStreamName);
+    }
+    async #createLogGroup() {
+        let failed = false;
+        await this.cloudWatchClient?.createLogGroup({
+            logGroupName: this.logGroupName,
+        }).catch((err) => {
+            if (err.__type !== 'ResourceAlreadyExistsException') {
+                console.error(err);
+                failed = true;
+            }
+        });
+        if (!failed) {
+            this.initialized = true;
+        }
+    }
+}
+export const attachRequestId = (asyncLocalStorage) => {
+    return (req, _res, next) => {
+        const availableCharacters = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0987654321";
+        let id = "";
+        while (id.length < 20) {
+            id +=
+                availableCharacters[Math.floor(Math.random() * availableCharacters.length)];
+        }
+        req.headers["X-Request-Id"] = id;
+        asyncLocalStorage.run(id, next);
+    };
+};
+export const logCrashes = () => {
+    process.on('uncaughtException', (err) => {
+        console.error(err);
+        fs.writeFileSync('./uncaughtErrors.txt', `${err.message}\n${err.stack}\n`, { flag: 'a' });
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        if (reason instanceof Error) {
+            console.error(reason);
+            fs.writeFileSync('./uncaughtErrors.txt', `${reason.message}\n${reason.stack}\n`, { flag: 'a' });
+        }
+        else if (typeof reason === 'string') {
+            console.error(reason);
+            fs.writeFileSync('./uncaughtErrors.txt', `${reason}\n`, { flag: 'a' });
+        }
+        else if (typeof reason === 'object') {
+            console.error(reason);
+            fs.writeFileSync('./uncaughtErrors.txt', `${JSON.stringify(reason, null, 2)}\n`, { flag: 'a' });
+        }
+        else if (reason === false || reason === 0 || reason) {
+            console.error(reason);
+            fs.writeFileSync('./uncaughtErrors.txt', `${JSON.stringify(reason, null, 2)}\n`, { flag: 'a' });
+        }
+        else {
+            console.error(promise);
+            fs.writeFileSync('./uncaughtErrors.txt', `Promise rejected with no reason provided\n`, { flag: 'a' });
+        }
+        process.exit(1);
+    });
+};
+export const reportCrashes = (logger) => {
+    if (!logger) {
+        return;
+    }
+    fs.writeFileSync('./uncaughtErrors.txt', '', { flag: 'a' });
+    const errors = fs.readFileSync('./uncaughtErrors.txt').toString();
+    if (errors.length) {
+        logger.fatal(new Error(errors), 'Server crash detected!');
+    }
+    fs.writeFileSync('./uncaughtErrors.txt', '');
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@factorypure/logger",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "./dist"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@aws-sdk/client-cloudwatch-logs": "^3.665.0",
+    "@aws-sdk/types": "^3.664.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^20.16.10",
+    "fpnotifications-client": "^1.0.6",
+    "typescript": "^5.6.2"
+  }
+}