nextrans-logger 0.2.20 → 0.3.0

package/dist/cloudwatch.d.ts

@@ -0,0 +1,25 @@
+import { LoggerContract, LogMeta } from './logger.contract';
+export interface CloudwatchOptions {
+    logGroupName: string;
+    logStreamName: string;
+    region: string;
+    credentials: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+}
+export declare class Cloudwatch implements LoggerContract {
+    private client;
+    private sequenceToken;
+    private DEFAULT_LOG_CONFIG;
+    constructor(options: CloudwatchOptions);
+    private _formatMessage;
+    private _send;
+    log(message: LogMeta): void;
+    info(message: LogMeta): void;
+    error(message: LogMeta): void;
+    fatal(message: LogMeta): void;
+    warn(message: LogMeta): void;
+    debug(message: LogMeta): void;
+    verbose(message: LogMeta): void;
+}

package/dist/cloudwatch.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cloudwatch = void 0;
+const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
+const crypto_1 = require("crypto");
+class Cloudwatch {
+    client;
+    sequenceToken;
+    DEFAULT_LOG_CONFIG;
+    constructor(options) {
+        this.client = new client_cloudwatch_logs_1.CloudWatchLogsClient({
+            region: options.region,
+            credentials: {
+                accessKeyId: options.credentials.accessKeyId,
+                secretAccessKey: options.credentials.secretAccessKey,
+            },
+        });
+        if (options.logGroupName && options.logStreamName) {
+            this.DEFAULT_LOG_CONFIG = {
+                logGroupName: options.logGroupName,
+                logStreamName: options.logStreamName,
+            };
+        }
+    }
+    _formatMessage(message) {
+        let formattedMessage = `[${message.level.toUpperCase()}][${message?.host}]  `;
+        return (formattedMessage +
+            message.message
+                .map(([type, value]) => value)
+                .filter((d) => d)
+                .join('\n  '));
+    }
+    async _send(message, retry = true) {
+        if (!this.client || !this.DEFAULT_LOG_CONFIG)
+            return;
+        try {
+            const command = new client_cloudwatch_logs_1.PutLogEventsCommand({
+                ...this.DEFAULT_LOG_CONFIG,
+                logEvents: [
+                    {
+                        timestamp: Date.now(),
+                        message: this._formatMessage(message),
+                    },
+                ],
+                sequenceToken: this.sequenceToken ?? (0, crypto_1.randomUUID)(),
+            });
+            const response = await this.client.send(command, {
+                requestTimeout: 50,
+                abortSignal: AbortSignal.timeout(30000),
+            });
+            this.sequenceToken = response.nextSequenceToken;
+        }
+        catch (error) {
+            console.error('Error sending log to CloudWatch:', error);
+            if (error.name === 'InvalidSequenceTokenException' && retry) {
+                await this._send(message, false);
+            }
+        }
+    }
+    log(message) {
+        this._send(message);
+    }
+    info(message) {
+        this._send(message);
+    }
+    error(message) {
+        this._send(message);
+    }
+    fatal(message) {
+        this._send(message);
+    }
+    warn(message) {
+        this._send(message);
+    }
+    debug(message) {
+        // this._send(message);
+    }
+    verbose(message) {
+        // this._send(message);
+    }
+}
+exports.Cloudwatch = Cloudwatch;

package/dist/helper.d.ts

@@ -0,0 +1,15 @@
+export declare const sanitizeRequests: string[];
+declare class DateUtil {
+    private date;
+    constructor(date?: Date | string | number);
+    utcOffset(offsetHourOrMinutes: number): DateUtil;
+    utc(): DateUtil;
+    isUtc(): boolean;
+    getTz(): number;
+    format(formatStr?: string): string;
+    toISOString(): string;
+    toString(): string;
+    toDate(): Date;
+}
+export declare const dateUtil: (date?: Date | string | number) => DateUtil;
+export {};

