zario 0.3.1 → 0.3.6

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/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

@@ -0,0 +1,37 @@
+import { LogData } from "../types/index.js";
+import { Formatter } from "../core/Formatter.js";
+export interface LogAggregator {
+    aggregate(logData: LogData, formatter: Formatter): void;
+    flush(): Promise<void> | void;
+}
+export declare class BatchAggregator implements LogAggregator {
+    private logs;
+    private maxSize;
+    private flushCallback;
+    private pendingFlush;
+    constructor(maxSize: number | undefined, flushCallback: (logs: {
+        logData: LogData;
+        formatter: Formatter;
+    }[]) => Promise<void> | void);
+    aggregate(logData: LogData, formatter: Formatter): void;
+    flush(): Promise<void> | void;
+}
+export declare class TimeBasedAggregator implements LogAggregator {
+    private logs;
+    private flushInterval;
+    private flushCallback;
+    private timer;
+    constructor(flushInterval: number, flushCallback: (logs: {
+        logData: LogData;
+        formatter: Formatter;
+    }[]) => Promise<void> | void);
+    aggregate(logData: LogData, formatter: Formatter): void;
+    flush(): Promise<void> | void;
+    stop(): void;
+}
+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,125 @@
+//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 && !this.pendingFlush) {
+            const result = this.flush();
+            if (result instanceof Promise) {
+                this.pendingFlush = result.finally(() => {
+                    this.pendingFlush = null;
+                });
+            }
+        }
+    }
+    flush() {
+        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
+export class TimeBasedAggregator {
+    constructor(flushInterval, 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];
+            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;
+            }
+        }
+    }
+    //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/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

@@ -1,6 +1,10 @@
 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";
+import { Timer } from "../utils/index.js";
 export interface LoggerOptions {
     level?: LogLevel;
     colorize?: boolean;
@@ -18,6 +22,9 @@ export interface LoggerOptions {
     customColors?: {
         [level: string]: string;
     };
+    filters?: Filter[];
+    aggregators?: LogAggregator[];
+    enrichers?: LogEnrichmentPipeline;
 }
 export declare class Logger {
     private level;
@@ -27,6 +34,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;
@@ -62,5 +72,29 @@ 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
+     */
+    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,20 @@
 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 = [];
-        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 +40,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 +159,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 +168,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 +198,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);
@@ -215,9 +259,61 @@ export class Logger {
         return new Logger({ ...options, parent: this });
     }
     startTimer(name) {
-        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) {
+            const result = aggregator.flush();
+            if (result instanceof Promise) {
+                flushPromises.push(result);
+            }
+        }
+        await Promise.all(flushPromises);
+    }
 }
 Logger.defaultTransportsFactory = null;
 Logger.LEVEL_PRIORITIES = {

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

@@ -0,0 +1,49 @@
+import { LogData } from '../types/index.js';
+import { LogLevel } from '../core/LogLevel.js';
+export interface Filter {
+    shouldEmit(logData: LogData): boolean;
+}
+export type FilterPredicate = (logData: LogData) => boolean;
+export declare class CompositeFilter implements Filter {
+    private filters;
+    constructor(filters: Filter[]);
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class OrFilter implements Filter {
+    private filters;
+    constructor(filters: Filter[]);
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class NotFilter implements Filter {
+    private filter;
+    constructor(filter: Filter);
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class PredicateFilter implements Filter {
+    private predicate;
+    constructor(predicate: FilterPredicate);
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class LevelFilter implements Filter {
+    private allowedLevels;
+    constructor(allowedLevels: LogLevel[]);
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class PrefixFilter implements Filter {
+    private allowedPrefixes;
+    constructor(allowedPrefixes: string[]);
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class MetadataFilter implements Filter {
+    private requiredMetadata;
+    constructor(requiredMetadata: {
+        [key: string]: any;
+    });
+    shouldEmit(logData: LogData): boolean;
+}
+export declare class FieldFilter implements Filter {
+    private fieldName;
+    private expectedValue;
+    constructor(fieldName: string, expectedValue: any);
+    shouldEmit(logData: LogData): boolean;
+}