@mhmdhammoud/meritt-utils 1.2.0 → 1.4.0

package/ReleaseNotes.md

@@ -1,8 +1,22 @@
 # Changes
 
-## Version 1.0.5
+## Version 1.4.0
+
+- Changed winston logger to Pino logger to improve performance and reduce memory usage
 
-### Added
+## Version 1.3.0
+
+- Added toUpperTitle method that accepts a string and removes all non alphanumeric characters and capitalizes each letter of every first word
+
+```typescript
+import {Logger} from '@mhmdhammoud/meritt-utils'
+
+// Usage Example
+Logger.info('className', ' functionName', 'logMessage', 'userIp')
+// Available levels info warn error
+```
+
+## Version 1.0.5
 
 - Added toUpperTitle method that accepts a string and removes all non alphanumeric characters and capitalizes each letter of every first word
 
@@ -19,8 +33,6 @@ console : Hello World 99
 
 ## Version 1.0.4
 
-### Added
-
 - Added generateKeys method that returns public and private keys
 
 ```typescript
@@ -38,14 +50,10 @@ console.log(response)
 
 ```
 
-### Fixes and Improvements
-
 - Checking for prime numbers discarding even and odd numbers and skips 6 iterations at a time until radical I
 
 ## Version 1.0.3
 
-### Added
-
 - Added Formatter class for manipulating strings
 
 ```typescript
@@ -55,8 +63,6 @@ import {Formatter} from '@mhmdhammoud/meritt-utils'
 const slug = Formatter.slugify('My Product Name') // my-product-name
 ```
 
-### Fixes and Improvements
-
 - Fixed bug in Crypto class where encrypting a string with a key that is not a number would throw an error
 - Improved Crypto class to allow encrypting and decrypting numbers and objects
 - Documented Crypto class

package/dist/__tests__/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/logger.test.js

@@ -0,0 +1,100 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importStar(require("../lib/logger"));
+const pino_1 = require("pino");
+jest.mock('pino');
+const LOGGER_NAME = 'logger-name';
+const PINO_DESTINATION = {};
+const PINO = {
+    info: jest.fn(),
+};
+describe('create logger wrapper', () => {
+    test('initially create & configure logger', () => {
+        //@ts-ignore
+        const mock_pino_destination = jest
+            .spyOn(pino_1.pino, 'destination')
+            //@ts-ignore
+            .mockReturnValue(PINO_DESTINATION);
+        //@ts-ignore
+        const mock_pino = pino_1.pino.mockReturnValue(PINO);
+        /** create logger */
+        const logger = new logger_1.default(LOGGER_NAME);
+        expect(logger).toBeDefined();
+        expect(logger['_name']).toBe(LOGGER_NAME);
+        expect(mock_pino).toHaveBeenCalledTimes(1);
+        expect(mock_pino).toHaveBeenCalledWith({
+            level: 'info',
+            timestamp: expect.any(Function),
+        }, PINO_DESTINATION);
+        expect(mock_pino_destination).toHaveBeenCalledWith({
+            minLength: 1024,
+            sync: true,
+        });
+    });
+    test('create repeatedly - stick to pino singleton', () => {
+        //@ts-ignore
+        jest.spyOn(pino_1.pino, 'destination').mockReturnValue(PINO_DESTINATION);
+        //@ts-ignore
+        const mock_pino = pino_1.pino.mockReturnValue(PINO);
+        new logger_1.default(LOGGER_NAME);
+        expect(mock_pino).toHaveBeenCalledTimes(1);
+        /** create additional logger */
+        new logger_1.default(LOGGER_NAME);
+        /** no new pino created */
+        expect(mock_pino).toHaveBeenCalledTimes(1);
+    });
+});
+describe('validate log level', () => {
+    test('throw on invalid log level', () => {
+        const INVALID_LOG_LEVEL = 'invalid-log-level';
+        expect(() => {
+            (0, logger_1.isValidLogLevel)(INVALID_LOG_LEVEL);
+        }).toThrowError(`Invalid log level "${INVALID_LOG_LEVEL}": only error, warn, info, debug, trace are valid.`);
+    });
+});
+describe('route and format logs', () => {
+    const LOG_EVENT = {
+        code: 'code',
+        msg: 'message',
+    };
+    const DETAILS = {
+        key0: 'val0',
+        key1: 'val1',
+    };
+    test('log info with details', () => {
+        //@ts-ignore
+        jest.spyOn(pino_1.pino, 'destination').mockReturnValue(PINO_DESTINATION);
+        //@ts-ignore
+        pino_1.pino.mockReturnValue(PINO);
+        const logger = new logger_1.default(LOGGER_NAME);
+        logger.info(LOG_EVENT, DETAILS);
+        expect(PINO.info).toHaveBeenCalledWith({
+            component: LOGGER_NAME,
+            ...LOG_EVENT,
+            detail: [DETAILS],
+        });
+    });
+});

