zario 0.3.5 → 0.4.0

package/dist/esm/core/Formatter.js

@@ -1,5 +1,4 @@
-import { TimeUtil } from "../utils/TimeUtil.js";
-import { ColorUtil } from "../utils/ColorUtil.js";
+import { TimeUtil, ColorUtil } from "../utils/index.js";
 export class Formatter {
     constructor(options = {}) {
         const { colorize = true, json = false, timestampFormat = "YYYY-MM-DD HH:mm:ss", timestamp = false, customColors = {}, } = options;

package/dist/esm/core/Logger.d.ts

@@ -1,9 +1,12 @@
 import { LogLevel } from "./LogLevel.js";
 import { Transport } from "../transports/Transport.js";
+import { RetryTransportOptions } from "../transports/RetryTransport.js";
 import { TransportConfig } from "../types/index.js";
 import { Filter } from "../filters/Filter.js";
 import { LogAggregator } from "../aggregation/LogAggregator.js";
 import { LogEnricher, LogEnrichmentPipeline } from "../structured/StructuredExtensions.js";
+import { Timer } from "../utils/index.js";
+import { EventEmitter } from "events";
 export interface LoggerOptions {
     level?: LogLevel;
     colorize?: boolean;
@@ -12,9 +15,10 @@ export interface LoggerOptions {
     timestampFormat?: string;
     prefix?: string;
     timestamp?: boolean;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
     parent?: Logger;
     asyncMode?: boolean;
+    async?: boolean;
     customLevels?: {
         [level: string]: number;
     };
@@ -24,8 +28,10 @@ export interface LoggerOptions {
     filters?: Filter[];
     aggregators?: LogAggregator[];
     enrichers?: LogEnrichmentPipeline;
+    deadLetterQueue?: any;
+    retryOptions?: RetryTransportOptions;
 }
-export declare class Logger {
+export declare class Logger extends EventEmitter {
     private level;
     private transports;
     private formatter;
@@ -36,6 +42,8 @@ export declare class Logger {
     private filters;
     private aggregators;
     private enrichers;
+    private deadLetterQueue?;
+    private retryOptions;
     private static _global;
     static defaultTransportsFactory: ((isProd: boolean) => TransportConfig[]) | null;
     private static readonly LEVEL_PRIORITIES;
@@ -58,6 +66,7 @@ export declare class Logger {
     info(message: string, metadata?: Record<string, any>): void;
     warn(message: string, metadata?: Record<string, any>): void;
     error(message: string, metadata?: Record<string, any>): void;
+    fatal(message: string, metadata?: Record<string, any>): void;
     silent(message: string, metadata?: Record<string, any>): void;
     boring(message: string, metadata?: Record<string, any>): void;
     /**
@@ -71,7 +80,7 @@ export declare class Logger {
     getTimestampSetting(): boolean;
     static get global(): Logger;
     createChild(options?: LoggerOptions): Logger;
-    startTimer(name: string): any;
+    startTimer(name: string): Timer;
     /**
      * Add a filter to the logger
      */
@@ -96,4 +105,5 @@ export declare class Logger {
      * Flush all aggregators
      */
     flushAggregators(): Promise<void>;
+    getTransports(): Transport[];
 }

package/dist/esm/core/Logger.js

@@ -1,24 +1,27 @@
 import { Formatter } from "./Formatter.js";
 import { ConsoleTransport } from "../transports/ConsoleTransport.js";
+import { RetryTransport } from "../transports/RetryTransport.js";
 import { LogEnrichmentPipeline } from "../structured/StructuredExtensions.js";
-export class Logger {
+import { Timer } from "../utils/index.js";
+import { EventEmitter } from "events";
+export class Logger extends 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 LogEnrichmentPipeline(); // Set enrichers, default to new instance
+        this.enrichers = enrichers ?? new 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)
@@ -64,7 +67,7 @@ export 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({
                 colorize: this.getDefaultColorizeValue(colorize),
@@ -111,7 +114,15 @@ export 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)) {
+                    transport = new RetryTransport({
+                        ...this.retryOptions,
+                        wrappedTransport: transport
+                    });
+                }
+                initializedTransports.push(transport);
             }
         }
         return initializedTransports;
@@ -168,7 +179,14 @@ export 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];
@@ -183,6 +201,7 @@ export 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 {
@@ -205,6 +224,7 @@ export class Logger {
                 }
                 catch (error) {
                     console.error('Error in aggregator:', error);
+                    this.emit('error', { type: 'aggregator', error });
                 }
             }
         }
@@ -221,6 +241,9 @@ export 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);
     }
@@ -258,7 +281,6 @@ export class Logger {
         return new Logger({ ...options, parent: this });
     }
     startTimer(name) {
-        const { Timer } = require("../utils/Timerutil");
         return new Timer(name, (message) => this.info(message));
     }
     /**
@@ -307,21 +329,16 @@ export 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;
+    }
 }
 Logger.defaultTransportsFactory = null;
 Logger.LEVEL_PRIORITIES = {

package/dist/esm/filters/Filter.d.ts

@@ -1,47 +1,49 @@
 import { LogData } from '../types/index.js';
+import { LogLevel } from '../core/LogLevel.js';
 export interface Filter {
-    /**
-     * Determines if a log record should be emitted
-     * @param logData The structured log record
-     * @returns true if the log should be emitted, false if it should be filtered out
-     */
     shouldEmit(logData: LogData): boolean;
 }
 export type FilterPredicate = (logData: LogData) => boolean;
-/**
- * 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.
- */
 export declare class CompositeFilter implements Filter {
     private filters;
     constructor(filters: Filter[]);
     shouldEmit(logData: LogData): boolean;
 }
-/**
- * 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.
- */
 export declare class OrFilter implements Filter {
     private filters;
     constructor(filters: Filter[]);
     shouldEmit(logData: LogData): boolean;
 }
-/**
- * A filter that negates another filter
- */
 export declare class NotFilter implements Filter {
     private filter;
     constructor(filter: Filter);
     shouldEmit(logData: LogData): boolean;
 }
-/**
- * A filter based on a predicate function
- */
 export declare class PredicateFilter implements Filter {
     private predicate;
     constructor(predicate: FilterPredicate);
     shouldEmit(logData: LogData): boolean;
 }
+export declare class LevelFilter implements Filter {
+    private allowedLevels;
+    constructor(allowedLevels: LogLevel[]);
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class PrefixFilter implements Filter {
+    private allowedPrefixes;
+    constructor(allowedPrefixes: string[]);
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class MetadataFilter implements Filter {
+    private requiredMetadata;
+    constructor(requiredMetadata: {
+        [key: string]: any;
+    });
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class FieldFilter implements Filter {
+    private fieldName;
+    private expectedValue;
+    constructor(fieldName: string, expectedValue: any);
+    shouldEmit(logData: LogData): boolean;
+}

package/dist/esm/filters/Filter.js

@@ -1,9 +1,3 @@
-/**
- * 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.
- */
 export class CompositeFilter {
     constructor(filters) {
         this.filters = filters;
@@ -12,11 +6,6 @@ export class CompositeFilter {
         return this.filters.every(filter => filter.shouldEmit(logData));
     }
 }
-/**
- * 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.
- */
 export class OrFilter {
     constructor(filters) {
         this.filters = filters;
@@ -25,9 +14,6 @@ export class OrFilter {
         return this.filters.some(filter => filter.shouldEmit(logData));
     }
 }
-/**
- * A filter that negates another filter
- */
 export class NotFilter {
     constructor(filter) {
         this.filter = filter;
@@ -36,9 +22,6 @@ export class NotFilter {
         return !this.filter.shouldEmit(logData);
     }
 }
-/**
- * A filter based on a predicate function
- */
 export class PredicateFilter {
     constructor(predicate) {
         this.predicate = predicate;
@@ -47,3 +30,50 @@ export class PredicateFilter {
         return this.predicate(logData);
     }
 }
+export class LevelFilter {
+    constructor(allowedLevels) {
+        this.allowedLevels = new Set(allowedLevels);
+    }
+    shouldEmit(logData) {
+        return this.allowedLevels.has(logData.level);
+    }
+}
+export class PrefixFilter {
+    constructor(allowedPrefixes) {
+        this.allowedPrefixes = new Set(allowedPrefixes);
+    }
+    shouldEmit(logData) {
+        if (!logData.prefix) {
+            return this.allowedPrefixes.has('');
+        }
+        return this.allowedPrefixes.has(logData.prefix);
+    }
+}
+export 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;
+    }
+}
+export 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;
+    }
+}

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

@@ -1,2 +1 @@
 export * from './Filter.js';
-export * from './SpecificFilters.js';

package/dist/esm/filters/index.js

@@ -1,2 +1 @@
 export * from './Filter.js';
-export * from './SpecificFilters.js';

package/dist/esm/index.d.ts

@@ -1,11 +1,12 @@
 import { Logger } from './core/Logger.js';
 import { LogLevel } from './core/LogLevel.js';
-import { ConsoleTransport, FileTransport, HttpTransport, Transport, FilterableTransport } from './transports/index.js';
+import { ConsoleTransport, FileTransport, HttpTransport, Transport, FilterableTransport, RetryTransport, CircuitBreakerTransport, DeadLetterQueue } from './transports/index.js';
 import { TransportConfig, LoggerConfig } from './types/index.js';
 import { CustomLogLevelConfig } from './core/CustomLogLevel.js';
 import { Filter, CompositeFilter, OrFilter, NotFilter, PredicateFilter, LevelFilter, PrefixFilter, MetadataFilter, FieldFilter } from './filters/index.js';
 import { LogAggregator, BatchAggregator, TimeBasedAggregator, CompositeAggregator } from './aggregation/index.js';
 import { LogEnricher, MetadataEnricher, LogEnrichmentPipeline } from './structured/index.js';
-export { Logger, ConsoleTransport, FileTransport, HttpTransport, FilterableTransport, CompositeFilter, OrFilter, NotFilter, PredicateFilter, LevelFilter, PrefixFilter, MetadataFilter, FieldFilter, BatchAggregator, TimeBasedAggregator, CompositeAggregator, MetadataEnricher, LogEnrichmentPipeline };
+import { Timer } from './utils/index.js';
+export { Logger, ConsoleTransport, FileTransport, HttpTransport, FilterableTransport, RetryTransport, CircuitBreakerTransport, DeadLetterQueue, CompositeFilter, OrFilter, NotFilter, PredicateFilter, LevelFilter, PrefixFilter, MetadataFilter, FieldFilter, BatchAggregator, TimeBasedAggregator, CompositeAggregator, MetadataEnricher, LogEnrichmentPipeline, Timer };
 export type { LogLevel, Transport, TransportConfig, LoggerConfig, CustomLogLevelConfig, Filter, LogAggregator, LogEnricher };
 export default Logger;

package/dist/esm/index.js

@@ -1,8 +1,9 @@
 import { Logger } from './core/Logger.js';
-import { ConsoleTransport, FileTransport, HttpTransport, FilterableTransport } from './transports/index.js';
+import { ConsoleTransport, FileTransport, HttpTransport, FilterableTransport, RetryTransport, CircuitBreakerTransport, DeadLetterQueue } from './transports/index.js';
 import { CompositeFilter, OrFilter, NotFilter, PredicateFilter, LevelFilter, PrefixFilter, MetadataFilter, FieldFilter } from './filters/index.js';
 import { BatchAggregator, TimeBasedAggregator, CompositeAggregator } from './aggregation/index.js';
 import { MetadataEnricher, LogEnrichmentPipeline } from './structured/index.js';
+import { Timer } from './utils/index.js';
 // Configure default transports to maintain backward compatibility
 Logger.defaultTransportsFactory = (isProd) => {
     if (isProd) {
@@ -12,11 +13,13 @@ Logger.defaultTransportsFactory = (isProd) => {
         return [new ConsoleTransport()];
     }
 };
-export { Logger, ConsoleTransport, FileTransport, HttpTransport, FilterableTransport, 
+export { Logger, ConsoleTransport, FileTransport, HttpTransport, FilterableTransport, RetryTransport, CircuitBreakerTransport, DeadLetterQueue, 
 // Filters
 CompositeFilter, OrFilter, NotFilter, PredicateFilter, LevelFilter, PrefixFilter, MetadataFilter, FieldFilter, 
 // Aggregators
 BatchAggregator, TimeBasedAggregator, CompositeAggregator, 
 // Structured logging extensions
-MetadataEnricher, LogEnrichmentPipeline };
+MetadataEnricher, LogEnrichmentPipeline, 
+// Utils
+Timer };
 export default Logger;

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

@@ -0,0 +1,43 @@
+import { Transport } from "../transports/Transport.js";
+import { TransportConfig, LogData } from "../types/index.js";
+import { Formatter } from "../core/Formatter.js";
+export interface CircuitBreakerOptions {
+    threshold?: number;
+    timeout?: number;
+    resetTimeout?: number;
+    onStateChange?: (fromState: string, toState: string) => void;
+    onTrip?: (failureCount: number) => void;
+    onReset?: () => void;
+}
+export interface CircuitBreakerStateInfo {
+    failureCount: number;
+    lastFailureTime: number;
+    state: 'closed' | 'half-open' | 'open';
+}
+export interface CircuitBreakerMetrics {
+    totalRequests: number;
+    failedRequests: number;
+    successfulRequests: number;
+    currentState: string;
+    averageResponseTime: number;
+}
+export declare class CircuitBreakerTransport implements Transport {
+    private baseTransport;
+    private state;
+    private metrics;
+    private options;
+    private resetTimer;
+    constructor(baseTransport: TransportConfig, options?: CircuitBreakerOptions);
+    private createTransport;
+    write(data: LogData, formatter: Formatter): void;
+    writeAsync(data: LogData, formatter: Formatter): Promise<void>;
+    private canWrite;
+    private setState;
+    private resetFailureCount;
+    private updateAverageResponseTime;
+    private recordFailure;
+    getMetrics(): CircuitBreakerMetrics;
+    reset(): void;
+    destroy(): void;
+    isAsyncSupported(): boolean;
+}

package/dist/esm/transports/CircuitBreakerTransport.js

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

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

@@ -0,0 +1,34 @@
+import { Transport } from "../transports/Transport.js";
+import { TransportConfig } from "../types/index.js";
+import { LogData } from "../types/index.js";
+import { Formatter } from "../core/Formatter.js";
+export interface DeadLetterQueueOptions {
+    transport: TransportConfig;
+    maxRetries?: number;
+    retryableErrorCodes?: string[];
+    deadLetterFile?: string;
+    onDeadLetter?: (deadLetter: DeadLetterLog) => void;
+}
+export interface DeadLetterLog extends LogData {
+    deadLetterReason: string;
+    originalError?: string;
+    retryCount: number;
+    failedAt: Date;
+}
+export declare class DeadLetterQueue implements Transport {
+    private transport;
+    private maxRetries;
+    private retryableErrorCodes;
+    private deadLetterFile?;
+    private onDeadLetter?;
+    private deadLetters;
+    constructor(options: DeadLetterQueueOptions);
+    write(data: LogData, formatter: Formatter): Promise<void>;
+    writeAsync(data: LogData, formatter: Formatter): Promise<void>;
+    private writeWithRetry;
+    private writeDeadLetterToFile;
+    getDeadLetters(): DeadLetterLog[];
+    clearDeadLetters(): void;
+    destroy(): Promise<void>;
+    isAsyncSupported(): boolean;
+}