@spinajs/log 2.0.481 → 2.0.482

package/lib/cjs/config/log.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Default configuration shipped with @spinajs/log ( Node only ).
+ *
+ * Everything the log package can be tuned with lives here, so the configuration
+ * module surfaces a single, discoverable list of what can be changed:
+ *
+ *  1. a DEFAULT fs provider `fs-log-default` rooted at the working process
+ *     directory, so FileTarget works without any user fs configuration,
+ *  2. `logger.file` - the default FileTarget options ( buffer / rotation /
+ *     retention tunables ). FileTarget merges these UNDER any per-target
+ *     `options`, and a user project config ( loaded last ) overrides them - the
+ *     same override chain every other spinajs package uses.
+ *
+ * Config files are merged with array concatenation, so the provider entry is
+ * APPENDED to any providers the user configures.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_FILE_DEFAULTS = void 0;
+const DEFAULT_FS_PROVIDER = "fs-log-default";
+/**
+ * Canonical default FileTarget options. This is the SINGLE source of truth for
+ * every log tunable - change a default HERE, never inline in the target or a
+ * strategy. It is exported ( not just embedded in the config below ) so the
+ * FileTarget can fall back to the exact same values when the config file is not
+ * discovered ( eg. isolated unit tests ), and so tests share one definition.
+ */
+exports.LOG_FILE_DEFAULTS = {
+    /** fs provider holding the active log file. */
+    fs: DEFAULT_FS_PROVIDER,
+    /** Zip the archived file when it is moved to the archive. */
+    compress: false,
+    /** Rotate the active log once it grows past this many bytes ( 1 MB ). */
+    maxSize: 1024 * 1024,
+    /** Flush the in-memory buffer after this many messages. */
+    maxBufferSize: 100,
+    /** Hard cap on buffered messages; oldest are dropped past this so a down sink cannot OOM. */
+    maxQueueSize: 100000,
+    /** Periodic flush tick in milliseconds, so a partial buffer is not held. */
+    flushInterval: 1000,
+    /** How often ( seconds ) SizeLogArchiveStrategy checks the active log size. */
+    archiveInterval: 60,
+    /** Rotation trigger strategy ( decides WHEN to archive ). */
+    archiveStrategy: "SizeLogArchiveStrategy",
+    /** Retention strategies applied in order after each rotation. */
+    retentionStrategies: ["CountLogRetentionStrategy"],
+    /** Archives to keep ( CountLogRetentionStrategy ), oldest deleted first. */
+    maxArchiveFiles: 5,
+    /** Max archive age in seconds ( AgeLogRetentionStrategy ), 7 days. */
+    maxAge: 7 * 24 * 60 * 60,
+};
+const log = {
+    fs: {
+        defaultProvider: DEFAULT_FS_PROVIDER,
+        providers: [
+            {
+                name: DEFAULT_FS_PROVIDER,
+                service: "fsNative",
+                basePath: process.cwd(),
+            },
+        ],
+    },
+    logger: {
+        file: exports.LOG_FILE_DEFAULTS,
+        perf: {
+            enabled: true,
+            thresholds: { "orm.query": 200, "http.request": 1000, default: 0 },
+            overThresholdLevel: "warn",
+            underThresholdLevel: "trace",
+            logCounters: false,
+        },
+    },
+};
+exports.default = log;
+//# sourceMappingURL=log.js.map

