@spinajs/log 2.0.480 → 2.0.482

package/lib/mjs/targets/JsonFileTarget.d.ts

@@ -0,0 +1,19 @@
+import { ILogEntry } from "@spinajs/log-common";
+import { FileTarget } from "./FileTarget.js";
+/**
+ * Emits newline-delimited JSON ( NDJSON ) to a file through the FileTarget
+ * pipeline ( batched append, write-lock, rotation, retention, zip ): one
+ * structured JSON object per log entry so log collectors ( Loki, Elastic,
+ * Datadog ) can index fields directly rather than regex-parsing a layout.
+ *
+ * It subclasses the concrete FileTarget and overrides ONLY the per-entry
+ * serialization, reusing IFileTargetOptions unchanged. The inherited `layout`
+ * option is intentionally IGNORED ( JSON, not a string layout ). `time` is
+ * event-time: it is stamped in formatEntry, which runs in write() before the
+ * entry is buffered, so it reflects when the event was logged, not when the
+ * batch is flushed to disk.
+ */
+export declare class JsonFileTarget extends FileTarget {
+    protected formatEntry(data: ILogEntry): string;
+}
+//# sourceMappingURL=JsonFileTarget.d.ts.map

package/lib/mjs/targets/JsonFileTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonFileTarget.d.ts","sourceRoot":"","sources":["../../../src/targets/JsonFileTarget.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAA2C,MAAM,qBAAqB,CAAC;AAEzF,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,qBAEa,cAAe,SAAQ,UAAU;IAC5C,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;CAW/C"}

package/lib/mjs/targets/JsonFileTarget.js

@@ -0,0 +1,41 @@
+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;
+};
+import { Injectable, PerInstanceCheck } from "@spinajs/di";
+import { LogLevelToSeverityNumber, safeStringify } from "@spinajs/log-common";
+import { FileTarget } from "./FileTarget.js";
+/**
+ * Emits newline-delimited JSON ( NDJSON ) to a file through the FileTarget
+ * pipeline ( batched append, write-lock, rotation, retention, zip ): one
+ * structured JSON object per log entry so log collectors ( Loki, Elastic,
+ * Datadog ) can index fields directly rather than regex-parsing a layout.
+ *
+ * It subclasses the concrete FileTarget and overrides ONLY the per-entry
+ * serialization, reusing IFileTargetOptions unchanged. The inherited `layout`
+ * option is intentionally IGNORED ( JSON, not a string layout ). `time` is
+ * event-time: it is stamped in formatEntry, which runs in write() before the
+ * entry is buffered, so it reflects when the event was logged, not when the
+ * batch is flushed to disk.
+ */
+let JsonFileTarget = class JsonFileTarget extends FileTarget {
+    formatEntry(data) {
+        // 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 ).
+        return safeStringify({
+            time: new Date().toISOString(),
+            severityNumber: LogLevelToSeverityNumber[data.Level],
+            ...data.Variables,
+        });
+    }
+};
+JsonFileTarget = __decorate([
+    PerInstanceCheck(),
+    Injectable("JsonFileTarget")
+], JsonFileTarget);
+export { JsonFileTarget };
+//# sourceMappingURL=JsonFileTarget.js.map

package/lib/mjs/targets/JsonFileTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonFileTarget.js","sourceRoot":"","sources":["../../../src/targets/JsonFileTarget.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAa,wBAAwB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzF,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;GAYG;AAGI,IAAM,cAAc,GAApB,MAAM,cAAe,SAAQ,UAAU;IAClC,WAAW,CAAC,IAAe;QACnC,qEAAqE;QACrE,uEAAuE;QACvE,yEAAyE;QACzE,6BAA6B;QAC7B,OAAO,aAAa,CAAC;YACnB,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YAC9B,cAAc,EAAE,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC;YACpD,GAAG,IAAI,CAAC,SAAS;SAClB,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AAZY,cAAc;IAF1B,gBAAgB,EAAE;IAClB,UAAU,CAAC,gBAAgB,CAAC;GAChB,cAAc,CAY1B"}

