zario 0.3.5 → 0.4.0

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 });

package/dist/cjs/utils/index.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = exports.TimeUtil = exports.ColorUtil = void 0;
+class ColorUtil {
+    static colorize(text, color) {
+        const supportsColor = process.env.FORCE_COLOR !== "0" &&
+            (process.stdout.isTTY || process.env.FORCE_COLOR === "1");
+        if (!supportsColor) {
+            return text;
+        }
+        const colorCode = ColorUtil.ANSI_COLORS[color] || ColorUtil.ANSI_COLORS.reset;
+        return `${colorCode}${text}${ColorUtil.ANSI_COLORS.reset}`;
+    }
+}
+exports.ColorUtil = ColorUtil;
+ColorUtil.ANSI_COLORS = {
+    black: "\x1b[30m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    brightRed: "\x1b[91m",
+    brightGreen: "\x1b[92m",
+    brightYellow: "\x1b[93m",
+    brightBlue: "\x1b[94m",
+    brightMagenta: "\x1b[95m",
+    brightCyan: "\x1b[96m",
+    brightWhite: "\x1b[97m",
+    info: "\x1b[32m",
+    warn: "\x1b[33m",
+    error: "\x1b[31m",
+    debug: "\x1b[36m",
+    boring: "\x1b[37m",
+    reset: "\x1b[0m",
+};
+class TimeUtil {
+    static format(date, format) {
+        if (format === "ISO")
+            return date.toISOString();
+        if (format === "UTC")
+            return date.toUTCString();
+        if (format === "LOCAL")
+            return date.toLocaleString();
+        const pad = (n, width = 2) => n.toString().padStart(width, "0");
+        const tokens = {
+            YYYY: pad(date.getFullYear(), 4),
+            MM: pad(date.getMonth() + 1),
+            DD: pad(date.getDate()),
+            HH: pad(date.getHours()),
+            mm: pad(date.getMinutes()),
+            ss: pad(date.getSeconds()),
+            SSS: pad(date.getMilliseconds(), 3),
+        };
+        return format.replace(/YYYY|MM|DD|HH|mm|ss|SSS/g, (match) => tokens[match] || match);
+    }
+}
+exports.TimeUtil = TimeUtil;
+class Timer {
+    constructor(name, logFn) {
+        this.hasEnded = false;
+        this.name = name;
+        this.logFn = logFn;
+        this.startTime = Date.now();
+    }
+    end() {
+        if (this.hasEnded) {
+            return;
+        }
+        const endTime = Date.now();
+        const duration = endTime - this.startTime;
+        this.logFn(`${this.name} took ${duration}ms`);
+        this.hasEnded = true;
+    }
+}
+exports.Timer = Timer;

package/dist/esm/aggregation/LogAggregator.d.ts

@@ -1,57 +1,36 @@
-import { LogData } from '../types/index.js';
-import { Formatter } from '../core/Formatter.js';
-/**
- * Interface for log aggregation targets
- */
+import { LogData } from "../types/index.js";
+import { Formatter } from "../core/Formatter.js";
 export interface LogAggregator {
-    /**
-     * Process a log record for aggregation
-     * @param logData The structured log record
-     * @param formatter The formatter used for the log
-     */
     aggregate(logData: LogData, formatter: Formatter): void;
-    /**
-     * Flush any pending aggregated logs
-     */
     flush(): Promise<void> | void;
 }
-/**
- * Aggregates logs in memory and flushes them in batches
- */
 export declare class BatchAggregator implements LogAggregator {
     private logs;
     private maxSize;
+    private maxQueueSize;
     private flushCallback;
+    private pendingFlush;
     constructor(maxSize: number | undefined, flushCallback: (logs: {
         logData: LogData;
         formatter: Formatter;
-    }[]) => Promise<void> | void);
+    }[]) => Promise<void> | void, maxQueueSize?: number);
     aggregate(logData: LogData, formatter: Formatter): void;
     flush(): Promise<void> | void;
 }
-/**
- * Aggregates logs based on a time interval
- */
 export declare class TimeBasedAggregator implements LogAggregator {
     private logs;
     private flushInterval;
+    private maxQueueSize;
     private flushCallback;
     private timer;
-    constructor(flushInterval: number, // in milliseconds
-    flushCallback: (logs: {
+    constructor(flushInterval: number, flushCallback: (logs: {
         logData: LogData;
         formatter: Formatter;
-    }[]) => Promise<void> | void);
+    }[]) => Promise<void> | void, maxQueueSize?: number);
     aggregate(logData: LogData, formatter: Formatter): void;
     flush(): Promise<void> | void;
-    /**
-     * Stop the aggregator and cancel any pending timer without flushing
-     */
     stop(): void;
 }
