zario 0.3.5 → 0.4.0

package/dist/cjs/core/Logger.js

@@ -3,25 +3,28 @@ 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");
+const RetryTransport_js_1 = require("../transports/RetryTransport.js");
 const StructuredExtensions_js_1 = require("../structured/StructuredExtensions.js");
-class Logger {
+const index_js_1 = require("../utils/index.js");
+const events_1 = require("events");
+class Logger extends events_1.EventEmitter {
     constructor(options = {}) {
-        this.transports = [];
-        this.filters = [];
-        this.aggregators = [];
-        const { level, colorize, json, transports = [], timestampFormat = "YYYY-MM-DD HH:mm:ss", prefix, timestamp, context = {}, parent, asyncMode, customLevels = {}, customColors = {}, filters = [], aggregators = [], enrichers, } = options;
-        this.parent = parent; // Set parent
+        const { level, colorize, json, transports = [], timestampFormat = "YYYY-MM-DD HH:mm:ss", prefix, timestamp, context = {}, parent, asyncMode, async, customLevels = {}, customColors = {}, filters = [], aggregators = [], enrichers, } = options;
+        super();
+        this.parent = parent;
         this.context = { ...context }; // Init context
         this.customLevels = customLevels; // custom log store
         this.asyncMode = false;
         this.filters = [...filters]; // Copy filters
         this.aggregators = [...aggregators]; // Copy aggregators
-        this.enrichers = enrichers ?? new StructuredExtensions_js_1.LogEnrichmentPipeline(); // Set enrichers, default to new instance
+        this.enrichers = enrichers ?? new StructuredExtensions_js_1.LogEnrichmentPipeline();
+        this.deadLetterQueue = options.deadLetterQueue;
+        this.retryOptions = options.retryOptions;
         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.asyncMode = (async ?? asyncMode) ?? this.parent.asyncMode;
             this.transports =
                 transports && transports.length > 0
                     ? this.initTransports(transports)
@@ -67,7 +70,7 @@ class Logger {
             const defaultTransports = transports && transports.length > 0
                 ? transports
                 : this.getDefaultTransports(isProd);
-            this.asyncMode = asyncMode ?? this.getDefaultAsyncMode(isProd);
+            this.asyncMode = (async ?? asyncMode) ?? this.getDefaultAsyncMode(isProd);
             this.transports = this.initTransports(defaultTransports);
             this.formatter = new Formatter_js_1.Formatter({
                 colorize: this.getDefaultColorizeValue(colorize),
@@ -114,7 +117,15 @@ class Logger {
         const initializedTransports = [];
         for (const transportConfig of transportConfigs) {
             if (this.isTransport(transportConfig)) {
-                initializedTransports.push(transportConfig);
+                let transport = transportConfig;
+                // Check if transport is already a RetryTransport to avoid double-wrapping
+                if (this.retryOptions && !(transport instanceof RetryTransport_js_1.RetryTransport)) {
+                    transport = new RetryTransport_js_1.RetryTransport({
+                        ...this.retryOptions,
+                        wrappedTransport: transport
+                    });
+                }
+                initializedTransports.push(transport);
             }
         }
         return initializedTransports;
@@ -171,7 +182,14 @@ class Logger {
             prefix: this.prefix,
         };
         // Apply enrichers to the log data
-        logData = this.enrichers.process(logData);
+        try {
+            logData = this.enrichers.process(logData);
+        }
+        catch (error) {
+            console.error('Error in enrichers:', error);
+            this.emit('error', { type: 'enricher', error });
+            // Continue with original logData if enrichment fails
+        }
         // Check if the log should be emitted based on filters
         // Use a copy to prevent concurrent modification issues if filters are modified during logging
         const currentFilters = [...this.filters];
@@ -186,6 +204,7 @@ class Logger {
                 if (transport.writeAsync) {
                     transport.writeAsync(logData, this.formatter).catch((error) => {
                         console.error("Error during async logging:", error);
+                        this.emit('error', { type: 'transport', error });
                     });
                 }
                 else {
@@ -208,6 +227,7 @@ class Logger {
                 }
                 catch (error) {
                     console.error('Error in aggregator:', error);
+                    this.emit('error', { type: 'aggregator', error });
                 }
             }
         }
@@ -224,6 +244,9 @@ class Logger {
     error(message, metadata) {
         this.log("error", message, metadata);
     }
+    fatal(message, metadata) {
+        this.log("fatal", message, metadata);
+    }
     silent(message, metadata) {
         this.log("silent", message, metadata);
     }
@@ -261,8 +284,7 @@ class Logger {
         return new Logger({ ...options, parent: this });
     }
     startTimer(name) {
-        const { Timer } = require("../utils/Timerutil");
-        return new Timer(name, (message) => this.info(message));
+        return new index_js_1.Timer(name, (message) => this.info(message));
     }
     /**
      * Add a filter to the logger
@@ -310,21 +332,16 @@ class Logger {
     async flushAggregators() {
         const flushPromises = [];
         for (const aggregator of this.aggregators) {
-            try {
-                const result = aggregator.flush();
-                if (result instanceof Promise) {
-                    // Wrap the promise to catch and log rejections, so one failure doesn't stop others
-                    flushPromises.push(result.catch(error => {
-                        console.error('Error flushing aggregator:', error);
-                    }));
-                }
-            }
-            catch (error) {
-                console.error('Error flushing aggregator:', error);
+            const result = aggregator.flush();
+            if (result instanceof Promise) {
+                flushPromises.push(result);
             }
         }
         await Promise.all(flushPromises);
     }
+    getTransports() {
+        return this.transports;
+    }
 }
 exports.Logger = Logger;
 Logger.defaultTransportsFactory = null;

package/dist/cjs/filters/Filter.js

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PredicateFilter = exports.NotFilter = exports.OrFilter = exports.CompositeFilter = void 0;
-/**
- * A filter that combines multiple filters with AND logic
- * Note: With an empty array of filters, this returns true (allows all logs).
- * This follows the mathematical concept of vacuous truth - "all" conditions
- * are satisfied when there are no conditions to check.
- */
+exports.FieldFilter = exports.MetadataFilter = exports.PrefixFilter = exports.LevelFilter = exports.PredicateFilter = exports.NotFilter = exports.OrFilter = exports.CompositeFilter = void 0;
 class CompositeFilter {
     constructor(filters) {
         this.filters = filters;
@@ -16,11 +10,6 @@ class CompositeFilter {
     }
 }
 exports.CompositeFilter = CompositeFilter;
-/**
- * A filter that combines multiple filters with OR logic
- * Note: With an empty array of filters, this returns false (blocks all logs).
- * This is because there are no matching conditions when the filter array is empty.
- */
 class OrFilter {
     constructor(filters) {
         this.filters = filters;
@@ -30,9 +19,6 @@ class OrFilter {
     }
 }
 exports.OrFilter = OrFilter;
-/**
- * A filter that negates another filter
- */
 class NotFilter {
     constructor(filter) {
         this.filter = filter;
@@ -42,9 +28,6 @@ class NotFilter {
     }
 }
 exports.NotFilter = NotFilter;
-/**
- * A filter based on a predicate function
- */
 class PredicateFilter {
     constructor(predicate) {
         this.predicate = predicate;
@@ -54,3 +37,54 @@ class PredicateFilter {
     }
 }
 exports.PredicateFilter = PredicateFilter;
+class LevelFilter {
+    constructor(allowedLevels) {
+        this.allowedLevels = new Set(allowedLevels);
+    }
+    shouldEmit(logData) {
+        return this.allowedLevels.has(logData.level);
+    }
+}
+exports.LevelFilter = LevelFilter;
+class PrefixFilter {
+    constructor(allowedPrefixes) {
+        this.allowedPrefixes = new Set(allowedPrefixes);
+    }
+    shouldEmit(logData) {
+        if (!logData.prefix) {
+            return this.allowedPrefixes.has('');
+        }
+        return this.allowedPrefixes.has(logData.prefix);
+    }
+}
+exports.PrefixFilter = PrefixFilter;
+class MetadataFilter {
+    constructor(requiredMetadata) {
+        this.requiredMetadata = requiredMetadata;
+    }
+    shouldEmit(logData) {
+        if (!logData.metadata) {
+            return Object.keys(this.requiredMetadata).length === 0;
+        }
+        for (const [key, value] of Object.entries(this.requiredMetadata)) {
+            if (logData.metadata[key] !== value) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.MetadataFilter = MetadataFilter;
+class FieldFilter {
+    constructor(fieldName, expectedValue) {
+        this.fieldName = fieldName;
+        this.expectedValue = expectedValue;
+    }
+    shouldEmit(logData) {
+        if (!logData.metadata) {
+            return false;
+        }
+        return logData.metadata[this.fieldName] === this.expectedValue;
+    }
+}
+exports.FieldFilter = FieldFilter;

package/dist/cjs/filters/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Filter.js"), exports);
-__exportStar(require("./SpecificFilters.js"), exports);

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogEnrichmentPipeline = exports.MetadataEnricher = exports.CompositeAggregator = exports.TimeBasedAggregator = exports.BatchAggregator = exports.FieldFilter = exports.MetadataFilter = exports.PrefixFilter = exports.LevelFilter = exports.PredicateFilter = exports.NotFilter = exports.OrFilter = exports.CompositeFilter = exports.FilterableTransport = exports.HttpTransport = exports.FileTransport = exports.ConsoleTransport = exports.Logger = void 0;
+exports.Timer = exports.LogEnrichmentPipeline = exports.MetadataEnricher = exports.CompositeAggregator = exports.TimeBasedAggregator = exports.BatchAggregator = exports.FieldFilter = exports.MetadataFilter = exports.PrefixFilter = exports.LevelFilter = exports.PredicateFilter = exports.NotFilter = exports.OrFilter = exports.CompositeFilter = exports.DeadLetterQueue = exports.CircuitBreakerTransport = exports.RetryTransport = exports.FilterableTransport = 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");
@@ -8,6 +8,9 @@ Object.defineProperty(exports, "ConsoleTransport", { enumerable: true, get: func
 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; } });
 Object.defineProperty(exports, "FilterableTransport", { enumerable: true, get: function () { return index_js_1.FilterableTransport; } });
+Object.defineProperty(exports, "RetryTransport", { enumerable: true, get: function () { return index_js_1.RetryTransport; } });
+Object.defineProperty(exports, "CircuitBreakerTransport", { enumerable: true, get: function () { return index_js_1.CircuitBreakerTransport; } });
+Object.defineProperty(exports, "DeadLetterQueue", { enumerable: true, get: function () { return index_js_1.DeadLetterQueue; } });
 const index_js_2 = require("./filters/index.js");
 Object.defineProperty(exports, "CompositeFilter", { enumerable: true, get: function () { return index_js_2.CompositeFilter; } });
 Object.defineProperty(exports, "OrFilter", { enumerable: true, get: function () { return index_js_2.OrFilter; } });
@@ -24,6 +27,8 @@ Object.defineProperty(exports, "CompositeAggregator", { enumerable: true, get: f
 const index_js_4 = require("./structured/index.js");
 Object.defineProperty(exports, "MetadataEnricher", { enumerable: true, get: function () { return index_js_4.MetadataEnricher; } });
 Object.defineProperty(exports, "LogEnrichmentPipeline", { enumerable: true, get: function () { return index_js_4.LogEnrichmentPipeline; } });
+const index_js_5 = require("./utils/index.js");
+Object.defineProperty(exports, "Timer", { enumerable: true, get: function () { return index_js_5.Timer; } });
 // Configure default transports to maintain backward compatibility
 Logger_js_1.Logger.defaultTransportsFactory = (isProd) => {
     if (isProd) {

package/dist/cjs/transports/CircuitBreakerTransport.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreakerTransport = void 0;
+class CircuitBreakerTransport {
+    constructor(baseTransport, options = {}) {
+        this.baseTransport = this.createTransport(baseTransport);
+        this.options = options;
+        this.state = {
+            failureCount: 0,
+            lastFailureTime: 0,
+            state: 'open'
+        };
+        this.metrics = {
+            totalRequests: 0,
+            failedRequests: 0,
+            successfulRequests: 0,
+            currentState: 'open',
+            averageResponseTime: 0
+        };
+    }
+    createTransport(config) {
+        if (typeof config === 'function') {
+            const TransportClass = config;
+            return new TransportClass();
+        }
+        else if (typeof config === 'object' && config !== null) {
+            return config;
+        }
+        else {
+            throw new Error('Invalid transport configuration');
+        }
+    }
+    write(data, formatter) {
+        if (!this.canWrite()) {
+            throw new Error('Circuit breaker is open');
+        }
+        this.metrics.totalRequests++;
+        const startTime = Date.now();
+        try {
+            this.baseTransport.write(data, formatter);
+            this.metrics.successfulRequests++;
+            this.resetFailureCount();
+        }
+        catch (error) {
+            this.metrics.failedRequests++;
+            this.recordFailure();
+            throw error;
+        }
+        const duration = Date.now() - startTime;
+        this.updateAverageResponseTime(duration);
+    }
+    async writeAsync(data, formatter) {
+        if (!this.canWrite()) {
+            throw new Error('Circuit breaker is open');
+        }
+        this.metrics.totalRequests++;
+        const startTime = Date.now();
+        try {
+            if (this.baseTransport.writeAsync) {
+                await this.baseTransport.writeAsync(data, formatter);
+            }
+            else {
+                this.baseTransport.write(data, formatter);
+            }
+            this.metrics.successfulRequests++;
+            this.resetFailureCount();
+        }
+        catch (error) {
+            this.metrics.failedRequests++;
+            this.recordFailure();
+            throw error;
+        }
+        const duration = Date.now() - startTime;
+        this.updateAverageResponseTime(duration);
+    }
+    canWrite() {
+        const threshold = this.options.threshold || 5;
+        const timeout = this.options.timeout || 60000;
+        if (this.state.state === 'closed') {
+            const timeSinceOpen = Date.now() - this.state.lastFailureTime;
+            if (timeSinceOpen >= timeout) {
+                this.setState('open');
+                return true;
+            }
+            return false;
+        }
+        if (this.state.failureCount >= threshold) {
+            this.setState('closed');
+            return false;
+        }
+        if (this.state.state === 'half-open' && this.state.lastFailureTime > 0 && Date.now() - this.state.lastFailureTime < timeout) {
+            this.setState('open');
+            return true;
+        }
+        return this.state.state === 'open' || this.state.state === 'half-open';
+    }
+    setState(newState) {
+        const oldState = this.state.state;
+        if (oldState !== newState) {
+            this.state.state = newState;
+            this.options.onStateChange?.(oldState, newState);
+            if (newState === 'closed') {
+                this.options.onTrip?.(this.state.failureCount);
+            }
+            else if (newState === 'open' && oldState === 'closed') {
+                this.options.onReset?.();
+            }
+        }
+    }
+    resetFailureCount() {
+        if (this.state.failureCount === 0)
+            return;
+        this.state.failureCount = Math.max(0, Math.floor(this.state.failureCount * 0.9));
+    }
+    updateAverageResponseTime(duration) {
+        if (this.metrics.totalRequests > 0) {
+            // Use exponential moving average: newAvg = oldAvg * 0.9 + duration * 0.1
+            this.metrics.averageResponseTime =
+                this.metrics.averageResponseTime * 0.9 + duration * 0.1;
+        }
+    }
+    recordFailure() {
+        this.state.failureCount++;
+        this.state.lastFailureTime = Date.now();
+        if (this.state.failureCount === 1) {
+            this.state.state = 'half-open';
+        }
+        if (this.state.failureCount >= (this.options.threshold || 5)) {
+            this.setState('closed');
+            if (this.options.resetTimeout) {
+                this.resetTimer = setTimeout(() => {
+                    this.reset();
+                }, this.options.resetTimeout);
+            }
+        }
+    }
+    getMetrics() {
+        return {
+            ...this.metrics,
+            currentState: this.state.state
+        };
+    }
+    reset() {
+        this.state = {
+            failureCount: 0,
+            lastFailureTime: 0,
+            state: 'open'
+        };
+        this.metrics = {
+            totalRequests: 0,
+            failedRequests: 0,
+            successfulRequests: 0,
+            currentState: 'open',
+            averageResponseTime: 0
+        };
+        if (this.resetTimer) {
+            clearTimeout(this.resetTimer);
+            this.resetTimer = undefined;
+        }
+    }
+    destroy() {
+        if (this.resetTimer) {
+            clearTimeout(this.resetTimer);
+            this.resetTimer = undefined;
+        }
+    }
+    isAsyncSupported() {
+        return this.baseTransport.isAsyncSupported?.() || false;
+    }
+}
+exports.CircuitBreakerTransport = CircuitBreakerTransport;

package/dist/cjs/transports/DeadLetterQueue.js

@@ -0,0 +1,129 @@
+"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.DeadLetterQueue = void 0;
+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 Promise.resolve().then(() => __importStar(require('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;
+    }
+}
+exports.DeadLetterQueue = DeadLetterQueue;