zario 0.3.5 → 0.3.6

package/README.md

@@ -267,10 +267,10 @@ aggregatedLogger.flushAggregators();
 
 ### Methods
 
-- `logger.debug(message, metadata?)` - Debug level logging
-- `logger.info(message, metadata?)` - Info level logging
-- `logger.warn(message, metadata?)` - Warning level logging
-- `logger.error(message, metadata?)` - Error level logging
+- `logger.debug(message, metadata?)` - Debug-level logging
+- `logger.info(message, metadata?)` - Info-level logging
+- `logger.warn(message, metadata?)` - Warning-level logging
+- `logger.error(message, metadata?)` - Error-level logging
 - `logger.logWithLevel(level, message, metadata?)` - Log a message at an arbitrary/custom level
 - `logger.createChild(options)` - Creates a child logger with inherited settings
 - `logger.setLevel(level)` - Change the logger level at runtime

package/dist/cjs/aggregation/LogAggregator.js

@@ -1,42 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompositeAggregator = exports.TimeBasedAggregator = exports.BatchAggregator = void 0;
-/**
- * Aggregates logs in memory and flushes them in batches
- */
+//Aggregates logs in memory and flushes them in batches
 class BatchAggregator {
     constructor(maxSize = 100, flushCallback) {
         this.logs = [];
+        this.pendingFlush = null;
         this.maxSize = maxSize;
         this.flushCallback = flushCallback;
     }
     aggregate(logData, formatter) {
         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;
         }
     }
 }
 exports.BatchAggregator = BatchAggregator;
-/**
- * Aggregates logs based on a time interval
- */
+//Aggregates logs based on a time interval
 class TimeBasedAggregator {
-    constructor(flushInterval, // in milliseconds
-    flushCallback) {
+    constructor(flushInterval, flushCallback) {
         this.logs = [];
         this.timer = null;
         this.flushInterval = flushInterval;
@@ -50,8 +62,8 @@ class TimeBasedAggregator {
                 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 TimeBasedAggregator flush callback:', error);
+                    result.catch((error) => {
+                        console.error("Error in TimeBasedAggregator flush callback:", error);
                     });
                 }
             }, this.flushInterval);
@@ -65,13 +77,24 @@ class TimeBasedAggregator {
                 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 the aggregator and cancel any pending timer without flushing
     stop() {
         if (this.timer) {
             clearTimeout(this.timer);
@@ -80,9 +103,7 @@ class TimeBasedAggregator {
     }
 }
 exports.TimeBasedAggregator = TimeBasedAggregator;
-/**
- * Combines multiple aggregators
- */
+//Combines multiple aggregators
 class CompositeAggregator {
     constructor(aggregators) {
         this.aggregators = aggregators;
@@ -101,8 +122,8 @@ 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(() => { });
         }
     }

package/dist/cjs/core/Formatter.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Formatter = void 0;
-const TimeUtil_js_1 = require("../utils/TimeUtil.js");
-const ColorUtil_js_1 = require("../utils/ColorUtil.js");
+const index_js_1 = require("../utils/index.js");
 class Formatter {
     constructor(options = {}) {
         const { colorize = true, json = false, timestampFormat = "YYYY-MM-DD HH:mm:ss", timestamp = false, customColors = {}, } = options;
@@ -37,7 +36,7 @@ class Formatter {
     formatAsText(data) {
         let output = "";
         if (this.timestamp) {
-            output += `[${TimeUtil_js_1.TimeUtil.format(data.timestamp, this.timestampFormat)}] `;
+            output += `[${index_js_1.TimeUtil.format(data.timestamp, this.timestampFormat)}] `;
         }
         if (data.prefix) {
             output += `${data.prefix} `;
@@ -45,7 +44,7 @@ class Formatter {
         let level = data.level.toUpperCase();
         if (this.colorize) {
             const color = this.customColors[data.level] || data.level;
-            level = ColorUtil_js_1.ColorUtil.colorize(level, color);
+            level = index_js_1.ColorUtil.colorize(level, color);
         }
         output += `[${level}] ${data.message}`;
         if (data.metadata) {

package/dist/cjs/core/Logger.js

@@ -4,6 +4,7 @@ exports.Logger = void 0;
 const Formatter_js_1 = require("./Formatter.js");
 const ConsoleTransport_js_1 = require("../transports/ConsoleTransport.js");
 const StructuredExtensions_js_1 = require("../structured/StructuredExtensions.js");
+const index_js_1 = require("../utils/index.js");
 class Logger {
     constructor(options = {}) {
         this.transports = [];
@@ -261,8 +262,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,17 +310,9 @@ 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);

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.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");
@@ -24,6 +24,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/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,27 +1,14 @@
-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 flushCallback;
+    private pendingFlush;
     constructor(maxSize: number | undefined, flushCallback: (logs: {
         logData: LogData;
         formatter: Formatter;
@@ -29,29 +16,19 @@ export declare class BatchAggregator implements LogAggregator {
     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 flushCallback;
     private timer;
-    constructor(flushInterval: number, // in milliseconds
-    flushCallback: (logs: {
+    constructor(flushInterval: number, flushCallback: (logs: {
         logData: LogData;
         formatter: Formatter;
     }[]) => Promise<void> | void);
     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,38 +1,50 @@
-/**
- * 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) {
         this.logs = [];
+        this.pendingFlush = null;
         this.maxSize = maxSize;
         this.flushCallback = flushCallback;
     }
     aggregate(logData, formatter) {
         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) {
         this.logs = [];
         this.timer = null;
         this.flushInterval = flushInterval;
@@ -46,8 +58,8 @@ export class TimeBasedAggregator {
                 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 TimeBasedAggregator flush callback:', error);
+                    result.catch((error) => {
+                        console.error("Error in TimeBasedAggregator flush callback:", error);
                     });
                 }
             }, this.flushInterval);
@@ -61,13 +73,24 @@ export class TimeBasedAggregator {
                 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 the aggregator and cancel any pending timer without flushing
     stop() {
         if (this.timer) {
             clearTimeout(this.timer);
@@ -75,9 +98,7 @@ export class TimeBasedAggregator {
         }
     }
 }
-/**
- * Combines multiple aggregators
- */
+//Combines multiple aggregators
 export class CompositeAggregator {
     constructor(aggregators) {
         this.aggregators = aggregators;
@@ -96,8 +117,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(() => { });
         }
     }

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

@@ -4,6 +4,7 @@ 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";
 export interface LoggerOptions {
     level?: LogLevel;
     colorize?: boolean;
@@ -71,7 +72,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
      */

package/dist/esm/core/Logger.js

@@ -1,6 +1,7 @@
 import { Formatter } from "./Formatter.js";
 import { ConsoleTransport } from "../transports/ConsoleTransport.js";
 import { LogEnrichmentPipeline } from "../structured/StructuredExtensions.js";
+import { Timer } from "../utils/index.js";
 export class Logger {
     constructor(options = {}) {
         this.transports = [];
@@ -258,7 +259,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,17 +307,9 @@ 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);