@mhmdhammoud/meritt-utils 1.3.0 → 1.4.1

package/ReleaseNotes.md

@@ -1,5 +1,9 @@
 # Changes
 
+## Version 1.4.0
+
+- Changed winston logger to Pino logger to improve performance and reduce memory usage
+
 ## 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

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/lib/logger.d.ts

@@ -1,43 +1,58 @@
-import { LoggerOptions } from 'winston';
+import { ElasticConfig, LOG_LEVEL, LogEvent } from '../types';
 /**
- * Service for logging information, warnings, and errors using Winston.
+ * Checks if a given log level is valid.
+ * @param level - The log level to check.
+ * @returns Whether the log level is valid.
  */
-declare class LoggerService {
-    private logger;
+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 an instance of LoggerService.
-     * @param config - The configuration options for Winston logger.
+     * Creates a new Logger instance with default configuration.
+     * @param name - The name of the logger.
      */
-    constructor(config: LoggerOptions);
+    constructor(name: string);
     /**
-     * Logs an informational message.
-     * @param className - The name of the class that generated the log.
-     * @param functionName - The name of the function that generated the log.
-     * @param logMessage - The log message text.
-     * @param userIp - The user's IP address associated with the log.
-     * @param data - Additional data associated with the log.
+     * 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.
      */
-    info(className: string, functionName: string, logMessage: string, userIp: string): void;
+    error(logEvent: LogEvent, ...args: unknown[]): void;
     /**
      * Logs a warning message.
-     * @param className - The name of the class that generated the log.
-     * @param functionName - The name of the function that generated the log.
-     * @param logMessage - The log message text.
-     * @param userIp - The user's IP address associated with the log.
-     * @param data - Additional data associated with the log.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
      */
-    warn(className: string, functionName: string, logMessage: string, userIp: string): void;
+    warn(logEvent: LogEvent, ...args: unknown[]): void;
     /**
-     * Logs an error message.
-     * @param className - The name of the class that generated the log.
-     * @param functionName - The name of the function that generated the log.
-     * @param logMessage - The log message text.
-     * @param userIp - The user's IP address associated with the log.
-     * @param data - Additional data associated with the log.
+     * Logs an informational message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
      */
-    error(className: string, functionName: string, logMessage: string, userIp: string, data?: Object): void;
-    private createLogMessage;
-    private 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;
 }
-declare const Logger: LoggerService;
 export default Logger;

package/dist/lib/logger.js

@@ -1,92 +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 });
-const winston_1 = __importDefault(require("winston"));
-const config_1 = require("../config");
+exports.isValidLogLevel = void 0;
+const pino_1 = require("pino");
+const dotenv = __importStar(require("dotenv"));
+const pino_elasticsearch_1 = __importDefault(require("pino-elasticsearch"));
+dotenv.config();
 /**
- * Service for logging information, warnings, and errors using Winston.
+ * Pino logger backend - singleton
  */
-class LoggerService {
-    /**
-     * Creates an instance of LoggerService.
-     * @param config - The configuration options for Winston logger.
-     */
-    constructor(config) {
-        this.logger = winston_1.default.createLogger({
-            ...config,
-            level: process.env.LOG_LEVEL,
-        });
-        if (process.env.NODE_ENV === 'local') {
-            this.logger.add(new winston_1.default.transports.Console({
-                level: 'info',
-                format: winston_1.default.format.combine(winston_1.default.format.simple(), winston_1.default.format.colorize(), winston_1.default.format.printf(({ level, message }) => {
-                    return `[${level}]: ${JSON.stringify(message)}`;
-                    // Parse the message as JSON and include in the log
-                })),
-            }));
+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);
         }
-        this.logger.level = process.env.LOG_LEVEL;
+    }
+    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 informational message.
-     * @param className - The name of the class that generated the log.
-     * @param functionName - The name of the function that generated the log.
-     * @param logMessage - The log message text.
-     * @param userIp - The user's IP address associated with the log.
-     * @param data - Additional data associated with the log.
+     * Logs an error message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
      */
