zario 0.3.1 → 0.3.5

package/README.md

@@ -2,6 +2,17 @@
 
 A minimal, fast logging library for Node.js with TypeScript support.
 
+## What's New in 0.3.5
+
+- Added advanced filtering capabilities with LevelFilter, PrefixFilter, MetadataFilter, CompositeFilter, OrFilter, and PredicateFilter
+- Added structured logging extensions with LogEnrichmentPipeline and MetadataEnricher
+- Added TimeBasedAggregator.stop() method for proper timer cleanup
+- Improved error handling for aggregators and filters with try-catch protection
+- Enhanced thread safety with defensive copying of filters during iteration
+- Fixed enricher inheritance in child loggers
+- Added documentation for empty array behavior in CompositeFilter (allows all) and OrFilter (blocks all)
+- Added note about strict equality in MetadataFilter for complex objects
+
 ## What's New in 0.2.11
 
 - Added HTTP transport support with new HttpTransport class
@@ -46,6 +57,9 @@ logger.error("❌ Database connection failed", { code: 500 });
 | **transports** | `array`  | Where logs are written (with transport-specific options like `path`, `maxSize`, `maxFiles`, `compression`, `batchInterval`, `compressOldFiles` for file transport) |
 | **customLevels** | `object` | Define custom log levels and their priorities |
 | **customColors** | `object` | Assign colors to custom log levels |
+| **filters** | `Filter[]` | Array of filters to apply before logging (LevelFilter, PrefixFilter, MetadataFilter, CompositeFilter, OrFilter, PredicateFilter) |
+| **aggregators** | `LogAggregator[]` | Array of log aggregators (BatchAggregator, TimeBasedAggregator, CompositeAggregator) |
+| **enrichers** | `LogEnrichmentPipeline` | Pipeline for structured logging extensions |
 
 ### Log Levels
 