package/dist/helper.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateUtil = exports.sanitizeRequests = void 0;
+exports.sanitizeRequests = [
+    'content',
+    'html',
+    'password',
+    'accessToken',
+    'refreshToken',
+    'otp',
+    'totp',
+    'secret',
+    'publicKey',
+    'privateKey',
+    'apiKey',
+    'secretKey',
+    'token',
+    'authorization',
+    'authToken',
+    'apiKey',
+    'secretKey',
+    'pin',
+    'secret',
+    'permissions',
+];
+class DateUtil {
+    date;
+    constructor(date) {
+        let parsedDate;
+        if (date instanceof Date) {
+            const isUTC = date.getTimezoneOffset() === 0;
+            if (isUTC) {
+                parsedDate = new Date(date);
+            }
+            else {
+                parsedDate = new Date(date.getTime() + date.getTimezoneOffset() * 60 * 1000);
+            }
+        }
+        else {
+            parsedDate = date ? new Date(date) : new Date();
+        }
+        if (isNaN(parsedDate.getTime())) {
+            throw new Error('Invalid date ' + date);
+        }
+        this.date = parsedDate;
+    }
+    utcOffset(offsetHourOrMinutes) {
+        if (offsetHourOrMinutes > 14 * 60 || offsetHourOrMinutes < -12 * 60) {
+            offsetHourOrMinutes = offsetHourOrMinutes * 60;
+        }
+        this.date = new Date(this.date.getTime() + offsetHourOrMinutes * 60 * 1000);
+        return this;
+    }
+    utc() {
+        const offset = this.date.getTimezoneOffset();
+        const utcTime = new Date(this.date.getTime() + offset * 60 * 1000);
+        const datePart = [
+            utcTime.getFullYear().toString().padStart(4, '0'),
+            (utcTime.getMonth() + 1).toString().padStart(2, '0'),
+            utcTime.getDate().toString().padStart(2, '0'),
+        ].join('-');
+        const timePart = [
+            utcTime.getHours().toString().padStart(2, '0'),
+            utcTime.getMinutes().toString().padStart(2, '0'),
+            utcTime.getSeconds().toString().padStart(2, '0'),
+        ].join(':');
+        const msPart = utcTime.getMilliseconds().toString().padStart(3, '0');
+        const isoString = `${datePart}T${timePart}.${msPart}Z`;
+        this.date = new Date(isoString);
+        return this;
+    }
+    isUtc() {
+        return this.date.getTimezoneOffset() === 0;
+    }
+    getTz() {
+        return -this.date.getTimezoneOffset() / 60;
+    }
+    format(formatStr = 'YYYY-MM-DD HH:mm:ss') {
+        const map = {
+            YYYY: this.date.getFullYear().toString(),
+            YY: this.date.getFullYear().toString().slice(-2),
+            MM: (this.date.getMonth() + 1).toString().padStart(2, '0'),
+            M: (this.date.getMonth() + 1).toString(),
+            DD: this.date.getDate().toString().padStart(2, '0'),
+            D: this.date.getDate().toString(),
+            HH: this.date.getHours().toString().padStart(2, '0'),
+            H: this.date.getHours().toString(),
+            mm: this.date.getMinutes().toString().padStart(2, '0'),
+            m: this.date.getMinutes().toString(),
+            ss: this.date.getSeconds().toString().padStart(2, '0'),
+            s: this.date.getSeconds().toString(),
+            SSS: this.date.getMilliseconds().toString().padStart(3, '0'),
+            Z: this.isUtc() ? 'Z' : `+${this.getTz().toString().padStart(2, '0')}:00`,
+        };
+        return formatStr.replace(/YYYY|YY|MM|M|DD|D|HH|H|mm|m|ss|s|SSS|Z/g, (matched) => map[matched] ?? matched);
+    }
+    toISOString() {
+        return this.format('YYYY-MM-DDTHH:mm:ss.SSSZ');
+    }
+    toString() {
+        return this.format('YYYY-MM-DD HH:mm:ss');
+    }
+    toDate() {
+        return this.date;
+    }
+}
+const dateUtil = (date) => new DateUtil(date);
+exports.dateUtil = dateUtil;

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { CloudwatchOptions } from './cloudwatch';
+import { LoggerContract, LogMessageType, LogMeta } from './logger.contract';
+export interface LoggingOptions {
+    env: string;
+    enable: boolean;
+    slackWebhook?: string;
+    cloudwatchOption?: CloudwatchOptions;
+}
+export default class Logger implements LoggerContract {
+    private LOG_STACKS;
+    private readonly HOST;
+    private readonly ENV;
+    private cloudwatch;
+    constructor(options: LoggingOptions);
+    private _sanitizePolicyData;
+    private _formatBgLevel;
+    private _formatException;
+    private _parseMessage;
+    private _mapLog;
+    private _formatConsoleError;
+    private _console;
+    log(...args: LogMessageType[]): void;
+    info(...args: LogMessageType[]): void;
+    error(...args: LogMessageType[]): void;
+    fatal(...args: LogMessageType[]): void;
+    warn(...args: LogMessageType[]): void;
+    verbose(message: LogMeta): void;
+    debug(...args: LogMessageType[]): void;
+}

