zario 0.2.11 → 0.3.1

package/README.md

@@ -2,7 +2,7 @@
 
 A minimal, fast logging library for Node.js with TypeScript support.
 
-## UPDATE 2.9
+## What's New in 0.2.11
 
 - Added HTTP transport support with new HttpTransport class
 - Added log batching functionality for efficient writes
@@ -61,6 +61,7 @@ logger.error("❌ Database connection failed", { code: 500 });
 ### Transports
 
 #### Console Transport
+
 ```js
 import { Logger, ConsoleTransport } from "zario";
 
@@ -72,6 +73,7 @@ const logger = new Logger({
 ```
 
 #### File Transport
+
 ```js
 import { Logger, FileTransport } from "zario";
 
@@ -90,6 +92,7 @@ const logger = new Logger({
 ```
 
 #### HTTP Transport
+
 ```js
 import { Logger, HttpTransport } from "zario";
 
@@ -115,6 +118,7 @@ const logger = new Logger({
 - `logger.info(message, metadata?)` - Info level logging  
 - `logger.warn(message, metadata?)` - Warning level logging
 - `logger.error(message, metadata?)` - Error level logging
+- `logger.logWithLevel(level, message, metadata?)` - Log a message at an arbitrary/custom level
 - `logger.createChild(options)` - Creates a child logger with inherited settings
 - `logger.setLevel(level)` - Change the logger level at runtime
 - `logger.setFormat(format)` - Set the output format to text or json
@@ -122,6 +126,7 @@ const logger = new Logger({
 ## Usage Examples
 
 ### Basic Usage
+
 ```js
 import { Logger, ConsoleTransport } from "zario";
 
@@ -136,11 +141,13 @@ logger.error("Something went wrong", { userId: 123 });
 ```
 
 ### JSON Format
+
 ```js
 const logger = new Logger({ json: true });
 ```
 
 ### Custom Levels & Colors
+
 ```js
 import { Logger, ConsoleTransport } from "zario";
 
@@ -168,6 +175,7 @@ logger.logWithLevel('critical', 'This is a critical message in bright red');
 ```
 
 ### Child Loggers
+
 ```js
 const main = new Logger({ prefix: "[APP]" });
 const db = main.createChild({ prefix: "[DB]" });
@@ -177,6 +185,7 @@ db.error("Connection timeout");
 ```
 
 ### Multiple Transports
+
 ```js
 import { Logger, ConsoleTransport, FileTransport } from "zario";
 

package/dist/cjs/core/CustomLogLevel.js

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

package/dist/cjs/core/Formatter.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formatter = void 0;
+const TimeUtil_js_1 = require("../utils/TimeUtil.js");
+const ColorUtil_js_1 = require("../utils/ColorUtil.js");
+class Formatter {
+    constructor(options = {}) {
+        const { colorize = true, json = false, timestampFormat = "YYYY-MM-DD HH:mm:ss", timestamp = false, customColors = {}, } = options;
+        this.colorize = colorize;
+        this.json = json;
+        this.timestampFormat = timestampFormat;
+        this.timestamp = timestamp;
+        this.customColors = customColors;
+    }
+    format(data) {
+        if (this.json) {
+            return this.formatAsJson(data);
+        }
+        else {
+            return this.formatAsText(data);
+        }
+    }
+    formatAsJson(data) {
+        const formattedData = {
+            ...data.metadata, // Spread first so core fields can override
+            level: data.level,
+            message: data.message,
+        };
+        if (this.timestamp) {
+            formattedData.timestamp = data.timestamp.toISOString();
+        }
+        if (data.prefix) {
+            formattedData.prefix = data.prefix;
+        }
+        return JSON.stringify(formattedData);
+    }
+    formatAsText(data) {
+        let output = "";
+        if (this.timestamp) {
+            output += `[${TimeUtil_js_1.TimeUtil.format(data.timestamp, this.timestampFormat)}] `;
+        }
+        if (data.prefix) {
+            output += `${data.prefix} `;
+        }
+        let level = data.level.toUpperCase();
+        if (this.colorize) {
+            const color = this.customColors[data.level] || data.level;
+            level = ColorUtil_js_1.ColorUtil.colorize(level, color);
+        }
+        output += `[${level}] ${data.message}`;
+        if (data.metadata) {
+            output += ` ${JSON.stringify(data.metadata)}`;
+        }
+        return output;
+    }
+    setJson(json) {
+        this.json = json;
+    }
+    isColorized() {
+        return this.colorize;
+    }
+    isJson() {
+        return this.json;
+    }
+    getTimestampFormat() {
+        return this.timestampFormat;
+    }
+    hasTimestamp() {
+        return this.timestamp;
+    }
+    getCustomColors() {
+        return { ...this.customColors };
+    }
+}
+exports.Formatter = Formatter;

package/dist/cjs/core/LogLevel.js

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