package/dist/config/index.d.ts

@@ -0,0 +1 @@
+export { default as WinstonConfiguaration } from './logger-config';

package/dist/config/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WinstonConfiguaration = void 0;
+var logger_config_1 = require("./logger-config");
+Object.defineProperty(exports, "WinstonConfiguaration", { enumerable: true, get: function () { return __importDefault(logger_config_1).default; } });

package/dist/config/logger-config.d.ts

@@ -0,0 +1,5 @@
+import { ElasticsearchTransport } from 'winston-elasticsearch';
+declare const loggerConfiguration: {
+    transports: ElasticsearchTransport[];
+};
+export default loggerConfiguration;

package/dist/config/logger-config.js

@@ -0,0 +1,86 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const winston_elasticsearch_1 = require("winston-elasticsearch");
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+const { ELASTICSEARCH_USERNAME, ELASTICSEARCH_PASSWORD, ELASTICSEARCH_NODE, SERVER_NICKNAME, LOG_LEVEL, } = process.env;
+const transports = process.env.NODE_ENV !== 'local'
+    ? [
+        // Elasticsearch Transport for 'info' logs
+        new winston_elasticsearch_1.ElasticsearchTransport({
+            level: 'info',
+            indexPrefix: process.env.SERVER_NICKNAME,
+            clientOpts: {
+                node: ELASTICSEARCH_NODE,
+                tls: {
+                    rejectUnauthorized: false, // Only for development, not recommended in production
+                },
+                auth: {
+                    username: ELASTICSEARCH_USERNAME,
+                    password: ELASTICSEARCH_PASSWORD,
+                },
+            },
+            // format: winston.format.combine(winston.format.json()), // Adjust as needed
+        }),
+        // Elasticsearch Transport for 'warn' logs
+        new winston_elasticsearch_1.ElasticsearchTransport({
+            level: LOG_LEVEL,
+            indexPrefix: SERVER_NICKNAME,
+            clientOpts: {
+                node: ELASTICSEARCH_NODE,
+                tls: {
+                    rejectUnauthorized: false, // Only for development, not recommended in production
+                },
+                auth: {
+                    username: ELASTICSEARCH_USERNAME,
+                    password: ELASTICSEARCH_PASSWORD,
+                },
+            },
+            // format: winston.format.combine(winston.format.json()), // Adjust as needed
+        }),
+        // Elasticsearch Transport for 'error' logs
+        new winston_elasticsearch_1.ElasticsearchTransport({
+            level: 'error',
+            indexPrefix: process.env.SERVER_NICKNAME,
+            clientOpts: {
+                node: ELASTICSEARCH_NODE,
+                tls: {
+                    rejectUnauthorized: false, // Only for development, not recommended in production
+                },
+                auth: {
+                    username: ELASTICSEARCH_USERNAME,
+                    password: ELASTICSEARCH_PASSWORD,
+                },
+            },
+            // format: winston.format.combine(winston.format.json()), // Adjust as needed
+        }),
+        // eslint-disable-next-line no-mixed-spaces-and-tabs
+    ]
+    : [];
+const loggerConfiguration = {
+    transports,
+};
+exports.default = loggerConfiguration;