@@ -112,16 +126,162 @@ const logger = new Logger({
 });
 ```
 
+### Advanced Filtering
+
+Filter logs based on various criteria using built-in filter classes:
+
+```js
+import {
+  Logger,
+  ConsoleTransport,
+  LevelFilter,
+  PrefixFilter,
+  MetadataFilter,
+  CompositeFilter,
+  OrFilter,
+  PredicateFilter
+} from "zario";
+
+// Level filter - only allow specific log levels
+const levelFilter = new LevelFilter(['info', 'error']);
+
+// Prefix filter - only allow logs with specific prefixes
+const prefixFilter = new PrefixFilter(['[API]', '[DB]']);
+
+// Metadata filter - only allow logs with specific metadata
+const metadataFilter = new MetadataFilter({ userId: 123 });
+
+// Composite filter - combines multiple filters with AND logic
+// Note: With an empty array, CompositeFilter allows all logs (vacuous truth)
+const compositeFilter = new CompositeFilter([levelFilter, prefixFilter]);
+
+// Or filter - combines multiple filters with OR logic
+// Note: With an empty array, OrFilter blocks all logs (no matching conditions)
+const orFilter = new OrFilter([levelFilter, metadataFilter]);
+
+// Predicate filter - custom filtering function
+const predicateFilter = new PredicateFilter((logData) => {
+  return logData.level !== 'debug'; // Filter out debug messages
+});
+
+// Create logger with filters
+const filteredLogger = new Logger({
+  level: 'debug',
+  transports: [new ConsoleTransport()],
+  filters: [compositeFilter, predicateFilter] // Apply multiple filters
+});
+```
+
+### Structured Logging Extensions
+
+Enhance your logs with additional metadata using structured logging extensions:
+
+```js
+import {
+  Logger,
+  ConsoleTransport,
+  LogEnrichmentPipeline,
+  MetadataEnricher
+} from "zario";
+
+// Create enrichers to add metadata to logs
+const staticEnricher = MetadataEnricher.addStaticFields({
+  service: 'user-service',
+  version: '1.0.0'
+});
+
+const dynamicEnricher = MetadataEnricher.addDynamicFields(() => ({
+  processId: process.pid,
+  memoryUsage: process.memoryUsage().heapUsed
+}));
+
+const processEnricher = MetadataEnricher.addProcessInfo();
+const envEnricher = MetadataEnricher.addEnvironmentInfo();
+
+// Create a pipeline with multiple enrichers
+const enricherPipeline = new LogEnrichmentPipeline([
+  staticEnricher,
+  dynamicEnricher,
+  processEnricher,
+  envEnricher
+]);
+
+// Create logger with enrichers
+const enrichedLogger = new Logger({
+  level: 'info',
+  transports: [new ConsoleTransport()],
+  enrichers: enricherPipeline
+});
+
+enrichedLogger.info('User login', { userId: 123 });
+// Output will include additional metadata fields
+
+// Add enrichers dynamically
+enrichedLogger.addEnricher((logData) => {
+  return {
+    ...logData,
+    timestamp: new Date().toISOString(),
+    additionalField: 'some-value'
+  };
+});
+```
+
+### Log Aggregation
+
+Aggregate logs in batches or based on time intervals:
+
+```js
+import {
+  Logger,
+  ConsoleTransport,
+  BatchAggregator,
+  TimeBasedAggregator,
+  CompositeAggregator
+} from "zario";
+
+// Batch aggregator - flushes when batch size is reached
+const batchAggregator = new BatchAggregator(10, (logs) => {
+  // Process batch of 10 logs
+  console.log(`Processing ${logs.length} logs`);
+});
+
+// Time-based aggregator - flushes after time interval
+const timeAggregator = new TimeBasedAggregator(5000, (logs) => {
+  // Process logs every 5 seconds
+  console.log(`Processing ${logs.length} logs`);
+});
+
+// Create logger with aggregators
+const aggregatedLogger = new Logger({
+  level: 'info',
+  transports: [new ConsoleTransport()],
+  aggregators: [batchAggregator]
+});
+
+// Manually flush aggregators
+aggregatedLogger.flushAggregators();
+
+// Stop time-based aggregator timer
+// timeAggregator.stop(); // Available for TimeBasedAggregator
+```
+
 ### Methods
 
 - `logger.debug(message, metadata?)` - Debug level logging
-- `logger.info(message, metadata?)` - Info 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
 - `logger.setFormat(format)` - Set the output format to text or json
+- `logger.addFilter(filter)` - Add a filter to the logger (LevelFilter, PrefixFilter, MetadataFilter, etc.)
+- `logger.removeFilter(filter)` - Remove a filter from the logger
+- `logger.addAggregator(aggregator)` - Add an aggregator to the logger (BatchAggregator, TimeBasedAggregator, etc.)
+- `logger.removeAggregator(aggregator)` - Remove an aggregator from the logger
+- `logger.flushAggregators()` - Manually flush all aggregators
+- `logger.addEnricher(enricher)` - Add an enricher to the logger for structured logging
+- `logger.startTimer(name)` - Create a performance timer
 
 ## Usage Examples
 

package/dist/cjs/aggregation/LogAggregator.js

@@ -0,0 +1,110 @@
+"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
+ */
+class BatchAggregator {
+    constructor(maxSize = 100, flushCallback) {
+        this.logs = [];
+        this.maxSize = maxSize;
+        this.flushCallback = flushCallback;
+    }
+    aggregate(logData, formatter) {
+        this.logs.push({ logData, formatter });
+        if (this.logs.length >= this.maxSize) {
+            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);
+                });
+            }
+        }
+    }
+    flush() {
+        if (this.logs.length > 0) {
+            const logsToFlush = [...this.logs];
+            this.logs = [];
+            return this.flushCallback(logsToFlush);
+        }
+    }
+}
+exports.BatchAggregator = BatchAggregator;
+/**
+ * Aggregates logs based on a time interval
+ */
+class TimeBasedAggregator {
+    constructor(flushInterval, // in milliseconds
+    flushCallback) {
+        this.logs = [];
+        this.timer = null;
+        this.flushInterval = flushInterval;
+        this.flushCallback = flushCallback;
+    }
+    aggregate(logData, formatter) {
+        this.logs.push({ logData, formatter });
+        // Start the 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)
+                if (result instanceof Promise) {
+                    result.catch(error => {
+                        console.error('Error in TimeBasedAggregator flush callback:', error);
+                    });
+                }
+            }, this.flushInterval);
+        }
+    }
+    flush() {
+        if (this.logs.length > 0) {
+            // Clear the timer if it exists
+            if (this.timer) {
+                clearTimeout(this.timer);
+                this.timer = null;
+            }
+            const logsToFlush = [...this.logs];
+            this.logs = [];
+            return this.flushCallback(logsToFlush);
+        }
+    }
+    /**
+     * Stop the aggregator and cancel any pending timer without flushing
+     */
+    stop() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+exports.TimeBasedAggregator = TimeBasedAggregator;
+/**
+ * Combines multiple aggregators
+ */
+class CompositeAggregator {
+    constructor(aggregators) {
+        this.aggregators = aggregators;
+    }
+    aggregate(logData, formatter) {
+        for (const aggregator of this.aggregators) {
+            aggregator.aggregate(logData, formatter);
+        }
+    }
+    flush() {
+        const results = [];
+        for (const aggregator of this.aggregators) {
+            const result = aggregator.flush();
+            if (result) {
+                results.push(result);
+            }
+        }
+        // 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);
+            return Promise.all(promiseResults).then(() => { });
+        }
+    }
+}
+exports.CompositeAggregator = CompositeAggregator;

package/dist/cjs/aggregation/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LogAggregator.js"), exports);

package/dist/cjs/core/Logger.js

@@ -3,14 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const Formatter_js_1 = require("./Formatter.js");
 const ConsoleTransport_js_1 = require("../transports/ConsoleTransport.js");
+const StructuredExtensions_js_1 = require("../structured/StructuredExtensions.js");
 class Logger {
     constructor(options = {}) {
         this.transports = [];
-        const { level, colorize, json, transports = [], timestampFormat = "YYYY-MM-DD HH:mm:ss", prefix, timestamp, context = {}, parent, asyncMode, customLevels = {}, customColors = {}, } = options;
+        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
         this.context = { ...context }; // Init context
         this.customLevels = customLevels; // custom log store
         this.asyncMode = false;
+        this.filters = [...filters]; // Copy filters
+        this.aggregators = [...aggregators]; // Copy aggregators
+        this.enrichers = enrichers ?? new StructuredExtensions_js_1.LogEnrichmentPipeline(); // Set enrichers, default to new instance
         if (this.parent) {
             this.level = level ?? this.parent.level;
             this.prefix = prefix ?? this.parent.prefix;
@@ -36,6 +42,21 @@ class Logger {
             this.context = { ...this.parent.context, ...this.context };
             // Merge custom levels with parent's custom levels
             this.customLevels = { ...this.parent.customLevels, ...customLevels };
+            // Merge filters with parent's filters
+            this.filters = [...this.parent.filters, ...filters];
+            // Merge aggregators with parent's aggregators
+            this.aggregators = [...this.parent.aggregators, ...aggregators];
+            // If child logger doesn't provide its own enrichers, use parent's
+            // If child logger provides enrichers, merge parent and child enrichers
+            if (enrichers) {
+                // Create a new pipeline that combines parent and child enrichers
+                const parentEnrichers = this.parent.enrichers.getEnrichers();
+                const childEnrichers = enrichers.getEnrichers();
+                this.enrichers = new StructuredExtensions_js_1.LogEnrichmentPipeline([...parentEnrichers, ...childEnrichers]);
+            }
+            else {
+                this.enrichers = this.parent.enrichers;
+            }
         }
         else {
             // Auto-configure based on environment
@@ -140,7 +161,7 @@ class Logger {
             finalMetadata = metadata;
         }
         // Only add metadata if it's not empty after merging
-        const logData = {
+        let logData = {
             level,
             message,
             timestamp,
@@ -149,6 +170,17 @@ class Logger {
                 : undefined,
             prefix: this.prefix,
         };
+        // Apply enrichers to the log data
+        logData = this.enrichers.process(logData);
+        // 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];
+        if (currentFilters.length > 0) {
+            const shouldEmit = currentFilters.every(filter => filter.shouldEmit(logData));
+            if (!shouldEmit) {
+                return; // Don't emit if any filter rejects the log
+            }
+        }
         if (this.asyncMode) {
             for (const transport of this.transports) {
                 if (transport.writeAsync) {
@@ -168,6 +200,17 @@ class Logger {
                 transport.write(logData, this.formatter);
             }
         }
+        // Send to aggregators if any exist
+        if (this.aggregators.length > 0) {
+            for (const aggregator of this.aggregators) {
+                try {
+                    aggregator.aggregate(logData, this.formatter);
+                }
+                catch (error) {
+                    console.error('Error in aggregator:', error);
+                }
+            }
+        }
     }
     debug(message, metadata) {
         this.log("debug", message, metadata);
@@ -221,6 +264,67 @@ class Logger {
         const { Timer } = require("../utils/Timerutil");
         return new Timer(name, (message) => this.info(message));
     }
+    /**
+     * Add a filter to the logger
+     */
+    addFilter(filter) {
+        this.filters.push(filter);
+    }
+    /**
+     * Remove a filter from the logger
+     */
+    removeFilter(filter) {
+        const index = this.filters.indexOf(filter);
+        if (index !== -1) {
+            this.filters.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Add an aggregator to the logger
+     */
+    addAggregator(aggregator) {
+        this.aggregators.push(aggregator);
+    }
+    /**
+     * Remove an aggregator from the logger
+     */
+    removeAggregator(aggregator) {
+        const index = this.aggregators.indexOf(aggregator);
+        if (index !== -1) {
+            this.aggregators.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Add an enricher to the logger
+     */
+    addEnricher(enricher) {
+        this.enrichers.add(enricher);
+    }
+    /**
+     * Flush all aggregators
+     */
+    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);
+            }
+        }
+        await Promise.all(flushPromises);
+    }
 }
 exports.Logger = Logger;
 Logger.defaultTransportsFactory = null;

package/dist/cjs/filters/Filter.js

@@ -0,0 +1,56 @@
+"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.
+ */
+class CompositeFilter {
+    constructor(filters) {
+        this.filters = filters;
+    }
+    shouldEmit(logData) {
+        return this.filters.every(filter => filter.shouldEmit(logData));
+    }
+}
+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;
+    }
+    shouldEmit(logData) {
+        return this.filters.some(filter => filter.shouldEmit(logData));
+    }
+}
+exports.OrFilter = OrFilter;
+/**
+ * A filter that negates another filter
+ */
+class NotFilter {
+    constructor(filter) {
+        this.filter = filter;
+    }
+    shouldEmit(logData) {
+        return !this.filter.shouldEmit(logData);
+    }
+}
+exports.NotFilter = NotFilter;
+/**
+ * A filter based on a predicate function
+ */
+class PredicateFilter {
+    constructor(predicate) {
+        this.predicate = predicate;
+    }
+    shouldEmit(logData) {
+        return this.predicate(logData);
+    }
+}
+exports.PredicateFilter = PredicateFilter;

package/dist/cjs/filters/SpecificFilters.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldFilter = exports.MetadataFilter = exports.PrefixFilter = exports.LevelFilter = void 0;
+/**
+ * A filter that allows logs based on their log level
+ */
+class LevelFilter {
+    constructor(allowedLevels) {
+        this.allowedLevels = new Set(allowedLevels);
+    }
+    shouldEmit(logData) {
+        return this.allowedLevels.has(logData.level);
+    }
+}
+exports.LevelFilter = LevelFilter;
+/**
+ * A filter that allows logs based on their prefix/namespace
+ */
+class PrefixFilter {
+    constructor(allowedPrefixes) {
+        this.allowedPrefixes = new Set(allowedPrefixes);
+    }
+    shouldEmit(logData) {
+        if (!logData.prefix) {
+            // If no prefix exists, only allow if empty string is in allowed prefixes
+            return this.allowedPrefixes.has('');
+        }
+        return this.allowedPrefixes.has(logData.prefix);
+    }
+}
+exports.PrefixFilter = PrefixFilter;
+/**
+ * A filter that allows logs based on specific metadata fields
+ * Note: Uses strict equality (===) for comparison, which means objects and arrays
+ * will only match if they are the same reference. For deep comparison of complex
+ * values, consider implementing a custom filter.
+ */
+class MetadataFilter {
+    constructor(requiredMetadata) {
+        this.requiredMetadata = requiredMetadata;
+    }
+    shouldEmit(logData) {
+        if (!logData.metadata) {
+            // If no metadata exists but we require some, return false
+            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;
+/**
+ * A filter that allows logs based on a custom field in metadata
+ */
+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

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Filter.js"), exports);
+__exportStar(require("./SpecificFilters.js"), exports);

package/dist/cjs/index.js

@@ -1,12 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpTransport = exports.FileTransport = exports.ConsoleTransport = exports.Logger = void 0;
+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");
 Object.defineProperty(exports, "ConsoleTransport", { enumerable: true, get: function () { return index_js_1.ConsoleTransport; } });
 Object.defineProperty(exports, "FileTransport", { enumerable: true, get: function () { return index_js_1.FileTransport; } });
 Object.defineProperty(exports, "HttpTransport", { enumerable: true, get: function () { return index_js_1.HttpTransport; } });
+Object.defineProperty(exports, "FilterableTransport", { enumerable: true, get: function () { return index_js_1.FilterableTransport; } });
+const index_js_2 = require("./filters/index.js");
+Object.defineProperty(exports, "CompositeFilter", { enumerable: true, get: function () { return index_js_2.CompositeFilter; } });
+Object.defineProperty(exports, "OrFilter", { enumerable: true, get: function () { return index_js_2.OrFilter; } });
+Object.defineProperty(exports, "NotFilter", { enumerable: true, get: function () { return index_js_2.NotFilter; } });
+Object.defineProperty(exports, "PredicateFilter", { enumerable: true, get: function () { return index_js_2.PredicateFilter; } });
+Object.defineProperty(exports, "LevelFilter", { enumerable: true, get: function () { return index_js_2.LevelFilter; } });
+Object.defineProperty(exports, "PrefixFilter", { enumerable: true, get: function () { return index_js_2.PrefixFilter; } });
+Object.defineProperty(exports, "MetadataFilter", { enumerable: true, get: function () { return index_js_2.MetadataFilter; } });
+Object.defineProperty(exports, "FieldFilter", { enumerable: true, get: function () { return index_js_2.FieldFilter; } });
+const index_js_3 = require("./aggregation/index.js");
+Object.defineProperty(exports, "BatchAggregator", { enumerable: true, get: function () { return index_js_3.BatchAggregator; } });
+Object.defineProperty(exports, "TimeBasedAggregator", { enumerable: true, get: function () { return index_js_3.TimeBasedAggregator; } });
+Object.defineProperty(exports, "CompositeAggregator", { enumerable: true, get: function () { return index_js_3.CompositeAggregator; } });
+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; } });
 // Configure default transports to maintain backward compatibility
 Logger_js_1.Logger.defaultTransportsFactory = (isProd) => {
     if (isProd) {