log-tonic 1.0.1 → 1.1.0

package/README.md

@@ -1,15 +1,15 @@
 
 # Log-Tonic
 
-**Log-Tonic** is a powerful and flexible logging utility for Node.js and TypeScript projects. It allows you to easily manage and format log messages across different features or modules within your application, with customizable prefixes, suffixes, and time formats.
+**Log-Tonic** is an enterprise-grade, flexible logging utility for Node.js and TypeScript projects. It supports structured JSON logging, multiple transports (Console, File, etc.), log levels, and customizable formatting.
 
 ## Features
 
-- **Easy Initialization**: Initialize once with global settings for your entire application.
-- **Feature-Specific Logging**: Create loggers tailored for specific features or modules.
-- **Customizable Message Format**: Add optional prefixes and suffixes to log messages for better readability.
-- **Support for Multiple Log Levels**: Includes support for `debug`, `info`, and `error` log levels.
-- **TypeScript Support**: Fully typed with `.d.ts` files included for better integration in TypeScript projects.
+- **Enterprise Ready**: Structured JSON logging out of the box for easy ingestion by tools like Splunk, ELK, etc.
+- **Transport System**: Modular transport system. Writes to Console by default, but extensible to File, HTTP, etc.
+- **Rich Log Levels**: Support for `debug`, `info`, `warn`, `error`, and `fatal`.
+- **Feature-Specific Logging**: Create scoped loggers for different modules or features.
+- **TypeScript Support**: Built with TypeScript for full type safety.
 
 ## Installation
 
@@ -26,13 +26,17 @@ npm install log-tonic
 Initialize the logger at the start of your application with the desired configuration:
 
 ```typescript
-import { LoggerFactory } from 'log-tonic';
+import { LoggerFactory, ConsoleTransport, LogLevel } from 'log-tonic';
 
 LoggerFactory.initialize({
-  level: 'debug',
-  appName: 'MyApp',
-  timeFormat: 'yyyy-MM-dd HH:mm:ss', // Custom time format using date-fns
-  messageFormat: { prefix: '--> INFO: ', suffix: ' <-- END' } // Optional custom prefix and suffix
+  minLevel: LogLevel.DEBUG,
+  appName: 'MyEnterpriseApp',
+  transports: [
+    new ConsoleTransport({ 
+      useJson: true, // Enable structured JSON logging
+      useColor: true // Enable colors for non-JSON output 
+    })
+  ]
 });
 ```
 
@@ -43,32 +47,80 @@ Create a logger for a specific feature or module within your application:
 ```typescript
 const authLogger = LoggerFactory.createLogger('AuthService');
 
-authLogger.info('User login successful');
-authLogger.error('User login failed');
-authLogger.debug('User login attempt with username "admin"');
+// Pass metadata object as the second argument
+authLogger.info('User login successful', { userId: '12345', role: 'admin' });
+authLogger.error('Login failed', { error: 'Invalid credentials' });
 ```
 
-### 3. Available Configuration Options
+### 3. Log Levels
+
+Available log levels in order of priority:
+1. `DEBUG`
+2. `INFO`
+3. `WARN`
+4. `ERROR`
+5. `FATAL`
 
-- **level**: Sets the global log level. Available options are `debug`, `info`, `error`.
-- **appName**: The name of your application (default is `MyApp`).
-- **timeFormat**: The format for timestamps, using date-fns format tokens (e.g., `yyyy-MM-dd HH:mm:ss`).
-- **messageFormat**: Optionally set `prefix` and `suffix` to wrap your log messages (e.g., `{ prefix: '--> INFO: ', suffix: ' <-- END' }`).
+### 4. Custom Transports
 
-## Example
+You can create custom transports by implementing the `Transport` interface:
 
 ```typescript
-const paymentLogger = LoggerFactory.createLogger('PaymentService');
+import { Transport, LogEntry } from 'log-tonic';
+
+class MyCustomTransport implements Transport {
+  log(entry: LogEntry): void {
+    // Send log to external service
+    console.log('Sending to cloud:', entry);
+  }
+}
+```
+
+## Migration Guide (v1.0.x -> v1.1.0)
+
+If you are upgrading from `v1.0.1` or earlier, there are some breaking changes to support the new enterprise features.
+
+### 1. Initialization Changes
 