package/dist/index.d.ts

@@ -1 +1 @@
-export { Crypto, Formatter, Colorful } from './lib';
+export * from './lib';

package/dist/index.js

@@ -1,7 +1,17 @@
 "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.Colorful = exports.Formatter = exports.Crypto = void 0;
-var lib_1 = require("./lib");
-Object.defineProperty(exports, "Crypto", { enumerable: true, get: function () { return lib_1.Crypto; } });
-Object.defineProperty(exports, "Formatter", { enumerable: true, get: function () { return lib_1.Formatter; } });
-Object.defineProperty(exports, "Colorful", { enumerable: true, get: function () { return lib_1.Colorful; } });
+__exportStar(require("./lib"), exports);

package/dist/lib/index.d.ts

@@ -3,3 +3,4 @@ export { default as Formatter } from './formatter';
 export { default as Pdf } from './formatter';
 export { default as Colorful } from './colorful';
 export { default as ImageFull } from './imagefull';
+export { default as Logger } from './logger';

package/dist/lib/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageFull = exports.Colorful = exports.Pdf = exports.Formatter = exports.Crypto = void 0;
+exports.Logger = exports.ImageFull = exports.Colorful = exports.Pdf = exports.Formatter = exports.Crypto = void 0;
 var cypto_1 = require("./cypto");
 Object.defineProperty(exports, "Crypto", { enumerable: true, get: function () { return __importDefault(cypto_1).default; } });
 var formatter_1 = require("./formatter");
@@ -14,3 +14,5 @@ var colorful_1 = require("./colorful");
 Object.defineProperty(exports, "Colorful", { enumerable: true, get: function () { return __importDefault(colorful_1).default; } });
 var imagefull_1 = require("./imagefull");
 Object.defineProperty(exports, "ImageFull", { enumerable: true, get: function () { return __importDefault(imagefull_1).default; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return __importDefault(logger_1).default; } });

package/dist/lib/logger.d.ts