-    info(className, functionName, logMessage, userIp) {
-        const message = this.createLogMessage(className, functionName, logMessage, userIp);
-        this.log('info', message);
+    error(logEvent, ...args) {
+        this.log('error', logEvent, ...args);
     }
     /**
      * Logs a warning message.
-     * @param className - The name of the class that generated the log.
-     * @param functionName - The name of the function that generated the log.
-     * @param logMessage - The log message text.
-     * @param userIp - The user's IP address associated with the log.
-     * @param data - Additional data associated with the log.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
      */
-    warn(className, functionName, logMessage, userIp) {
-        const message = this.createLogMessage(className, functionName, logMessage, userIp);
-        this.log('warn', message);
+    warn(logEvent, ...args) {
+        this.log('warn', logEvent, ...args);
     }
     /**
-     * Logs an error message.
-     * @param className - The name of the class that generated the log.
-     * @param functionName - The name of the function that generated the log.
-     * @param logMessage - The log message text.
-     * @param userIp - The user's IP address associated with the log.
-     * @param data - Additional data associated with the log.
+     * Logs an informational message.
+     * @param logEvent - The event to log.
+     * @param args - Additional arguments to include in the log.
      */
-    error(className, functionName, logMessage, userIp, data = {}) {
-        const message = this.createLogMessage(className, functionName, logMessage, userIp, data);
-        this.log('error', message);
+    info(logEvent, ...args) {
+        this.log('info', logEvent, ...args);
     }
-    createLogMessage(className, functionName, logMessage, userIp, data = {}) {
-        return {
-            className,
-            functionName,
-            logMessage,
-            userIp,
-            data,
-        };
+    /**
+     * 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);
     }
-    log(level, logMessage) {
-        this.logger.log({
-            level,
-            //@ts-ignore
-            message: logMessage,
-        });
-        process.on('unhandledRejection', (reason, promise) => {
-            this.logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
-        });
-        process.on('uncaughtException', (err) => {
-            this.logger.error('Uncaught Exception:', err);
-        });
+    /**
+     * 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);
     }
 }
-const Logger = new LoggerService(config_1.WinstonConfiguaration);
 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mhmdhammoud/meritt-utils",
-	"version": "1.3.0",
+	"version": "1.4.1",
 	"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"
@@ -42,7 +43,7 @@
 		"axios": "^1.4.0",
 		"dotenv": "^16.4.1",
 		"imagesloaded": "^5.0.0",
-		"winston": "^3.11.0",
-		"winston-elasticsearch": "^0.17.4"
+		"pino": "^8.19.0",
+		"pino-elasticsearch": "^8.0.0"
 	}
 }

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/lib/logger.ts

@@ -1,172 +1,151 @@
-import Winston, {Logger as WinstonLogger, LoggerOptions} from 'winston'
-import {WinstonConfiguaration} from '../config'
+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()
 
 /**
- * Represents a log message with structured information.
+ * Pino logger backend - singleton
  */
-interface LogMessage {
-	/**
-	 * The name of the class that generated the log.
-	 */
-	className: string
+let pinoLogger: PinoLogger
 
-	/**
-	 * The name of the function that generated the log.
-	 */
-	functionName: string
+/**
+ * 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
+}
 
-	/**
-	 * The log message text.
-	 */
-	logMessage: string
+/**
+ * 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
 
 	/**
-	 * The user's IP address associated with the log.
+	 * Creates a new Logger instance with default configuration.
+	 * @param name - The name of the logger.
 	 */
-	userIp: string
+	constructor(name: string)
 
 	/**
-	 * Additional data associated with the log.
+	 * Creates a new Logger instance with custom Elasticsearch configuration.
+	 * @param name - The name of the logger.
+	 * @param elasticConfig - Optional Elasticsearch configuration.
 	 */
-	data?: Record<string, any>
-}
+	constructor(name: string, elasticConfig?: ElasticConfig)
 
-/**
- * Service for logging information, warnings, and errors using Winston.
- */
-class LoggerService {
-	private logger: WinstonLogger
+	constructor(name: string, elasticConfig?: ElasticConfig) {
+		this._name = name
+		this._logger = getLogger(elasticConfig)
+	}
 
-	/**
-	 * Creates an instance of LoggerService.
-	 * @param config - The configuration options for Winston logger.
-	 */
-	constructor(config: LoggerOptions) {
-		this.logger = Winston.createLogger({
-			...config,
-			level: process.env.LOG_LEVEL,
+	private log(logLevel: LOG_LEVEL, logEvent: LogEvent, ...args: unknown[]) {
+		this._logger[logLevel]({
+			component: this._name,
+			...logEvent,
+			detail: args,
 		})
-		if (process.env.NODE_ENV === 'local') {
-			this.logger.add(
-				new Winston.transports.Console({
-					level: 'info',
-					format: Winston.format.combine(
-						Winston.format.simple(),
-						Winston.format.colorize(),
-						Winston.format.printf(({level, message}) => {
-							return `[${level}]: ${JSON.stringify(message)}`
-							// Parse the message as JSON and include in the log
-						})
-					),
-				})
-			)
-		}
-
-		this.logger.level = process.env.LOG_LEVEL
 	}
 
 	/**
-	 * Logs an informational message.
-	 * @param className - The name of the class that generated the log.
-	 * @param functionName - The name of the function that generated the log.
-	 * @param logMessage - The log message text.
-	 * @param userIp - The user's IP address associated with the log.
-	 * @param data - Additional data associated with the log.
+	 * Logs an error message.
+	 * @param logEvent - The event to log.
+	 * @param args - Additional arguments to include in the log.
 	 */
-	info(
-		className: string,
-		functionName: string,
-		logMessage: string,
-		userIp: string
-	): void {
-		const message = this.createLogMessage(
-			className,
-			functionName,
-			logMessage,
-			userIp
-		)
-		this.log('info', message)
+	error(logEvent: LogEvent, ...args: unknown[]) {
+		this.log('error', logEvent, ...args)
 	}
 
 	/**
 	 * Logs a warning message.
-	 * @param className - The name of the class that generated the log.
-	 * @param functionName - The name of the function that generated the log.
-	 * @param logMessage - The log message text.
-	 * @param userIp - The user's IP address associated with the log.
-	 * @param data - Additional data associated with the log.
+	 * @param logEvent - The event to log.
+	 * @param args - Additional arguments to include in the log.
 	 */
-	warn(
-		className: string,
-		functionName: string,
-		logMessage: string,
-		userIp: string
-	): void {
-		const message = this.createLogMessage(
-			className,
-			functionName,
-			logMessage,
-			userIp
-		)
-		this.log('warn', message)
+	warn(logEvent: LogEvent, ...args: unknown[]) {
+		this.log('warn', logEvent, ...args)
 	}
 
 	/**
-	 * Logs an error message.
-	 * @param className - The name of the class that generated the log.
-	 * @param functionName - The name of the function that generated the log.
-	 * @param logMessage - The log message text.
-	 * @param userIp - The user's IP address associated with the log.
-	 * @param data - Additional data associated with the log.
+	 * Logs an informational message.
+	 * @param logEvent - The event to log.
+	 * @param args - Additional arguments to include in the log.
 	 */
-	error(
-		className: string,
-		functionName: string,
-		logMessage: string,
-		userIp: string,
-		data: Object = {}
-	): void {
-		const message = this.createLogMessage(
-			className,
-			functionName,
-			logMessage,
-			userIp,
-			data
-		)
-		this.log('error', message)
+	info(logEvent: LogEvent, ...args: unknown[]) {
+		this.log('info', logEvent, ...args)
 	}
 
-	private createLogMessage(
-		className: string,
-		functionName: string,
-		logMessage: string,
-		userIp: string,
-		data: Record<string, any> = {}
-	): LogMessage {
-		return {
-			className,
-			functionName,
-			logMessage,
-			userIp,
-			data,
-		}
+	/**
+	 * 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)
 	}
 
-	private log(level: string, logMessage: LogMessage): void {
-		this.logger.log({
-			level,
-			//@ts-ignore
-			message: logMessage,
-		})
-		process.on('unhandledRejection', (reason, promise) => {
-			this.logger.error('Unhandled Rejection at:', promise, 'reason:', reason)
-		})
-
-		process.on('uncaughtException', (err) => {
-			this.logger.error('Uncaught Exception:', err)
-		})
+	/**
+	 * 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)
 	}
 }
 
-const Logger = new LoggerService(WinstonConfiguaration)
 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
+}

package/src/config/index.ts

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

package/src/config/logger-config.ts

@@ -1,73 +0,0 @@
-import {ElasticsearchTransport} from 'winston-elasticsearch'
-import * as dotenv from '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 ElasticsearchTransport({
-					level: 'info',
-					indexPrefix: process.env.SERVER_NICKNAME, // Index prefix for Elasticsearch
-					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 ElasticsearchTransport({
-					level: LOG_LEVEL,
-					indexPrefix: SERVER_NICKNAME, // Index prefix for Elasticsearch
-					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 ElasticsearchTransport({
-					level: 'error',
-					indexPrefix: process.env.SERVER_NICKNAME, // Index prefix for Elasticsearch
-					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,
-}
-
-export default loggerConfiguration