-paymentLogger.info('Payment processed successfully');
-paymentLogger.error('Payment failed');
-paymentLogger.debug('Processing payment for user ID 123');
+The `level` property has been renamed to `minLevel` and now accepts a `LogLevel` enum instead of a string.
+
+**v1.0.0 (Old):**
+```typescript
+LoggerFactory.initialize({
+  level: 'debug',
+  appName: 'MyApp'
+});
 ```
 
-This example will produce logs formatted like:
+**v1.1.0 (New):**
+```typescript
+import { LoggerFactory, LogLevel } from 'log-tonic';
 
+LoggerFactory.initialize({
+  minLevel: LogLevel.DEBUG, // Changed from string to Enum
+  appName: 'MyApp'
+  // Transports are optional, defaults to ConsoleTransport
+});
 ```
-2024-08-11 13:45:30 [MyApp] [PaymentService] INFO: --> INFO: Payment processed successfully <-- END
+
+### 2. Log Levels
+
+We have moved from strict string types to an Enum for better type safety and added new levels.
+
+- Old: `'debug'`, `'info'`, `'error'`
+- New: `LogLevel.DEBUG`, `LogLevel.INFO`, `LogLevel.WARN`, `LogLevel.ERROR`, `LogLevel.FATAL`
+
+### 3. Creating Loggers
+
+`createLogger` remains largely valid, but methods now support metadata objects.
+
+```typescript
+// v1.0.0
+logger.info('Message');
+
+// v1.1.0
+logger.info('Message'); // Still works
+logger.info('Message', { meta: 'data' }); // New capability
 ```
 
 ## Contributing

package/lib/index.d.ts

@@ -13,5 +13,7 @@
  *
  * Copyright 2024 Sitharaj Seenivasan
  */
-export { LoggerFactory, LoggerConfig } from './loggerFactory';
+export * from './types';
+export * from './transports';
+export { LoggerFactory } from './loggerFactory';
 export { default as Logger } from './logger';

package/lib/index.js

@@ -14,11 +14,27 @@
  *
  * Copyright 2024 Sitharaj Seenivasan
  */
+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);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = exports.LoggerFactory = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./transports"), exports);
 var loggerFactory_1 = require("./loggerFactory");
 Object.defineProperty(exports, "LoggerFactory", { enumerable: true, get: function () { return loggerFactory_1.LoggerFactory; } });
 var logger_1 = require("./logger");

package/lib/logger.d.ts

@@ -13,70 +13,29 @@
  *
  * Copyright 2024 Sitharaj Seenivasan
  */
+import { LoggerConfig } from './types';
 /**
- * Logger class responsible for handling log messages with different levels and features.
+ * Enterprise-grade Logger class.
+ * Supports multiple transports, structured logging, and configurable formatting.
  *
  * @class Logger
  */
 declare class Logger {
-    private level;
-    private appName;
-    private timeFormat;
-    private messageFormat;
-    private levels;
+    private config;
+    private transports;
     /**
      * Constructs a Logger instance.
      *
-     * @param {string} level - The logging level (debug, info, error).
-     * @param {string} [appName] - The name of the application.
-     * @param {string} [timeFormat] - The format for the timestamp.
-     * @param {Object} [messageFormat] - The prefix and suffix for log messages.
-     */
-    constructor(level: string, appName?: string, timeFormat?: string, messageFormat?: {
-        prefix?: string;
-        suffix?: string;
-    });
-    /**
-     * Formats the current timestamp according to the specified time format using date-fns.
-     *
-     * @returns {string} The formatted timestamp.
+     * @param {LoggerConfig} config - Configuration object.
      */
+    constructor(config: LoggerConfig);
     private formatTime;
-    /**
-     * Formats the log message by adding the specified prefix and suffix.
-     *
-     * @param {string} message - The log message.
-     * @returns {string} The formatted log message.
-     */
     private formatMessage;
-    /**
-     * Logs a message with the specified level and feature.
-     *
-     * @param {string} level - The logging level (debug, info, error).
-     * @param {string} feature - The feature name associated with the log message.
-     * @param {string} message - The log message.
-     */
     private log;
-    /**
-     * Logs an informational message.
-     *
-     * @param {string} feature - The feature name associated with the log message.
-     * @param {string} message - The log message.
-     */
-    info(feature: string, message: string): void;
-    /**
-     * Logs an error message.
-     *
-     * @param {string} feature - The feature name associated with the log message.
-     * @param {string} message - The log message.
-     */
-    error(feature: string, message: string): void;
-    /**
-     * Logs a debug message.
-     *
-     * @param {string} feature - The feature name associated with the log message.
-     * @param {string} message - The log message.
-     */
-    debug(feature: string, message: string): void;
+    debug(feature: string, message: string, meta?: Record<string, any>): void;
+    info(feature: string, message: string, meta?: Record<string, any>): void;
+    warn(feature: string, message: string, meta?: Record<string, any>): void;
+    error(feature: string, message: string, meta?: Record<string, any>): void;
+    fatal(feature: string, message: string, meta?: Record<string, any>): void;
 }
 export default Logger;