package/dist/cjs/core/Logger.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const Formatter_js_1 = require("./Formatter.js");
+const ConsoleTransport_js_1 = require("../transports/ConsoleTransport.js");
+class Logger {
+    constructor(options = {}) {
+        this.transports = [];
+        const { level, colorize, json, transports = [], timestampFormat = "YYYY-MM-DD HH:mm:ss", prefix, timestamp, context = {}, parent, asyncMode, customLevels = {}, customColors = {}, } = options;
+        this.parent = parent; // Set parent
+        this.context = { ...context }; // Init context
+        this.customLevels = customLevels; // custom log store
+        this.asyncMode = false;
+        if (this.parent) {
+            this.level = level ?? this.parent.level;
+            this.prefix = prefix ?? this.parent.prefix;
+            this.timestamp = timestamp ?? this.parent.timestamp;
+            this.asyncMode = asyncMode ?? this.parent.asyncMode;
+            this.transports =
+                transports && transports.length > 0
+                    ? this.initTransports(transports)
+                    : this.parent.transports;
+            // Merge colors; child overrides parent
+            const mergedCColors = {
+                ...this.parent.formatter.getCustomColors(),
+                ...customColors,
+            };
+            this.formatter = new Formatter_js_1.Formatter({
+                colorize: this.getDefaultColorizeValue(colorize) ??
+                    this.parent.formatter.isColorized(),
+                json: json ?? this.parent.formatter.isJson(),
+                timestampFormat: timestampFormat ?? this.parent.formatter.getTimestampFormat(),
+                timestamp: timestamp ?? this.parent.formatter.hasTimestamp(),
+                customColors: mergedCColors,
+            });
+            this.context = { ...this.parent.context, ...this.context };
+            // Merge custom levels with parent's custom levels
+            this.customLevels = { ...this.parent.customLevels, ...customLevels };
+        }
+        else {
+            // Auto-configure based on environment
+            const isProd = this.isProductionEnvironment();
+            this.level = level ?? this.getDefaultLevel(isProd);
+            this.prefix = prefix ?? "";
+            this.timestamp = timestamp ?? this.getDefaultTimestamp(isProd);
+            const defaultTransports = transports && transports.length > 0
+                ? transports
+                : this.getDefaultTransports(isProd);
+            this.asyncMode = asyncMode ?? this.getDefaultAsyncMode(isProd);
+            this.transports = this.initTransports(defaultTransports);
+            this.formatter = new Formatter_js_1.Formatter({
+                colorize: this.getDefaultColorizeValue(colorize),
+                json: json ?? this.getDefaultJson(isProd),
+                timestampFormat,
+                timestamp: this.getDefaultTimestamp(isProd),
+                customColors,
+            });
+        }
+        if (!Logger._global) {
+            Logger._global = this;
+        }
+    }
+    isProductionEnvironment() {
+        const env = process.env.NODE_ENV?.toLowerCase();
+        return env === "production" || env === "prod";
+    }
+    getDefaultLevel(isProd) {
+        return isProd ? "warn" : "debug";
+    }
+    getDefaultColorizeValue(colorize) {
+        if (colorize !== undefined) {
+            return colorize;
+        }
+        const isProd = this.isProductionEnvironment();
+        return !isProd;
+    }
+    getDefaultJson(isProd) {
+        return isProd;
+    }
+    getDefaultTimestamp(isProd) {
+        return true;
+    }
+    getDefaultTransports(isProd) {
+        if (Logger.defaultTransportsFactory) {
+            return Logger.defaultTransportsFactory(isProd);
+        }
+        return [new ConsoleTransport_js_1.ConsoleTransport()];
+    }
+    getDefaultAsyncMode(isProd) {
+        return isProd;
+    }
+    initTransports(transportConfigs) {
+        const initializedTransports = [];
+        for (const transportConfig of transportConfigs) {
+            if (this.isTransport(transportConfig)) {
+                initializedTransports.push(transportConfig);
+            }
+        }
+        return initializedTransports;
+    }
+    isTransport(transport) {
+        return (typeof transport === "object" &&
+            transport !== null &&
+            typeof transport.write === "function");
+    }
+    shouldLog(level) {
+        // Get the priority of the current logger level
+        const currentLevelPriority = this.getLevelPriority(this.level);
+        // Get the priority of the message level
+        const messageLevelPriority = this.getLevelPriority(level);
+        return messageLevelPriority >= currentLevelPriority;
+    }
+    getLevelPriority(level) {
+        // use a static map to avoid repeated allocations
+        if (Logger.LEVEL_PRIORITIES.hasOwnProperty(level)) {
+            return Logger.LEVEL_PRIORITIES[level];
+        }
+        // Check if it's a custom level
+        if (this.customLevels && level in this.customLevels) {
+            const customPriority = this.customLevels[level];
+            return customPriority !== undefined ? customPriority : 999;
+        }
+        return 999;
+    }
+    log(level, message, metadata) {
+        if (!this.shouldLog(level) || level === "silent") {
+            return;
+        }
+        const timestamp = new Date();
+        // Optimize metadata merging
+        let finalMetadata;
+        const hasContext = this.context && Object.keys(this.context).length > 0;
+        if (hasContext && metadata) {
+            finalMetadata = { ...this.context, ...metadata };
+        }
+        else if (hasContext) {
+            finalMetadata = this.context;
+        }
+        else if (metadata) {
+            finalMetadata = metadata;
+        }
+        // Only add metadata if it's not empty after merging
+        const logData = {
+            level,
+            message,
+            timestamp,
+            metadata: finalMetadata && Object.keys(finalMetadata).length > 0
+                ? finalMetadata
+                : undefined,
+            prefix: this.prefix,
+        };
+        if (this.asyncMode) {
+            for (const transport of this.transports) {
+                if (transport.writeAsync) {
+                    transport.writeAsync(logData, this.formatter).catch((error) => {
+                        console.error("Error during async logging:", error);
+                    });
+                }
+                else {
+                    setImmediate(() => {
+                        transport.write(logData, this.formatter);
+                    });
+                }
+            }
+        }
+        else {
+            for (const transport of this.transports) {
+                transport.write(logData, this.formatter);
+            }
+        }
+    }
+    debug(message, metadata) {
+        this.log("debug", message, metadata);
+    }
+    info(message, metadata) {
+        this.log("info", message, metadata);
+    }
+    warn(message, metadata) {
+        this.log("warn", message, metadata);
+    }
+    error(message, metadata) {
+        this.log("error", message, metadata);
+    }
+    silent(message, metadata) {
+        this.log("silent", message, metadata);
+    }
+    boring(message, metadata) {
+        this.log("boring", message, metadata);
+    }
+    /**
+     * Generic log method that allows logging with custom levels
+     */
+    logWithLevel(level, message, metadata) {
+        this.log(level, message, metadata);
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    setFormat(format) {
+        this.formatter.setJson(format === "json");
+    }
+    setAsyncMode(asyncMode) {
+        this.asyncMode = asyncMode;
+    }
+    addTransport(transport) {
+        this.transports.push(transport);
+    }
+    getTimestampSetting() {
+        return this.timestamp;
+    }
+    static get global() {
+        if (!Logger._global) {
+            Logger._global = new Logger();
+        }
+        return Logger._global;
+    }
+    createChild(options = {}) {
+        return new Logger({ ...options, parent: this });
+    }
+    startTimer(name) {
+        const { Timer } = require("../utils/Timerutil");
+        return new Timer(name, (message) => this.info(message));
+    }
+}
+exports.Logger = Logger;
+Logger.defaultTransportsFactory = null;
+Logger.LEVEL_PRIORITIES = {
+    silent: 0,
+    boring: 1,
+    debug: 2,
+    info: 3,
+    warn: 4,
+    error: 5,
+};

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpTransport = exports.FileTransport = exports.ConsoleTransport = exports.Logger = void 0;
+const Logger_js_1 = require("./core/Logger.js");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return Logger_js_1.Logger; } });
+const index_js_1 = require("./transports/index.js");
+Object.defineProperty(exports, "ConsoleTransport", { enumerable: true, get: function () { return index_js_1.ConsoleTransport; } });
+Object.defineProperty(exports, "FileTransport", { enumerable: true, get: function () { return index_js_1.FileTransport; } });
+Object.defineProperty(exports, "HttpTransport", { enumerable: true, get: function () { return index_js_1.HttpTransport; } });
+// Configure default transports to maintain backward compatibility
+Logger_js_1.Logger.defaultTransportsFactory = (isProd) => {
+    if (isProd) {
+        return [new index_js_1.ConsoleTransport(), new index_js_1.FileTransport({ path: "./logs/app.log" })];
+    }
+    else {
+        return [new index_js_1.ConsoleTransport()];
+    }
+};
+exports.default = Logger_js_1.Logger;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/transports/ConsoleTransport.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleTransport = void 0;
+class ConsoleTransport {
+    constructor(options = {}) {
+        const { colorize = true } = options;
+        this.colorize = colorize;
+    }
+    write(data, formatter) {
+        // Toggle colorize temporarily, then restore it
+        const originalColorizeSetting = formatter["colorize"];
+        if (this.colorize !== originalColorizeSetting) {
+            formatter["colorize"] = this.colorize;
+        }
+        const output = formatter.format(data);
+        // Restore
+        if (this.colorize !== originalColorizeSetting) {
+            formatter["colorize"] = originalColorizeSetting;
+        }
+        switch (data.level) {
+            case "error":
+                console.error(output);
+                break;
+            case "warn":
+                console.warn(output);
+                break;
+            default:
+                console.log(output);
+                break;
+        }
+    }
+    async writeAsync(data, formatter) {
+        setImmediate(() => {
+            this.write(data, formatter);
+        });
+        return Promise.resolve();
+    }
+}
+exports.ConsoleTransport = ConsoleTransport;