zario 0.3.1 → 0.3.5

package/dist/cjs/structured/StructuredExtensions.js

@@ -0,0 +1,112 @@
+"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.LogEnrichmentPipeline = exports.MetadataEnricher = void 0;
+const os = __importStar(require("os"));
+/**
+ * Enriches logs with additional metadata
+ */
+class MetadataEnricher {
+    static addStaticFields(staticFields) {
+        return (logData) => {
+            return {
+                ...logData,
+                metadata: {
+                    ...logData.metadata,
+                    ...staticFields
+                }
+            };
+        };
+    }
+    static addDynamicFields(dynamicFields) {
+        return (logData) => {
+            const fields = dynamicFields();
+            return {
+                ...logData,
+                metadata: {
+                    ...logData.metadata,
+                    ...fields
+                }
+            };
+        };
+    }
+    static addProcessInfo() {
+        return (logData) => {
+            return {
+                ...logData,
+                metadata: {
+                    ...logData.metadata,
+                    pid: process.pid,
+                    hostname: os.hostname(),
+                    nodeVersion: process.version
+                }
+            };
+        };
+    }
+    static addEnvironmentInfo() {
+        return (logData) => {
+            return {
+                ...logData,
+                metadata: {
+                    ...logData.metadata,
+                    environment: process.env.NODE_ENV || 'development',
+                    platform: process.platform,
+                    arch: process.arch
+                }
+            };
+        };
+    }
+}
+exports.MetadataEnricher = MetadataEnricher;
+MetadataEnricher.addContext = MetadataEnricher.addStaticFields;
+/**
+ * Applies a series of enrichers to a log record
+ */
+class LogEnrichmentPipeline {
+    constructor(enrichers = []) {
+        this.enrichers = enrichers;
+    }
+    add(enricher) {
+        this.enrichers.push(enricher);
+        return this;
+    }
+    process(logData) {
+        return this.enrichers.reduce((data, enricher) => enricher(data), logData);
+    }
+    getEnrichers() {
+        return [...this.enrichers]; // Return a copy to prevent external modification
+    }
+}
+exports.LogEnrichmentPipeline = LogEnrichmentPipeline;

package/dist/cjs/structured/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("./StructuredExtensions.js"), exports);

package/dist/cjs/transports/FilterableTransport.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterableTransport = void 0;
+/**
+ * A transport wrapper that applies filters before writing logs
+ */
+class FilterableTransport {
+    constructor(transport, filters) {
+        this.transport = transport;
+        this.filters = filters;
+    }
+    write(data, formatter) {
+        // Check if the log should be emitted based on all filters
+        if (this.filters.every(filter => filter.shouldEmit(data))) {
+            this.transport.write(data, formatter);
+        }
+    }
+    writeAsync(data, formatter) {
+        // Check if the log should be emitted based on all filters
+        if (this.filters.every(filter => filter.shouldEmit(data))) {
+            if (this.transport.writeAsync) {
+                return this.transport.writeAsync(data, formatter);
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    try {
+                        this.transport.write(data, formatter);
+                        resolve();
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            }
+        }
+        return Promise.resolve();
+    }
+}
+exports.FilterableTransport = FilterableTransport;

package/dist/cjs/transports/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./Transport.js"), exports);
 __exportStar(require("./ConsoleTransport.js"), exports);
 __exportStar(require("./FileTransport.js"), exports);
 __exportStar(require("./HttpTransport.js"), exports);
+__exportStar(require("./FilterableTransport.js"), exports);

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

@@ -0,0 +1,60 @@
+import { LogData } from '../types/index.js';
+import { Formatter } from '../core/Formatter.js';
+/**
+ * Interface for log aggregation targets
+ */
+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;
+    constructor(maxSize: number | undefined, flushCallback: (logs: {
+        logData: LogData;
+        formatter: Formatter;
+    }[]) => Promise<void> | void);
+    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: {
+        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[]);
+    aggregate(logData: LogData, formatter: Formatter): void;
+    flush(): Promise<void> | void;
+}

package/dist/esm/aggregation/LogAggregator.js

@@ -0,0 +1,104 @@
+/**
+ * Aggregates logs in memory and flushes them in batches
+ */
+export 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);
+        }
+    }
+}
+/**
+ * Aggregates logs based on a time interval
+ */
+export 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;
+        }
+    }
+}
+/**
+ * Combines multiple aggregators
+ */
+export 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(() => { });
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export * from './LogAggregator.js';

package/dist/esm/aggregation/index.js

@@ -0,0 +1 @@
+export * from './LogAggregator.js';

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

@@ -1,6 +1,9 @@
 import { LogLevel } from "./LogLevel.js";
 import { Transport } from "../transports/Transport.js";
 import { TransportConfig } from "../types/index.js";
