@spinajs/log 2.0.481 → 2.0.484

package/lib/cjs/archive/LogArchiveService.d.ts

@@ -0,0 +1,75 @@
+import { AsyncService, Class } from "@spinajs/di";
+import { Log } from "@spinajs/log-common";
+import { LogArchiveStrategy } from "./archive-strategy.js";
+import { LogRetentionStrategy } from "./retention-strategy.js";
+import { ILogArchiveContext } from "./context.js";
+/**
+ * Orchestrates rotation + retention for a single file log target.
+ *
+ * It owns nothing schedule-wise itself: it resolves ONE rotation strategy
+ * ( `archiveStrategy` ) and a LIST of retention strategies
+ * ( `retentionStrategies` ) by class name from DI, delegates start / stop to the
+ * rotation strategy, and provides the shared `rotate()` routine every rotation
+ * ( interval, cron or manual ) funnels through.
+ *
+ * `@NewInstance()` - each file target gets its own service ( per-target
+ * scheduling and strategy state ).
+ */
+export declare class LogArchiveService extends AsyncService {
+    protected Logger: Log;
+    protected ArchiveStrategy: LogArchiveStrategy;
+    protected RetentionStrategies: LogRetentionStrategy[];
+    /**
+     * Resolves the configured rotation + retention strategies by class name.
+     * Follows the fs temp-provider mechanism: look the class up in the DI
+     * registry by name, then resolve an instance.
+     */
+    resolve(): Promise<void>;
+    /**
+     * Wires strategies for the given context and starts the rotation schedule.
+     */
+    start(ctx: ILogArchiveContext): Promise<void>;
+    /**
+     * Stops the rotation schedule. Safe to call multiple times.
+     */
+    stop(): void;
+    /**
+     * Single rotation routine, shared by every scheduling strategy:
+     *
+     *  1. acquire the target write-lock so no append runs while we rename,
+     *  2. rename the active file to a sequenced archive name in the archive dir,
+     *  3. compress ( zip into archiveFs, drop the raw file ) OR move cross-fs,
+     *  4. run every retention strategy in order,
+     *  5. release the lock ( always, even on failure ).
+     *
+     * The whole routine is guarded so a failed rotation neither crashes the
+     * scheduler nor leaves the lock held.
+     */
+    rotate(ctx: ILogArchiveContext): Promise<void>;
+    /**
+     * Renames the active log file into the archive dir under a unique
+     * `archived_<name>_<seq><ext>` name. When `archiveFs` differs from `fs` the
+     * file is first renamed within `fs` then moved across.
+     *
+     * Returns the archive path relative to `archiveFs`.
+     */
+    protected moveToArchive(ctx: ILogArchiveContext): Promise<string>;
+    /**
+     * Zips `archived` into `archiveFs` and removes the raw archived file, so the
+     * archive dir only ever holds the compressed copy.
+     */
+    protected compress(ctx: ILogArchiveContext, archived: string): Promise<void>;
+    /**
+     * Next archive sequence number for a given base name. Uses existing archive
+     * file names first, falling back to a timestamp so two rotations in the same
+     * tick never collide.
+     */
+    protected nextSequence(ctx: ILogArchiveContext, name: string, ext: string): Promise<number>;
+    /**
+     * Resolves a strategy instance by class name, mirroring the fs temp-provider
+     * mechanism: look the class up in the DI registry by name, then resolve an
+     * instance ( `@NewInstance()` gives a fresh per-target instance ).
+     */
+    protected resolveStrategy<T>(base: Class<T>, className: string): T;
+}
+//# sourceMappingURL=LogArchiveService.d.ts.map

package/lib/cjs/archive/LogArchiveService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogArchiveService.d.ts","sourceRoot":"","sources":["../../../src/archive/LogArchiveService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,EAAiD,MAAM,aAAa,CAAC;AACjG,OAAO,EAAU,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGlD;;;;;;;;;;;GAWG;AACH,qBAEa,iBAAkB,SAAQ,YAAY;IAEjD,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC;IAEtB,SAAS,CAAC,eAAe,EAAE,kBAAkB,CAAC;IAC9C,SAAS,CAAC,mBAAmB,EAAE,oBAAoB,EAAE,CAAM;IAE3D;;;;OAIG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrC;;OAEG;IACU,KAAK,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAY1D;;OAEG;IACI,IAAI,IAAI,IAAI;IAInB;;;;;;;;;;;OAWG;IACU,MAAM,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB3D;;;;;;OAMG;cACa,aAAa,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAkBvE;;;OAGG;cACa,QAAQ,CAAC,GAAG,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUlF;;;;OAIG;cACa,YAAY,CAAC,GAAG,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAoCjG;;;;OAIG;IACH,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,CAAC;CAcnE"}