package/lib/logger.js

@@ -16,8 +16,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 var date_fns_1 = require("date-fns");
+var types_1 = require("./types");
+var transports_1 = require("./transports");
 /**
- * Logger class responsible for handling log messages with different levels and features.
+ * Enterprise-grade Logger class.
+ * Supports multiple transports, structured logging, and configurable formatting.
  *
  * @class Logger
  */
@@ -25,85 +28,63 @@ var Logger = /** @class */ (function () {
     /**
      * Constructs a Logger instance.
      *
-     * @param {string} level - The logging level (debug, info, error).
-     * @param {string} [appName] - The name of the application.
-     * @param {string} [timeFormat] - The format for the timestamp.
-     * @param {Object} [messageFormat] - The prefix and suffix for log messages.
+     * @param {LoggerConfig} config - Configuration object.
      */
-    function Logger(level, appName, timeFormat, messageFormat) {
-        this.level = level;
-        this.appName = appName || "MyApp";
-        this.timeFormat = timeFormat || "YYYY-MM-DD HH:mm:ss";
-        this.messageFormat = messageFormat || null;
-        this.levels = { debug: 0, info: 1, error: 2 };
+    function Logger(config) {
+        this.config = config;
+        this.transports = config.transports && config.transports.length > 0
+            ? config.transports
+            : [new transports_1.ConsoleTransport()];
     }
-    /**
-     * Formats the current timestamp according to the specified time format using date-fns.
-     *
-     * @returns {string} The formatted timestamp.
-     */
     Logger.prototype.formatTime = function () {
         var now = new Date();
         try {
-            return (0, date_fns_1.format)(now, this.timeFormat);
+            return (0, date_fns_1.format)(now, this.config.timeFormat || "yyyy-MM-dd HH:mm:ss");
         }
         catch (error) {
-            console.warn("Invalid time format provided: ".concat(this.timeFormat, ". Falling back to default ISO format."));
-            return now.toISOString().replace("T", " ").split(".")[0]; // Fallback to ISO format
+            return now.toISOString();
         }
     };
-    /**
-     * Formats the log message by adding the specified prefix and suffix.
-     *
-     * @param {string} message - The log message.
-     * @returns {string} The formatted log message.
-     */
     Logger.prototype.formatMessage = function (message) {
-        if (this.messageFormat) {
-            return "".concat(this.messageFormat.prefix || "").concat(message).concat(this.messageFormat.suffix || "");
-        }
-        return message;
+        var _a = this.config.messageFormat || {}, prefix = _a.prefix, suffix = _a.suffix;
+        return "".concat(prefix || "").concat(message).concat(suffix || "");
     };
-    /**
-     * Logs a message with the specified level and feature.
-     *
-     * @param {string} level - The logging level (debug, info, error).
-     * @param {string} feature - The feature name associated with the log message.
-     * @param {string} message - The log message.
-     */
-    Logger.prototype.log = function (level, feature, message) {
-        if (this.levels[level] >= this.levels[this.level]) {
-            var timestamp = this.formatTime();
-            var formattedMessage = this.formatMessage(message);
-            console.log("".concat(timestamp, " [").concat(this.appName, "] [").concat(feature, "] ").concat(level.toUpperCase(), ": ").concat(formattedMessage));
+    Logger.prototype.log = function (level, feature, message, meta) {
+        if (types_1.LogLevelPriority[level] < types_1.LogLevelPriority[this.config.minLevel]) {
+            return;
+        }
+        var entry = {
+            timestamp: this.formatTime(),
+            level: level,
+            appName: this.config.appName || "MyApp",
+            feature: feature,
+            message: this.formatMessage(message),
+            meta: meta,
+        };
+        for (var _i = 0, _a = this.transports; _i < _a.length; _i++) {
+            var transport = _a[_i];
+            try {
+                transport.log(entry);
+            }
+            catch (e) {
+                console.error("Failed to log to transport:", e);
+            }
         }
     };
-    /**
-     * Logs an informational message.
-     *
-     * @param {string} feature - The feature name associated with the log message.
-     * @param {string} message - The log message.
-     */
-    Logger.prototype.info = function (feature, message) {
-        this.log("info", feature, message);
+    Logger.prototype.debug = function (feature, message, meta) {
+        this.log(types_1.LogLevel.DEBUG, feature, message, meta);
     };
-    /**
-     * Logs an error message.
-     *
-     * @param {string} feature - The feature name associated with the log message.
-     * @param {string} message - The log message.
-     */
-    Logger.prototype.error = function (feature, message) {
-        this.log("error", feature, message);
+    Logger.prototype.info = function (feature, message, meta) {
+        this.log(types_1.LogLevel.INFO, feature, message, meta);
     };
-    /**
-     * Logs a debug message.
-     *
-     * @param {string} feature - The feature name associated with the log message.
-     * @param {string} message - The log message.
-     */
-    Logger.prototype.debug = function (feature, message) {
-        this.log("debug", feature, message);
+    Logger.prototype.warn = function (feature, message, meta) {
+        this.log(types_1.LogLevel.WARN, feature, message, meta);
+    };
+    Logger.prototype.error = function (feature, message, meta) {
+        this.log(types_1.LogLevel.ERROR, feature, message, meta);
+    };
+    Logger.prototype.fatal = function (feature, message, meta) {
+        this.log(types_1.LogLevel.FATAL, feature, message, meta);
     };
     return Logger;
 }());

package/lib/loggerFactory.d.ts

@@ -12,21 +12,9 @@
  * limitations under the License.
  *
  * Copyright 2024 Sitharaj Seenivasan
-
  */
 import Logger from "./logger";
-/**
- * Interface representing the configuration options for the Logger.
- */
-export interface LoggerConfig {
-    level: "debug" | "info" | "error";
-    appName?: string;
-    timeFormat?: string;
-    messageFormat?: {
-        prefix?: string;
-        suffix?: string;
-    };
-}
+import { LoggerConfig } from "./types";
 /**
  * LoggerFactory class responsible for creating and managing Logger instances.
  *
@@ -45,11 +33,13 @@ export declare class LoggerFactory {
      * Creates a logger for the specified feature.
      *
      * @param {string} feature - The feature name for which to create the logger.
-     * @returns {Object} An object containing methods for logging info, error, and debug messages.
+     * @returns {Object} An object containing methods for logging.
      */
     static createLogger(feature: string): {
-        info: (message: string) => void;
-        error: (message: string) => void;
-        debug: (message: string) => void;
+        debug: (message: string, meta?: Record<string, any>) => void;
+        info: (message: string, meta?: Record<string, any>) => void;
+        warn: (message: string, meta?: Record<string, any>) => void;
+        error: (message: string, meta?: Record<string, any>) => void;
+        fatal: (message: string, meta?: Record<string, any>) => void;
     };
 }

package/lib/loggerFactory.js

@@ -13,7 +13,6 @@
  * limitations under the License.
  *
  * Copyright 2024 Sitharaj Seenivasan
-
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -37,7 +36,7 @@ var LoggerFactory = /** @class */ (function () {
      */
     LoggerFactory.initialize = function (config) {
         if (!LoggerFactory.loggerInstance) {
-            LoggerFactory.loggerInstance = new logger_1.default(config.level, config.appName, config.timeFormat, config.messageFormat);
+            LoggerFactory.loggerInstance = new logger_1.default(config);
         }
         return LoggerFactory.loggerInstance;
     };
@@ -45,21 +44,27 @@ var LoggerFactory = /** @class */ (function () {
      * Creates a logger for the specified feature.
      *
      * @param {string} feature - The feature name for which to create the logger.
-     * @returns {Object} An object containing methods for logging info, error, and debug messages.
+     * @returns {Object} An object containing methods for logging.
      */
     LoggerFactory.createLogger = function (feature) {
         if (!LoggerFactory.loggerInstance) {
             throw new Error("Logger is not initialized. Call LoggerFactory.initialize(config) first.");
         }
         return {
-            info: function (message) {
-                return LoggerFactory.loggerInstance.info(feature, message);
+            debug: function (message, meta) {
+                return LoggerFactory.loggerInstance.debug(feature, message, meta);
             },
-            error: function (message) {
-                return LoggerFactory.loggerInstance.error(feature, message);
+            info: function (message, meta) {
+                return LoggerFactory.loggerInstance.info(feature, message, meta);
             },
-            debug: function (message) {
-                return LoggerFactory.loggerInstance.debug(feature, message);
+            warn: function (message, meta) {
+                return LoggerFactory.loggerInstance.warn(feature, message, meta);
+            },
+            error: function (message, meta) {
+                return LoggerFactory.loggerInstance.error(feature, message, meta);
+            },
+            fatal: function (message, meta) {
+                return LoggerFactory.loggerInstance.fatal(feature, message, meta);
             },
         };
     };

package/lib/transports.d.ts

@@ -0,0 +1,12 @@
+import { Transport, LogEntry } from './types';
+export declare class ConsoleTransport implements Transport {
+    private useJson;
+    private useColor;
+    constructor(options?: {
+        useJson?: boolean;
+        useColor?: boolean;
+    });
+    private getColor;
+    private getReset;
+    log(entry: LogEntry): void;
+}

package/lib/transports.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleTransport = void 0;
+var types_1 = require("./types");
+var ConsoleTransport = /** @class */ (function () {
+    function ConsoleTransport(options) {
+        if (options === void 0) { options = {}; }
+        this.useJson = options.useJson || false;
+        this.useColor = options.useColor !== false; // Default to true
+    }
+    ConsoleTransport.prototype.getColor = function (level) {
+        if (!this.useColor)
+            return '';
+        switch (level) {
+            case types_1.LogLevel.DEBUG: return '\x1b[34m'; // Blue
+            case types_1.LogLevel.INFO: return '\x1b[32m'; // Green
+            case types_1.LogLevel.WARN: return '\x1b[33m'; // Yellow
+            case types_1.LogLevel.ERROR: return '\x1b[31m'; // Red
+            case types_1.LogLevel.FATAL: return '\x1b[35m'; // Magenta
+            default: return '\x1b[37m'; // White
+        }
+    };
+    ConsoleTransport.prototype.getReset = function () {
+        return this.useColor ? '\x1b[0m' : '';
+    };
+    ConsoleTransport.prototype.log = function (entry) {
+        if (this.useJson) {
+            console.log(JSON.stringify(entry));
+            return;
+        }
+        var color = this.getColor(entry.level);
+        var reset = this.getReset();
+        var metaStr = entry.meta && Object.keys(entry.meta).length > 0
+            ? " ".concat(JSON.stringify(entry.meta))
+            : '';
+        var featureStr = entry.feature ? " [".concat(entry.feature, "]") : '';
+        console.log("".concat(entry.timestamp, " [").concat(entry.appName, "]").concat(featureStr, " ").concat(color).concat(entry.level.toUpperCase()).concat(reset, ": ").concat(entry.message).concat(metaStr));
+    };
+    return ConsoleTransport;
+}());
+exports.ConsoleTransport = ConsoleTransport;

package/lib/types.d.ts

@@ -0,0 +1,29 @@
+export declare enum LogLevel {
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    FATAL = "fatal"
+}
+export declare const LogLevelPriority: Record<LogLevel, number>;
+export interface LogEntry {
+    timestamp: string;
+    level: LogLevel;
+    appName: string;
+    feature?: string;
+    message: string;
+    meta?: Record<string, any>;
+}
+export interface Transport {
+    log(entry: LogEntry): void;
+}
+export interface LoggerConfig {
+    minLevel: LogLevel;
+    appName?: string;
+    timeFormat?: string;
+    transports?: Transport[];
+    messageFormat?: {
+        prefix?: string;
+        suffix?: string;
+    };
+}

package/lib/types.js

@@ -0,0 +1,19 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevelPriority = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+    LogLevel["FATAL"] = "fatal";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+exports.LogLevelPriority = (_a = {},
+    _a[LogLevel.DEBUG] = 0,
+    _a[LogLevel.INFO] = 1,
+    _a[LogLevel.WARN] = 2,
+    _a[LogLevel.ERROR] = 3,
+    _a[LogLevel.FATAL] = 4,
+    _a);

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "log-tonic",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "A powerful and flexible logging utility for Node.js and TypeScript projects.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
@@ -33,4 +36,4 @@
   "devDependencies": {
     "typescript": "^5.5.4"
   }
-}
+}

package/src/index.ts

@@ -1,18 +0,0 @@
-/**
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * 
- * Copyright 2024 Sitharaj Seenivasan 
- */
-
-export { LoggerFactory, LoggerConfig } from './loggerFactory';
-export { default as Logger } from './logger';

package/src/logger.ts

@@ -1,132 +0,0 @@
-/**
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * 
- * Copyright 2024 Sitharaj Seenivasan 
- */
-
-import { format } from 'date-fns';
-
-/**
- * Logger class responsible for handling log messages with different levels and features.
- *
- * @class Logger
- */
-class Logger {
-  private level: string;
-  private appName: string;
-  private timeFormat: string;
-  private messageFormat: { prefix?: string; suffix?: string } | null;
-  private levels: { [key: string]: number };
-
-  /**
-   * Constructs a Logger instance.
-   *
-   * @param {string} level - The logging level (debug, info, error).
-   * @param {string} [appName] - The name of the application.
-   * @param {string} [timeFormat] - The format for the timestamp.
-   * @param {Object} [messageFormat] - The prefix and suffix for log messages.
-   */
-  constructor(
-    level: string,
-    appName?: string,
-    timeFormat?: string,
-    messageFormat?: { prefix?: string; suffix?: string }
-  ) {
-    this.level = level;
-    this.appName = appName || "MyApp";
-    this.timeFormat = timeFormat || "YYYY-MM-DD HH:mm:ss";
-    this.messageFormat = messageFormat || null;
-    this.levels = { debug: 0, info: 1, error: 2 };
-  }
-
-/**
- * Formats the current timestamp according to the specified time format using date-fns.
- * 
- * @returns {string} The formatted timestamp.
- */
-private formatTime(): string {
-  const now = new Date();
-
-  try {
-    return format(now, this.timeFormat);
-  } catch (error) {
-    console.warn(`Invalid time format provided: ${this.timeFormat}. Falling back to default ISO format.`);
-    return now.toISOString().replace("T", " ").split(".")[0]; // Fallback to ISO format
-  }
-}
-  /**
-   * Formats the log message by adding the specified prefix and suffix.
-   *
-   * @param {string} message - The log message.
-   * @returns {string} The formatted log message.
-   */
-  private formatMessage(message: string): string {
-    if (this.messageFormat) {
-      return `${this.messageFormat.prefix || ""}${message}${
-        this.messageFormat.suffix || ""
-      }`;
-    }
-    return message;
-  }
-
-  /**
-   * Logs a message with the specified level and feature.
-   *
-   * @param {string} level - The logging level (debug, info, error).
-   * @param {string} feature - The feature name associated with the log message.
-   * @param {string} message - The log message.
-   */
-  private log(level: string, feature: string, message: string): void {
-    if (this.levels[level] >= this.levels[this.level]) {
-      const timestamp = this.formatTime();
-      const formattedMessage = this.formatMessage(message);
-      console.log(
-        `${timestamp} [${
-          this.appName
-        }] [${feature}] ${level.toUpperCase()}: ${formattedMessage}`
-      );
-    }
-  }
-
-  /**
-   * Logs an informational message.
-   *
-   * @param {string} feature - The feature name associated with the log message.
-   * @param {string} message - The log message.
-   */
-  public info(feature: string, message: string): void {
-    this.log("info", feature, message);
-  }
-
-  /**
-   * Logs an error message.
-   *
-   * @param {string} feature - The feature name associated with the log message.
-   * @param {string} message - The log message.
-   */
-  public error(feature: string, message: string): void {
-    this.log("error", feature, message);
-  }
-
-  /**
-   * Logs a debug message.
-   *
-   * @param {string} feature - The feature name associated with the log message.
-   * @param {string} message - The log message.
-   */
-  public debug(feature: string, message: string): void {
-    this.log("debug", feature, message);
-  }
-}
-
-export default Logger;

package/src/loggerFactory.ts

@@ -1,77 +0,0 @@
-/**
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * 
- * Copyright 2024 Sitharaj Seenivasan 
-
- */
-
-import Logger from "./logger";
-
-/**
- * Interface representing the configuration options for the Logger.
- */
-export interface LoggerConfig {
-  level: "debug" | "info" | "error";
-  appName?: string;
-  timeFormat?: string;
-  messageFormat?: { prefix?: string; suffix?: string };
-}
-
-/**
- * LoggerFactory class responsible for creating and managing Logger instances.
- *
- * @class LoggerFactory
- */
-export class LoggerFactory {
-  private static loggerInstance: Logger | null = null;
-
-  /**
-   * Initializes the logger with the provided configuration.
-   *
-   * @param {LoggerConfig} config - The configuration for the logger.
-   * @returns {Logger} The initialized Logger instance.
-   */
-  public static initialize(config: LoggerConfig): Logger {
-    if (!LoggerFactory.loggerInstance) {
-      LoggerFactory.loggerInstance = new Logger(
-        config.level,
-        config.appName,
-        config.timeFormat,
-        config.messageFormat
-      );
-    }
-    return LoggerFactory.loggerInstance;
-  }
-
-  /**
-   * Creates a logger for the specified feature.
-   *
-   * @param {string} feature - The feature name for which to create the logger.
-   * @returns {Object} An object containing methods for logging info, error, and debug messages.
-   */
-  public static createLogger(feature: string) {
-    if (!LoggerFactory.loggerInstance) {
-      throw new Error(
-        "Logger is not initialized. Call LoggerFactory.initialize(config) first."
-      );
-    }
-    return {
-      info: (message: string) =>
-        LoggerFactory.loggerInstance!.info(feature, message),
-      error: (message: string) =>
-        LoggerFactory.loggerInstance!.error(feature, message),
-      debug: (message: string) =>
-        LoggerFactory.loggerInstance!.debug(feature, message),
-    };
-  }
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es5",                         // Target ECMAScript version
-    "module": "commonjs",                    // Module system to be used in the generated code
-    "declaration": true,                     // Generate .d.ts files alongside the compiled .js files
-    "outDir": "./lib",                       // Output directory for compiled JavaScript files
-    "rootDir": "./src",                      // Root directory of your TypeScript source files
-    "strict": true,                          // Enable all strict type-checking options
-    "esModuleInterop": true,                 // Allows default imports from modules with no default export
-    "skipLibCheck": true,                    // Skip type checking of declaration files (to speed up compilation)
-    "forceConsistentCasingInFileNames": true // Ensure file names are consistent between case-sensitive and insensitive environments
-  },
-  "include": ["src/**/*"],                    // Include all TypeScript files in the src directory
-  "exclude": ["node_modules", "lib"]          // Exclude the node_modules and lib directories from compilation
-}