zario 0.3.5 → 0.4.0

package/dist/esm/transports/DeadLetterQueue.js

@@ -0,0 +1,92 @@
+export class DeadLetterQueue {
+    constructor(options) {
+        this.deadLetters = [];
+        const { transport, maxRetries = 3, retryableErrorCodes = ['ECONNREFUSED', 'ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND'], deadLetterFile, onDeadLetter, } = options;
+        // Initialize the wrapped transport
+        if (typeof transport === 'function') {
+            this.transport = transport();
+        }
+        else {
+            this.transport = transport;
+        }
+        this.maxRetries = maxRetries;
+        this.retryableErrorCodes = new Set(retryableErrorCodes);
+        if (deadLetterFile)
+            this.deadLetterFile = deadLetterFile;
+        if (onDeadLetter)
+            this.onDeadLetter = onDeadLetter;
+    }
+    async write(data, formatter) {
+        return this.writeWithRetry(data, formatter, 0);
+    }
+    async writeAsync(data, formatter) {
+        return this.writeWithRetry(data, formatter, 0);
+    }
+    async writeWithRetry(data, formatter, attempt) {
+        try {
+            if (this.transport.writeAsync) {
+                await this.transport.writeAsync(data, formatter);
+            }
+            else {
+                this.transport.write(data, formatter);
+            }
+        }
+        catch (error) {
+            const errorCode = error?.code || 'UNKNOWN';
+            // Check if this error is retryable
+            if (this.retryableErrorCodes.has(errorCode)) {
+                if (attempt < this.maxRetries) {
+                    // Exponential backoff with jitter
+                    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                    const jitter = Math.random() * 0.1 * delay;
+                    await new Promise(resolve => setTimeout(resolve, delay + jitter));
+                    return this.writeWithRetry(data, formatter, attempt + 1);
+                }
+            }
+            // This is a permanent failure - create dead letter
+            const deadLetter = {
+                ...data,
+                deadLetterReason: error instanceof Error ? error.message : String(error),
+                originalError: errorCode,
+                retryCount: attempt,
+                failedAt: new Date(),
+            };
+            this.deadLetters.push(deadLetter);
+            if (this.deadLetterFile) {
+                await this.writeDeadLetterToFile(deadLetter);
+            }
+            if (this.onDeadLetter) {
+                this.onDeadLetter(deadLetter);
+            }
+            // Re-throw the error for upstream handling
+            throw error;
+        }
+    }
+    async writeDeadLetterToFile(deadLetter) {
+        if (!this.deadLetterFile)
+            return;
+        try {
+            const fs = await import('fs');
+            const deadLetterLine = JSON.stringify(deadLetter) + '\n';
+            await fs.promises.appendFile(this.deadLetterFile, deadLetterLine);
+        }
+        catch (error) {
+            console.error('Failed to write dead letter:', error);
+        }
+    }
+    getDeadLetters() {
+        return [...this.deadLetters];
+    }
+    clearDeadLetters() {
+        this.deadLetters = [];
+    }
+    // Clean up resources
+    async destroy() {
+        if (this.transport && typeof this.transport.destroy === 'function') {
+            await this.transport.destroy();
+        }
+    }
+    isAsyncSupported() {
+        return true;
+    }
+}

package/dist/esm/transports/FileTransport.d.ts