+import { Filter } from "../filters/Filter.js";
+import { LogAggregator } from "../aggregation/LogAggregator.js";
+import { LogEnricher, LogEnrichmentPipeline } from "../structured/StructuredExtensions.js";
 export interface LoggerOptions {
     level?: LogLevel;
     colorize?: boolean;
@@ -18,6 +21,9 @@ export interface LoggerOptions {
     customColors?: {
         [level: string]: string;
     };
+    filters?: Filter[];
+    aggregators?: LogAggregator[];
+    enrichers?: LogEnrichmentPipeline;
 }
 export declare class Logger {
     private level;
@@ -27,6 +33,9 @@ export declare class Logger {
     private parent;
     private asyncMode;
     private customLevels;
+    private filters;
+    private aggregators;
+    private enrichers;
     private static _global;
     static defaultTransportsFactory: ((isProd: boolean) => TransportConfig[]) | null;
     private static readonly LEVEL_PRIORITIES;
@@ -63,4 +72,28 @@ export declare class Logger {
     static get global(): Logger;
     createChild(options?: LoggerOptions): Logger;
     startTimer(name: string): any;
+    /**
+     * Add a filter to the logger
+     */
+    addFilter(filter: Filter): void;
+    /**
+     * Remove a filter from the logger
+     */
+    removeFilter(filter: Filter): boolean;
+    /**
+     * Add an aggregator to the logger
+     */
+    addAggregator(aggregator: LogAggregator): void;
+    /**
+     * Remove an aggregator from the logger
+     */
+    removeAggregator(aggregator: LogAggregator): boolean;
+    /**
+     * Add an enricher to the logger
+     */
+    addEnricher(enricher: LogEnricher): void;
+    /**
+     * Flush all aggregators
+     */
+    flushAggregators(): Promise<void>;
 }

package/dist/esm/core/Logger.js

@@ -1,13 +1,19 @@
 import { Formatter } from "./Formatter.js";
 import { ConsoleTransport } from "../transports/ConsoleTransport.js";
+import { LogEnrichmentPipeline } from "../structured/StructuredExtensions.js";
 export 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 LogEnrichmentPipeline(); // Set enrichers, default to new instance
         if (this.parent) {
             this.level = level ?? this.parent.level;
             this.prefix = prefix ?? this.parent.prefix;
@@ -33,6 +39,21 @@ export 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 LogEnrichmentPipeline([...parentEnrichers, ...childEnrichers]);
+            }
+            else {
+                this.enrichers = this.parent.enrichers;
+            }
         }
         else {
             // Auto-configure based on environment
@@ -137,7 +158,7 @@ export class Logger {
             finalMetadata = metadata;
         }
         // Only add metadata if it's not empty after merging
-        const logData = {
+        let logData = {
             level,
             message,
             timestamp,
@@ -146,6 +167,17 @@ export 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) {
@@ -165,6 +197,17 @@ export 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);
@@ -218,6 +261,67 @@ export 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);
+    }
 }
 Logger.defaultTransportsFactory = null;
 Logger.LEVEL_PRIORITIES = {

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

@@ -0,0 +1,47 @@
+import { LogData } from '../types/index.js';
+export interface Filter {
+    /**
+     * Determines if a log record should be emitted
+     * @param logData The structured log record
+     * @returns true if the log should be emitted, false if it should be filtered out
+     */
+    shouldEmit(logData: LogData): boolean;
+}
+export type FilterPredicate = (logData: LogData) => boolean;
+/**
+ * A filter that combines multiple filters with AND logic
+ * Note: With an empty array of filters, this returns true (allows all logs).
+ * This follows the mathematical concept of vacuous truth - "all" conditions
+ * are satisfied when there are no conditions to check.
+ */
+export declare class CompositeFilter implements Filter {
+    private filters;
+    constructor(filters: Filter[]);
+    shouldEmit(logData: LogData): boolean;
+}
+/**
+ * A filter that combines multiple filters with OR logic
+ * Note: With an empty array of filters, this returns false (blocks all logs).
+ * This is because there are no matching conditions when the filter array is empty.
+ */
+export declare class OrFilter implements Filter {
+    private filters;
+    constructor(filters: Filter[]);
+    shouldEmit(logData: LogData): boolean;
+}
+/**
+ * A filter that negates another filter
+ */
+export declare class NotFilter implements Filter {
+    private filter;
+    constructor(filter: Filter);
+    shouldEmit(logData: LogData): boolean;
+}
+/**
+ * A filter based on a predicate function
+ */
+export declare class PredicateFilter implements Filter {
+    private predicate;
+    constructor(predicate: FilterPredicate);
+    shouldEmit(logData: LogData): boolean;
+}

package/dist/esm/filters/Filter.js

@@ -0,0 +1,49 @@
+/**
+ * A filter that combines multiple filters with AND logic
+ * Note: With an empty array of filters, this returns true (allows all logs).
+ * This follows the mathematical concept of vacuous truth - "all" conditions
+ * are satisfied when there are no conditions to check.
+ */
+export class CompositeFilter {
+    constructor(filters) {
+        this.filters = filters;
+    }
+    shouldEmit(logData) {
+        return this.filters.every(filter => filter.shouldEmit(logData));
+    }
+}
+/**
+ * A filter that combines multiple filters with OR logic
+ * Note: With an empty array of filters, this returns false (blocks all logs).
+ * This is because there are no matching conditions when the filter array is empty.
+ */
+export class OrFilter {
+    constructor(filters) {
+        this.filters = filters;
+    }
+    shouldEmit(logData) {
+        return this.filters.some(filter => filter.shouldEmit(logData));
+    }
+}
+/**
+ * A filter that negates another filter
+ */
+export class NotFilter {
+    constructor(filter) {
+        this.filter = filter;
+    }
+    shouldEmit(logData) {
+        return !this.filter.shouldEmit(logData);
+    }
+}
+/**
+ * A filter based on a predicate function
+ */
+export class PredicateFilter {
+    constructor(predicate) {
+        this.predicate = predicate;
+    }
+    shouldEmit(logData) {
+        return this.predicate(logData);
+    }
+}