zario 0.2.11 → 0.3.1

package/dist/cjs/transports/FileTransport.js

@@ -0,0 +1,260 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTransport = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const zlib = __importStar(require("zlib"));
+const util_1 = require("util");
+const compressGzip = (0, util_1.promisify)(zlib.gzip);
+const compressDeflate = (0, util_1.promisify)(zlib.deflate);
+class FileTransport {
+    constructor(options) {
+        // batching funct
+        this.batchQueue = [];
+        this.batchTimer = null;
+        const { path: filePath, maxSize = 10 * 1024 * 1024, maxFiles = 5, compression = "none", batchInterval = 0, // no batching
+        compressOldFiles = true, } = options;
+        this.filePath = filePath;
+        this.maxSize = maxSize;
+        this.maxFiles = maxFiles;
+        this.compression = compression;
+        this.batchInterval = batchInterval;
+        this.compressOldFiles = compressOldFiles;
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        if (!fs.existsSync(this.filePath)) {
+            fs.writeFileSync(this.filePath, "", "utf8");
+        }
+        // Start batching if an interval is set
+        if (batchInterval > 0) {
+            this.startBatching();
+        }
+    }
+    write(data, formatter) {
+        const output = formatter.format(data);
+        const formattedOutput = output + "\n";
+        if (this.batchInterval > 0) {
+            // Queue entry if batching is enabled
+            this.batchQueue.push({
+                data: formattedOutput,
+                timestamp: new Date(),
+            });
+        }
+        else {
+            // Write immediately when batching is disabled
+            fs.appendFileSync(this.filePath, formattedOutput);
+            if (this.shouldRotate()) {
+                this.rotateFiles();
+            }
+        }
+    }
+    async writeAsync(data, formatter) {
+        const formattedOutput = formatter.format(data) + "\n";
+        if (this.batchInterval > 0) {
+            this.batchQueue.push({
+                data: formattedOutput,
+                timestamp: new Date(),
+            });
+        }
+        else {
+            try {
+                await fs.promises.appendFile(this.filePath, formattedOutput);
+                if (this.shouldRotate()) {
+                    await this.rotateFilesAsync();
+                }
+            }
+            catch (err) {
+                throw err;
+            }
+        }
+    }
+    shouldRotate() {
+        if (!fs.existsSync(this.filePath))
+            return false;
+        try {
+            return fs.statSync(this.filePath).size >= this.maxSize;
+        }
+        catch {
+            return false;
+        }
+    }
+    rotateFiles() {
+        try {
+            if (!fs.existsSync(this.filePath))
+                return;
+            const currentContent = fs.readFileSync(this.filePath, "utf8");
+            this.performRotation(currentContent, fs.writeFileSync);
+            this.cleanupOldFiles();
+        }
+        catch (error) {
+            console.error("Error during file rotation:", error);
+        }
+    }
+    async rotateFilesAsync() {
+        try {
+            if (!fs.existsSync(this.filePath))
+                return;
+            const currentContent = await fs.promises.readFile(this.filePath, "utf8");
+            await this.performRotationAsync(currentContent);
+            await this.cleanupOldFilesAsync();
+        }
+        catch (error) {
+            console.error("Error during async file rotation:", error);
+        }
+    }
+    performRotation(content, writeFn) {
+        let rotatedFilePath = this.getRotatedFilePath();
+        if (this.compression !== "none" && this.compressOldFiles) {
+            rotatedFilePath += `.${this.compression === "gzip" ? "gz" : "zz"}`;
+            const compressed = this.compression === "gzip" ? zlib.gzipSync(content) : zlib.deflateSync(content);
+            writeFn(rotatedFilePath, compressed);
+        }
+        else {
+            writeFn(rotatedFilePath, content, "utf8");
+        }
+        writeFn(this.filePath, "", "utf8");
+    }
+    async performRotationAsync(content) {
+        let rotatedFilePath = this.getRotatedFilePath();
+        if (this.compression !== "none" && this.compressOldFiles) {
+            rotatedFilePath += `.${this.compression === "gzip" ? "gz" : "zz"}`;
+            const compressed = this.compression === "gzip" ? await compressGzip(content) : await compressDeflate(content);
+            await fs.promises.writeFile(rotatedFilePath, compressed);
+        }
+        else {
+            await fs.promises.writeFile(rotatedFilePath, content, "utf8");
+        }
+        await fs.promises.writeFile(this.filePath, "", "utf8");
+    }
+    getRotatedFilePath() {
+        const dir = path.dirname(this.filePath);
+        return path.join(dir, `${path.basename(this.filePath)}.${Date.now()}`);
+    }
+    filterRotatedFiles(files, baseName) {
+        return files
+            .filter(f => f !== baseName && f.startsWith(baseName + "."))
+            .sort((a, b) => {
+            const getTs = (s) => parseInt(s.slice(baseName.length + 1).split(".")[0] ?? "0");
+            return getTs(b) - getTs(a);
+        });
+    }
+    cleanupOldFiles() {
+        const dir = path.dirname(this.filePath);
+        const baseName = path.basename(this.filePath);
+        try {
+            const files = fs.readdirSync(dir);
+            const rotated = this.filterRotatedFiles(files, baseName);
+            for (let i = this.maxFiles; i < rotated.length; i++) {
+                const file = rotated[i];
+                if (file) {
+                    try {
+                        fs.unlinkSync(path.join(dir, file));
+                    }
+                    catch { }
+                }
+            }
+        }
+        catch { }
+    }
+    async cleanupOldFilesAsync() {
+        const dir = path.dirname(this.filePath);
+        const baseName = path.basename(this.filePath);
+        try {
+            const files = await fs.promises.readdir(dir);
+            const rotated = this.filterRotatedFiles(files, baseName);
+            await Promise.all(rotated.slice(this.maxFiles).map(f => fs.promises.unlink(path.join(dir, f)).catch(() => { })));
+        }
+        catch { }
+    }
+    startBatching() {
+        if (this.batchInterval > 0) {
+            this.batchTimer = setInterval(() => {
+                this.processBatch().catch((error) => {
+                    console.error("Error in batch processing timer:", error);
+                });
+            }, this.batchInterval);
+        }
+    }
+    async processBatch() {
+        if (this.batchQueue.length === 0) {
+            return;
+        }
+        // Atomically capture and clear queue
+        const currentBatch = this.batchQueue;
+        this.batchQueue = [];
+        // Combine queued entries into one batch
+        const batchContent = currentBatch.map((entry) => entry.data).join("");
+        try {
+            await new Promise((resolve, reject) => {
+                fs.appendFile(this.filePath, batchContent, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            // Rotate if needed after writing
+            if (this.shouldRotate()) {
+                await this.rotateFilesAsync();
+            }
+        }
+        catch (error) {
+            console.error("Error processing log batch:", error);
+            // On error, restore entries for retry (prepend to preserve order)
+            this.batchQueue = [...currentBatch, ...this.batchQueue];
+        }
+    }
+    // Clean up resources when the transport is disposed
+    async destroy() {
+        if (this.batchTimer) {
+            clearInterval(this.batchTimer);
+            this.batchTimer = null;
+        }
+        // Flush remaining queued entries
+        if (this.batchQueue.length > 0) {
+            try {
+                await this.processBatch();
+            }
+            catch (error) {
+                console.error("Error processing final batch:", error);
+            }
+        }
+    }
+}
+exports.FileTransport = FileTransport;

package/dist/cjs/transports/HttpTransport.js

@@ -0,0 +1,150 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpTransport = void 0;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const url = __importStar(require("url"));
+class HttpTransport {
+    constructor(options) {
+        const { url, method = 'POST', headers = {}, timeout = 5000, retries = 3 // defaults
+         } = options;
+        if (!url) {
+            throw new Error('HttpTransport requires a URL option');
+        }
+        this.url = url;
+        this.method = method.toUpperCase();
+        this.headers = { ...headers };
+        this.timeout = timeout;
+        this.retries = retries;
+        // Set default Content-Type if not provided
+        if (!this.headers['Content-Type'] && !this.headers['content-type']) {
+            this.headers['Content-Type'] = 'application/json';
+        }
+    }
+    write(data, formatter) {
+        // Format the data as JSON for HTTP transport
+        const logObject = this.parseFormattedData(data);
+        const body = JSON.stringify(logObject);
+        setImmediate(() => {
+            this.sendHttpRequestWithRetry(body, 0)
+                .catch((error) => {
+                console.error('HttpTransport error (sync mode):', error.message);
+            });
+        });
+    }
+    async writeAsync(data, formatter) {
+        // json formating for HttpTransport
+        const logObject = this.parseFormattedData(data);
+        const body = JSON.stringify(logObject);
+        await this.sendHttpRequestWithRetry(body, this.retries);
+    }
+    parseFormattedData(originalData) {
+        // structured log overide original params
+        return {
+            level: originalData.level,
+            message: originalData.message,
+            timestamp: originalData.timestamp.toISOString(),
+            ...(originalData.prefix && { prefix: originalData.prefix }),
+            ...(originalData.metadata && { metadata: originalData.metadata })
+        };
+    }
+    async sendHttpRequestWithRetry(body, maxRetries) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                await this.sendHttpRequest(body);
+                return; // success then exit
+            }
+            catch (error) {
+                lastError = error;
+                // stop if last attempt
+                if (attempt === maxRetries) {
+                    break;
+                }
+                // timer wait before continue
+                await this.delay(Math.pow(2, attempt) * 1000);
+            }
+        }
+        if (lastError) {
+            throw lastError;
+        }
+    }
+    sendHttpRequest(body) {
+        return new Promise((resolve, reject) => {
+            const parsedUrl = new url.URL(this.url);
+            const isHttps = parsedUrl.protocol === 'https:';
+            const client = isHttps ? https : http;
+            const requestOptions = {
+                hostname: parsedUrl.hostname,
+                port: parsedUrl.port,
+                path: parsedUrl.pathname + parsedUrl.search,
+                method: this.method,
+                headers: {
+                    ...this.headers,
+                    'Content-Length': Buffer.byteLength(body, 'utf8'),
+                },
+                timeout: this.timeout,
+            };
+            const req = client.request(requestOptions, (res) => {
+                let responseData = '';
+                res.on('data', (chunk) => {
+                    responseData += chunk;
+                });
+                res.on('end', () => {
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`HTTP request failed with status ${res.statusCode}: ${responseData}`));
+                    }
+                });
+            });
+            req.on('error', (error) => {
+                reject(error);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            req.write(body);
+            req.end();
+        });
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.HttpTransport = HttpTransport;

package/dist/cjs/transports/Transport.js

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

package/dist/cjs/transports/index.js

@@ -0,0 +1,20 @@
+"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("./Transport.js"), exports);
+__exportStar(require("./ConsoleTransport.js"), exports);
+__exportStar(require("./FileTransport.js"), exports);
+__exportStar(require("./HttpTransport.js"), exports);

package/dist/cjs/utils/ColorUtil.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorUtil = void 0;
+class ColorUtil {
+    static colorize(text, color) {
+        const supportsColor = process.env.FORCE_COLOR !== "0" &&
+            (process.stdout.isTTY || process.env.FORCE_COLOR === "1");
+        if (!supportsColor) {
+            return text;
+        }
+        const colorCode = ColorUtil.ANSI_COLORS[color] || ColorUtil.ANSI_COLORS.reset;
+        return `${colorCode}${text}${ColorUtil.ANSI_COLORS.reset}`;
+    }
+}
+exports.ColorUtil = ColorUtil;
+// ANSI color codes
+ColorUtil.ANSI_COLORS = {
+    // Standard colors
+    black: "\x1b[30m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    // Bright colors
+    brightRed: "\x1b[91m",
+    brightGreen: "\x1b[92m",
+    brightYellow: "\x1b[93m",
+    brightBlue: "\x1b[94m",
+    brightMagenta: "\x1b[95m",
+    brightCyan: "\x1b[96m",
+    brightWhite: "\x1b[97m",
+    // Default log level colors
+    info: "\x1b[32m",
+    warn: "\x1b[33m",
+    error: "\x1b[31m",
+    debug: "\x1b[36m",
+    boring: "\x1b[37m",
+    reset: "\x1b[0m",
+};

package/dist/cjs/utils/TimeUtil.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeUtil = void 0;
+class TimeUtil {
+    // util class for date formating
+    static format(date, format) {
+        if (format === "ISO")
+            return date.toISOString();
+        if (format === "UTC")
+            return date.toUTCString();
+        if (format === "LOCAL")
+            return date.toLocaleString();
+        const pad = (n, width = 2) => n.toString().padStart(width, "0");
+        const tokens = {
+            YYYY: pad(date.getFullYear(), 4),
+            MM: pad(date.getMonth() + 1),
+            DD: pad(date.getDate()),
+            HH: pad(date.getHours()),
+            mm: pad(date.getMinutes()),
+            ss: pad(date.getSeconds()),
+            SSS: pad(date.getMilliseconds(), 3),
+        };
+        return format.replace(/YYYY|MM|DD|HH|mm|ss|SSS/g, (match) => tokens[match] || match);
+    }
+}
+exports.TimeUtil = TimeUtil;

package/dist/cjs/utils/Timerutil.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+class Timer {
+    constructor(name, logFn) {
+        this.hasEnded = false;
+        this.name = name;
+        this.logFn = logFn;
+        this.startTime = Date.now();
+    }
+    end() {
+        // If already ended, do nothing (idempotent)
+        if (this.hasEnded) {
+            return;
+        }
+        const endTime = Date.now();
+        const duration = endTime - this.startTime;
+        this.logFn(`${this.name} took ${duration}ms`);
+        this.hasEnded = true;
+    }
+}
+exports.Timer = Timer;

package/dist/{core → esm/core}/CustomLogLevel.d.ts

@@ -3,4 +3,4 @@ export interface CustomLogLevelConfig {
     color: string;
     priority: number;
 }
-export type { LogLevel } from './LogLevel';
+export type { LogLevel } from './LogLevel.js';

package/dist/esm/core/CustomLogLevel.js

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

package/dist/{core → esm/core}/Formatter.d.ts

@@ -1,4 +1,4 @@
-import { LogData } from "../types";
+import { LogData } from "../types/index.js";
 export interface FormatterOptions {
     colorize?: boolean;
     json?: boolean;

package/dist/esm/core/Formatter.js

@@ -0,0 +1,71 @@
+import { TimeUtil } from "../utils/TimeUtil.js";
+import { ColorUtil } from "../utils/ColorUtil.js";
+export 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.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.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 };
+    }
+}

