@spinajs/log 2.0.481 → 2.0.484

package/lib/cjs/targets/JsonTarget.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;
+};
+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.JsonTarget = void 0;
+const log_common_1 = require("@spinajs/log-common");
+const di_1 = require("@spinajs/di");
+let JsonTarget = class JsonTarget extends log_common_1.LogTarget {
+    constructor(options) {
+        super(options);
+        this.Options = Object.assign({ stream: "stdout" }, this.Options);
+    }
+    write(data) {
+        if (!this.Options.enabled) {
+            return;
+        }
+        // data.Variables already carries level ( uppercase string ), logger,
+        // message, a structured error ( from the serializer registry ), and any
+        // merged fields. safeStringify / JSON.stringify naturally omit undefined
+        // ( eg. error when absent ).
+        const record = { time: new Date().toISOString(), severityNumber: log_common_1.LogLevelToSeverityNumber[data.Level], ...data.Variables };
+        const line = (0, log_common_1.safeStringify)(record) + "\n";
+        if (typeof process !== "undefined" && process.stdout && typeof process.stdout.write === "function") {
+            const out = this.Options.stream === "stderr" && process.stderr ? process.stderr : process.stdout;
+            out.write(line);
+        }
+        else {
+            // browser fallback
+            console.log(line.replace(/\n$/, ""));
+        }
+    }
+};
+exports.JsonTarget = JsonTarget;
+exports.JsonTarget = JsonTarget = __decorate([
+    (0, di_1.Singleton)(),
+    (0, di_1.Injectable)("JsonTarget"),
+    __metadata("design:paramtypes", [Object])
+], JsonTarget);
+//# sourceMappingURL=JsonTarget.js.map

package/lib/cjs/targets/JsonTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonTarget.js","sourceRoot":"","sources":["../../../src/targets/JsonTarget.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oDAA0H;AAC1H,oCAAoD;AA2B7C,IAAM,UAAU,GAAhB,MAAM,UAAW,SAAQ,sBAA6B;IAC3D,YAAY,OAA2B;QACrC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,IAAe;QAC1B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,qEAAqE;QACrE,wEAAwE;QACxE,yEAAyE;QACzE,6BAA6B;QAC7B,MAAM,MAAM,GAAG,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,cAAc,EAAE,qCAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC3H,MAAM,IAAI,GAAG,IAAA,0BAAa,EAAC,MAAM,CAAC,GAAG,IAAI,CAAC;QAE1C,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;YACnG,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;YACjG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC;aAAM,CAAC;YACN,mBAAmB;YACnB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;CACF,CAAA;AA3BY,gCAAU;qBAAV,UAAU;IAFtB,IAAA,cAAS,GAAE;IACX,IAAA,eAAU,EAAC,YAAY,CAAC;;GACZ,UAAU,CA2BtB"}

package/lib/cjs/targets/MemoryTarget.d.ts