package/lib/cjs/config/log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.js","sourceRoot":"","sources":["../../../src/config/log.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;AAE7C;;;;;;GAMG;AACU,QAAA,iBAAiB,GAAG;IAC/B,+CAA+C;IAC/C,EAAE,EAAE,mBAAmB;IAEvB,6DAA6D;IAC7D,QAAQ,EAAE,KAAK;IAEf,yEAAyE;IACzE,OAAO,EAAE,IAAI,GAAG,IAAI;IAEpB,2DAA2D;IAC3D,aAAa,EAAE,GAAG;IAElB,6FAA6F;IAC7F,YAAY,EAAE,MAAM;IAEpB,4EAA4E;IAC5E,aAAa,EAAE,IAAI;IAEnB,+EAA+E;IAC/E,eAAe,EAAE,EAAE;IAEnB,6DAA6D;IAC7D,eAAe,EAAE,wBAAwB;IAEzC,iEAAiE;IACjE,mBAAmB,EAAE,CAAC,2BAA2B,CAAC;IAElD,4EAA4E;IAC5E,eAAe,EAAE,CAAC;IAElB,sEAAsE;IACtE,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;CACzB,CAAC;AAEF,MAAM,GAAG,GAAG;IACV,EAAE,EAAE;QACF,eAAe,EAAE,mBAAmB;QACpC,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,mBAAmB;gBACzB,OAAO,EAAE,UAAU;gBACnB,QAAQ,EAAE,OAAO,CAAC,GAAG,EAAE;aACxB;SACF;KACF;IACD,MAAM,EAAE;QACN,IAAI,EAAE,yBAAiB;QACvB,IAAI,EAAE;YACJ,OAAO,EAAE,IAAI;YACb,UAAU,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE;YAClE,kBAAkB,EAAE,MAAM;YAC1B,mBAAmB,EAAE,OAAO;YAC5B,WAAW,EAAE,KAAK;SACnB;KACF;CACF,CAAC;AAEF,kBAAe,GAAG,CAAC"}

package/lib/cjs/context.browser.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Browser fallback for {@link LogContext}. The browser has no
+ * `node:async_hooks` / AsyncLocalStorage, so this keeps a single module-level
+ * `current` object and swaps it synchronously around `with`.
+ *
+ * LIMITATION: there is NO async isolation here. `with` only holds the context
+ * for the synchronous portion of `fn`; anything that runs after an `await` or a
+ * deferred callback ( unless wrapped with {@link LogContextImpl.bind} ) will not
+ * see it. This mirrors the Node API surface so callers write the same code, but
+ * on the browser ambient context is best-effort and synchronous only.
+ */
+declare class LogContextImpl {
+    private current;
+    /**
+     * The current ambient store.
+     */
+    active(): Record<string, unknown>;
+    /**
+     * Synchronously set the context to `{ ...current, ...vars }` for the duration
+     * of `fn`, restoring the previous value afterwards. No async isolation.
+     */
+    with<T>(vars: Record<string, unknown>, fn: () => T): T;
+    /**
+     * Mutate the current store in place ( late-bound values ).
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Capture the current store and restore it around each invocation of the
+     * returned function.
+     */
+    bind<A extends unknown[], R>(fn: (...a: A) => R): (...a: A) => R;
+}
+/**
+ * Shared ambient log context ( browser, synchronous fallback ).
+ */
+export declare const LogContext: LogContextImpl;
+/**
+ * Projects only primitive scalar values ( string / number / boolean / bigint )
+ * from an ambient-context object, dropping objects, arrays, Dates, functions,
+ * null and undefined. Ambient context is meant for correlation ids ( requestId,
+ * traceId, ... ) that belong on every log line; structured payloads should be
+ * passed explicitly per call ( log.info({ obj }, ... ) ), not via ambient context.
+ */
+export declare function scalarContext(ctx: Record<string, unknown>): Record<string, unknown>;
+export {};
+//# sourceMappingURL=context.browser.d.ts.map

package/lib/cjs/context.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.browser.d.ts","sourceRoot":"","sources":["../../src/context.browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,OAAO,CAA+B;IAE9C;;OAEG;IACI,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIxC;;;OAGG;IACI,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAU7D;;OAEG;IACI,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI7C;;;OAGG;IACI,IAAI,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC;CAYxE;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,gBAAuB,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASnF"}