package/lib/cjs/archive/LogArchiveService.js

@@ -0,0 +1,189 @@
+"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.LogArchiveService = void 0;
+const di_1 = require("@spinajs/di");
+const log_common_1 = require("@spinajs/log-common");
+const luxon_1 = require("luxon");
+const path_1 = require("path");
+const archive_strategy_js_1 = require("./archive-strategy.js");
+const retention_strategy_js_1 = require("./retention-strategy.js");
+const util_js_1 = require("./strategies/util.js");
+/**
+ * Orchestrates rotation + retention for a single file log target.
+ *
+ * It owns nothing schedule-wise itself: it resolves ONE rotation strategy
+ * ( `archiveStrategy` ) and a LIST of retention strategies
+ * ( `retentionStrategies` ) by class name from DI, delegates start / stop to the
+ * rotation strategy, and provides the shared `rotate()` routine every rotation
+ * ( interval, cron or manual ) funnels through.
+ *
+ * `@NewInstance()` - each file target gets its own service ( per-target
+ * scheduling and strategy state ).
+ */
+let LogArchiveService = class LogArchiveService extends di_1.AsyncService {
+    constructor() {
+        super(...arguments);
+        this.RetentionStrategies = [];
+    }
+    /**
+     * Resolves the configured rotation + retention strategies by class name.
+     * Follows the fs temp-provider mechanism: look the class up in the DI
+     * registry by name, then resolve an instance.
+     */
+    async resolve() {
+        await super.resolve();
+    }
+    /**
+     * Wires strategies for the given context and starts the rotation schedule.
+     */
+    async start(ctx) {
+        // archiveStrategy / retentionStrategies are populated from the logger.file
+        // config defaults ( see FileTarget.resolve ), so no inline fallback here -
+        // the config is the single source of truth for what runs.
+        this.ArchiveStrategy = this.resolveStrategy(archive_strategy_js_1.LogArchiveStrategy, ctx.options.archiveStrategy);
+        const retentionNames = ctx.options.retentionStrategies ?? [];
+        this.RetentionStrategies = retentionNames.map((n) => this.resolveStrategy(retention_strategy_js_1.LogRetentionStrategy, n));
+        this.ArchiveStrategy.start(ctx);
+    }
+    /**
+     * Stops the rotation schedule. Safe to call multiple times.
+     */
+    stop() {
+        this.ArchiveStrategy?.stop();
+    }
+    /**
+     * Single rotation routine, shared by every scheduling strategy:
+     *
+     *  1. acquire the target write-lock so no append runs while we rename,
+     *  2. rename the active file to a sequenced archive name in the archive dir,
+     *  3. compress ( zip into archiveFs, drop the raw file ) OR move cross-fs,
+     *  4. run every retention strategy in order,
+     *  5. release the lock ( always, even on failure ).
+     *
+     * The whole routine is guarded so a failed rotation neither crashes the
+     * scheduler nor leaves the lock held.
+     */
+    async rotate(ctx) {
+        await ctx.withWriteLock(async () => {
+            // nothing written yet - nothing to rotate
+            if (!(await ctx.fs.exists(ctx.activePath))) {
+                return;
+            }
+            const archived = await this.moveToArchive(ctx);
+            if (ctx.options.compress) {
+                await this.compress(ctx, archived);
+            }
+        });
+        // retention runs OUTSIDE the write-lock - it only touches archive files,
+        // never the active log, so it must not block appends.
+        for (const strategy of this.RetentionStrategies) {
+            await strategy.safePrune(ctx);
+        }
+    }
+    /**
+     * Renames the active log file into the archive dir under a unique
+     * `archived_<name>_<seq><ext>` name. When `archiveFs` differs from `fs` the
+     * file is first renamed within `fs` then moved across.
+     *
+     * Returns the archive path relative to `archiveFs`.
+     */
+    async moveToArchive(ctx) {
+        const { name, ext } = (0, path_1.parse)(path_1.posix.basename(ctx.activePath.replace(/\\/g, "/")));
+        const seq = await this.nextSequence(ctx, name, ext);
+        const archiveName = `${util_js_1.ARCHIVE_PREFIX}${name}_${seq}${ext}`;
+        const archiveRel = (0, util_js_1.archivePath)(ctx, archiveName);
+        if (ctx.archiveFs === ctx.fs) {
+            await ctx.fs.rename(ctx.activePath, archiveRel);
+            return archiveRel;
+        }
+        // cross-fs: rename to a temp name inside `fs`, then move into archiveFs
+        const stagingRel = `${util_js_1.ARCHIVE_PREFIX}${name}_${seq}${ext}`;
+        await ctx.fs.rename(ctx.activePath, stagingRel);
+        await ctx.fs.move(stagingRel, archiveRel, ctx.archiveFs);
+        return archiveRel;
+    }
+    /**
+     * Zips `archived` into `archiveFs` and removes the raw archived file, so the
+     * archive dir only ever holds the compressed copy.
+     */
+    async compress(ctx, archived) {
+        const zipRel = `${archived}.zip`;
+        // zip() honors a non-temp dstFs / dstFile - output lands directly in archiveFs
+        await ctx.archiveFs.zip(archived, ctx.archiveFs, zipRel);
+        await ctx.archiveFs.rm(archived);
+        this.Logger.trace(`Compressed archive ${archived} -> ${zipRel}`);
+    }
+    /**
+     * Next archive sequence number for a given base name. Uses existing archive
+     * file names first, falling back to a timestamp so two rotations in the same
+     * tick never collide.
+     */
+    async nextSequence(ctx, name, ext) {
+        let existing = [];
+        try {
+            existing = await ctx.archiveFs.list(ctx.archiveDir || "/");
+        }
+        catch {
+            existing = [];
+        }
+        const prefix = `${util_js_1.ARCHIVE_PREFIX}${name}_`;
+        // prefix is escaped via escapeRegExp before interpolation
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        const seqReg = new RegExp(`^${escapeRegExp(prefix)}(\\d+)`);
+        let max = 0;
+        for (const f of existing) {
+            const m = seqReg.exec(f);
+            if (m) {
+                const n = parseInt(m[1], 10);
+                if (n > max) {
+                    max = n;
+                }
+            }
+        }
+        const next = max + 1;
+        // guard against a name clash ( eg. same-second cron + size rotation ) by
+        // appending a millisecond timestamp only when the computed name already exists
+        const candidate = (0, util_js_1.archivePath)(ctx, `${util_js_1.ARCHIVE_PREFIX}${name}_${next}${ext}`);
+        if (await ctx.archiveFs.exists(candidate)) {
+            return luxon_1.DateTime.now().toMillis();
+        }
+        return next;
+    }
+    /**
+     * Resolves a strategy instance by class name, mirroring the fs temp-provider
+     * mechanism: look the class up in the DI registry by name, then resolve an
+     * instance ( `@NewInstance()` gives a fresh per-target instance ).
+     */
+    resolveStrategy(base, className) {
+        const types = di_1.DI.RootContainer.Registry.getTypes(base);
+        const type = types.find((x) => x.name === className);
+        if (!type) {
+            const baseName = base.name;
+            throw new di_1.ResolveException(`Log archive strategy ${className} ( ${baseName} ) not registered, make sure it is imported and registered in DI container`);
+        }
+        // strategies are plain ( non-async ) services, so resolve is synchronous
+        return di_1.DI.resolve(type);
+    }
+};
+exports.LogArchiveService = LogArchiveService;
+__decorate([
+    (0, log_common_1.Logger)("LogFileTarget"),
+    __metadata("design:type", log_common_1.Log)
+], LogArchiveService.prototype, "Logger", void 0);
+exports.LogArchiveService = LogArchiveService = __decorate([
+    (0, di_1.Injectable)(),
+    (0, di_1.NewInstance)()
+], LogArchiveService);
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=LogArchiveService.js.map

