zario 0.3.6 → 0.4.0

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;

package/dist/cjs/transports/FileTransport.js

@@ -42,17 +42,18 @@ const compressGzip = (0, util_1.promisify)(zlib.gzip);
 const compressDeflate = (0, util_1.promisify)(zlib.deflate);
 class FileTransport {
     constructor(options) {
-        // batching funct
         this.batchQueue = [];
         this.batchTimer = null;
         const { path: filePath, maxSize = 10 * 1024 * 1024, maxFiles = 5, compression = "none", batchInterval = 0, // no batching
-        compressOldFiles = true, } = options;
+        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 });
@@ -69,7 +70,11 @@ 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(),
@@ -86,6 +91,9 @@ 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(),
@@ -117,8 +125,7 @@ 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) {
@@ -129,8 +136,7 @@ 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) {
@@ -161,6 +167,71 @@ 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/cjs/transports/HttpTransport.js

@@ -39,7 +39,8 @@ const https = __importStar(require("https"));
 const url = __importStar(require("url"));
 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');
@@ -49,6 +50,7 @@ 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';
@@ -58,12 +60,22 @@ 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/cjs/transports/RetryTransport.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryTransport = exports.CircuitBreakerState = void 0;
+const events_1 = require("events");
+var CircuitBreakerState;
+(function (CircuitBreakerState) {
+    CircuitBreakerState["CLOSED"] = "closed";
+    CircuitBreakerState["OPEN"] = "open";
+    CircuitBreakerState["HALF_OPEN"] = "half_open";
+})(CircuitBreakerState || (exports.CircuitBreakerState = CircuitBreakerState = {}));
+class RetryTransport extends events_1.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;
+    }
+}
+exports.RetryTransport = RetryTransport;

package/dist/cjs/transports/index.js

@@ -19,3 +19,6 @@ __exportStar(require("./ConsoleTransport.js"), exports);
 __exportStar(require("./FileTransport.js"), exports);
 __exportStar(require("./HttpTransport.js"), exports);
 __exportStar(require("./FilterableTransport.js"), exports);
+__exportStar(require("./RetryTransport.js"), exports);
+__exportStar(require("./CircuitBreakerTransport.js"), exports);
+__exportStar(require("./DeadLetterQueue.js"), exports);

package/dist/cjs/types/TypeInterfaces.js

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