package/dist/esm/core/LogLevel.js

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

package/dist/{core → esm/core}/Logger.d.ts

@@ -1,6 +1,6 @@
-import { LogLevel } from "./LogLevel";
-import { Transport } from "../transports";
-import { TransportConfig } from "../types";
+import { LogLevel } from "./LogLevel.js";
+import { Transport } from "../transports/Transport.js";
+import { TransportConfig } from "../types/index.js";
 export interface LoggerOptions {
     level?: LogLevel;
     colorize?: boolean;
@@ -28,6 +28,7 @@ export declare class Logger {
     private asyncMode;
     private customLevels;
     private static _global;
+    static defaultTransportsFactory: ((isProd: boolean) => TransportConfig[]) | null;
     private static readonly LEVEL_PRIORITIES;
     prefix: string;
     timestamp: boolean;
@@ -40,12 +41,10 @@ export declare class Logger {
     private getDefaultTransports;
     private getDefaultAsyncMode;
     private initTransports;
-    private isLegacyTransportOptions;
     private isTransport;
     private shouldLog;
     private getLevelPriority;
     private log;
-    private logAsyncDirect;
     debug(message: string, metadata?: Record<string, any>): void;
     info(message: string, metadata?: Record<string, any>): void;
     warn(message: string, metadata?: Record<string, any>): void;