package/lib/cjs/archive/LogArchiveService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogArchiveService.js","sourceRoot":"","sources":["../../../src/archive/LogArchiveService.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oCAAiG;AACjG,oDAAkD;AAClD,iCAAiC;AACjC,+BAAoC;AACpC,+DAA2D;AAC3D,mEAA+D;AAE/D,kDAAmE;AAEnE;;;;;;;;;;;GAWG;AAGI,IAAM,iBAAiB,GAAvB,MAAM,iBAAkB,SAAQ,iBAAY;IAA5C;;QAKK,wBAAmB,GAA2B,EAAE,CAAC;IAqK7D,CAAC;IAnKC;;;;OAIG;IACI,KAAK,CAAC,OAAO;QAClB,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,KAAK,CAAC,GAAuB;QACxC,2EAA2E;QAC3E,2EAA2E;QAC3E,0DAA0D;QAC1D,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,wCAAkB,EAAE,GAAG,CAAC,OAAO,CAAC,eAAyB,CAAC,CAAC;QAEvG,MAAM,cAAc,GAAG,GAAG,CAAC,OAAO,CAAC,mBAAmB,IAAI,EAAE,CAAC;QAC7D,IAAI,CAAC,mBAAmB,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,4CAAoB,EAAE,CAAC,CAAC,CAAC,CAAC;QAEpG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,IAAI;QACT,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,MAAM,CAAC,GAAuB;QACzC,MAAM,GAAG,CAAC,aAAa,CAAC,KAAK,IAAI,EAAE;YACjC,0CAA0C;YAC1C,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC;gBAC3C,OAAO;YACT,CAAC;YAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YAE/C,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACzB,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;YACrC,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,yEAAyE;QACzE,sDAAsD;QACtD,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAChD,MAAM,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACO,KAAK,CAAC,aAAa,CAAC,GAAuB;QACnD,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,IAAA,YAAK,EAAC,YAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;QAChF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QACpD,MAAM,WAAW,GAAG,GAAG,wBAAc,GAAG,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;QAC5D,MAAM,UAAU,GAAG,IAAA,qBAAW,EAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QAEjD,IAAI,GAAG,CAAC,SAAS,KAAK,GAAG,CAAC,EAAE,EAAE,CAAC;YAC7B,MAAM,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;YAChD,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,wEAAwE;QACxE,MAAM,UAAU,GAAG,GAAG,wBAAc,GAAG,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;QAC3D,MAAM,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAChD,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;QACzD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;OAGG;IACO,KAAK,CAAC,QAAQ,CAAC,GAAuB,EAAE,QAAgB;QAChE,MAAM,MAAM,GAAG,GAAG,QAAQ,MAAM,CAAC;QAEjC,+EAA+E;QAC/E,MAAM,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACzD,MAAM,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;QAEjC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,QAAQ,OAAO,MAAM,EAAE,CAAC,CAAC;IACnE,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,YAAY,CAAC,GAAuB,EAAE,IAAY,EAAE,GAAW;QAC7E,IAAI,QAAQ,GAAa,EAAE,CAAC;QAC5B,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,CAAC;QAC7D,CAAC;QAAC,MAAM,CAAC;YACP,QAAQ,GAAG,EAAE,CAAC;QAChB,CAAC;QAED,MAAM,MAAM,GAAG,GAAG,wBAAc,GAAG,IAAI,GAAG,CAAC;QAC3C,0DAA0D;QAC1D,8DAA8D;QAC9D,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE5D,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,CAAC,EAAE,CAAC;gBACN,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC7B,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;oBACZ,GAAG,GAAG,CAAC,CAAC;gBACV,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC;QAErB,yEAAyE;QACzE,+EAA+E;QAC/E,MAAM,SAAS,GAAG,IAAA,qBAAW,EAAC,GAAG,EAAE,GAAG,wBAAc,GAAG,IAAI,IAAI,IAAI,GAAG,GAAG,EAAE,CAAC,CAAC;QAC7E,IAAI,MAAM,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1C,OAAO,gBAAQ,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;QACnC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACO,eAAe,CAAI,IAAc,EAAE,SAAiB;QAC5D,MAAM,KAAK,GAAG,OAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACvD,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,CAAsB,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;QAE3E,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,QAAQ,GAAI,IAAyB,CAAC,IAAI,CAAC;YACjD,MAAM,IAAI,qBAAgB,CACxB,wBAAwB,SAAS,MAAM,QAAQ,4EAA4E,CAC5H,CAAC;QACJ,CAAC;QAED,yEAAyE;QACzE,OAAO,OAAE,CAAC,OAAO,CAAC,IAAgB,CAAM,CAAC;IAC3C,CAAC;CACF,CAAA;AA1KY,8CAAiB;AAElB;IADT,IAAA,mBAAM,EAAC,eAAe,CAAC;8BACN,gBAAG;iDAAC;4BAFX,iBAAiB;IAF7B,IAAA,eAAU,GAAE;IACZ,IAAA,gBAAW,GAAE;GACD,iBAAiB,CA0K7B;AAED,SAAS,YAAY,CAAC,CAAS;IAC7B,OAAO,CAAC,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAClD,CAAC"}