@@ -0,0 +1,33 @@
+import { ICommonTargetOptions, ILogEntry, LogTarget } from "@spinajs/log-common";
+/**
+ * Options for {@link MemoryTarget}.
+ */
+export interface IMemoryTargetOptions extends ICommonTargetOptions {
+    /**
+     * Max number of log entries retained in the ring buffer. Once exceeded, the
+     * oldest entries are dropped. Default is 100.
+     */
+    limit: number;
+}
+/**
+ * Ring-buffer target that keeps the last N log entries in memory. Lets a debug
+ * / health endpoint or a crash handler read recent log context back in-process
+ * ( eg. capturing all levels incl. trace ) without parsing the log file.
+ *
+ * Pure and browser-safe - no filesystem, no timers, no external deps.
+ */
+export declare class MemoryTarget extends LogTarget<IMemoryTargetOptions> {
+    protected Buffer: ILogEntry[];
+    constructor(options: IMemoryTargetOptions);
+    write(data: ILogEntry): void;
+    /**
+     * Returns a shallow copy of the retained entries ( oldest first ) so callers
+     * cannot mutate the ring buffer.
+     */
+    getRecords(): ILogEntry[];
+    /**
+     * Empties the buffer.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=MemoryTarget.d.ts.map

package/lib/cjs/targets/MemoryTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryTarget.d.ts","sourceRoot":"","sources":["../../../src/targets/MemoryTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGjF;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB;IAChE;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,qBAEa,YAAa,SAAQ,SAAS,CAAC,oBAAoB,CAAC;IAC/D,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAM;gBAEvB,OAAO,EAAE,oBAAoB;IAalC,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAcnC;;;OAGG;IACI,UAAU,IAAI,SAAS,EAAE;IAIhC;;OAEG;IACI,KAAK,IAAI,IAAI;CAGrB"}

package/lib/cjs/targets/MemoryTarget.js

@@ -0,0 +1,63 @@
+"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.MemoryTarget = void 0;
+const log_common_1 = require("@spinajs/log-common");
+const di_1 = require("@spinajs/di");
+/**
+ * Ring-buffer target that keeps the last N log entries in memory. Lets a debug
+ * / health endpoint or a crash handler read recent log context back in-process
+ * ( eg. capturing all levels incl. trace ) without parsing the log file.
+ *
+ * Pure and browser-safe - no filesystem, no timers, no external deps.
+ */
+let MemoryTarget = class MemoryTarget extends log_common_1.LogTarget {
+    constructor(options) {
+        super(options);
+        this.Buffer = [];
+        // apply defaults over the ( already layout-merged ) options, mirroring the
+        // Loki target's Object.assign approach.
+        this.Options = Object.assign({
+            limit: 100,
+        }, this.Options);
+    }
+    write(data) {
+        if (!this.Options.enabled) {
+            return;
+        }
+        this.Buffer.push(data);
+        // drop oldest while over the cap. splice ( rather than a single shift )
+        // handles a limit lowered at runtime, not just push-by-one growth.
+        if (this.Buffer.length > this.Options.limit) {
+            this.Buffer.splice(0, this.Buffer.length - this.Options.limit);
+        }
+    }
+    /**
+     * Returns a shallow copy of the retained entries ( oldest first ) so callers
+     * cannot mutate the ring buffer.
+     */
+    getRecords() {
+        return [...this.Buffer];
+    }
+    /**
+     * Empties the buffer.
+     */
+    clear() {
+        this.Buffer = [];
+    }
+};
+exports.MemoryTarget = MemoryTarget;
+exports.MemoryTarget = MemoryTarget = __decorate([
+    (0, di_1.Singleton)(),
+    (0, di_1.Injectable)("MemoryTarget"),
+    __metadata("design:paramtypes", [Object])
+], MemoryTarget);
+//# sourceMappingURL=MemoryTarget.js.map

package/lib/cjs/targets/MemoryTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryTarget.js","sourceRoot":"","sources":["../../../src/targets/MemoryTarget.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oDAAiF;AACjF,oCAAoD;AAapD;;;;;;GAMG;AAGI,IAAM,YAAY,GAAlB,MAAM,YAAa,SAAQ,sBAA+B;IAG/D,YAAY,OAA6B;QACvC,KAAK,CAAC,OAAO,CAAC,CAAC;QAHP,WAAM,GAAgB,EAAE,CAAC;QAKjC,2EAA2E;QAC3E,wCAAwC;QACxC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAC1B;YACE,KAAK,EAAE,GAAG;SACX,EACD,IAAI,CAAC,OAAO,CACb,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,IAAe;QAC1B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEvB,wEAAwE;QACxE,mEAAmE;QACnE,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YAC5C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,UAAU;QACf,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED;;OAEG;IACI,KAAK;QACV,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;IACnB,CAAC;CACF,CAAA;AA5CY,oCAAY;uBAAZ,YAAY;IAFxB,IAAA,cAAS,GAAE;IACX,IAAA,eAAU,EAAC,cAAc,CAAC;;GACd,YAAY,CA4CxB"}

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

@@ -1,4 +1,11 @@
 export * from "./BlackHoleTarget.js";
 export * from "./ColoredConsoleTarget.js";
 export * from "./FileTarget.js";
+export * from "./JsonFileTarget.js";
+export * from "./JsonTarget.js";
+export * from "./MemoryTarget.js";
+export * from "./wrappers/SplitGroupTarget.js";
+export * from "./wrappers/AutoFlushTarget.js";
+export * from "./wrappers/RetryingTarget.js";
+export * from "./wrappers/FallbackGroupTarget.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/targets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/targets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mCAAmC,CAAC"}