package/lib/mjs/targets/JsonTarget.d.ts

@@ -0,0 +1,27 @@
+import { ICommonTargetOptions, ILogEntry, LogTarget } from "@spinajs/log-common";
+/**
+ * Emits NDJSON ( newline-delimited JSON ) to stdout for machine ingestion:
+ * one structured JSON object per log entry instead of a formatted string, so
+ * log collectors ( Loki, Elastic, Datadog, container stdout ) can index fields
+ * directly rather than regex-parsing a layout.
+ *
+ * The inherited `layout` option is intentionally IGNORED - JSON is not a string
+ * layout. `time` is stamped at write; because this target is synchronous /
+ * unbuffered that is ~event time. An event-time-stamped, file-backed variant
+ * will come with the batching base in a later phase.
+ */
+/**
+ * Options for {@link JsonTarget}.
+ */
+export interface IJsonTargetOptions extends ICommonTargetOptions {
+    /**
+     * Which stream to write to. A single stream is the 12-factor norm for machine
+     * logs. Default is "stdout".
+     */
+    stream?: "stdout" | "stderr";
+}
+export declare class JsonTarget extends LogTarget<IJsonTargetOptions> {
+    constructor(options: IJsonTargetOptions);
+    write(data: ILogEntry): void;
+}
+//# sourceMappingURL=JsonTarget.d.ts.map

package/lib/mjs/targets/JsonTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonTarget.d.ts","sourceRoot":"","sources":["../../../src/targets/JsonTarget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAA4B,SAAS,EAAiB,MAAM,qBAAqB,CAAC;AAG1H;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,oBAAoB;IAC9D;;;OAGG;IACH,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAC9B;AAED,qBAEa,UAAW,SAAQ,SAAS,CAAC,kBAAkB,CAAC;gBAC/C,OAAO,EAAE,kBAAkB;IAMhC,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;CAoBpC"}

package/lib/mjs/targets/JsonTarget.js

@@ -0,0 +1,43 @@
+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);
+};
+import { LogLevelToSeverityNumber, LogTarget, safeStringify } from "@spinajs/log-common";
+import { Injectable, Singleton } from "@spinajs/di";
+let JsonTarget = class JsonTarget extends 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: LogLevelToSeverityNumber[data.Level], ...data.Variables };
+        const line = 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$/, ""));
+        }
+    }
+};
+JsonTarget = __decorate([
+    Singleton(),
+    Injectable("JsonTarget"),
+    __metadata("design:paramtypes", [Object])
+], JsonTarget);
+export { JsonTarget };
+//# sourceMappingURL=JsonTarget.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JsonTarget.js","sourceRoot":"","sources":["../../../src/targets/JsonTarget.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAmC,wBAAwB,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC1H,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AA2B7C,IAAM,UAAU,GAAhB,MAAM,UAAW,SAAQ,SAA6B;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,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC3H,MAAM,IAAI,GAAG,aAAa,CAAC,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,UAAU;IAFtB,SAAS,EAAE;IACX,UAAU,CAAC,YAAY,CAAC;;GACZ,UAAU,CA2BtB"}

package/lib/mjs/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/mjs/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/mjs/targets/MemoryTarget.js

@@ -0,0 +1,60 @@
+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);
+};
+import { LogTarget } from "@spinajs/log-common";
+import { Injectable, Singleton } from "@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 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 = [];
+    }
+};
+MemoryTarget = __decorate([
+    Singleton(),
+    Injectable("MemoryTarget"),
+    __metadata("design:paramtypes", [Object])
+], MemoryTarget);
+export { MemoryTarget };
+//# sourceMappingURL=MemoryTarget.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryTarget.js","sourceRoot":"","sources":["../../../src/targets/MemoryTarget.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAmC,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAapD;;;;;;GAMG;AAGI,IAAM,YAAY,GAAlB,MAAM,YAAa,SAAQ,SAA+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,YAAY;IAFxB,SAAS,EAAE;IACX,UAAU,CAAC,cAAc,CAAC;;GACd,YAAY,CA4CxB"}