package/lib/cjs/archive/archive-strategy.d.ts

@@ -0,0 +1,32 @@
+import { Log } from "@spinajs/log-common";
+import { ILogArchiveContext } from "./context.js";
+/**
+ * Rotation policy for a file log target. Decides WHEN the active log file is
+ * rotated ( moved to the archive ) and owns its own schedule - the scheduling
+ * mechanism ( interval, cron, ... ) is strategy specific and implemented in
+ * `start` / `stop`.
+ *
+ * Mirrors the shape of fs `TempCleanupStrategy`: strategies hold per-target
+ * scheduling state, so implementations MUST be registered with `@NewInstance()`
+ * - otherwise a single instance would be shared between all file targets.
+ */
+export declare abstract class LogArchiveStrategy {
+    protected Logger: Log;
+    /**
+     * Starts scheduled rotation. How rotations are scheduled is up to the
+     * strategy.
+     *
+     * @param ctx archive context of the file target
+     */
+    abstract start(ctx: ILogArchiveContext): void;
+    /**
+     * Stops scheduled rotation. Safe to call multiple times.
+     */
+    abstract stop(): void;
+    /**
+     * Single rotation trigger guarded against errors - a failed rotation ( disk
+     * full, remote backend down, ... ) must never crash the scheduler tick.
+     */
+    protected triggerRotation(ctx: ILogArchiveContext): Promise<void>;
+}
+//# sourceMappingURL=archive-strategy.d.ts.map

