zario 0.2.11 → 0.3.1

package/dist/esm/core/Logger.js

@@ -0,0 +1,230 @@
+import { Formatter } from "./Formatter.js";
+import { ConsoleTransport } from "../transports/ConsoleTransport.js";
+export 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({
+                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({
+                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()];
+    }
+    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));
+    }
+}
+Logger.defaultTransportsFactory = null;
+Logger.LEVEL_PRIORITIES = {
+    silent: 0,
+    boring: 1,
+    debug: 2,
+    info: 3,
+    warn: 4,
+    error: 5,
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from './core/Logger.js';
+import { LogLevel } from './core/LogLevel.js';
+import { ConsoleTransport, FileTransport, HttpTransport, Transport } from './transports/index.js';
+import { TransportConfig, LoggerConfig } from './types/index.js';
+import { CustomLogLevelConfig } from './core/CustomLogLevel.js';
+export { Logger, ConsoleTransport, FileTransport, HttpTransport };
+export type { LogLevel, Transport, TransportConfig, LoggerConfig, CustomLogLevelConfig };
+export default Logger;

package/dist/esm/index.js

@@ -0,0 +1,13 @@
+import { Logger } from './core/Logger.js';
+import { ConsoleTransport, FileTransport, HttpTransport } from './transports/index.js';
+// Configure default transports to maintain backward compatibility
+Logger.defaultTransportsFactory = (isProd) => {
+    if (isProd) {
+        return [new ConsoleTransport(), new FileTransport({ path: "./logs/app.log" })];
+    }
+    else {
+        return [new ConsoleTransport()];
+    }
+};
+export { Logger, ConsoleTransport, FileTransport, HttpTransport };
+export default Logger;

package/dist/{transports → esm/transports}/ConsoleTransport.d.ts

@@ -1,6 +1,6 @@
-import { Transport } from "./Transport";
-import { LogData } from "../types";
-import { Formatter } from "../core/Formatter";
+import { Transport } from "./Transport.js";
+import { LogData } from "../types/index.js";
+import { Formatter } from "../core/Formatter.js";
 export interface ConsoleTransportOptions {
     colorize?: boolean;
 }

package/dist/esm/transports/ConsoleTransport.js

@@ -0,0 +1,35 @@
+export 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();
+    }
+}

package/dist/{transports → esm/transports}/FileTransport.d.ts

@@ -1,6 +1,6 @@
-import { Transport } from "./Transport";
-import { LogData } from "../types";
-import { Formatter } from "../core/Formatter";
+import { Transport } from "./Transport.js";
+import { LogData } from "../types/index.js";
+import { Formatter } from "../core/Formatter.js";
 export type CompressionType = "gzip" | "deflate" | "none";
 export interface FileTransportOptions {
     path: string;
@@ -26,11 +26,13 @@ export declare class FileTransport implements Transport {
     constructor(options: FileTransportOptions);
     write(data: LogData, formatter: Formatter): void;
     writeAsync(data: LogData, formatter: Formatter): Promise<void>;
-    private rotateIfNeeded;
-    private rotateIfNeededAsync;
+    private shouldRotate;
     private rotateFiles;
     private rotateFilesAsync;
+    private performRotation;
+    private performRotationAsync;
     private getRotatedFilePath;
+    private filterRotatedFiles;
     private cleanupOldFiles;
     private cleanupOldFilesAsync;
     private startBatching;

package/dist/esm/transports/FileTransport.js

@@ -0,0 +1,223 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as zlib from "zlib";
+import { promisify } from "util";
+const compressGzip = promisify(zlib.gzip);
+const compressDeflate = promisify(zlib.deflate);
+export 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);
+            }
+        }
+    }
+}

package/dist/{transports → esm/transports}/HttpTransport.d.ts

@@ -1,6 +1,6 @@
-import { Transport } from "./Transport";
-import { LogData } from "../types";
-import { Formatter } from "../core/Formatter";
+import { Transport } from "./Transport.js";
+import { LogData } from "../types/index.js";
+import { Formatter } from "../core/Formatter.js";
 export interface HttpTransportOptions {
     url: string;
     method?: string;

package/dist/esm/transports/HttpTransport.js

@@ -0,0 +1,113 @@
+import * as http from "http";
+import * as https from "https";
+import * as url from "url";
+export 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));
+    }
+}

package/dist/{transports → esm/transports}/Transport.d.ts

@@ -1,5 +1,5 @@
-import { LogData } from '../types';
-import { Formatter } from '../core/Formatter';
+import { LogData } from '../types/index.js';
+import { Formatter } from '../core/Formatter.js';
 export interface Transport {
     write(data: LogData, formatter: Formatter): void;
     writeAsync?(data: LogData, formatter: Formatter): Promise<void>;

package/dist/esm/transports/Transport.js

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