package/dist/index.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const util_1 = require("util");
+const cloudwatch_1 = require("./cloudwatch");
+const helper_1 = require("./helper");
+const logger_contract_1 = require("./logger.contract");
+class Logger {
+    LOG_STACKS = 5;
+    HOST = os_1.default.hostname();
+    ENV = 'development';
+    cloudwatch;
+    constructor(options) {
+        this.ENV = options.env ?? this.ENV;
+        if (options.enable && options.cloudwatchOption) {
+            this.cloudwatch = new cloudwatch_1.Cloudwatch(options.cloudwatchOption);
+        }
+    }
+    _sanitizePolicyData(object) {
+        if (!object)
+            return undefined;
+        if (Array.isArray(object)) {
+            return object.map((d) => typeof d !== 'object' ? d : this._sanitizePolicyData(d));
+        }
+        else {
+            return Object.keys(object).reduce((acc, key) => {
+                let value = object[key];
+                if (helper_1.sanitizeRequests.includes(key)) {
+                    // @ts-ignore
+                    value = '***';
+                }
+                else if (typeof value === 'object') {
+                    // @ts-ignore
+                    value = this._sanitizePolicyData(value);
+                }
+                return { ...acc, [key]: value };
+            }, {});
+        }
+    }
+    _formatBgLevel(level, ...args) {
+        const msg = `[${args.map((d) => d?.trim()).join('][')}]`;
+        switch (level) {
+            case 'log':
+                return (0, logger_contract_1.logInfo)(msg);
+            case 'warn':
+                return (0, logger_contract_1.logWarn)(msg);
+            case 'error':
+                return (0, logger_contract_1.logError)(msg);
+            case 'fatal':
+                return (0, logger_contract_1.logError)(msg);
+            case 'debug':
+                return (0, logger_contract_1.logDebug)(msg);
+            default:
+                return (0, logger_contract_1.logInfo)(msg);
+        }
+    }
+    _formatException(error) {
+        let stacks = (error?.stack ?? '')
+            ?.split('\n')
+            .map((o) => o.trim().replace?.(error.name + ': ', ''));
+        if (!['development', 'local', 'staging'].includes(this.ENV.toLocaleLowerCase()))
+            stacks = stacks.slice(0, this.LOG_STACKS);
+        return (error?.name ?? 'UnknownErrorException') + ' ' + stacks.join(`\n`);
+    }
+    _parseMessage(arg) {
+        if (arg instanceof Error)
+            return ['error', this._formatException(arg)];
+        if (typeof arg === 'object')
+            return ['object', JSON.stringify(this._sanitizePolicyData(arg), null, 2)];
+        return ['string', arg?.toString()];
+    }
+    _mapLog(level, ...args) {
+        if (this.ENV?.toLowerCase() === 'test')
+            return;
+        const message = [];
+        for (const arg of args?.flat()?.flat()) {
+            if (!arg)
+                continue;
+            message.push(this._parseMessage(arg));
+        }
+        return {
+            level,
+            host: this.HOST,
+            env: this.ENV.toUpperCase(),
+            timestamp: (0, helper_1.dateUtil)().format('YYYY-MM-DD HH:mm:ss.SSS'),
+            message,
+        };
+    }
+    _formatConsoleError(error) {
+        return error
+            .split('\n')
+            .map((d) => d.endsWith('Exception')
+            ? d.replace(/(.*)Exception(.*)/, (0, logger_contract_1.logError)('$1Exception') + (0, logger_contract_1.logError)('$2'))
+            : (0, logger_contract_1.logError)(d))
+            .join('\n  ');
+    }
+    _console(logMeta) {
+        const log = this._formatBgLevel(logMeta.level, logMeta.timestamp, this.HOST, logMeta.level.toUpperCase() === 'LOG'
+            ? 'INFO'
+            : logMeta.level.toUpperCase()) +
+            (0, util_1.styleText)('reset', ` `) +
+            logMeta.message
+                .map(([type, value]) => {
+                if (typeof value === 'function')
+                    return;
+                if (type === 'error')
+                    return (0, logger_contract_1.logError)(this._formatConsoleError(value));
+                if (type === 'object') {
+                    return (0, logger_contract_1.logWarn)((0, logger_contract_1.logWarnBg)('Object') +
+                        ' ' +
+                        value.split('\n').map(logger_contract_1.logWarn).join('\n  '));
+                }
+                return value;
+            })
+                .filter((d) => d)
+                .join('\n  ');
+        return console.log(log);
+    }
+    log(...args) {
+        const logMeta = this._mapLog('log', ...args);
+        if (!logMeta)
+            return;
+        this._console(logMeta);
+        this.cloudwatch?.log(logMeta);
+    }
+    info(...args) {
+        const logMeta = this._mapLog('info', ...args);
+        if (!logMeta)
+            return;
+        this._console(logMeta);
+        this.cloudwatch?.info(logMeta);
+    }
+    error(...args) {
+        const logMeta = this._mapLog('error', ...args);
+        if (!logMeta)
+            return;
+        this._console(logMeta);
+        this.cloudwatch?.error(logMeta);
+    }
+    fatal(...args) {
+        const logMeta = this._mapLog('fatal', ...args);
+        if (!logMeta)
+            return;
+        this._console(logMeta);
+        this.cloudwatch?.fatal(logMeta);
+    }
+    warn(...args) {
+        const logMeta = this._mapLog('warn', ...args);
+        if (!logMeta)
+            return;
+        this._console(logMeta);
+        this.cloudwatch?.warn(logMeta);
+    }
+    verbose(message) {
+        throw new Error('Method not implemented.');
+    }
+    debug(...args) {
+        const logMeta = this._mapLog('debug', ...args);
+        if (!logMeta)
+            return;
+        this._console(logMeta);
+        this.cloudwatch?.debug(logMeta);
+    }
+}
+exports.default = Logger;