package/lib/cjs/context.browser.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogContext = void 0;
+exports.scalarContext = scalarContext;
+/**
+ * Browser fallback for {@link LogContext}. The browser has no
+ * `node:async_hooks` / AsyncLocalStorage, so this keeps a single module-level
+ * `current` object and swaps it synchronously around `with`.
+ *
+ * LIMITATION: there is NO async isolation here. `with` only holds the context
+ * for the synchronous portion of `fn`; anything that runs after an `await` or a
+ * deferred callback ( unless wrapped with {@link LogContextImpl.bind} ) will not
+ * see it. This mirrors the Node API surface so callers write the same code, but
+ * on the browser ambient context is best-effort and synchronous only.
+ */
+class LogContextImpl {
+    constructor() {
+        this.current = {};
+    }
+    /**
+     * The current ambient store.
+     */
+    active() {
+        return this.current;
+    }
+    /**
+     * Synchronously set the context to `{ ...current, ...vars }` for the duration
+     * of `fn`, restoring the previous value afterwards. No async isolation.
+     */
+    with(vars, fn) {
+        const previous = this.current;
+        this.current = { ...previous, ...vars };
+        try {
+            return fn();
+        }
+        finally {
+            this.current = previous;
+        }
+    }
+    /**
+     * Mutate the current store in place ( late-bound values ).
+     */
+    set(key, value) {
+        this.current[key] = value;
+    }
+    /**
+     * Capture the current store and restore it around each invocation of the
+     * returned function.
+     */
+    bind(fn) {
+        const captured = this.current;
+        return (...args) => {
+            const previous = this.current;
+            this.current = captured;
+            try {
+                return fn(...args);
+            }
+            finally {
+                this.current = previous;
+            }
+        };
+    }
+}
+/**
+ * Shared ambient log context ( browser, synchronous fallback ).
+ */
+exports.LogContext = new LogContextImpl();
+/**
+ * Projects only primitive scalar values ( string / number / boolean / bigint )
+ * from an ambient-context object, dropping objects, arrays, Dates, functions,
+ * null and undefined. Ambient context is meant for correlation ids ( requestId,
+ * traceId, ... ) that belong on every log line; structured payloads should be
+ * passed explicitly per call ( log.info({ obj }, ... ) ), not via ambient context.
+ */
+function scalarContext(ctx) {
+    const out = {};
+    for (const [k, v] of Object.entries(ctx)) {
+        const t = typeof v;
+        if (t === "string" || t === "number" || t === "boolean" || t === "bigint") {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=context.browser.js.map

package/lib/cjs/context.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.browser.js","sourceRoot":"","sources":["../../src/context.browser.ts"],"names":[],"mappings":";;;AAwEA,sCASC;AAjFD;;;;;;;;;;GAUG;AACH,MAAM,cAAc;IAApB;QACU,YAAO,GAA4B,EAAE,CAAC;IA8ChD,CAAC;IA5CC;;OAEG;IACI,MAAM;QACX,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;OAGG;IACI,IAAI,CAAI,IAA6B,EAAE,EAAW;QACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,QAAQ,EAAE,GAAG,IAAI,EAAE,CAAC;QACxC,IAAI,CAAC;YACH,OAAO,EAAE,EAAE,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;QAC1B,CAAC;IACH,CAAC;IAED;;OAEG;IACI,GAAG,CAAC,GAAW,EAAE,KAAc;QACpC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACI,IAAI,CAAyB,EAAkB;QACpD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC;QAC9B,OAAO,CAAC,GAAG,IAAO,EAAK,EAAE;YACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC;YAC9B,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;YACxB,IAAI,CAAC;gBACH,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;YACrB,CAAC;oBAAS,CAAC;gBACT,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;YAC1B,CAAC;QACH,CAAC,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACU,QAAA,UAAU,GAAG,IAAI,cAAc,EAAE,CAAC;AAE/C;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,GAA4B;IACxD,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACzC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC;QACnB,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;YAC1E,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACb,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/lib/cjs/context.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Ambient log context backed by `node:async_hooks` AsyncLocalStorage.
+ *
+ * It deliberately resolves the SAME DI-singleton AsyncLocalStorage instance the
+ * @spinajs/http module runs per action ( `als.run(req.storage, ...)` ). Because
+ * that instance is a shared DI singleton, any log emitted anywhere inside a
+ * request automatically inherits the request store ( requestId, realIp, ... )
+ * with zero threading — the log package wires `setLogContextProvider(() =>
+ * LogContext.active())` so `createLogMessageObject` merges it at lowest
+ * precedence.
+ *
+ * The store type is a plain `Record<string, unknown>` — a superset of http's
+ * `IActionLocalStoregeContext` — so log stays independent of http.
+ */
+declare class LogContextImpl {
+    /**
+     * Resolve the shared AsyncLocalStorage from DI. Resolved as a bare concrete
+     * class it is a shared singleton, so this is the very instance http drives per
+     * action. We deliberately do NOT cache the reference: DI returns the same
+     * singleton on every call ( cheap lookup ), and NOT caching keeps LogContext
+     * consistent with the current DI instance even if the container is reset /
+     * re-registered ( a stale cached reference would silently diverge — e.g. after
+     * a `DI.clearCache()` the store written via a freshly-resolved instance would
+     * be invisible here ).
+     */
+    private storage;
+    /**
+     * The current ambient store, or an empty object when outside any context.
+     */
+    active(): Record<string, unknown>;
+    /**
+     * Run `fn` with `vars` merged ( copy-on-write ) onto the current store, so
+     * nesting accumulates and http's already-set fields ( eg. requestId ) survive.
+     */
+    with<T>(vars: Record<string, unknown>, fn: () => T): T;
+    /**
+     * Mutate the current store in place ( late-bound values ). No-op when called
+     * outside any active context.
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Capture the current store and re-attach it whenever the returned function is
+     * invoked. Use to carry context across detached callbacks / EventEmitter
+     * handlers that would otherwise lose it.
+     */
+    bind<A extends unknown[], R>(fn: (...a: A) => R): (...a: A) => R;
+}
+/**
+ * Shared ambient log context. See {@link LogContextImpl}.
+ */
+export declare const LogContext: LogContextImpl;
+/**
+ * Projects only primitive scalar values ( string / number / boolean / bigint )
+ * from an ambient-context object, dropping objects, arrays, Dates, functions,
+ * null and undefined. Ambient context is meant for correlation ids ( requestId,
+ * traceId, ... ) that belong on every log line; structured payloads should be
+ * passed explicitly per call ( log.info({ obj }, ... ) ), not via ambient context.
+ */
+export declare function scalarContext(ctx: Record<string, unknown>): Record<string, unknown>;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/lib/cjs/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/context.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,cAAM,cAAc;IAClB;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAO;IAIf;;OAEG;IACI,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIxC;;;OAGG;IACI,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAI7D;;;OAGG;IACI,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAO7C;;;;OAIG;IACI,IAAI,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC;CAOxE;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,gBAAuB,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASnF"}

package/lib/cjs/context.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogContext = void 0;
+exports.scalarContext = scalarContext;
+const node_async_hooks_1 = require("node:async_hooks");
+const di_1 = require("@spinajs/di");
+/**
+ * Ambient log context backed by `node:async_hooks` AsyncLocalStorage.
+ *
+ * It deliberately resolves the SAME DI-singleton AsyncLocalStorage instance the
+ * @spinajs/http module runs per action ( `als.run(req.storage, ...)` ). Because
+ * that instance is a shared DI singleton, any log emitted anywhere inside a
+ * request automatically inherits the request store ( requestId, realIp, ... )
+ * with zero threading — the log package wires `setLogContextProvider(() =>
+ * LogContext.active())` so `createLogMessageObject` merges it at lowest
+ * precedence.
+ *
+ * The store type is a plain `Record<string, unknown>` — a superset of http's
+ * `IActionLocalStoregeContext` — so log stays independent of http.
+ */
+class LogContextImpl {
+    /**
+     * Resolve the shared AsyncLocalStorage from DI. Resolved as a bare concrete
+     * class it is a shared singleton, so this is the very instance http drives per
+     * action. We deliberately do NOT cache the reference: DI returns the same
+     * singleton on every call ( cheap lookup ), and NOT caching keeps LogContext
+     * consistent with the current DI instance even if the container is reset /
+     * re-registered ( a stale cached reference would silently diverge — e.g. after
+     * a `DI.clearCache()` the store written via a freshly-resolved instance would
+     * be invisible here ).
+     */
+    storage() {
+        return di_1.DI.resolve(node_async_hooks_1.AsyncLocalStorage);
+    }
+    /**
+     * The current ambient store, or an empty object when outside any context.
+     */
+    active() {
+        return this.storage().getStore() ?? {};
+    }
+    /**
+     * Run `fn` with `vars` merged ( copy-on-write ) onto the current store, so
+     * nesting accumulates and http's already-set fields ( eg. requestId ) survive.
+     */
+    with(vars, fn) {
+        return this.storage().run({ ...this.active(), ...vars }, fn);
+    }
+    /**
+     * Mutate the current store in place ( late-bound values ). No-op when called
+     * outside any active context.
+     */
+    set(key, value) {
+        const store = this.storage().getStore();
+        if (store) {
+            store[key] = value;
+        }
+    }
+    /**
+     * Capture the current store and re-attach it whenever the returned function is
+     * invoked. Use to carry context across detached callbacks / EventEmitter
+     * handlers that would otherwise lose it.
+     */
+    bind(fn) {
+        const store = this.storage().getStore();
+        if (!store) {
+            return fn;
+        }
+        return (...args) => this.storage().run(store, () => fn(...args));
+    }
+}
+/**
+ * Shared ambient log context. See {@link LogContextImpl}.
+ */
+exports.LogContext = new LogContextImpl();
+/**
+ * Projects only primitive scalar values ( string / number / boolean / bigint )
+ * from an ambient-context object, dropping objects, arrays, Dates, functions,
+ * null and undefined. Ambient context is meant for correlation ids ( requestId,
+ * traceId, ... ) that belong on every log line; structured payloads should be
+ * passed explicitly per call ( log.info({ obj }, ... ) ), not via ambient context.
+ */
+function scalarContext(ctx) {
+    const out = {};
+    for (const [k, v] of Object.entries(ctx)) {
+        const t = typeof v;
+        if (t === "string" || t === "number" || t === "boolean" || t === "bigint") {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=context.js.map

package/lib/cjs/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/context.ts"],"names":[],"mappings":";;;AAoFA,sCASC;AA7FD,uDAAqD;AACrD,oCAAiC;AAEjC;;;;;;;;;;;;;GAaG;AACH,MAAM,cAAc;IAClB;;;;;;;;;OASG;IACK,OAAO;QACb,OAAO,OAAE,CAAC,OAAO,CAAC,oCAAiB,CAA+C,CAAC;IACrF,CAAC;IAED;;OAEG;IACI,MAAM;QACX,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;IACzC,CAAC;IAED;;;OAGG;IACI,IAAI,CAAI,IAA6B,EAAE,EAAW;QACvD,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED;;;OAGG;IACI,GAAG,CAAC,GAAW,EAAE,KAAc;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC;QACxC,IAAI,KAAK,EAAE,CAAC;YACV,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACrB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,IAAI,CAAyB,EAAkB;QACpD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC;QACxC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,OAAO,CAAC,GAAG,IAAO,EAAK,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACzE,CAAC;CACF;AAED;;GAEG;AACU,QAAA,UAAU,GAAG,IAAI,cAAc,EAAE,CAAC;AAE/C;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,GAA4B;IACxD,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACzC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC;QACnB,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;YAC1E,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACb,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/lib/cjs/filters/LevelFilter.d.ts

@@ -0,0 +1,24 @@
+import { ILogEntry, ILogFilterOptions, LogFilter, LogLevel, StrToLogLevel } from "@spinajs/log-common";
+type LevelName = keyof typeof StrToLogLevel;
+/**
+ * Options for {@link LevelFilter}.
+ */
+export interface ILevelFilterOptions extends ILogFilterOptions {
+    /** Lowest level to keep ( inclusive ). Entries below are dropped. */
+    min?: LevelName;
+    /** Highest level to keep ( inclusive ). Entries above are dropped. */
+    max?: LevelName;
+}
+/**
+ * Level-window filter. Keeps an entry only when its numeric {@link LogLevel} is
+ * within `[min, max]` ( both inclusive, both optional ), otherwise drops it.
+ * Useful for routing eg. only warn..error to a given target via a filter.
+ */
+export declare class LevelFilter extends LogFilter {
+    protected min: LogLevel;
+    protected max: LogLevel;
+    constructor(options?: ILevelFilterOptions);
+    apply(entry: ILogEntry): ILogEntry | null;
+}
+export {};
+//# sourceMappingURL=LevelFilter.d.ts.map

package/lib/cjs/filters/LevelFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LevelFilter.d.ts","sourceRoot":"","sources":["../../../src/filters/LevelFilter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGvG,KAAK,SAAS,GAAG,MAAM,OAAO,aAAa,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,qEAAqE;IACrE,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,sEAAsE;IACtE,GAAG,CAAC,EAAE,SAAS,CAAC;CACjB;AAED;;;;GAIG;AACH,qBAEa,WAAY,SAAQ,SAAS;IACxC,SAAS,CAAC,GAAG,EAAE,QAAQ,CAAC;IACxB,SAAS,CAAC,GAAG,EAAE,QAAQ,CAAC;gBAEZ,OAAO,CAAC,EAAE,mBAAmB;IAMlC,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;CAMjD"}

package/lib/cjs/filters/LevelFilter.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LevelFilter = void 0;
+const log_common_1 = require("@spinajs/log-common");
+const di_1 = require("@spinajs/di");
+/**
+ * Level-window filter. Keeps an entry only when its numeric {@link LogLevel} is
+ * within `[min, max]` ( both inclusive, both optional ), otherwise drops it.
+ * Useful for routing eg. only warn..error to a given target via a filter.
+ */
+let LevelFilter = class LevelFilter extends log_common_1.LogFilter {
+    constructor(options) {
+        super(options);
+        this.min = options?.min !== undefined ? log_common_1.StrToLogLevel[options.min] : log_common_1.LogLevel.Trace;
+        this.max = options?.max !== undefined ? log_common_1.StrToLogLevel[options.max] : log_common_1.LogLevel.Security;
+    }
+    apply(entry) {
+        if (entry.Level < this.min || entry.Level > this.max) {
+            return null;
+        }
+        return entry;
+    }
+};
+exports.LevelFilter = LevelFilter;
+exports.LevelFilter = LevelFilter = __decorate([
+    (0, di_1.Injectable)("LevelFilter"),
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [Object])
+], LevelFilter);
+//# sourceMappingURL=LevelFilter.js.map

package/lib/cjs/filters/LevelFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LevelFilter.js","sourceRoot":"","sources":["../../../src/filters/LevelFilter.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oDAAuG;AACvG,oCAAsD;AActD;;;;GAIG;AAGI,IAAM,WAAW,GAAjB,MAAM,WAAY,SAAQ,sBAAS;IAIxC,YAAY,OAA6B;QACvC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,GAAG,GAAG,OAAO,EAAE,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,0BAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,qBAAQ,CAAC,KAAK,CAAC;QACpF,IAAI,CAAC,GAAG,GAAG,OAAO,EAAE,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,0BAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,qBAAQ,CAAC,QAAQ,CAAC;IACzF,CAAC;IAEM,KAAK,CAAC,KAAgB;QAC3B,IAAI,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACrD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAA;AAhBY,kCAAW;sBAAX,WAAW;IAFvB,IAAA,eAAU,EAAC,aAAa,CAAC;IACzB,IAAA,gBAAW,GAAE;;GACD,WAAW,CAgBvB"}

package/lib/cjs/filters/MatchFilter.d.ts

@@ -0,0 +1,30 @@
+import { ILogEntry, ILogFilterOptions, LogFilter } from "@spinajs/log-common";
+/**
+ * Options for {@link MatchFilter}.
+ */
+export interface IMatchFilterOptions extends ILogFilterOptions {
+    /** Regex source tested against the chosen field. Required. */
+    pattern: string;
+    /** Variable field to test. Default "message". */
+    field?: string;
+    /** "keep" ( default ) keeps on match, drops otherwise; "drop" drops on match. */
+    mode?: "keep" | "drop";
+    /** RegExp flags ( eg. "i" ). */
+    flags?: string;
+}
+/**
+ * Regex keep/drop filter. Builds a RegExp from `pattern`/`flags` and tests it
+ * against `String(entry.Variables[field])` ( field defaults to "message" ).
+ * In "keep" mode the entry is kept only on a match; in "drop" mode it is
+ * dropped on a match. An invalid pattern degrades to a no-op ( pass-through )
+ * and warns ONCE so a bad config never silently swallows or drops everything.
+ */
+export declare class MatchFilter extends LogFilter {
+    protected regex: RegExp | null;
+    protected field: string;
+    protected mode: "keep" | "drop";
+    protected warned: boolean;
+    constructor(options?: IMatchFilterOptions);
+    apply(entry: ILogEntry): ILogEntry | null;
+}
+//# sourceMappingURL=MatchFilter.d.ts.map

package/lib/cjs/filters/MatchFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatchFilter.d.ts","sourceRoot":"","sources":["../../../src/filters/MatchFilter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAG9E;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,qBAEa,WAAY,SAAQ,SAAS;IACxC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAQ;IACtC,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,SAAS,CAAC,MAAM,UAAS;gBAEb,OAAO,CAAC,EAAE,mBAAmB;IAqBlC,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;CAejD"}

package/lib/cjs/filters/MatchFilter.js

@@ -0,0 +1,65 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchFilter = void 0;
+const log_common_1 = require("@spinajs/log-common");
+const di_1 = require("@spinajs/di");
+/**
+ * Regex keep/drop filter. Builds a RegExp from `pattern`/`flags` and tests it
+ * against `String(entry.Variables[field])` ( field defaults to "message" ).
+ * In "keep" mode the entry is kept only on a match; in "drop" mode it is
+ * dropped on a match. An invalid pattern degrades to a no-op ( pass-through )
+ * and warns ONCE so a bad config never silently swallows or drops everything.
+ */
+let MatchFilter = class MatchFilter extends log_common_1.LogFilter {
+    constructor(options) {
+        super(options);
+        this.regex = null;
+        this.warned = false;
+        this.field = options?.field ?? "message";
+        this.mode = options?.mode ?? "keep";
+        try {
+            if (options?.pattern === undefined) {
+                throw new Error("MatchFilter requires a `pattern` option");
+            }
+            // eslint-disable-next-line security/detect-non-literal-regexp
+            this.regex = new RegExp(options.pattern, options.flags);
+        }
+        catch (err) {
+            this.regex = null;
+            // no-op on bad config; warn once to the raw console ( never re-enter the
+            // logger pipeline ) so a broken filter is visible but harmless.
+            // eslint-disable-next-line no-console
+            console.warn(`MatchFilter: invalid pattern "${options?.pattern}" - filter disabled ( no-op ). ${err.message}`);
+            this.warned = true;
+        }
+    }
+    apply(entry) {
+        // invalid / missing pattern => no-op pass-through
+        if (!this.regex) {
+            return entry;
+        }
+        const value = String(entry.Variables[this.field]);
+        const matched = this.regex.test(value);
+        if (this.mode === "drop") {
+            return matched ? null : entry;
+        }
+        // keep mode
+        return matched ? entry : null;
+    }
+};
+exports.MatchFilter = MatchFilter;
+exports.MatchFilter = MatchFilter = __decorate([
+    (0, di_1.Injectable)("MatchFilter"),
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [Object])
+], MatchFilter);
+//# sourceMappingURL=MatchFilter.js.map

package/lib/cjs/filters/MatchFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatchFilter.js","sourceRoot":"","sources":["../../../src/filters/MatchFilter.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oDAA8E;AAC9E,oCAAsD;AAgBtD;;;;;;GAMG;AAGI,IAAM,WAAW,GAAjB,MAAM,WAAY,SAAQ,sBAAS;IAMxC,YAAY,OAA6B;QACvC,KAAK,CAAC,OAAO,CAAC,CAAC;QANP,UAAK,GAAkB,IAAI,CAAC;QAG5B,WAAM,GAAG,KAAK,CAAC;QAIvB,IAAI,CAAC,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,SAAS,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,MAAM,CAAC;QAEpC,IAAI,CAAC;YACH,IAAI,OAAO,EAAE,OAAO,KAAK,SAAS,EAAE,CAAC;gBACnC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;YAC7D,CAAC;YACD,8DAA8D;YAC9D,IAAI,CAAC,KAAK,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;QAC1D,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAClB,yEAAyE;YACzE,gEAAgE;YAChE,sCAAsC;YACtC,OAAO,CAAC,IAAI,CAAC,iCAAiC,OAAO,EAAE,OAAO,kCAAmC,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;YAC1H,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,KAAgB;QAC3B,kDAAkD;QAClD,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAClD,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEvC,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACzB,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;QAChC,CAAC;QACD,YAAY;QACZ,OAAO,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IAChC,CAAC;CACF,CAAA;AA1CY,kCAAW;sBAAX,WAAW;IAFvB,IAAA,eAAU,EAAC,aAAa,CAAC;IACzB,IAAA,gBAAW,GAAE;;GACD,WAAW,CA0CvB"}

package/lib/cjs/filters/RateLimitFilter.d.ts

@@ -0,0 +1,37 @@
+import { ILogEntry, ILogFilterOptions, LogFilter } from "@spinajs/log-common";
+/**
+ * Options for {@link RateLimitFilter}.
+ */
+export interface IRateLimitFilterOptions extends ILogFilterOptions {
+    /** Max entries kept per window. Required. */
+    limit: number;
+    /** Fixed window length in SECONDS. Required. */
+    intervalSeconds: number;
+    /** Variable field used to bucket the limit ( eg. per-logger ). Global if unset. */
+    key?: string;
+}
+interface IWindowRecord {
+    count: number;
+    windowStart: number;
+}
+/**
+ * Fixed-window rate limiter. Keeps at most `limit` entries per `intervalSeconds`
+ * window, bucketed by `entry.Variables[key]` when `key` is given ( else a single
+ * global bucket ). Overflow entries within a window are DROPPED; the counter
+ * resets when the window elapses. The bucket map is self-pruning ( stale windows
+ * dropped on access ) so memory stays bounded. Clock is injectable for tests.
+ */
+export declare class RateLimitFilter extends LogFilter {
+    protected now: () => number;
+    protected limit: number;
+    protected intervalMs: number;
+    protected keyField?: string;
+    protected windows: Map<string, IWindowRecord>;
+    constructor(options?: IRateLimitFilterOptions, now?: () => number);
+    protected keyOf(entry: ILogEntry): string;
+    apply(entry: ILogEntry): ILogEntry | null;
+    /** Drops windows whose interval has fully elapsed so the map stays bounded. */
+    protected prune(now: number): void;
+}
+export {};
+//# sourceMappingURL=RateLimitFilter.d.ts.map

package/lib/cjs/filters/RateLimitFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RateLimitFilter.d.ts","sourceRoot":"","sources":["../../../src/filters/RateLimitFilter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAG9E;;GAEG;AACH,MAAM,WAAW,uBAAwB,SAAQ,iBAAiB;IAChE,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,eAAe,EAAE,MAAM,CAAC;IACxB,mFAAmF;IACnF,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,UAAU,aAAa;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAID;;;;;;GAMG;AACH,qBAEa,eAAgB,SAAQ,SAAS;IAMG,SAAS,CAAC,GAAG,EAAE,MAAM,MAAM;IAL1E,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAa;gBAE9C,OAAO,CAAC,EAAE,uBAAuB,EAAY,GAAG,GAAE,MAAM,MAAyB;IAO7F,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM;IAOlC,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;IAqBhD,+EAA+E;IAC/E,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAOnC"}