package/lib/cjs/archive/archive-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-strategy.d.ts","sourceRoot":"","sources":["../../../src/archive/archive-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD;;;;;;;;;GASG;AACH,8BAAsB,kBAAkB;IAEtC,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC;IAEtB;;;;;OAKG;aACa,KAAK,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI;IAEpD;;OAEG;aACa,IAAI,IAAI,IAAI;IAE5B;;;OAGG;cACa,eAAe,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAOxE"}

package/lib/cjs/archive/archive-strategy.js

@@ -0,0 +1,43 @@
+"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.LogArchiveStrategy = void 0;
+const log_common_1 = require("@spinajs/log-common");
+/**
+ * Rotation policy for a file log target. Decides WHEN the active log file is
+ * rotated ( moved to the archive ) and owns its own schedule - the scheduling
+ * mechanism ( interval, cron, ... ) is strategy specific and implemented in
+ * `start` / `stop`.
+ *
+ * Mirrors the shape of fs `TempCleanupStrategy`: strategies hold per-target
+ * scheduling state, so implementations MUST be registered with `@NewInstance()`
+ * - otherwise a single instance would be shared between all file targets.
+ */
+class LogArchiveStrategy {
+    /**
+     * Single rotation trigger guarded against errors - a failed rotation ( disk
+     * full, remote backend down, ... ) must never crash the scheduler tick.
+     */
+    async triggerRotation(ctx) {
+        try {
+            await ctx.rotate();
+        }
+        catch (err) {
+            this.Logger.warn(`Log rotation for target ${ctx.options.path} failed: ${err.message}`);
+        }
+    }
+}
+exports.LogArchiveStrategy = LogArchiveStrategy;
+__decorate([
+    (0, log_common_1.Logger)("LogFileTarget"),
+    __metadata("design:type", log_common_1.Log)
+], LogArchiveStrategy.prototype, "Logger", void 0);
+//# sourceMappingURL=archive-strategy.js.map

package/lib/cjs/archive/archive-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-strategy.js","sourceRoot":"","sources":["../../../src/archive/archive-strategy.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oDAAkD;AAGlD;;;;;;;;;GASG;AACH,MAAsB,kBAAkB;IAiBtC;;;OAGG;IACO,KAAK,CAAC,eAAe,CAAC,GAAuB;QACrD,IAAI,CAAC;YACH,MAAM,GAAG,CAAC,MAAM,EAAE,CAAC;QACrB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,2BAA2B,GAAG,CAAC,OAAO,CAAC,IAAI,YAAa,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;QACpG,CAAC;IACH,CAAC;CACF;AA5BD,gDA4BC;AA1BW;IADT,IAAA,mBAAM,EAAC,eAAe,CAAC;8BACN,gBAAG;kDAAC"}

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