package/lib/cjs/targets/index.js

@@ -17,4 +17,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./BlackHoleTarget.js"), exports);
 __exportStar(require("./ColoredConsoleTarget.js"), exports);
 __exportStar(require("./FileTarget.js"), exports);
+__exportStar(require("./JsonFileTarget.js"), exports);
+__exportStar(require("./JsonTarget.js"), exports);
+__exportStar(require("./MemoryTarget.js"), exports);
+__exportStar(require("./wrappers/SplitGroupTarget.js"), exports);
+__exportStar(require("./wrappers/AutoFlushTarget.js"), exports);
+__exportStar(require("./wrappers/RetryingTarget.js"), exports);
+__exportStar(require("./wrappers/FallbackGroupTarget.js"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/targets/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC;AACrC,4DAA0C;AAC1C,kDAAgC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/targets/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC;AACrC,4DAA0C;AAC1C,kDAAgC;AAChC,sDAAoC;AACpC,kDAAgC;AAChC,oDAAkC;AAClC,iEAA+C;AAC/C,gEAA8C;AAC9C,+DAA6C;AAC7C,oEAAkD"}

package/lib/cjs/targets/wrappers/AutoFlushTarget.d.ts

@@ -0,0 +1,37 @@
+import { ICommonTargetOptions, ILogEntry, ITargetsOption, LogTarget } from "@spinajs/log-common";
+/**
+ * Options for {@link AutoFlushTarget}.
+ */
+export interface IAutoFlushTargetOptions extends ICommonTargetOptions {
+    options: {
+        /**
+         * Inline child target this wrapper decorates. Resolved through DI exactly
+         * like a top-level target.
+         */
+        target: ITargetsOption;
+        /**
+         * Severity ( inclusive ) at or above which the inner target is force-flushed
+         * right after the entry is written, so a crash-level event is never left
+         * buffered. Default `"error"`.
+         */
+        flushLevel?: string;
+    };
+}
+/**
+ * Wraps ONE inner target and force-flushes it whenever an entry at or above
+ * `flushLevel` ( default error ) is written, so a high-severity / crash-level
+ * event is never left sitting in a buffer. The inner target is declared inline
+ * and owned by this wrapper ( resolve / flush / dispose ).
+ *
+ * Pure / browser-safe - just delegates to its child.
+ */
+export declare class AutoFlushTarget extends LogTarget<IAutoFlushTargetOptions> {
+    protected Inner: LogTarget<ICommonTargetOptions>;
+    /** Resolved numeric severity threshold at/above which we force-flush. */
+    protected Threshold: number;
+    resolve(): void;
+    write(entry: ILogEntry): Promise<void>;
+    forceFlush(): Promise<void>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=AutoFlushTarget.d.ts.map

package/lib/cjs/targets/wrappers/AutoFlushTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoFlushTarget.d.ts","sourceRoot":"","sources":["../../../../src/targets/wrappers/AutoFlushTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAiB,MAAM,qBAAqB,CAAC;AAGhH;;GAEG;AACH,MAAM,WAAW,uBAAwB,SAAQ,oBAAoB;IACnE,OAAO,EAAE;QACP;;;WAGG;QACH,MAAM,EAAE,cAAc,CAAC;QAEvB;;;;WAIG;QACH,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED;;;;;;;GAOG;AACH,qBAEa,eAAgB,SAAQ,SAAS,CAAC,uBAAuB,CAAC;IACrE,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;IAEjD,yEAAyE;IACzE,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAErB,OAAO,IAAI,IAAI;IAOT,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAGtC"}

package/lib/cjs/targets/wrappers/AutoFlushTarget.js

@@ -0,0 +1,48 @@
+"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.AutoFlushTarget = void 0;
+const log_common_1 = require("@spinajs/log-common");
+const di_1 = require("@spinajs/di");
+/**
+ * Wraps ONE inner target and force-flushes it whenever an entry at or above
+ * `flushLevel` ( default error ) is written, so a high-severity / crash-level
+ * event is never left sitting in a buffer. The inner target is declared inline
+ * and owned by this wrapper ( resolve / flush / dispose ).
+ *
+ * Pure / browser-safe - just delegates to its child.
+ */
+let AutoFlushTarget = class AutoFlushTarget extends log_common_1.LogTarget {
+    resolve() {
+        this.Inner = di_1.DI.resolve(this.Options.options.target.type, [this.Options.options.target]);
+        this.Threshold = log_common_1.StrToLogLevel[(this.Options.options.flushLevel ?? "error")];
+        super.resolve();
+    }
+    async write(entry) {
+        if (!this.Options.enabled) {
+            return;
+        }
+        // wrap in Promise.resolve because some targets' write is sync / void.
+        await Promise.resolve(this.Inner.write(entry));
+        if (entry.Level >= this.Threshold) {
+            await this.Inner.forceFlush();
+        }
+    }
+    forceFlush() {
+        return this.Inner.forceFlush();
+    }
+    async dispose() {
+        await this.Inner.dispose?.();
+    }
+};
+exports.AutoFlushTarget = AutoFlushTarget;
+exports.AutoFlushTarget = AutoFlushTarget = __decorate([
+    (0, di_1.Singleton)(),
+    (0, di_1.Injectable)("AutoFlushTarget")
+], AutoFlushTarget);
+//# sourceMappingURL=AutoFlushTarget.js.map

package/lib/cjs/targets/wrappers/AutoFlushTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoFlushTarget.js","sourceRoot":"","sources":["../../../../src/targets/wrappers/AutoFlushTarget.ts"],"names":[],"mappings":";;;;;;;;;AAAA,oDAAgH;AAChH,oCAAwD;AAsBxD;;;;;;;GAOG;AAGI,IAAM,eAAe,GAArB,MAAM,eAAgB,SAAQ,sBAAkC;IAM9D,OAAO;QACZ,IAAI,CAAC,KAAK,GAAG,OAAE,CAAC,OAAO,CAAkC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAC1H,IAAI,CAAC,SAAS,GAAG,0BAAa,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,IAAI,OAAO,CAA+B,CAAC,CAAC;QAE3G,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,KAAK,CAAC,KAAgB;QACjC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,sEAAsE;QACtE,MAAM,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAE/C,IAAI,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAClC,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;QAChC,CAAC;IACH,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;IACjC,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,MAAO,IAAI,CAAC,KAAa,CAAC,OAAO,EAAE,EAAE,CAAC;IACxC,CAAC;CACF,CAAA;AAjCY,0CAAe;0BAAf,eAAe;IAF3B,IAAA,cAAS,GAAE;IACX,IAAA,eAAU,EAAC,iBAAiB,CAAC;GACjB,eAAe,CAiC3B"}

package/lib/cjs/targets/wrappers/FallbackGroupTarget.d.ts

@@ -0,0 +1,45 @@
+import { ICommonTargetOptions, ILogEntry, ITargetsOption, Log, LogTarget } from "@spinajs/log-common";
+/**
+ * Options for {@link FallbackGroupTarget}.
+ */
+export interface IFallbackGroupTargetOptions extends ICommonTargetOptions {
+    options: {
+        /**
+         * ORDERED inline child target definitions: the PRIMARY first, then one or
+         * more fallbacks. Each is resolved through DI exactly like a top-level
+         * target, so any registered target type ( File, Loki, another wrapper ... )
+         * can be nested here.
+         */
+        targets: ITargetsOption[];
+    };
+}
+/**
+ * Failover wrapper: an ORDERED list of targets ( primary first, fallbacks
+ * after ). It handles TWO complementary failure modes so a durable fallback
+ * catches exactly what a down primary never delivered — with no duplicates:
+ *
+ *  - **A ( immediate write rejection ).** `write()` tries the primary; if it
+ *    REJECTS ( see the contract on {@link LogTarget.write} ) it advances to the
+ *    next target, and so on, resolving on the first success. If every target
+ *    rejects the last rejection is swallowed ( warn-only ) so logging never
+ *    throws into the caller.
+ *
+ *  - **D ( later async drop ).** Self-healing network targets ( Loki / OTLP )
+ *    RESOLVE `write()` immediately and only later GIVE UP on an entry ( buffer
+ *    overflow or a non-retryable delivery failure ). resolve() wires each
+ *    target's {@link LogTarget.OnDropped} hook to the NEXT target's write, so
+ *    those late drops spill down the chain to the fallback. The last target has
+ *    no successor, so its OnDropped stays null.
+ *
+ * The inner targets are declared inline and owned by this wrapper ( resolve /
+ * flush / dispose ). Pure / browser-safe - just delegates to its children.
+ */
+export declare class FallbackGroupTarget extends LogTarget<IFallbackGroupTargetOptions> {
+    protected Log: Log;
+    protected Inner: LogTarget<ICommonTargetOptions>[];
+    resolve(): void;
+    write(entry: ILogEntry): Promise<void>;
+    forceFlush(): Promise<void>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=FallbackGroupTarget.d.ts.map

package/lib/cjs/targets/wrappers/FallbackGroupTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FallbackGroupTarget.d.ts","sourceRoot":"","sources":["../../../../src/targets/wrappers/FallbackGroupTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,cAAc,EAAU,GAAG,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAG9G;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB;IACvE,OAAO,EAAE;QACP;;;;;WAKG;QACH,OAAO,EAAE,cAAc,EAAE,CAAC;KAC3B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAEa,mBAAoB,SAAQ,SAAS,CAAC,2BAA2B,CAAC;IAE7E,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC;IAEnB,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,oBAAoB,CAAC,EAAE,CAAM;IAEjD,OAAO,IAAI,IAAI;IAoBT,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB5C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAKtC"}

package/lib/cjs/targets/wrappers/FallbackGroupTarget.js

@@ -0,0 +1,94 @@
+"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.FallbackGroupTarget = void 0;
+const log_common_1 = require("@spinajs/log-common");
+const di_1 = require("@spinajs/di");
+/**
+ * Failover wrapper: an ORDERED list of targets ( primary first, fallbacks
+ * after ). It handles TWO complementary failure modes so a durable fallback
+ * catches exactly what a down primary never delivered — with no duplicates:
+ *
+ *  - **A ( immediate write rejection ).** `write()` tries the primary; if it
+ *    REJECTS ( see the contract on {@link LogTarget.write} ) it advances to the
+ *    next target, and so on, resolving on the first success. If every target
+ *    rejects the last rejection is swallowed ( warn-only ) so logging never
+ *    throws into the caller.
+ *
+ *  - **D ( later async drop ).** Self-healing network targets ( Loki / OTLP )
+ *    RESOLVE `write()` immediately and only later GIVE UP on an entry ( buffer
+ *    overflow or a non-retryable delivery failure ). resolve() wires each
+ *    target's {@link LogTarget.OnDropped} hook to the NEXT target's write, so
+ *    those late drops spill down the chain to the fallback. The last target has
+ *    no successor, so its OnDropped stays null.
+ *
+ * The inner targets are declared inline and owned by this wrapper ( resolve /
+ * flush / dispose ). Pure / browser-safe - just delegates to its children.
+ */
+let FallbackGroupTarget = class FallbackGroupTarget extends log_common_1.LogTarget {
+    constructor() {
+        super(...arguments);
+        this.Inner = [];
+    }
+    resolve() {
+        // resolve each child via DI exactly like FrameworkLogger.resolveLogTargets
+        // does - the child's ITargetsOption is passed as the single ctor arg.
+        this.Inner = this.Options.options.targets.map((t) => di_1.DI.resolve(t.type, [t]));
+        // mechanism D: wire the drop-hook chain. For each consecutive pair, entries
+        // target[i] GIVES UP on flow to target[i+1].write. The last target has no
+        // fallback -> its OnDropped stays null.
+        for (let i = 0; i < this.Inner.length - 1; i++) {
+            const next = this.Inner[i + 1];
+            this.Inner[i].OnDropped = (entry) => {
+                void Promise.resolve(next.write(entry)).catch(() => {
+                    /* fallback itself gave up - nothing more to do */
+                });
+            };
+        }
+        super.resolve();
+    }
+    async write(entry) {
+        if (!this.Options.enabled) {
+            return;
+        }
+        // mechanism A: try each target in order; resolve on the first success. Only
+        // advance to the next when the current one REJECTS.
+        for (const t of this.Inner) {
+            try {
+                await Promise.resolve(t.write(entry));
+                return;
+            }
+            catch {
+                /* rejected -> try the next fallback */
+            }
+        }
+        // every target rejected - swallow ( warn-only ) so logging never throws.
+        this.Log?.warn(`FallbackGroupTarget ${this.Options.name}: all ${this.Inner.length} targets rejected the entry.`);
+    }
+    forceFlush() {
+        return Promise.allSettled(this.Inner.map((t) => t.forceFlush())).then(() => undefined);
+    }
+    async dispose() {
+        // the wrapper owns its children ( they are not in the logger's Targets list )
+        // so it drives their teardown.
+        await Promise.allSettled(this.Inner.map((t) => t.dispose?.()));
+    }
+};
+exports.FallbackGroupTarget = FallbackGroupTarget;
+__decorate([
+    (0, log_common_1.Logger)("FallbackGroupTarget"),
+    __metadata("design:type", log_common_1.Log)
+], FallbackGroupTarget.prototype, "Log", void 0);
+exports.FallbackGroupTarget = FallbackGroupTarget = __decorate([
+    (0, di_1.Singleton)(),
+    (0, di_1.Injectable)("FallbackGroupTarget")
+], FallbackGroupTarget);
+//# sourceMappingURL=FallbackGroupTarget.js.map

package/lib/cjs/targets/wrappers/FallbackGroupTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FallbackGroupTarget.js","sourceRoot":"","sources":["../../../../src/targets/wrappers/FallbackGroupTarget.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oDAA8G;AAC9G,oCAAwD;AAiBxD;;;;;;;;;;;;;;;;;;;;GAoBG;AAGI,IAAM,mBAAmB,GAAzB,MAAM,mBAAoB,SAAQ,sBAAsC;IAAxE;;QAIK,UAAK,GAAsC,EAAE,CAAC;IAmD1D,CAAC;IAjDQ,OAAO;QACZ,2EAA2E;QAC3E,sEAAsE;QACtE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAE,CAAC,OAAO,CAAkC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE/G,4EAA4E;QAC5E,0EAA0E;QAC1E,wCAAwC;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC/B,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,KAAgB,EAAE,EAAE;gBAC7C,KAAK,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;oBACjD,kDAAkD;gBACpD,CAAC,CAAC,CAAC;YACL,CAAC,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,KAAK,CAAC,KAAgB;QACjC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,4EAA4E;QAC5E,oDAAoD;QACpD,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC3B,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gBACtC,OAAO;YACT,CAAC;YAAC,MAAM,CAAC;gBACP,uCAAuC;YACzC,CAAC;QACH,CAAC;QAED,yEAAyE;QACzE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,uBAAuB,IAAI,CAAC,OAAO,CAAC,IAAI,SAAS,IAAI,CAAC,KAAK,CAAC,MAAM,8BAA8B,CAAC,CAAC;IACnH,CAAC;IAEM,UAAU;QACf,OAAO,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACzF,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,8EAA8E;QAC9E,+BAA+B;QAC/B,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,CAAS,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC;CACF,CAAA;AAvDY,kDAAmB;AAEpB;IADT,IAAA,mBAAM,EAAC,qBAAqB,CAAC;8BACf,gBAAG;gDAAC;8BAFR,mBAAmB;IAF/B,IAAA,cAAS,GAAE;IACX,IAAA,eAAU,EAAC,qBAAqB,CAAC;GACrB,mBAAmB,CAuD/B"}

package/lib/cjs/targets/wrappers/RetryingTarget.d.ts

@@ -0,0 +1,44 @@
+import { ICommonTargetOptions, ILogEntry, ITargetsOption, LogTarget } from "@spinajs/log-common";
+import { ResiliencePipeline } from "@spinajs/util";
+/**
+ * Options for {@link RetryingTarget}.
+ */
+export interface IRetryingTargetOptions extends ICommonTargetOptions {
+    options: {
+        /**
+         * Inline child target this wrapper decorates. Resolved through DI exactly
+         * like a top-level target.
+         */
+        target: ITargetsOption;
+        /**
+         * Total number of write attempts ( the first try plus retries ). Default 3.
+         */
+        maxAttempts?: number;
+        /**
+         * Base delay in milliseconds between retries ( exponential backoff + jitter
+         * is applied on top ). Default 100.
+         */
+        delayMs?: number;
+    };
+}
+/**
+ * Wraps ONE inner target and RETRIES its `write` when it REJECTS, using the
+ * `@spinajs/util` resilience pipeline ( exponential backoff + jitter ). Only
+ * useful for targets that surface failure by rejecting ( console / custom /
+ * strict ) — self-healing targets ( File / Loki / OTLP ) own their reliability
+ * and resolve, so wrapping them is a no-op. See the write() rejection contract
+ * on {@link LogTarget.write}.
+ *
+ * The inner target is declared inline and owned by this wrapper ( resolve /
+ * flush / dispose ). Pure / browser-safe - just delegates to its child.
+ */
+export declare class RetryingTarget extends LogTarget<IRetryingTargetOptions> {
+    protected Inner: LogTarget<ICommonTargetOptions>;
+    /** Reusable retry pipeline guarding the inner write. */
+    protected RetryPipeline: ResiliencePipeline<void>;
+    resolve(): void;
+    write(entry: ILogEntry): Promise<void>;
+    forceFlush(): Promise<void>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=RetryingTarget.d.ts.map

package/lib/cjs/targets/wrappers/RetryingTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetryingTarget.d.ts","sourceRoot":"","sources":["../../../../src/targets/wrappers/RetryingTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEjG,OAAO,EAAe,kBAAkB,EAAuC,MAAM,eAAe,CAAC;AAErG;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,oBAAoB;IAClE,OAAO,EAAE;QACP;;;WAGG;QACH,MAAM,EAAE,cAAc,CAAC;QAEvB;;WAEG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QAErB;;;WAGG;QACH,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED;;;;;;;;;;GAUG;AACH,qBAEa,cAAe,SAAQ,SAAS,CAAC,sBAAsB,CAAC;IACnE,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;IAEjD,wDAAwD;IACxD,SAAS,CAAC,aAAa,EAAE,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAE3C,OAAO,IAAI,IAAI;IAoBf,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAUtC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAGtC"}

package/lib/cjs/targets/wrappers/RetryingTarget.js

@@ -0,0 +1,61 @@
+"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.RetryingTarget = void 0;
+const log_common_1 = require("@spinajs/log-common");
+const di_1 = require("@spinajs/di");
+const util_1 = require("@spinajs/util");
+/**
+ * Wraps ONE inner target and RETRIES its `write` when it REJECTS, using the
+ * `@spinajs/util` resilience pipeline ( exponential backoff + jitter ). Only
+ * useful for targets that surface failure by rejecting ( console / custom /
+ * strict ) — self-healing targets ( File / Loki / OTLP ) own their reliability
+ * and resolve, so wrapping them is a no-op. See the write() rejection contract
+ * on {@link LogTarget.write}.
+ *
+ * The inner target is declared inline and owned by this wrapper ( resolve /
+ * flush / dispose ). Pure / browser-safe - just delegates to its child.
+ */
+let RetryingTarget = class RetryingTarget extends log_common_1.LogTarget {
+    resolve() {
+        this.Inner = di_1.DI.resolve(this.Options.options.target.type, [this.Options.options.target]);
+        const maxAttempts = this.Options.options.maxAttempts ?? 3;
+        const delayMs = this.Options.options.delayMs ?? 100;
+        // MaxRetryAttempts counts RETRIES ( on top of the first attempt ), so
+        // subtract one from the total attempt budget.
+        this.RetryPipeline = new util_1.ResiliencePipelineBuilder()
+            .addRetry({
+            MaxRetryAttempts: Math.max(0, maxAttempts - 1),
+            Delay: util_1.TimeSpan.fromMilliseconds(delayMs),
+            BackoffType: util_1.BackoffType.Exponential,
+            UseJitter: true,
+        })
+            .build();
+        super.resolve();
+    }
+    write(entry) {
+        if (!this.Options.enabled) {
+            return Promise.resolve();
+        }
+        // wrap in Promise.resolve because some targets' write is sync / void. The
+        // pipeline retries whenever the inner write REJECTS.
+        return this.RetryPipeline.execute(() => Promise.resolve(this.Inner.write(entry)).then(() => undefined));
+    }
+    forceFlush() {
+        return this.Inner.forceFlush();
+    }
+    async dispose() {
+        await this.Inner.dispose?.();
+    }
+};
+exports.RetryingTarget = RetryingTarget;
+exports.RetryingTarget = RetryingTarget = __decorate([
+    (0, di_1.Singleton)(),
+    (0, di_1.Injectable)("RetryingTarget")
+], RetryingTarget);
+//# sourceMappingURL=RetryingTarget.js.map

package/lib/cjs/targets/wrappers/RetryingTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetryingTarget.js","sourceRoot":"","sources":["../../../../src/targets/wrappers/RetryingTarget.ts"],"names":[],"mappings":";;;;;;;;;AAAA,oDAAiG;AACjG,oCAAwD;AACxD,wCAAqG;AA0BrG;;;;;;;;;;GAUG;AAGI,IAAM,cAAc,GAApB,MAAM,cAAe,SAAQ,sBAAiC;IAM5D,OAAO;QACZ,IAAI,CAAC,KAAK,GAAG,OAAE,CAAC,OAAO,CAAkC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAE1H,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC;QAC1D,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,IAAI,GAAG,CAAC;QAEpD,sEAAsE;QACtE,8CAA8C;QAC9C,IAAI,CAAC,aAAa,GAAG,IAAI,gCAAyB,EAAQ;aACvD,QAAQ,CAAC;YACR,gBAAgB,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,CAAC,CAAC;YAC9C,KAAK,EAAE,eAAQ,CAAC,gBAAgB,CAAC,OAAO,CAAC;YACzC,WAAW,EAAE,kBAAW,CAAC,WAAW;YACpC,SAAS,EAAE,IAAI;SAChB,CAAC;aACD,KAAK,EAAE,CAAC;QAEX,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,KAAgB;QAC3B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1B,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QAC3B,CAAC;QAED,0EAA0E;QAC1E,qDAAqD;QACrD,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IAC1G,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;IACjC,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,MAAO,IAAI,CAAC,KAAa,CAAC,OAAO,EAAE,EAAE,CAAC;IACxC,CAAC;CACF,CAAA;AA3CY,wCAAc;yBAAd,cAAc;IAF1B,IAAA,cAAS,GAAE;IACX,IAAA,eAAU,EAAC,gBAAgB,CAAC;GAChB,cAAc,CA2C1B"}

package/lib/cjs/targets/wrappers/SplitGroupTarget.d.ts

@@ -0,0 +1,30 @@
+import { ICommonTargetOptions, ILogEntry, ITargetsOption, LogTarget } from "@spinajs/log-common";
+/**
+ * Options for {@link SplitGroupTarget}.
+ */
+export interface ISplitGroupTargetOptions extends ICommonTargetOptions {
+    options: {
+        /**
+         * Inline child target definitions this group fans out to. Each is resolved
+         * through DI exactly like a top-level target, so any registered target type
+         * ( File, Json, Loki, another wrapper ... ) can be nested here.
+         */
+        targets: ITargetsOption[];
+    };
+}
+/**
+ * Fan-out wrapper: one configured target name that writes every entry to MANY
+ * inner targets. The inner targets are declared inline under `options.targets`
+ * and are owned by this wrapper ( they are NOT part of the logger's Targets
+ * list ), so the wrapper resolves, flushes and disposes them.
+ *
+ * Pure / browser-safe - just delegates to its children.
+ */
+export declare class SplitGroupTarget extends LogTarget<ISplitGroupTargetOptions> {
+    protected Inner: LogTarget<ICommonTargetOptions>[];
+    resolve(): void;
+    write(entry: ILogEntry): Promise<void>;
+    forceFlush(): Promise<void>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=SplitGroupTarget.d.ts.map

package/lib/cjs/targets/wrappers/SplitGroupTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SplitGroupTarget.d.ts","sourceRoot":"","sources":["../../../../src/targets/wrappers/SplitGroupTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGjG;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE,OAAO,EAAE;QACP;;;;WAIG;QACH,OAAO,EAAE,cAAc,EAAE,CAAC;KAC3B,CAAC;CACH;AAED;;;;;;;GAOG;AACH,qBAEa,gBAAiB,SAAQ,SAAS,CAAC,wBAAwB,CAAC;IACvE,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,oBAAoB,CAAC,EAAE,CAAM;IAEjD,OAAO,IAAI,IAAI;IAQf,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAStC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAKtC"}