@@ -9,6 +9,7 @@ export interface FileTransportOptions {
     compression?: CompressionType;
     batchInterval?: number;
     compressOldFiles?: boolean;
+    maxQueueSize?: number;
 }
 export interface BatchLogEntry {
     data: string;
@@ -21,6 +22,7 @@ export declare class FileTransport implements Transport {
     private compression;
     private batchInterval;
     private compressOldFiles;
+    private maxQueueSize;
     private batchQueue;
     private batchTimer;
     constructor(options: FileTransportOptions);
@@ -31,6 +33,8 @@ export declare class FileTransport implements Transport {
     private rotateFilesAsync;
     private performRotation;
     private performRotationAsync;
+    private performRotationWithStreams;
+    private performRotationWithStreamsAsync;
     private getRotatedFilePath;
     private filterRotatedFiles;
     private cleanupOldFiles;

package/dist/esm/transports/FileTransport.js

@@ -6,17 +6,18 @@ 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;
+        compressOldFiles = true, maxQueueSize = 10000, // default maximum queue size
+         } = options;
         this.filePath = filePath;
         this.maxSize = maxSize;
         this.maxFiles = maxFiles;
         this.compression = compression;
         this.batchInterval = batchInterval;
         this.compressOldFiles = compressOldFiles;
+        this.maxQueueSize = maxQueueSize;
         const dir = path.dirname(this.filePath);
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
@@ -33,7 +34,11 @@ export class FileTransport {
         const output = formatter.format(data);
         const formattedOutput = output + "\n";
         if (this.batchInterval > 0) {
-            // Queue entry if batching is enabled
+            // Queue entry if batching is enabled, with queue size limit
+            if (this.batchQueue.length >= this.maxQueueSize) {
+                // Drop oldest entry to maintain queue limit
+                this.batchQueue.shift();
+            }
             this.batchQueue.push({
                 data: formattedOutput,
                 timestamp: new Date(),
@@ -50,6 +55,9 @@ export class FileTransport {
     async writeAsync(data, formatter) {
         const formattedOutput = formatter.format(data) + "\n";
         if (this.batchInterval > 0) {
+            if (this.batchQueue.length >= this.maxQueueSize) {
+                this.batchQueue.shift();
+            }
             this.batchQueue.push({
                 data: formattedOutput,
                 timestamp: new Date(),
@@ -81,8 +89,7 @@ export class FileTransport {
         try {
             if (!fs.existsSync(this.filePath))
                 return;
-            const currentContent = fs.readFileSync(this.filePath, "utf8");
-            this.performRotation(currentContent, fs.writeFileSync);
+            this.performRotationWithStreams();
             this.cleanupOldFiles();
         }
         catch (error) {
@@ -93,8 +100,7 @@ export class FileTransport {
         try {
             if (!fs.existsSync(this.filePath))
                 return;
-            const currentContent = await fs.promises.readFile(this.filePath, "utf8");
-            await this.performRotationAsync(currentContent);
+            await this.performRotationWithStreamsAsync();
             await this.cleanupOldFilesAsync();
         }
         catch (error) {
@@ -125,6 +131,71 @@ export class FileTransport {
         }
         await fs.promises.writeFile(this.filePath, "", "utf8");
     }
+    performRotationWithStreams() {
+        const rotatedFilePath = this.getRotatedFilePath();
+        const readStream = fs.createReadStream(this.filePath);
+        if (this.compression !== "none" && this.compressOldFiles) {
+            const compressedFilePath = `${rotatedFilePath}.${this.compression === "gzip" ? "gz" : "zz"}`;
+            const writeStream = fs.createWriteStream(compressedFilePath);
+            const compressStream = this.compression === "gzip" ? zlib.createGzip() : zlib.createDeflate();
+            readStream.pipe(compressStream).pipe(writeStream);
+            writeStream.on('finish', () => {
+                fs.writeFileSync(this.filePath, "", "utf8");
+            });
+            writeStream.on('error', (error) => {
+                console.error("Error during stream compression:", error);
+            });
+        }
+        else {
+            const writeStream = fs.createWriteStream(rotatedFilePath);
+            readStream.pipe(writeStream);
+            writeStream.on('finish', () => {
+                fs.writeFileSync(this.filePath, "", "utf8");
+            });
+            writeStream.on('error', (error) => {
+                console.error("Error during stream rotation:", error);
+            });
+        }
+    }
+    async performRotationWithStreamsAsync() {
+        return new Promise((resolve, reject) => {
+            const rotatedFilePath = this.getRotatedFilePath();
+            const readStream = fs.createReadStream(this.filePath);
+            if (this.compression !== "none" && this.compressOldFiles) {
+                const compressedFilePath = `${rotatedFilePath}.${this.compression === "gzip" ? "gz" : "zz"}`;
+                const writeStream = fs.createWriteStream(compressedFilePath);
+                const compressStream = this.compression === "gzip" ? zlib.createGzip() : zlib.createDeflate();
+                readStream.pipe(compressStream).pipe(writeStream);
+                writeStream.on('finish', async () => {
+                    try {
+                        await fs.promises.writeFile(this.filePath, "", "utf8");
+                        resolve();
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+                writeStream.on('error', reject);
+                readStream.on('error', reject);
+                compressStream.on('error', reject);
+            }
+            else {
+                const writeStream = fs.createWriteStream(rotatedFilePath);
+                readStream.pipe(writeStream);
+                writeStream.on('finish', async () => {
+                    try {
+                        await fs.promises.writeFile(this.filePath, "", "utf8");
+                        resolve();
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+                writeStream.on('error', reject);
+                readStream.on('error', reject);
+            }
+        });
+    }
     getRotatedFilePath() {
         const dir = path.dirname(this.filePath);
         return path.join(dir, `${path.basename(this.filePath)}.${Date.now()}`);

package/dist/esm/transports/HttpTransport.d.ts

@@ -7,6 +7,7 @@ export interface HttpTransportOptions {
     headers?: Record<string, string>;
     timeout?: number;
     retries?: number;
+    forceAsync?: boolean;
 }
 export declare class HttpTransport implements Transport {
     private url;
@@ -14,6 +15,7 @@ export declare class HttpTransport implements Transport {
     private headers;
     private timeout;
     private retries;
+    private forceAsync;
     constructor(options: HttpTransportOptions);
     write(data: LogData, formatter: Formatter): void;
     writeAsync(data: LogData, formatter: Formatter): Promise<void>;

package/dist/esm/transports/HttpTransport.js

@@ -3,7 +3,8 @@ 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
+        const { url, method = 'POST', headers = {}, timeout = 5000, retries = 3, // defaults
+        forceAsync = false // Force async mode even in write() method
          } = options;
         if (!url) {
             throw new Error('HttpTransport requires a URL option');
@@ -13,6 +14,7 @@ export class HttpTransport {
         this.headers = { ...headers };
         this.timeout = timeout;
         this.retries = retries;
+        this.forceAsync = forceAsync;
         // Set default Content-Type if not provided
         if (!this.headers['Content-Type'] && !this.headers['content-type']) {
             this.headers['Content-Type'] = 'application/json';
@@ -22,12 +24,22 @@ export class HttpTransport {
         // Format the data as JSON for HTTP transport
         const logObject = this.parseFormattedData(data);
         const body = JSON.stringify(logObject);
-        setImmediate(() => {
+        if (this.forceAsync) {
+            // Force async mode using setImmediate
+            setImmediate(() => {
+                this.sendHttpRequestWithRetry(body, 0)
+                    .catch((error) => {
+                    console.error('HttpTransport error (forced async mode):', error.message);
+                });
+            });
+        }
+        else {
+            // Best-effort synchronous mode - note: actual network I/O is still async
             this.sendHttpRequestWithRetry(body, 0)
                 .catch((error) => {
                 console.error('HttpTransport error (sync mode):', error.message);
             });
-        });
+        }
     }
     async writeAsync(data, formatter) {
         // json formating for HttpTransport

package/dist/esm/transports/RetryTransport.d.ts

@@ -0,0 +1,67 @@
+import { Transport } from "./Transport.js";
+import { LogData } from "../types/index.js";
+import { Formatter } from "../core/Formatter.js";
+import { EventEmitter } from "events";
+export interface RetryTransportOptions {
+    wrappedTransport: Transport;
+    maxAttempts?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+    jitter?: boolean;
+    retryableErrorCodes?: string[];
+    retryableErrorPatterns?: RegExp[];
+    circuitBreakerThreshold?: number;
+    circuitBreakerTimeout?: number;
+    onRetryAttempt?: (attempt: number, error: Error, delay: number) => void;
+    onRetryExhausted?: (lastError: Error, attempts: number) => void;
+    onCircuitBreakerOpen?: () => void;
+    onCircuitBreakerClose?: () => void;
+}
+export interface RetryContext {
+    attempt: number;
+    totalAttempts: number;
+    originalError: Error;
+    delay: number;
+    startTime: number;
+}
+export declare enum CircuitBreakerState {
+    CLOSED = "closed",
+    OPEN = "open",
+    HALF_OPEN = "half_open"
+}
+export declare class RetryTransport extends EventEmitter implements Transport {
+    private wrappedTransport;
+    private maxAttempts;
+    private baseDelay;
+    private maxDelay;
+    private backoffMultiplier;
+    private jitter;
+    private retryableErrorCodes;
+    private retryableErrorPatterns;
+    private circuitBreakerThreshold;
+    private circuitBreakerTimeout;
+    private circuitBreakerState;
+    private failureCount;
+    private circuitBreakerOpenTime;
+    private onRetryAttempt;
+    private onRetryExhausted;
+    private onCircuitBreakerOpen;
+    private onCircuitBreakerClose;
+    constructor(options: RetryTransportOptions);
+    write(data: LogData, formatter: Formatter): void;
+    writeAsync(data: LogData, formatter: Formatter): Promise<void>;
+    private writeWithRetry;
+    private isRetryableError;
+    private calculateDelay;
+    private delay;
+    private isCircuitBreakerOpen;
+    private incrementFailureCount;
+    private resetFailureCount;
+    private maybeOpenCircuitBreaker;
+    private maybeCloseCircuitBreaker;
+    getCircuitBreakerState(): CircuitBreakerState;
+    getFailureCount(): number;
+    resetCircuitBreaker(): void;
+    getWrappedTransport(): Transport;
+}

package/dist/esm/transports/RetryTransport.js

@@ -0,0 +1,195 @@
+import { EventEmitter } from "events";
+export var CircuitBreakerState;
+(function (CircuitBreakerState) {
+    CircuitBreakerState["CLOSED"] = "closed";
+    CircuitBreakerState["OPEN"] = "open";
+    CircuitBreakerState["HALF_OPEN"] = "half_open";
+})(CircuitBreakerState || (CircuitBreakerState = {}));
+export class RetryTransport extends EventEmitter {
+    constructor(options) {
+        super();
+        this.circuitBreakerState = CircuitBreakerState.CLOSED;
+        this.failureCount = 0;
+        this.circuitBreakerOpenTime = 0;
+        const { wrappedTransport, maxAttempts = 3, baseDelay = 1000, maxDelay = 30000, backoffMultiplier = 2, jitter = true, retryableErrorCodes = [
+            'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ENOTFOUND',
+            'EAI_AGAIN', 'EHOSTUNREACH', 'ENETUNREACH', 'ENOENT',
+            'EMFILE', 'ENFILE'
+        ], retryableErrorPatterns = [
+            /timeout/i,
+            /network/i,
+            /connection/i,
+            /temporary/i,
+            /rate limit/i,
+            /too many requests/i,
+            /service unavailable/i,
+            /bad gateway/i
+        ], circuitBreakerThreshold = 5, circuitBreakerTimeout = 60000, onRetryAttempt, onRetryExhausted, onCircuitBreakerOpen, onCircuitBreakerClose } = options;
+        if (!wrappedTransport) {
+            throw new Error('RetryTransport requires a wrappedTransport');
+        }
+        this.wrappedTransport = wrappedTransport;
+        this.maxAttempts = maxAttempts;
+        this.baseDelay = baseDelay;
+        this.maxDelay = maxDelay;
+        this.backoffMultiplier = backoffMultiplier;
+        this.jitter = jitter;
+        this.retryableErrorCodes = new Set(retryableErrorCodes);
+        this.retryableErrorPatterns = retryableErrorPatterns;
+        this.circuitBreakerThreshold = circuitBreakerThreshold;
+        this.circuitBreakerTimeout = circuitBreakerTimeout;
+        this.onRetryAttempt = onRetryAttempt;
+        this.onRetryExhausted = onRetryExhausted;
+        this.onCircuitBreakerOpen = onCircuitBreakerOpen;
+        this.onCircuitBreakerClose = onCircuitBreakerClose;
+    }
+    write(data, formatter) {
+        setImmediate(async () => {
+            try {
+                await this.writeWithRetry(data, formatter);
+            }
+            catch (error) {
+                this.emit('error', { type: 'retry_transport_exhausted', error });
+            }
+        });
+    }
+    async writeAsync(data, formatter) {
+        return this.writeWithRetry(data, formatter);
+    }
+    async writeWithRetry(data, formatter) {
+        if (this.isCircuitBreakerOpen()) {
+            throw new Error('Circuit breaker is open - rejecting requests');
+        }
+        let lastError = null;
+        const startTime = Date.now();
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+            try {
+                if (this.wrappedTransport.writeAsync) {
+                    await this.wrappedTransport.writeAsync(data, formatter);
+                }
+                else {
+                    await new Promise((resolve, reject) => {
+                        try {
+                            this.wrappedTransport.write(data, formatter);
+                            resolve();
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    });
+                }
+                this.resetFailureCount();
+                this.maybeCloseCircuitBreaker();
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                if (!this.isRetryableError(lastError) || attempt === this.maxAttempts) {
+                    break;
+                }
+                const delay = this.calculateDelay(attempt);
+                const retryContext = {
+                    attempt,
+                    totalAttempts: this.maxAttempts,
+                    originalError: lastError,
+                    delay,
+                    startTime
+                };
+                this.emit('retryAttempt', retryContext);
+                this.onRetryAttempt?.(attempt, lastError, delay);
+                await this.delay(delay);
+            }
+        }
+        this.incrementFailureCount();
+        this.maybeOpenCircuitBreaker();
+        const errorContext = {
+            lastError,
+            attempts: this.maxAttempts,
+            totalTime: Date.now() - startTime,
+            data: {
+                level: data.level,
+                message: data.message,
+                timestamp: data.timestamp
+            }
+        };
+        this.emit('retryExhausted', errorContext);
+        this.onRetryExhausted?.(lastError, this.maxAttempts);
+        throw lastError;
+    }
+    isRetryableError(error) {
+        const errorCode = error.code;
+        const errorMessage = error.message;
+        if (errorCode && this.retryableErrorCodes.has(errorCode)) {
+            return true;
+        }
+        for (const pattern of this.retryableErrorPatterns) {
+            if (pattern.test(errorMessage)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    calculateDelay(attempt) {
+        let delay = this.baseDelay * Math.pow(this.backoffMultiplier, attempt - 1);
+        delay = Math.min(delay, this.maxDelay);
+        if (this.jitter) {
+            const jitterAmount = delay * 0.25;
+            const jitter = (Math.random() * 2 - 1) * jitterAmount;
+            delay += jitter;
+        }
+        return Math.max(0, Math.floor(delay));
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    isCircuitBreakerOpen() {
+        if (this.circuitBreakerState === CircuitBreakerState.OPEN) {
+            if (Date.now() - this.circuitBreakerOpenTime >= this.circuitBreakerTimeout) {
+                this.circuitBreakerState = CircuitBreakerState.HALF_OPEN;
+                this.emit('circuitBreakerHalfOpen');
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    incrementFailureCount() {
+        this.failureCount++;
+        this.maybeOpenCircuitBreaker();
+    }
+    resetFailureCount() {
+        this.failureCount = 0;
+    }
+    maybeOpenCircuitBreaker() {
+        if (this.circuitBreakerState === CircuitBreakerState.CLOSED &&
+            this.failureCount >= this.circuitBreakerThreshold) {
+            this.circuitBreakerState = CircuitBreakerState.OPEN;
+            this.circuitBreakerOpenTime = Date.now();
+            this.emit('circuitBreakerOpen');
+            this.onCircuitBreakerOpen?.();
+        }
+    }
+    maybeCloseCircuitBreaker() {
+        if (this.circuitBreakerState === CircuitBreakerState.HALF_OPEN) {
+            this.circuitBreakerState = CircuitBreakerState.CLOSED;
+            this.failureCount = 0;
+            this.emit('circuitBreakerClose');
+            this.onCircuitBreakerClose?.();
+        }
+    }
+    getCircuitBreakerState() {
+        return this.circuitBreakerState;
+    }
+    getFailureCount() {
+        return this.failureCount;
+    }
+    resetCircuitBreaker() {
+        this.circuitBreakerState = CircuitBreakerState.CLOSED;
+        this.failureCount = 0;
+        this.circuitBreakerOpenTime = 0;
+        this.emit('circuitBreakerReset');
+    }
+    getWrappedTransport() {
+        return this.wrappedTransport;
+    }
+}

package/dist/esm/transports/Transport.d.ts

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

package/dist/esm/transports/index.d.ts

@@ -3,3 +3,6 @@ export * from "./ConsoleTransport.js";
 export * from "./FileTransport.js";
 export * from "./HttpTransport.js";
 export * from "./FilterableTransport.js";
+export * from "./RetryTransport.js";
+export * from "./CircuitBreakerTransport.js";
+export * from "./DeadLetterQueue.js";

package/dist/esm/transports/index.js

@@ -3,3 +3,6 @@ export * from "./ConsoleTransport.js";
 export * from "./FileTransport.js";
 export * from "./HttpTransport.js";
 export * from "./FilterableTransport.js";
+export * from "./RetryTransport.js";
+export * from "./CircuitBreakerTransport.js";
+export * from "./DeadLetterQueue.js";

package/dist/esm/types/TypeInterfaces.d.ts

@@ -0,0 +1,7 @@
+export interface LoggerMetadata {
+    [key: string]: unknown;
+}
+export interface ErrorEvent {
+    type: string;
+    error: Error;
+}

package/dist/esm/types/TypeInterfaces.js

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

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,15 @@
+export declare class ColorUtil {
+    private static readonly ANSI_COLORS;
+    static colorize(text: string, color: string): string;
+}
+export declare class TimeUtil {
+    static format(date: Date, format: string): string;
+}
+export declare class Timer {
+    private startTime;
+    private name;
+    private logFn;
+    private hasEnded;
+    constructor(name: string, logFn: (message: string) => void);
+    end(): void;
+}