@@ -0,0 +1,50 @@
+import { fs } from "@spinajs/fs";
+import { Log, IFileTargetOptions } from "@spinajs/log-common";
+/**
+ * Shared context handed to every archive / retention strategy.
+ *
+ * It exposes the filesystems and paths a strategy needs, plus the two
+ * cross-cutting hooks it must go through:
+ *
+ *  - `rotate()`   - perform a single rotation ( owned by LogArchiveService ),
+ *  - `withWriteLock()` - run a critical section under the target write-lock so
+ *    a rename never races an in-flight append.
+ */
+export interface ILogArchiveContext {
+    /**
+     * Filesystem holding the ACTIVE log file.
+     */
+    fs: fs;
+    /**
+     * Filesystem archives ( rotated / zipped files ) are moved to. Defaults to
+     * the same provider as `fs`.
+     */
+    archiveFs: fs;
+    /**
+     * Path ( relative to `fs` base path ) of the active log file.
+     */
+    activePath: string;
+    /**
+     * Directory ( relative to `archiveFs` base path ) archives are stored in.
+     */
+    archiveDir: string;
+    /**
+     * Resolved file target options ( maxSize, maxAge, compress, ... ).
+     */
+    options: IFileTargetOptions["options"];
+    /**
+     * Target logger, used for diagnostics.
+     */
+    logger: Log;
+    /**
+     * Perform a single rotation of the active log file. Implemented by
+     * LogArchiveService - strategies call this from their schedule.
+     */
+    rotate(): Promise<void>;
+    /**
+     * Run `fn` under the target write-lock so it cannot overlap with an
+     * in-flight append / flush.
+     */
+    withWriteLock<T>(fn: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/archive/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACjC,OAAO,EAAE,GAAG,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,EAAE,EAAE,EAAE,CAAC;IAEP;;;OAGG;IACH,SAAS,EAAE,EAAE,CAAC;IAEd;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,OAAO,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAEvC;;OAEG;IACH,MAAM,EAAE,GAAG,CAAC;IAEZ;;;OAGG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;OAGG;IACH,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACpD"}

package/lib/cjs/archive/context.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/archive/context.ts"],"names":[],"mappings":""}

package/lib/cjs/archive/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./context.js";
+export * from "./archive-strategy.js";
+export * from "./retention-strategy.js";
+export * from "./LogArchiveService.js";
+export * from "./strategies/util.js";
+export * from "./strategies/SizeLogArchiveStrategy.js";
+export * from "./strategies/CronLogArchiveStrategy.js";
+export * from "./strategies/CountLogRetentionStrategy.js";
+export * from "./strategies/AgeLogRetentionStrategy.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/cjs/archive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/archive/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yCAAyC,CAAC"}

package/lib/cjs/archive/index.js

@@ -0,0 +1,26 @@
+"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("./context.js"), exports);
+__exportStar(require("./archive-strategy.js"), exports);
+__exportStar(require("./retention-strategy.js"), exports);
+__exportStar(require("./LogArchiveService.js"), exports);
+__exportStar(require("./strategies/util.js"), exports);
+__exportStar(require("./strategies/SizeLogArchiveStrategy.js"), exports);
+__exportStar(require("./strategies/CronLogArchiveStrategy.js"), exports);
+__exportStar(require("./strategies/CountLogRetentionStrategy.js"), exports);
+__exportStar(require("./strategies/AgeLogRetentionStrategy.js"), exports);
+//# sourceMappingURL=index.js.map

package/lib/cjs/archive/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/archive/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B;AAC7B,wDAAsC;AACtC,0DAAwC;AACxC,yDAAuC;AACvC,uDAAqC;AACrC,yEAAuD;AACvD,yEAAuD;AACvD,4EAA0D;AAC1D,0EAAwD"}

package/lib/cjs/archive/retention-strategy.d.ts

@@ -0,0 +1,26 @@
+import { Log } from "@spinajs/log-common";
+import { ILogArchiveContext } from "./context.js";
+/**
+ * Retention policy for archived log files. Decides WHICH archives are deleted
+ * after a rotation ( eg. keep newest N, drop older than maxAge ).
+ *
+ * Retention strategies are composable - a file target applies a LIST of them in
+ * sequence, so count + age can be combined. Each concrete strategy is
+ * `@NewInstance()` to keep per-target state isolated, mirroring the fs cleanup
+ * strategies.
+ */
+export declare abstract class LogRetentionStrategy {
+    protected Logger: Log;
+    /**
+     * Removes archives from `ctx.archiveDir` according to the strategy policy.
+     *
+     * @param ctx archive context of the file target
+     */
+    abstract prune(ctx: ILogArchiveContext): Promise<void>;
+    /**
+     * Single prune guarded against errors so one failing retention strategy never
+     * aborts the rest of the retention list or the rotation routine.
+     */
+    safePrune(ctx: ILogArchiveContext): Promise<void>;
+}
+//# sourceMappingURL=retention-strategy.d.ts.map

package/lib/cjs/archive/retention-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention-strategy.d.ts","sourceRoot":"","sources":["../../../src/archive/retention-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD;;;;;;;;GAQG;AACH,8BAAsB,oBAAoB;IAExC,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC;IAEtB;;;;OAIG;aACa,KAAK,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAE7D;;;OAGG;IACU,SAAS,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAO/D"}

package/lib/cjs/archive/retention-strategy.js

@@ -0,0 +1,42 @@
+"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.LogRetentionStrategy = void 0;
+const log_common_1 = require("@spinajs/log-common");
+/**
+ * Retention policy for archived log files. Decides WHICH archives are deleted
+ * after a rotation ( eg. keep newest N, drop older than maxAge ).
+ *
+ * Retention strategies are composable - a file target applies a LIST of them in
+ * sequence, so count + age can be combined. Each concrete strategy is
+ * `@NewInstance()` to keep per-target state isolated, mirroring the fs cleanup
+ * strategies.
+ */
+class LogRetentionStrategy {
+    /**
+     * Single prune guarded against errors so one failing retention strategy never
+     * aborts the rest of the retention list or the rotation routine.
+     */
+    async safePrune(ctx) {
+        try {
+            await this.prune(ctx);
+        }
+        catch (err) {
+            this.Logger.warn(`Log retention for target ${ctx.options.path} failed: ${err.message}`);
+        }
+    }
+}
+exports.LogRetentionStrategy = LogRetentionStrategy;
+__decorate([
+    (0, log_common_1.Logger)("LogFileTarget"),
+    __metadata("design:type", log_common_1.Log)
+], LogRetentionStrategy.prototype, "Logger", void 0);
+//# sourceMappingURL=retention-strategy.js.map

package/lib/cjs/archive/retention-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention-strategy.js","sourceRoot":"","sources":["../../../src/archive/retention-strategy.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oDAAkD;AAGlD;;;;;;;;GAQG;AACH,MAAsB,oBAAoB;IAWxC;;;OAGG;IACI,KAAK,CAAC,SAAS,CAAC,GAAuB;QAC5C,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4BAA4B,GAAG,CAAC,OAAO,CAAC,IAAI,YAAa,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;QACrG,CAAC;IACH,CAAC;CACF;AAtBD,oDAsBC;AApBW;IADT,IAAA,mBAAM,EAAC,eAAe,CAAC;8BACN,gBAAG;oDAAC"}

package/lib/cjs/archive/strategies/AgeLogRetentionStrategy.d.ts

@@ -0,0 +1,10 @@
+import { LogRetentionStrategy } from "../retention-strategy.js";
+import { ILogArchiveContext } from "../context.js";
+/**
+ * Deletes archives older than `maxAge` seconds ( from the logger.file config
+ * defaults ). Age is taken from the archive modification time.
+ */
+export declare class AgeLogRetentionStrategy extends LogRetentionStrategy {
+    prune(ctx: ILogArchiveContext): Promise<void>;
+}
+//# sourceMappingURL=AgeLogRetentionStrategy.d.ts.map

package/lib/cjs/archive/strategies/AgeLogRetentionStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgeLogRetentionStrategy.d.ts","sourceRoot":"","sources":["../../../../src/archive/strategies/AgeLogRetentionStrategy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGnD;;;GAGG;AACH,qBAEa,uBAAwB,SAAQ,oBAAoB;IAClD,KAAK,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAuB3D"}

package/lib/cjs/archive/strategies/AgeLogRetentionStrategy.js

@@ -0,0 +1,46 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgeLogRetentionStrategy = void 0;
+const di_1 = require("@spinajs/di");
+const luxon_1 = require("luxon");
+const retention_strategy_js_1 = require("../retention-strategy.js");
+const util_js_1 = require("./util.js");
+/**
+ * Deletes archives older than `maxAge` seconds ( from the logger.file config
+ * defaults ). Age is taken from the archive modification time.
+ */
+let AgeLogRetentionStrategy = class AgeLogRetentionStrategy extends retention_strategy_js_1.LogRetentionStrategy {
+    async prune(ctx) {
+        // maxAge is always populated from the config defaults ( see logger.file )
+        const maxAge = ctx.options.maxAge;
+        const now = luxon_1.DateTime.now();
+        const archives = await (0, util_js_1.listArchives)(ctx);
+        for (const a of archives) {
+            const ts = a.stat.ModifiedTime;
+            if (!ts || !ts.isValid) {
+                continue;
+            }
+            if (now.diff(ts, "seconds").seconds > maxAge) {
+                try {
+                    this.Logger.trace(`Deleting archive ${a.path} ( older than ${maxAge}s )`);
+                    await ctx.archiveFs.rm(a.path);
+                }
+                catch (err) {
+                    this.Logger.warn(`Cannot delete archive ${a.path}: ${err.message}`);
+                }
+            }
+        }
+    }
+};
+exports.AgeLogRetentionStrategy = AgeLogRetentionStrategy;
+exports.AgeLogRetentionStrategy = AgeLogRetentionStrategy = __decorate([
+    (0, di_1.Injectable)(retention_strategy_js_1.LogRetentionStrategy),
+    (0, di_1.NewInstance)()
+], AgeLogRetentionStrategy);
+//# sourceMappingURL=AgeLogRetentionStrategy.js.map

package/lib/cjs/archive/strategies/AgeLogRetentionStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgeLogRetentionStrategy.js","sourceRoot":"","sources":["../../../../src/archive/strategies/AgeLogRetentionStrategy.ts"],"names":[],"mappings":";;;;;;;;;AAAA,oCAAsD;AACtD,iCAAiC;AACjC,oEAAgE;AAEhE,uCAAyC;AAEzC;;;GAGG;AAGI,IAAM,uBAAuB,GAA7B,MAAM,uBAAwB,SAAQ,4CAAoB;IACxD,KAAK,CAAC,KAAK,CAAC,GAAuB;QACxC,0EAA0E;QAC1E,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,MAAgB,CAAC;QAC5C,MAAM,GAAG,GAAG,gBAAQ,CAAC,GAAG,EAAE,CAAC;QAE3B,MAAM,QAAQ,GAAG,MAAM,IAAA,sBAAY,EAAC,GAAG,CAAC,CAAC;QAEzC,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;YACzB,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC;YAC/B,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC;gBACvB,SAAS;YACX,CAAC;YAED,IAAI,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,OAAO,GAAG,MAAM,EAAE,CAAC;gBAC7C,IAAI,CAAC;oBACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,IAAI,iBAAiB,MAAM,KAAK,CAAC,CAAC;oBAC1E,MAAM,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBACjC,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC,IAAI,KAAM,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;gBACjF,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;CACF,CAAA;AAxBY,0DAAuB;kCAAvB,uBAAuB;IAFnC,IAAA,eAAU,EAAC,4CAAoB,CAAC;IAChC,IAAA,gBAAW,GAAE;GACD,uBAAuB,CAwBnC"}

package/lib/cjs/archive/strategies/CountLogRetentionStrategy.d.ts

@@ -0,0 +1,10 @@
+import { LogRetentionStrategy } from "../retention-strategy.js";
+import { ILogArchiveContext } from "../context.js";
+/**
+ * Keeps the newest N archives ( `maxArchiveFiles`, from the logger.file config
+ * defaults ) and deletes the oldest, ordered by modification time.
+ */
+export declare class CountLogRetentionStrategy extends LogRetentionStrategy {
+    prune(ctx: ILogArchiveContext): Promise<void>;
+}
+//# sourceMappingURL=CountLogRetentionStrategy.d.ts.map

package/lib/cjs/archive/strategies/CountLogRetentionStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CountLogRetentionStrategy.d.ts","sourceRoot":"","sources":["../../../../src/archive/strategies/CountLogRetentionStrategy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGnD;;;GAGG;AACH,qBAEa,yBAA0B,SAAQ,oBAAoB;IACpD,KAAK,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAqB3D"}