@@ -0,0 +1,58 @@
+import { ElasticConfig, LOG_LEVEL, LogEvent } from '../types';
+/**
+ * Checks if a given log level is valid.
+ * @param level - The log level to check.
+ * @returns Whether the log level is valid.
+ */
+export declare function isValidLogLevel(level: string): level is LOG_LEVEL;
+/**
+ * Logger Wrapper.
+ * Wraps a Pino logger instance and provides logging methods.
+ */
+declare class Logger {
+    private readonly _name;
+    private readonly _logger;
+    /**
+     * Creates a new Logger instance with default configuration.
+     * @param name - The name of the logger.
+     */
+    constructor(name: string);
+    /**
+     * Creates a new Logger instance with custom Elasticsearch configuration.
+     * @param name - The name of the logger.
+     * @param elasticConfig - Optional Elasticsearch configuration.
+     */
+    constructor(name: string, elasticConfig?: ElasticConfig);
+    private log;
+    /**
+     * Logs an error message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    error(logEvent: LogEvent, ...args: unknown[]): void;
+    /**
+     * Logs a warning message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    warn(logEvent: LogEvent, ...args: unknown[]): void;
+    /**
+     * Logs an informational message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    info(logEvent: LogEvent, ...args: unknown[]): void;
+    /**
+     * Logs a debug message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    debug(logEvent: LogEvent, ...args: unknown[]): void;
+    /**
+     * Logs a trace message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    trace(logEvent: LogEvent, ...args: unknown[]): void;
+}
+export default Logger;

package/dist/lib/logger.js

@@ -0,0 +1,146 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidLogLevel = void 0;
+const pino_1 = require("pino");
+const dotenv = __importStar(require("dotenv"));
+const pino_elasticsearch_1 = __importDefault(require("pino-elasticsearch"));
+dotenv.config();
+/**
+ * Pino logger backend - singleton
+ */
+let pinoLogger;
+/**
+ * Creates a Pino logger instance with specified Elasticsearch configuration.
+ * @param elasticConfig - Optional Elasticsearch configuration.
+ * @returns The Pino logger instance.
+ */
+function getLogger(elasticConfig) {
+    if (!pinoLogger) {
+        if (isValidLogLevel(process.env.LOG_LEVEL)) {
+            const transports = [];
+            if (process.env.NODE_ENV !== 'local' && process.env.NODE_ENV !== 'test') {
+                const esConfig = {
+                    index: process.env.SERVER_NICKNAME,
+                    node: process.env.ELASTICSEARCH_NODE,
+                    auth: {
+                        username: process.env.ELASTICSEARCH_USERNAME,
+                        password: process.env.ELASTICSEARCH_PASSWORD,
+                    },
+                    flushInterval: 10000,
+                };
+                if (elasticConfig) {
+                    Object.assign(esConfig, elasticConfig);
+                }
+                const esTransport = (0, pino_elasticsearch_1.default)(esConfig);
+                transports.push(esTransport);
+            }
+            else {
+                transports.push(pino_1.pino.destination({
+                    minLength: 1024,
+                    sync: true,
+                }));
+            }
+            pinoLogger = (0, pino_1.pino)({
+                level: process.env.LOG_LEVEL,
+                timestamp: pino_1.stdTimeFunctions.isoTime.bind(pino_1.stdTimeFunctions),
+            }, ...transports);
+        }
+    }
+    return pinoLogger;
+}
+/**
+ * Checks if a given log level is valid.
+ * @param level - The log level to check.
+ * @returns Whether the log level is valid.
+ */
+function isValidLogLevel(level) {
+    if (!['error', 'warn', 'info', 'debug', 'trace'].includes(level)) {
+        throw new Error(`Invalid log level "${level}": only error, warn, info, debug, trace are valid.`);
+    }
+    return true;
+}
+exports.isValidLogLevel = isValidLogLevel;
+/**
+ * Logger Wrapper.
+ * Wraps a Pino logger instance and provides logging methods.
+ */
+class Logger {
+    constructor(name, elasticConfig) {
+        this._name = name;
+        this._logger = getLogger(elasticConfig);
+    }
+    log(logLevel, logEvent, ...args) {
+        this._logger[logLevel]({
+            component: this._name,
+            ...logEvent,
+            detail: args,
+        });
+    }
+    /**
+     * Logs an error message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    error(logEvent, ...args) {
+        this.log('error', logEvent, ...args);
+    }
+    /**
+     * Logs a warning message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    warn(logEvent, ...args) {
+        this.log('warn', logEvent, ...args);
+    }
+    /**
+     * Logs an informational message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    info(logEvent, ...args) {
+        this.log('info', logEvent, ...args);
+    }
+    /**
+     * Logs a debug message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    debug(logEvent, ...args) {
+        this.log('debug', logEvent, ...args);
+    }
+    /**
+     * Logs a trace message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
+     */
+    trace(logEvent, ...args) {
+        this.log('trace', logEvent, ...args);
+    }
+}
+exports.default = Logger;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './logger';

package/dist/types/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./logger"), exports);

package/dist/types/logger.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Log levels
+ */
+export type LOG_LEVEL = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+/**
+ * Represents a log event.
+ */
+export interface LogEvent {
+    /**
+     * The code associated with the log event.
+     */
+    code: string;
+    /**
+     * The message describing the log event.
+     */
+    msg: string;
+}
+/**
+ * Configuration options for Elasticsearch.
+ */
+export interface ElasticConfig {
+    /**
+     * The Elasticsearch index to write logs to.
+     */
+    index?: string;
+    /**
+     * The URL of the Elasticsearch node.
+     */
+    node?: string;
+    /**
+     * Authentication details for accessing Elasticsearch.
+     */
+    auth?: {
+        /**
+         * The username for authentication.
+         */
+        username: string;
+        /**
+         * The password for authentication.
+         */
+        password: string;
+    };
+    /**
+     * The interval (in milliseconds) at which logs are flushed to Elasticsearch.
+     */
+    flushInterval?: number;
+}

package/dist/types/logger.js

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

package/example.env

@@ -0,0 +1,6 @@
+ELASTICSEARCH_USERNAME=
+ELASTICSEARCH_PASSWORD=
+ELASTICSEARCH_NODE=
+SERVER_NICKNAME=
+NODE_ENV=
+LOG_LEVEL=info

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mhmdhammoud/meritt-utils",
-	"version": "1.2.0",
+	"version": "1.4.0",
 	"description": "",
 	"main": "./dist/index.js",
 	"private": false,
@@ -13,7 +13,7 @@
 		"access": "public"
 	},
 	"scripts": {
-		"dev-ts": "ts-node-dev --respawn --transpile-only src/index.ts",
+		"dev-ts": "ts-node-dev --respawn --transpile-only src/index.ts  | pino-pretty",
 		"dev": "nodemon ./dist/index.js",
 		"watch": "tsc --watch",
 		"build": "tsc",
@@ -32,6 +32,7 @@
 		"eslint-plugin-tsdoc": "^0.2.14",
 		"husky": "^8.0.0",
 		"jest": "^29.7.0",
+		"pino-pretty": "^10.3.1",
 		"ts-jest": "^29.1.1",
 		"ts-node-dev": "^1.1.8",
 		"typescript": "^4.6.3"
@@ -40,6 +41,11 @@
 	"license": "ISC",
 	"dependencies": {
 		"axios": "^1.4.0",
-		"imagesloaded": "^5.0.0"
+		"dotenv": "^16.4.1",
+		"imagesloaded": "^5.0.0",
+		"pino": "^8.19.0",
+		"pino-elasticsearch": "^8.0.0",
+		"winston": "^3.11.0",
+		"winston-elasticsearch": "^0.17.4"
 	}
 }