package/lib/mjs/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/mjs/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/mjs/targets/index.js

@@ -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.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/targets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","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/mjs/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/mjs/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/mjs/targets/wrappers/AutoFlushTarget.js

@@ -0,0 +1,45 @@
+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;
+};
+import { LogTarget, StrToLogLevel } from "@spinajs/log-common";
+import { DI, Injectable, Singleton } from "@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 LogTarget {
+    resolve() {
+        this.Inner = DI.resolve(this.Options.options.target.type, [this.Options.options.target]);
+        this.Threshold = 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?.();
+    }
+};
+AutoFlushTarget = __decorate([
+    Singleton(),
+    Injectable("AutoFlushTarget")
+], AutoFlushTarget);
+export { AutoFlushTarget };
+//# sourceMappingURL=AutoFlushTarget.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AutoFlushTarget.js","sourceRoot":"","sources":["../../../../src/targets/wrappers/AutoFlushTarget.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAmD,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAChH,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAsBxD;;;;;;;GAOG;AAGI,IAAM,eAAe,GAArB,MAAM,eAAgB,SAAQ,SAAkC;IAM9D,OAAO;QACZ,IAAI,CAAC,KAAK,GAAG,EAAE,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,aAAa,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,eAAe;IAF3B,SAAS,EAAE;IACX,UAAU,CAAC,iBAAiB,CAAC;GACjB,eAAe,CAiC3B"}

package/lib/mjs/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/mjs/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/mjs/targets/wrappers/FallbackGroupTarget.js

@@ -0,0 +1,91 @@
+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);
+};
+import { Logger, Log, LogTarget } from "@spinajs/log-common";
+import { DI, Injectable, Singleton } from "@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 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.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?.()));
+    }
+};
+__decorate([
+    Logger("FallbackGroupTarget"),
+    __metadata("design:type", Log)
+], FallbackGroupTarget.prototype, "Log", void 0);
+FallbackGroupTarget = __decorate([
+    Singleton(),
+    Injectable("FallbackGroupTarget")
+], FallbackGroupTarget);
+export { FallbackGroupTarget };
+//# sourceMappingURL=FallbackGroupTarget.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FallbackGroupTarget.js","sourceRoot":"","sources":["../../../../src/targets/wrappers/FallbackGroupTarget.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAmD,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC9G,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAiBxD;;;;;;;;;;;;;;;;;;;;GAoBG;AAGI,IAAM,mBAAmB,GAAzB,MAAM,mBAAoB,SAAQ,SAAsC;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,EAAE,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;AArDW;IADT,MAAM,CAAC,qBAAqB,CAAC;8BACf,GAAG;gDAAC;AAFR,mBAAmB;IAF/B,SAAS,EAAE;IACX,UAAU,CAAC,qBAAqB,CAAC;GACrB,mBAAmB,CAuD/B"}

package/lib/mjs/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/mjs/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/mjs/targets/wrappers/RetryingTarget.js

@@ -0,0 +1,58 @@
+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;
+};
+import { LogTarget } from "@spinajs/log-common";
+import { DI, Injectable, Singleton } from "@spinajs/di";
+import { BackoffType, ResiliencePipelineBuilder, TimeSpan } from "@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 LogTarget {
+    resolve() {
+        this.Inner = 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 ResiliencePipelineBuilder()
+            .addRetry({
+            MaxRetryAttempts: Math.max(0, maxAttempts - 1),
+            Delay: TimeSpan.fromMilliseconds(delayMs),
+            BackoffType: 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?.();
+    }
+};
+RetryingTarget = __decorate([
+    Singleton(),
+    Injectable("RetryingTarget")
+], RetryingTarget);
+export { RetryingTarget };
+//# sourceMappingURL=RetryingTarget.js.map