package/dist/logger.contract.d.ts

@@ -0,0 +1,26 @@
+export type LogLevel = 'error' | 'log' | 'info' | 'warn' | 'debug' | 'fatal' | 'verbose';
+export type LogMessageType = string | object | Error | undefined | null | number | boolean | unknown | any;
+export interface LogMeta {
+    level: LogLevel;
+    env: string;
+    host: string;
+    timestamp: string;
+    message: ['error' | 'object' | 'string', string][];
+}
+export interface LoggerContract {
+    log(message: LogMeta): void;
+    info(message: LogMeta): void;
+    error(message: LogMeta): void;
+    fatal(message: LogMeta): void;
+    warn(message: LogMeta): void;
+    debug(message: LogMeta): void;
+    verbose(message: LogMeta): void;
+}
+export declare const logWarnBg: (log: string) => string;
+export declare const logErrorBg: (log: string) => string;
+export declare const logInfoBg: (log: string) => string;
+export declare const logDebugBg: (log: string) => string;
+export declare const logWarn: (log: string) => string;
+export declare const logInfo: (log: string) => string;
+export declare const logDebug: (log: string) => string;
+export declare const logError: (log: string) => string;

package/dist/logger.contract.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logError = exports.logDebug = exports.logInfo = exports.logWarn = exports.logDebugBg = exports.logInfoBg = exports.logErrorBg = exports.logWarnBg = void 0;
+const util_1 = require("util");
+const bgLog = (option, log) => {
+    return (0, util_1.styleText)('reset', (0, util_1.styleText)('bold', (0, util_1.styleText)(option, (0, util_1.styleText)('black', ` ${log} `))));
+};
+const logWarnBg = (log) => bgLog('bgYellow', log);
+exports.logWarnBg = logWarnBg;
+const logErrorBg = (log) => bgLog('bgRed', log);
+exports.logErrorBg = logErrorBg;
+const logInfoBg = (log) => bgLog('bgGreen', log);
+exports.logInfoBg = logInfoBg;
+const logDebugBg = (log) => bgLog('bgMagenta', log);
+exports.logDebugBg = logDebugBg;
+const logWarn = (log) => (0, util_1.styleText)('yellow', log);
+exports.logWarn = logWarn;
+const logInfo = (log) => (0, util_1.styleText)('green', log);
+exports.logInfo = logInfo;
+const logDebug = (log) => (0, util_1.styleText)('magenta', log);
+exports.logDebug = logDebug;
+const logError = (log) => (0, util_1.styleText)('red', log);
+exports.logError = logError;