package/src/__tests__/logger.test.ts

@@ -0,0 +1,88 @@
+import Logger, {isValidLogLevel} from '../lib/logger'
+import {pino} from 'pino'
+
+jest.mock('pino')
+
+const LOGGER_NAME = 'logger-name'
+const PINO_DESTINATION = {}
+const PINO = {
+	info: jest.fn(),
+}
+
+describe('create logger wrapper', () => {
+	test('initially create & configure logger', () => {
+		//@ts-ignore
+		const mock_pino_destination = jest
+			.spyOn(pino, 'destination')
+			//@ts-ignore
+			.mockReturnValue(PINO_DESTINATION)
+		//@ts-ignore
+		const mock_pino = pino.mockReturnValue(PINO)
+
+		/** create logger */
+		const logger = new Logger(LOGGER_NAME)
+
+		expect(logger).toBeDefined()
+		expect(logger['_name']).toBe(LOGGER_NAME)
+		expect(mock_pino).toHaveBeenCalledTimes(1)
+		expect(mock_pino).toHaveBeenCalledWith(
+			{
+				level: 'info',
+				timestamp: expect.any(Function),
+			},
+			PINO_DESTINATION
+		)
+		expect(mock_pino_destination).toHaveBeenCalledWith({
+			minLength: 1024,
+			sync: true,
+		})
+	})
+	test('create repeatedly - stick to pino singleton', () => {
+		//@ts-ignore
+		jest.spyOn(pino, 'destination').mockReturnValue(PINO_DESTINATION)
+		//@ts-ignore
+		const mock_pino = pino.mockReturnValue(PINO)
+		new Logger(LOGGER_NAME)
+		expect(mock_pino).toHaveBeenCalledTimes(1)
+
+		/** create additional logger */
+		new Logger(LOGGER_NAME)
+		/** no new pino created */
+		expect(mock_pino).toHaveBeenCalledTimes(1)
+	})
+})
+describe('validate log level', () => {
+	test('throw on invalid log level', () => {
+		const INVALID_LOG_LEVEL = 'invalid-log-level'
+		expect(() => {
+			isValidLogLevel(INVALID_LOG_LEVEL)
+		}).toThrowError(
+			`Invalid log level "${INVALID_LOG_LEVEL}": only error, warn, info, debug, trace are valid.`
+		)
+	})
+})
+describe('route and format logs', () => {
+	const LOG_EVENT = {
+		code: 'code',
+		msg: 'message',
+	}
+	const DETAILS = {
+		key0: 'val0',
+		key1: 'val1',
+	}
+	test('log info with details', () => {
+		//@ts-ignore
+		jest.spyOn(pino, 'destination').mockReturnValue(PINO_DESTINATION)
+		//@ts-ignore
+		pino.mockReturnValue(PINO)
+		const logger = new Logger(LOGGER_NAME)
+
+		logger.info(LOG_EVENT, DETAILS)
+
+		expect(PINO.info).toHaveBeenCalledWith({
+			component: LOGGER_NAME,
+			...LOG_EVENT,
+			detail: [DETAILS],
+		})
+	})
+})