-/**
- * Combines multiple aggregators
- */
 export declare class CompositeAggregator implements LogAggregator {
     private aggregators;
     constructor(aggregators: LogAggregator[]);

package/dist/esm/aggregation/LogAggregator.js

@@ -1,53 +1,73 @@
-/**
- * Aggregates logs in memory and flushes them in batches
- */
+//Aggregates logs in memory and flushes them in batches
 export class BatchAggregator {
-    constructor(maxSize = 100, flushCallback) {
+    constructor(maxSize = 100, flushCallback, maxQueueSize = 10000) {
         this.logs = [];
+        this.pendingFlush = null;
         this.maxSize = maxSize;
+        this.maxQueueSize = maxQueueSize;
         this.flushCallback = flushCallback;
     }
     aggregate(logData, formatter) {
+        if (this.logs.length >= this.maxQueueSize) {
+            this.logs.shift();
+        }
         this.logs.push({ logData, formatter });
-        if (this.logs.length >= this.maxSize) {
+        if (this.logs.length >= this.maxSize && !this.pendingFlush) {
             const result = this.flush();
-            // Handle the case where flush returns a Promise (async flushCallback)
             if (result instanceof Promise) {
-                result.catch(error => {
-                    console.error('Error in BatchAggregator flush callback:', error);
+                this.pendingFlush = result.finally(() => {
+                    this.pendingFlush = null;
                 });
             }
         }
     }
     flush() {
-        if (this.logs.length > 0) {
-            const logsToFlush = [...this.logs];
-            this.logs = [];
-            return this.flushCallback(logsToFlush);
+        if (this.pendingFlush) {
+            return this.pendingFlush;
+        }
+        if (this.logs.length === 0) {
+            return;
+        }
+        const logsToFlush = [...this.logs];
+        const originalLogs = [...this.logs];
+        this.logs = [];
+        try {
+            const callbackResult = this.flushCallback(logsToFlush);
+            if (callbackResult instanceof Promise) {
+                return callbackResult.catch((error) => {
+                    this.logs = originalLogs;
+                    throw error;
+                });
+            }
+        }
+        catch (error) {
+            this.logs = originalLogs;
+            throw error;
         }
     }
 }
-/**
- * Aggregates logs based on a time interval
- */
+//Aggregates logs based on a time interval
 export class TimeBasedAggregator {
-    constructor(flushInterval, // in milliseconds
-    flushCallback) {
+    constructor(flushInterval, flushCallback, maxQueueSize = 10000) {
         this.logs = [];
         this.timer = null;
         this.flushInterval = flushInterval;
+        this.maxQueueSize = maxQueueSize;
         this.flushCallback = flushCallback;
     }
     aggregate(logData, formatter) {
+        if (this.logs.length >= this.maxQueueSize) {
+            this.logs.shift();
+        }
         this.logs.push({ logData, formatter });
-        // Start the timer if it's not already running
+        // Start timer if it's not already running
         if (!this.timer) {
             this.timer = setTimeout(() => {
                 const result = this.flush();
-                // Handle the case where flush returns a Promise (async flushCallback)
+                // Handle case where flush returns a Promise (async flushCallback)
                 if (result instanceof Promise) {
-                    result.catch(error => {
-                        console.error('Error in TimeBasedAggregator flush callback:', error);
+                    result.catch((error) => {
+                        console.error("Error in TimeBasedAggregator flush callback:", error);
                     });
                 }
             }, this.flushInterval);
@@ -55,19 +75,30 @@ export class TimeBasedAggregator {
     }
     flush() {
         if (this.logs.length > 0) {
-            // Clear the timer if it exists
+            // Clear timer if it exists
             if (this.timer) {
                 clearTimeout(this.timer);
                 this.timer = null;
             }
             const logsToFlush = [...this.logs];
+            const originalLogs = [...this.logs];
             this.logs = [];
-            return this.flushCallback(logsToFlush);
+            try {
+                const callbackResult = this.flushCallback(logsToFlush);
+                if (callbackResult instanceof Promise) {
+                    return callbackResult.catch((error) => {
+                        this.logs = originalLogs;
+                        throw error;
+                    });
+                }
+            }
+            catch (error) {
+                this.logs = originalLogs;
+                throw error;
+            }
         }
     }
-    /**
-     * Stop the aggregator and cancel any pending timer without flushing
-     */
+    //Stop aggregator and cancel any pending timer without flushing
     stop() {
         if (this.timer) {
             clearTimeout(this.timer);
@@ -75,9 +106,7 @@ export class TimeBasedAggregator {
         }
     }
 }
-/**
- * Combines multiple aggregators
- */
+//Combines multiple aggregators
 export class CompositeAggregator {
     constructor(aggregators) {
         this.aggregators = aggregators;
@@ -96,8 +125,8 @@ export class CompositeAggregator {
             }
         }
         // If any aggregator returns a promise, wait for all of them
-        if (results.some(r => r instanceof Promise)) {
-            const promiseResults = results.filter(r => r instanceof Promise);
+        if (results.some((r) => r instanceof Promise)) {
+            const promiseResults = results.filter((r) => r instanceof Promise);
             return Promise.all(promiseResults).then(() => { });
         }
     }