package/package.json

@@ -1,46 +1,34 @@
 {
-	"name": "nextrans-logger",
-	"version": "0.2.20",
-	"description": "Logging for nextrans app service",
-	"main": "lib/index.cjs",
-	"module": "lib/index.js",
-	"types": "lib/index.d.ts",
-	"scripts": {
-		"build": "rm -fr lib/* && tsc -p tsconfig.json",
-		"build:cjs": "tsc -p tsconfig-cjs.json",
-		"move:cjs": "cp lib/cjs/index.js lib/index.cjs && rm -r lib/cjs",
-		"test": "jest"
-	},
-	"author": "nextrans-team",
-	"license": "ISC",
-	"dependencies": {
-		"@aws-sdk/client-cloudwatch-logs": "^3.347.0",
-		"moment": "^2.29.4",
-		"winston": "^3.8.2",
-		"winston-cloudwatch": "^6.1.1",
-		"winston-slack-webhook-transport": "^2.2.3"
-	},
-	"devDependencies": {
-		"@types/jest": "^29.4.0",
-		"@types/node": "^18.14.6",
-		"dotenv": "^16.0.3",
-		"jest": "^29.5.0",
-		"ts-jest": "^29.0.5",
-		"ts-node": "^10.9.1",
-		"typescript": "^4.9.5"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://bitbucket.org/nexpay-nextrans/nextrans-logger.git"
-	},
-	"bugs": {
-		"url": "https://bitbucket.org/nexpay-nextrans/nextrans-logger/issues"
-	},
-	"homepage": "https://bitbucket.org/nexpay-nextrans/nextrans-logger#readme",
-	"exports": {
-		".": {
-			"import": "./lib/index.js",
-			"require": "./lib/index.cjs"
-		}
-	}
+  "name": "nextrans-logger",
+  "version": "0.3.0",
+  "description": "Logging for nextrans app service",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "jest"
+  },
+  "author": "nextrans-team",
+  "license": "ISC",
+  "peerDependencies": {
+    "@aws-sdk/client-cloudwatch-logs": "^3.1055.0"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-cloudwatch-logs": "^3.1055.0",
+    "@types/jest": "^29.4.0",
+    "@types/node": "^25.9.1",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.0.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^4.9.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/nexpay-nextrans/nextrans-logger.git"
+  },
+  "bugs": {
+    "url": "https://bitbucket.org/nexpay-nextrans/nextrans-logger/issues"
+  },
+  "homepage": "https://bitbucket.org/nexpay-nextrans/nextrans-logger#readme"
 }

package/.vscode/settings.json

@@ -1,6 +0,0 @@
-{
-  "editor.tabSize": 2,
-  "prettier.singleQuote": true,
-  "javascript.preferences.quoteStyle": "single",
-  "typescript.preferences.quoteStyle": "single"
-}