package/src/env.d.ts

@@ -0,0 +1,9 @@
+declare namespace NodeJS {
+	export interface ProcessEnv {
+		NODE_ENV: 'development' | 'production' | 'test' | 'local'
+		ELASTICSEARCH_NODE: string
+		ELASTICSEARCH_USERNAME: string
+		ELASTICSEARCH_PASSWORD: string
+		LOG_LEVEL: string
+	}
+}

package/src/index.ts

@@ -1 +1 @@
-export {Crypto, Formatter, Colorful} from './lib'
+export * from './lib'

package/src/lib/index.ts

@@ -3,3 +3,4 @@ export {default as Formatter} from './formatter'
 export {default as Pdf} from './formatter'
 export {default as Colorful} from './colorful'
 export {default as ImageFull} from './imagefull'
+export {default as Logger} from './logger'

package/src/lib/logger.ts

@@ -0,0 +1,151 @@
+import {Logger as PinoLogger, pino, stdTimeFunctions} from 'pino'
+import * as dotenv from 'dotenv'
+import pinoElastic from 'pino-elasticsearch'
+import {ElasticConfig, LOG_LEVEL, LogEvent} from '../types'
+
+dotenv.config()
+
+/**
+ * Pino logger backend - singleton
+ */
+let pinoLogger: PinoLogger
+
+/**
+ * Creates a Pino logger instance with specified Elasticsearch configuration.
+ * @param elasticConfig - Optional Elasticsearch configuration.
+ * @returns The Pino logger instance.
+ */
+function getLogger(elasticConfig?: ElasticConfig): PinoLogger {
+	if (!pinoLogger) {
+		if (isValidLogLevel(process.env.LOG_LEVEL)) {
+			const transports = []
+			if (process.env.NODE_ENV !== 'local' && process.env.NODE_ENV !== 'test') {
+				const esConfig: ElasticConfig = {
+					index: process.env.SERVER_NICKNAME,
+					node: process.env.ELASTICSEARCH_NODE,
+					auth: {
+						username: process.env.ELASTICSEARCH_USERNAME,
+						password: process.env.ELASTICSEARCH_PASSWORD,
+					},
+					flushInterval: 10000,
+				}
+				if (elasticConfig) {
+					Object.assign(esConfig, elasticConfig)
+				}
+				const esTransport = pinoElastic(esConfig)
+				transports.push(esTransport)
+			} else {
+				transports.push(
+					pino.destination({
+						minLength: 1024,
+						sync: true,
+					})
+				)
+			}
+			pinoLogger = pino(
+				{
+					level: process.env.LOG_LEVEL,
+					timestamp: stdTimeFunctions.isoTime.bind(stdTimeFunctions),
+				},
+				...transports
+			)
+		}
+	}
+	return pinoLogger
+}
+
+/**
+ * Checks if a given log level is valid.
+ * @param level - The log level to check.
+ * @returns Whether the log level is valid.
+ */
+export function isValidLogLevel(level: string): level is LOG_LEVEL {
+	if (!['error', 'warn', 'info', 'debug', 'trace'].includes(level)) {
+		throw new Error(
+			`Invalid log level "${level}": only error, warn, info, debug, trace are valid.`
+		)
+	}
+	return true
+}
+
+/**
+ * Logger Wrapper.
+ * Wraps a Pino logger instance and provides logging methods.
+ */
+class Logger {
+	private readonly _name: string
+	private readonly _logger: PinoLogger
+
+	/**
+	 * Creates a new Logger instance with default configuration.
+	 * @param name - The name of the logger.
+	 */
+	constructor(name: string)
+
+	/**
+	 * Creates a new Logger instance with custom Elasticsearch configuration.
+	 * @param name - The name of the logger.
+	 * @param elasticConfig - Optional Elasticsearch configuration.
+	 */
+	constructor(name: string, elasticConfig?: ElasticConfig)
+
+	constructor(name: string, elasticConfig?: ElasticConfig) {
+		this._name = name
+		this._logger = getLogger(elasticConfig)
+	}
+
+	private log(logLevel: LOG_LEVEL, logEvent: LogEvent, ...args: unknown[]) {
+		this._logger[logLevel]({
+			component: this._name,
+			...logEvent,
+			detail: args,
+		})
+	}
+
+	/**
+	 * Logs an error message.
+	 * @param logEvent - The event to log.
+	 * @param args - Additional arguments to include in the log.
+	 */
+	error(logEvent: LogEvent, ...args: unknown[]) {
+		this.log('error', logEvent, ...args)
+	}
+
+	/**
+	 * Logs a warning message.
+	 * @param logEvent - The event to log.
+	 * @param args - Additional arguments to include in the log.
+	 */
+	warn(logEvent: LogEvent, ...args: unknown[]) {
+		this.log('warn', logEvent, ...args)
+	}
+
+	/**
+	 * Logs an informational message.
+	 * @param logEvent - The event to log.
+	 * @param args - Additional arguments to include in the log.
+	 */
+	info(logEvent: LogEvent, ...args: unknown[]) {
+		this.log('info', logEvent, ...args)
+	}
+
+	/**
+	 * Logs a debug message.
+	 * @param logEvent - The event to log.
+	 * @param args - Additional arguments to include in the log.
+	 */
+	debug(logEvent: LogEvent, ...args: unknown[]) {
+		this.log('debug', logEvent, ...args)
+	}
+
+	/**
+	 * Logs a trace message.
+	 * @param logEvent - The event to log.
+	 * @param args - Additional arguments to include in the log.
+	 */
+	trace(logEvent: LogEvent, ...args: unknown[]) {
+		this.log('trace', logEvent, ...args)
+	}
+}
+
+export default Logger

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './logger'

package/src/types/logger.ts

@@ -0,0 +1,49 @@
+/**
+ * Log levels
+ */
+export type LOG_LEVEL = 'error' | 'warn' | 'info' | 'debug' | 'trace'
+
+/**
+ * Represents a log event.
+ */
+export interface LogEvent {
+	/**
+	 * The code associated with the log event.
+	 */
+	code: string
+	/**
+	 * The message describing the log event.
+	 */
+	msg: string
+}
+
+/**
+ * Configuration options for Elasticsearch.
+ */
+export interface ElasticConfig {
+	/**
+	 * The Elasticsearch index to write logs to.
+	 */
+	index?: string
+	/**
+	 * The URL of the Elasticsearch node.
+	 */
+	node?: string
+	/**
+	 * Authentication details for accessing Elasticsearch.
+	 */
+	auth?: {
+		/**
+		 * The username for authentication.
+		 */
+		username: string
+		/**
+		 * The password for authentication.
+		 */
+		password: string
+	}
+	/**
+	 * The interval (in milliseconds) at which logs are flushed to Elasticsearch.
+	 */
+	flushInterval?: number
+}