@wireio/shared 1.0.18 → 1.0.20

package/lib/esm/logging/appenders/push/PushLogRecordsAppender.d.ts

@@ -0,0 +1,76 @@
+import EventEmitter3 from "eventemitter3";
+import { LogRecord } from "../../LogRecord.js";
+import { Appender } from "../../Appender.js";
+interface PushLogRecordsCredentialManagerEventMap {
+    received: () => void;
+    expired: () => void;
+}
+/**
+ * Manages credential cookie for PushLogRecordsAppender.
+ * Invokes the endpoint via POST to obtain a session cookie.
+ */
+export declare class PushLogRecordsCredentialManager extends EventEmitter3<PushLogRecordsCredentialManagerEventMap> {
+    readonly endpointUrl: string;
+    private refreshTimer;
+    private credentialDeferred;
+    private cookieExpirationTime;
+    constructor(endpointUrl: string);
+    /**
+     * Check if valid credentials exist
+     */
+    hasCredentials(): boolean;
+    /**
+     * Get credentials, fetching them if necessary
+     */
+    ensureCredentials(): Promise<boolean>;
+    /**
+     * Force refresh of credentials
+     */
+    forceRefresh(): void;
+    /**
+     * Fetch credentials from the endpoint
+     */
+    private fetchCredentials;
+    /**
+     * Schedule a credential refresh before expiration
+     */
+    private scheduleRefresh;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+}
+/**
+ * Appender that pushes log records to a remote endpoint via HTTP PUT.
+ * Batches records and sends when queue reaches FLUSH_QUEUE_DEPTH or FLUSH_INTERVAL_MS has elapsed.
+ */
+export declare class PushLogRecordsAppender<Record extends LogRecord = LogRecord> implements Appender<Record> {
+    readonly endpointUrl: string;
+    private pendingRecords;
+    private flushDeferred;
+    private flushTimer;
+    readonly credentialManager: PushLogRecordsCredentialManager;
+    constructor(endpointUrl: string);
+    /**
+     * Append a log record to the queue
+     */
+    append(record: Record): void;
+    /**
+     * Schedule a flush after the interval
+     */
+    private scheduleFlush;
+    /**
+     * Flush pending records to the endpoint
+     */
+    private flush;
+    /**
+     * Force an immediate flush
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+}
+export default PushLogRecordsAppender;
+//# sourceMappingURL=PushLogRecordsAppender.d.ts.map

package/lib/esm/logging/appenders/push/PushLogRecordsAppender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PushLogRecordsAppender.d.ts","sourceRoot":"","sources":["../../../../../src/logging/appenders/push/PushLogRecordsAppender.ts"],"names":[],"mappings":"AACA,OAAO,aAAa,MAAM,eAAe,CAAA;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAa5C,UAAU,uCAAuC;IAC/C,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;GAGG;AACH,qBAAa,+BAAgC,SAAQ,aAAa,CAAC,uCAAuC,CAAC;aAK7E,WAAW,EAAE,MAAM;IAJ/C,OAAO,CAAC,YAAY,CAA6C;IACjE,OAAO,CAAC,kBAAkB,CAA8B;IACxD,OAAO,CAAC,oBAAoB,CAAsB;gBAEtB,WAAW,EAAE,MAAM;IAI/C;;OAEG;IACH,cAAc,IAAI,OAAO;IAczB;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAoB3C;;OAEG;IACH,YAAY,IAAI,IAAI;IAkBpB;;OAEG;YACW,gBAAgB;IAoC9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAevB;;OAEG;IACH,OAAO,IAAI,IAAI;CAahB;AAED;;;GAGG;AACH,qBAAa,sBAAsB,CAAC,MAAM,SAAS,SAAS,GAAG,SAAS,CAAE,YAAW,QAAQ,CAAC,MAAM,CAAC;aAOvE,WAAW,EAAE,MAAM;IAN/C,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,UAAU,CAA6C;IAE/D,SAAgB,iBAAiB,EAAE,+BAA+B,CAAA;gBAEtC,WAAW,EAAE,MAAM;IAa/C;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IA6B5B;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;OAEG;YACW,KAAK;IAyDnB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC;;OAEG;IACH,OAAO,IAAI,IAAI;CAehB;AAED,eAAe,sBAAsB,CAAA"}

package/lib/esm/logging/appenders/push/PushLogRecordsAppender.js

@@ -0,0 +1,286 @@
+/* eslint-disable typescript/no-explicit-any */
+import EventEmitter3 from "eventemitter3";
+import { Deferred } from "../../../helpers/index.js";
+import { getInternalLogger } from "../../InternalLogger.js";
+// Constants for tuning (adjustable in development)
+const COOKIE_EXPIRATION_MS = 5 * 60 * 1000; // 30 minutes
+const COOKIE_REFRESH_BUFFER_MS = 2 * 60 * 1000; // Refresh 2 minutes before expiration
+const FLUSH_QUEUE_DEPTH = 1000;
+const FLUSH_INTERVAL_MS = 5 * 1000; // 10 seconds
+const LOG_QUEUE_MAX_RECORDS = 10000;
+const COOKIE_NAME = "wire_logs_id";
+const log = getInternalLogger();
+/**
+ * Manages credential cookie for PushLogRecordsAppender.
+ * Invokes the endpoint via POST to obtain a session cookie.
+ */
+export class PushLogRecordsCredentialManager extends EventEmitter3 {
+    endpointUrl;
+    refreshTimer = null;
+    credentialDeferred = null;
+    cookieExpirationTime = null;
+    constructor(endpointUrl) {
+        super();
+        this.endpointUrl = endpointUrl;
+    }
+    /**
+     * Check if valid credentials exist
+     */
+    hasCredentials() {
+        if (!this.cookieExpirationTime) {
+            return false;
+        }
+        if (Date.now() >= this.cookieExpirationTime) {
+            this.cookieExpirationTime = null;
+            this.emit("expired");
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get credentials, fetching them if necessary
+     */
+    async ensureCredentials() {
+        // If we have valid credentials, return immediately
+        if (this.hasCredentials()) {
+            return true;
+        }
+        // If a fetch is already in progress, wait for it
+        if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {
+            try {
+                await this.credentialDeferred.promise;
+                return this.hasCredentials();
+            }
+            catch {
+                return false;
+            }
+        }
+        // Fetch new credentials
+        return this.fetchCredentials();
+    }
+    /**
+     * Force refresh of credentials
+     */
+    forceRefresh() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        this.cookieExpirationTime = null;
+        if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {
+            this.credentialDeferred.reject(new Error("Force refresh requested"));
+        }
+        this.credentialDeferred = null;
+        this.fetchCredentials().catch(() => {
+            // Ignore errors during force refresh, they'll be handled on next request
+        });
+    }
+    /**
+     * Fetch credentials from the endpoint
+     */
+    async fetchCredentials() {
+        const deferred = (this.credentialDeferred = new Deferred());
+        try {
+            const response = await fetch(this.endpointUrl, {
+                method: "POST",
+                mode: "cors",
+                credentials: "include",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({}),
+            });
+            if (!response.ok) {
+                throw new Error(`Credential request failed with status ${response.status}`);
+            }
+            // Cookie is set by Set-Cookie header, we just need to track expiration
+            this.cookieExpirationTime = Date.now() + COOKIE_EXPIRATION_MS;
+            // Schedule refresh before expiration
+            this.scheduleRefresh();
+            deferred.resolve();
+            this.emit("received");
+            return true;
+        }
+        catch (err) {
+            log.warn("Failed to fetch push log credentials", err);
+            deferred.reject(err);
+            this.credentialDeferred = null;
+            return false;
+        }
+    }
+    /**
+     * Schedule a credential refresh before expiration
+     */
+    scheduleRefresh() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+        }
+        const refreshIn = COOKIE_EXPIRATION_MS - COOKIE_REFRESH_BUFFER_MS;
+        this.refreshTimer = setTimeout(() => {
+            this.credentialDeferred = null;
+            this.fetchCredentials().catch(() => {
+                // Log but don't throw - will retry on next request
+                log.debug("Scheduled credential refresh failed");
+            });
+        }, refreshIn);
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {
+            this.credentialDeferred.reject(new Error("Credential manager destroyed"));
+        }
+        this.credentialDeferred = null;
+        this.cookieExpirationTime = null;
+    }
+}
+/**
+ * Appender that pushes log records to a remote endpoint via HTTP PUT.
+ * Batches records and sends when queue reaches FLUSH_QUEUE_DEPTH or FLUSH_INTERVAL_MS has elapsed.
+ */
+export class PushLogRecordsAppender {
+    endpointUrl;
+    pendingRecords = [];
+    flushDeferred = null;
+    flushTimer = null;
+    credentialManager;
+    constructor(endpointUrl) {
+        this.endpointUrl = endpointUrl;
+        this.credentialManager = new PushLogRecordsCredentialManager(endpointUrl);
+        this.credentialManager.on("received", () => {
+            if (!this.pendingRecords.length || this.flushDeferred) {
+                return;
+            }
+            this.flush().catch(() => {
+                // Errors handled in flush
+            });
+        });
+    }
+    /**
+     * Append a log record to the queue
+     */
+    append(record) {
+        // Enforce max queue size by removing oldest records
+        const pendingCount = this.pendingRecords.length + 1;
+        const removeCount = pendingCount - LOG_QUEUE_MAX_RECORDS;
+        if (removeCount > 0) {
+            this.pendingRecords.splice(0, removeCount);
+        }
+        // Add the record with enriched metadata
+        this.pendingRecords.push({
+            timestamp: Date.now(),
+            ...record,
+            app: record.app && record.app.length > 0 ? record.app : "UNKNOWN",
+            env: record.env && record.env.length > 0 ? record.env : "UNKNOWN",
+            url: typeof window === "undefined" ? "local://" : window.location.href,
+        });
+        // Check if we should flush immediately due to queue depth
+        if (this.pendingRecords.length >= FLUSH_QUEUE_DEPTH) {
+            this.flush().catch(() => {
+                // Errors handled in flush
+            });
+        }
+        else {
+            // Schedule a flush if not already scheduled
+            this.scheduleFlush();
+        }
+    }
+    /**
+     * Schedule a flush after the interval
+     */
+    scheduleFlush() {
+        if (this.flushTimer) {
+            return; // Already scheduled
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.flush().catch(() => {
+                // Errors handled in flush
+            });
+        }, FLUSH_INTERVAL_MS);
+    }
+    /**
+     * Flush pending records to the endpoint
+     */
+    async flush() {
+        // Prevent concurrent flushes
+        if (this.flushDeferred) {
+            return this.flushDeferred.promise;
+        }
+        // Nothing to flush
+        if (!this.pendingRecords.length) {
+            return;
+        }
+        // Ensure we have valid credentials
+        const hasCredentials = await this.credentialManager.ensureCredentials();
+        if (!hasCredentials) {
+            log.debug("Failed to push log records", "No valid credentials available");
+            return;
+        }
+        const deferred = (this.flushDeferred = new Deferred());
+        try {
+            // Take all pending records for this flush
+            const records = this.pendingRecords.splice(0, this.pendingRecords.length);
+            const payload = { records: records.map(record => JSON.stringify(record)) };
+            const response = await fetch(this.endpointUrl, {
+                method: "PUT",
+                mode: "cors",
+                credentials: "include",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                // Re-queue records on failure
+                this.pendingRecords.unshift(...records);
+                throw new Error(`Push failed with status ${response.status}`);
+            }
+            deferred.resolve();
+        }
+        catch (err) {
+            log.debug("Failed to push log records", err);
+            deferred.reject(err);
+        }
+        finally {
+            this.flushDeferred = null;
+            // If more records accumulated during flush, schedule another
+            if (this.pendingRecords.length > 0) {
+                this.scheduleFlush();
+            }
+        }
+        return deferred.promise;
+    }
+    /**
+     * Force an immediate flush
+     */
+    async forceFlush() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        return this.flush();
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.credentialManager.destroy();
+        if (this.flushDeferred && !this.flushDeferred.isSettled()) {
+            this.flushDeferred.reject(new Error("Appender destroyed"));
+        }
+        this.flushDeferred = null;
+        this.pendingRecords = [];
+    }
+}
+export default PushLogRecordsAppender;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PushLogRecordsAppender.js","sourceRoot":"","sources":["../../../../../src/logging/appenders/push/PushLogRecordsAppender.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable typescript/no-explicit-any */\nimport EventEmitter3 from \"eventemitter3\"\nimport { Deferred } from \"../../../helpers/index.js\"\nimport { LogRecord } from \"../../LogRecord.js\"\nimport { Appender } from \"../../Appender.js\"\nimport { getInternalLogger } from \"../../InternalLogger.js\"\n\n// Constants for tuning (adjustable in development)\nconst COOKIE_EXPIRATION_MS = 5 * 60 * 1000 // 30 minutes\nconst COOKIE_REFRESH_BUFFER_MS = 2 * 60 * 1000 // Refresh 2 minutes before expiration\nconst FLUSH_QUEUE_DEPTH = 1000\nconst FLUSH_INTERVAL_MS = 5 * 1000 // 10 seconds\nconst LOG_QUEUE_MAX_RECORDS = 10000\nconst COOKIE_NAME = \"wire_logs_id\"\n\nconst log = getInternalLogger()\n\ninterface PushLogRecordsCredentialManagerEventMap {\n  received: () => void\n  expired: () => void\n}\n\n/**\n * Manages credential cookie for PushLogRecordsAppender.\n * Invokes the endpoint via POST to obtain a session cookie.\n */\nexport class PushLogRecordsCredentialManager extends EventEmitter3<PushLogRecordsCredentialManagerEventMap> {\n  private refreshTimer: ReturnType<typeof setTimeout> | null = null\n  private credentialDeferred: Deferred<void> | null = null\n  private cookieExpirationTime: number | null = null\n\n  constructor(public readonly endpointUrl: string) {\n    super()\n  }\n\n  /**\n   * Check if valid credentials exist\n   */\n  hasCredentials(): boolean {\n    if (!this.cookieExpirationTime) {\n      return false\n    }\n\n    if (Date.now() >= this.cookieExpirationTime) {\n      this.cookieExpirationTime = null\n      this.emit(\"expired\")\n      return false\n    }\n\n    return true\n  }\n\n  /**\n   * Get credentials, fetching them if necessary\n   */\n  async ensureCredentials(): Promise<boolean> {\n    // If we have valid credentials, return immediately\n    if (this.hasCredentials()) {\n      return true\n    }\n\n    // If a fetch is already in progress, wait for it\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      try {\n        await this.credentialDeferred.promise\n        return this.hasCredentials()\n      } catch {\n        return false\n      }\n    }\n\n    // Fetch new credentials\n    return this.fetchCredentials()\n  }\n\n  /**\n   * Force refresh of credentials\n   */\n  forceRefresh(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n      this.refreshTimer = null\n    }\n\n    this.cookieExpirationTime = null\n\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      this.credentialDeferred.reject(new Error(\"Force refresh requested\"))\n    }\n    this.credentialDeferred = null\n\n    this.fetchCredentials().catch(() => {\n      // Ignore errors during force refresh, they'll be handled on next request\n    })\n  }\n\n  /**\n   * Fetch credentials from the endpoint\n   */\n  private async fetchCredentials(): Promise<boolean> {\n    const deferred = (this.credentialDeferred = new Deferred<void>())\n\n    try {\n      const response = await fetch(this.endpointUrl, {\n        method: \"POST\",\n        mode: \"cors\",\n        credentials: \"include\",\n        headers: {\n          \"Content-Type\": \"application/json\",\n        },\n        body: JSON.stringify({}),\n      })\n\n      if (!response.ok) {\n        throw new Error(`Credential request failed with status ${response.status}`)\n      }\n\n      // Cookie is set by Set-Cookie header, we just need to track expiration\n      this.cookieExpirationTime = Date.now() + COOKIE_EXPIRATION_MS\n\n      // Schedule refresh before expiration\n      this.scheduleRefresh()\n\n      deferred.resolve()\n      this.emit(\"received\")\n\n      return true\n    } catch (err) {\n      log.warn(\"Failed to fetch push log credentials\", err)\n      deferred.reject(err)\n      this.credentialDeferred = null\n      return false\n    }\n  }\n\n  /**\n   * Schedule a credential refresh before expiration\n   */\n  private scheduleRefresh(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n    }\n\n    const refreshIn = COOKIE_EXPIRATION_MS - COOKIE_REFRESH_BUFFER_MS\n    this.refreshTimer = setTimeout(() => {\n      this.credentialDeferred = null\n      this.fetchCredentials().catch(() => {\n        // Log but don't throw - will retry on next request\n        log.debug(\"Scheduled credential refresh failed\")\n      })\n    }, refreshIn)\n  }\n\n  /**\n   * Clean up resources\n   */\n  destroy(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n      this.refreshTimer = null\n    }\n\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      this.credentialDeferred.reject(new Error(\"Credential manager destroyed\"))\n    }\n\n    this.credentialDeferred = null\n    this.cookieExpirationTime = null\n  }\n}\n\n/**\n * Appender that pushes log records to a remote endpoint via HTTP PUT.\n * Batches records and sends when queue reaches FLUSH_QUEUE_DEPTH or FLUSH_INTERVAL_MS has elapsed.\n */\nexport class PushLogRecordsAppender<Record extends LogRecord = LogRecord> implements Appender<Record> {\n  private pendingRecords: LogRecord[] = []\n  private flushDeferred: Deferred<void> | null = null\n  private flushTimer: ReturnType<typeof setTimeout> | null = null\n\n  public readonly credentialManager: PushLogRecordsCredentialManager\n\n  constructor(public readonly endpointUrl: string) {\n    this.credentialManager = new PushLogRecordsCredentialManager(endpointUrl)\n\n    this.credentialManager.on(\"received\", () => {\n      if (!this.pendingRecords.length || this.flushDeferred) {\n        return\n      }\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    })\n  }\n\n  /**\n   * Append a log record to the queue\n   */\n  append(record: Record): void {\n    // Enforce max queue size by removing oldest records\n    const pendingCount = this.pendingRecords.length + 1\n    const removeCount = pendingCount - LOG_QUEUE_MAX_RECORDS\n\n    if (removeCount > 0) {\n      this.pendingRecords.splice(0, removeCount)\n    }\n\n    // Add the record with enriched metadata\n    this.pendingRecords.push({\n      timestamp: Date.now(),\n      ...record,\n      app: record.app && record.app.length > 0 ? record.app : \"UNKNOWN\",\n      env: record.env && record.env.length > 0 ? record.env : \"UNKNOWN\",\n      url: typeof window === \"undefined\" ? \"local://\" : window.location.href,\n    })\n\n    // Check if we should flush immediately due to queue depth\n    if (this.pendingRecords.length >= FLUSH_QUEUE_DEPTH) {\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    } else {\n      // Schedule a flush if not already scheduled\n      this.scheduleFlush()\n    }\n  }\n\n  /**\n   * Schedule a flush after the interval\n   */\n  private scheduleFlush(): void {\n    if (this.flushTimer) {\n      return // Already scheduled\n    }\n\n    this.flushTimer = setTimeout(() => {\n      this.flushTimer = null\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    }, FLUSH_INTERVAL_MS)\n  }\n\n  /**\n   * Flush pending records to the endpoint\n   */\n  private async flush(): Promise<void> {\n    // Prevent concurrent flushes\n    if (this.flushDeferred) {\n      return this.flushDeferred.promise\n    }\n\n    // Nothing to flush\n    if (!this.pendingRecords.length) {\n      return\n    }\n\n    // Ensure we have valid credentials\n    const hasCredentials = await this.credentialManager.ensureCredentials()\n    if (!hasCredentials) {\n      log.debug(\"Failed to push log records\", \"No valid credentials available\")\n      return\n    }\n\n    const deferred = (this.flushDeferred = new Deferred<void>())\n\n    try {\n      // Take all pending records for this flush\n      const records = this.pendingRecords.splice(0, this.pendingRecords.length)\n      const payload = { records: records.map(record => JSON.stringify(record)) }\n\n      const response = await fetch(this.endpointUrl, {\n        method: \"PUT\",\n        mode: \"cors\",\n        credentials: \"include\",\n        headers: {\n          \"Content-Type\": \"application/json\"\n        },\n        body: JSON.stringify(payload),\n      })\n\n      if (!response.ok) {\n        // Re-queue records on failure\n        this.pendingRecords.unshift(...records)\n        throw new Error(`Push failed with status ${response.status}`)\n      }\n\n      deferred.resolve()\n    } catch (err) {\n      log.debug(\"Failed to push log records\", err)\n      deferred.reject(err)\n    } finally {\n      this.flushDeferred = null\n\n      // If more records accumulated during flush, schedule another\n      if (this.pendingRecords.length > 0) {\n        this.scheduleFlush()\n      }\n    }\n\n    return deferred.promise\n  }\n\n  /**\n   * Force an immediate flush\n   */\n  async forceFlush(): Promise<void> {\n    if (this.flushTimer) {\n      clearTimeout(this.flushTimer)\n      this.flushTimer = null\n    }\n\n    return this.flush()\n  }\n\n  /**\n   * Clean up resources\n   */\n  destroy(): void {\n    if (this.flushTimer) {\n      clearTimeout(this.flushTimer)\n      this.flushTimer = null\n    }\n\n    this.credentialManager.destroy()\n\n    if (this.flushDeferred && !this.flushDeferred.isSettled()) {\n      this.flushDeferred.reject(new Error(\"Appender destroyed\"))\n    }\n\n    this.flushDeferred = null\n    this.pendingRecords = []\n  }\n}\n\nexport default PushLogRecordsAppender\n"]}

package/lib/esm/logging/appenders/push/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./PushLogRecordsAppender.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/esm/logging/appenders/push/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/logging/appenders/push/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA"}

package/lib/esm/logging/appenders/push/index.js

@@ -0,0 +1,2 @@
+export * from "./PushLogRecordsAppender.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbG9nZ2luZy9hcHBlbmRlcnMvcHVzaC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vUHVzaExvZ1JlY29yZHNBcHBlbmRlci5qc1wiXG4iXX0=

package/lib/esm/logging/context/LogContext.d.ts

@@ -0,0 +1,48 @@
+import { Appender } from "../Appender.js";
+import { Level } from "../Level.js";
+export declare class LogContext {
+    readonly appenders: Appender[];
+    /**
+     * Threshold override level
+     *
+     * @type {Level}
+     */
+    readonly thresholdLevel: Level;
+    /**
+     * If specified, only categories that match will
+     * use this context
+     *
+     * @type {RegExp}
+     */
+    readonly pattern: RegExp;
+    /**
+     * Exclusive, only use this config in context.  Defaults to `false`
+     *
+     * @type {boolean}
+     */
+    readonly exclusive: RegExp;
+    /**
+     * Use a logger context within
+     *
+     * @param {() => Promise<T>} fn
+     * @returns {Promise<T>}
+     */
+    use<T = unknown>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Creates a new logger context
+     *
+     * @param {Appender[]} appenders - additional appenders for the context
+     * @param {LoggerContextOptions} options -
+     */
+    protected constructor(appenders: Appender[], options: LoggerContextOptions);
+    /**
+     * Create a new logger context
+     *
+     * @param {Appender[]} appenders
+     * @param {LoggerContextOptions} options
+     * @returns {LogContext}
+     */
+    static with(appenders: Appender[], options?: LoggerContextOptions): LogContext;
+}
+export type LoggerContextOptions = Partial<Pick<LogContext, "pattern" | "exclusive">>;
+//# sourceMappingURL=LogContext.d.ts.map

package/lib/esm/logging/context/LogContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogContext.d.ts","sourceRoot":"","sources":["../../../../src/logging/context/LogContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AASnC,qBAAa,UAAU;IAwCnB,QAAQ,CAAC,SAAS,EAAE,QAAQ,EAAE;IAvChC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,KAAK,CAAA;IAE9B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B;;;;;OAKG;IACH,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IAIrC;;;;;OAKG;IACH,SAAS,aACE,SAAS,EAAE,QAAQ,EAAE,EAC9B,OAAO,EAAE,oBAAoB;IAU/B;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,OAAO,GAAE,oBAAyB;CAGtE;AAED,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,WAAW,CAAC,CAAC,CAAA"}

package/lib/esm/logging/context/LogContext.js

@@ -0,0 +1,58 @@
+import { LogContextContainer } from "./LogContextContainer.js";
+export class LogContext {
+    appenders;
+    /**
+     * Threshold override level
+     *
+     * @type {Level}
+     */
+    thresholdLevel;
+    /**
+     * If specified, only categories that match will
+     * use this context
+     *
+     * @type {RegExp}
+     */
+    pattern;
+    /**
+     * Exclusive, only use this config in context.  Defaults to `false`
+     *
+     * @type {boolean}
+     */
+    exclusive;
+    /**
+     * Use a logger context within
+     *
+     * @param {() => Promise<T>} fn
+     * @returns {Promise<T>}
+     */
+    use(fn) {
+        return LogContextContainer.runInContext(this, fn);
+    }
+    /**
+     * Creates a new logger context
+     *
+     * @param {Appender[]} appenders - additional appenders for the context
+     * @param {LoggerContextOptions} options -
+     */
+    constructor(appenders, options) {
+        this.appenders = appenders;
+        Object.assign(this, {
+            exclusive: false,
+            thresholdLevel: null,
+            pattern: null,
+            ...options
+        });
+    }
+    /**
+     * Create a new logger context
+     *
+     * @param {Appender[]} appenders
+     * @param {LoggerContextOptions} options
+     * @returns {LogContext}
+     */
+    static with(appenders, options = {}) {
+        return new LogContext(appenders, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/logging/context/LogContextContainer.d.ts

@@ -0,0 +1,9 @@
+import { LogContext } from "./LogContext.js";
+import { LogContextProvider } from "./LogContextProvider.js";
+export declare namespace LogContextContainer {
+    function setProvider(provider: LogContextProvider): void;
+    function getProvider(): LogContextProvider;
+    function currentContext(): Array<LogContext>;
+    function runInContext<T = unknown>(context: LogContext, fn: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=LogContextContainer.d.ts.map

package/lib/esm/logging/context/LogContextContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogContextContainer.d.ts","sourceRoot":"","sources":["../../../../src/logging/context/LogContextContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAA6B,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAOvF,yBAAiB,mBAAmB,CAAE;IAEpC,SAAgB,WAAW,CAAC,QAAQ,EAAE,kBAAkB,QAEvD;IAED,SAAgB,WAAW,IAAG,kBAAkB,CAE/C;IAED,SAAgB,cAAc,IAAI,KAAK,CAAC,UAAU,CAAC,CAElD;IAED,SAAgB,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAG/F;CAEF"}

package/lib/esm/logging/context/LogContextContainer.js

@@ -0,0 +1,25 @@
+import { DefaultLogContextProvider } from "./LogContextProvider.js";
+const state = {
+    provider: DefaultLogContextProvider
+};
+export var LogContextContainer;
+(function (LogContextContainer) {
+    function setProvider(provider) {
+        state.provider = provider ?? DefaultLogContextProvider;
+    }
+    LogContextContainer.setProvider = setProvider;
+    function getProvider() {
+        return state.provider ?? DefaultLogContextProvider;
+    }
+    LogContextContainer.getProvider = getProvider;
+    function currentContext() {
+        return getProvider().currentContext?.() ?? [];
+    }
+    LogContextContainer.currentContext = currentContext;
+    function runInContext(context, fn) {
+        const provider = getProvider();
+        return provider.runInContext(context, fn);
+    }
+    LogContextContainer.runInContext = runInContext;
+})(LogContextContainer || (LogContextContainer = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/logging/context/LogContextProvider.d.ts

@@ -0,0 +1,24 @@
+import type { LogContext } from "./LogContext";
+export interface LogContextProvider {
+    /**
+     * Get current context stack
+     *
+     * @returns {any[]}
+     */
+    currentContext(): Array<LogContext>;
+    /**
+     * Run in context
+     *
+     * @param {LogContext} context
+     * @param {() => Promise<T>} fn
+     * @returns {Promise<T>}
+     */
+    runInContext<T = unknown>(context: LogContext, fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Dummy/Noop context provider
+ *
+ * @type {{currentContext(): Array<LogContext>, runInContext<T=unknown>(context: LogContext, fn: () => Promise<T>): Promise<T>}}
+ */
+export declare const DefaultLogContextProvider: LogContextProvider;
+//# sourceMappingURL=LogContextProvider.d.ts.map

package/lib/esm/logging/context/LogContextProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogContextProvider.d.ts","sourceRoot":"","sources":["../../../../src/logging/context/LogContextProvider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAI9C,MAAM,WAAW,kBAAkB;IAEjC;;;;OAIG;IACH,cAAc,IAAI,KAAK,CAAC,UAAU,CAAC,CAAA;IAEnC;;;;;;OAMG;IACH,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CACjF;AAGD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAC,kBAWtC,CAAA"}

package/lib/esm/logging/context/LogContextProvider.js

@@ -0,0 +1,18 @@
+// noinspection JSValidateJSDoc
+/**
+ * Dummy/Noop context provider
+ *
+ * @type {{currentContext(): Array<LogContext>, runInContext<T=unknown>(context: LogContext, fn: () => Promise<T>): Promise<T>}}
+ */
+export const DefaultLogContextProvider = {
+    currentContext() {
+        return [];
+    },
+    runInContext(context, fn) {
+        if (process.env.NODE_ENV === "development") {
+            console.warn(`Attempting to use LogContext without any installed provider`);
+        }
+        return fn();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nQ29udGV4dFByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xvZ2dpbmcvY29udGV4dC9Mb2dDb250ZXh0UHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0JBQStCO0FBMEIvQjs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQXNCO0lBQzFELGNBQWM7UUFDWixPQUFPLEVBQUUsQ0FBQTtJQUNYLENBQUM7SUFDRCxZQUFZLENBQWMsT0FBbUIsRUFBRSxFQUFvQjtRQUNqRSxJQUFJLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxLQUFLLGFBQWEsRUFBRSxDQUFDO1lBQzNDLE9BQU8sQ0FBQyxJQUFJLENBQUMsNkRBQTZELENBQUMsQ0FBQTtRQUM3RSxDQUFDO1FBRUQsT0FBTyxFQUFFLEVBQUUsQ0FBQTtJQUNiLENBQUM7Q0FDRixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gbm9pbnNwZWN0aW9uIEpTVmFsaWRhdGVKU0RvY1xuXG5pbXBvcnQgdHlwZSB7IExvZ0NvbnRleHQgfSBmcm9tIFwiLi9Mb2dDb250ZXh0XCJcblxuXG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9nQ29udGV4dFByb3ZpZGVyIHtcbiAgXG4gIC8qKlxuICAgKiBHZXQgY3VycmVudCBjb250ZXh0IHN0YWNrXG4gICAqXG4gICAqIEByZXR1cm5zIHthbnlbXX1cbiAgICovXG4gIGN1cnJlbnRDb250ZXh0KCk6IEFycmF5PExvZ0NvbnRleHQ+XG4gIFxuICAvKipcbiAgICogUnVuIGluIGNvbnRleHRcbiAgICpcbiAgICogQHBhcmFtIHtMb2dDb250ZXh0fSBjb250ZXh0XG4gICAqIEBwYXJhbSB7KCkgPT4gUHJvbWlzZTxUPn0gZm5cbiAgICogQHJldHVybnMge1Byb21pc2U8VD59XG4gICAqL1xuICBydW5JbkNvbnRleHQ8VCA9IHVua25vd24+KGNvbnRleHQ6IExvZ0NvbnRleHQsIGZuOiAoKSA9PiBQcm9taXNlPFQ+KTogUHJvbWlzZTxUPlxufVxuXG5cbi8qKlxuICogRHVtbXkvTm9vcCBjb250ZXh0IHByb3ZpZGVyXG4gKlxuICogQHR5cGUge3tjdXJyZW50Q29udGV4dCgpOiBBcnJheTxMb2dDb250ZXh0PiwgcnVuSW5Db250ZXh0PFQ9dW5rbm93bj4oY29udGV4dDogTG9nQ29udGV4dCwgZm46ICgpID0+IFByb21pc2U8VD4pOiBQcm9taXNlPFQ+fX1cbiAqL1xuZXhwb3J0IGNvbnN0IERlZmF1bHRMb2dDb250ZXh0UHJvdmlkZXI6TG9nQ29udGV4dFByb3ZpZGVyID0ge1xuICBjdXJyZW50Q29udGV4dCgpOiBBcnJheTxMb2dDb250ZXh0PiB7XG4gICAgcmV0dXJuIFtdXG4gIH0sXG4gIHJ1bkluQ29udGV4dDxUID0gdW5rbm93bj4oY29udGV4dDogTG9nQ29udGV4dCwgZm46ICgpID0+IFByb21pc2U8VD4pOiBQcm9taXNlPFQ+IHtcbiAgICBpZiAocHJvY2Vzcy5lbnYuTk9ERV9FTlYgPT09IFwiZGV2ZWxvcG1lbnRcIikge1xuICAgICAgY29uc29sZS53YXJuKGBBdHRlbXB0aW5nIHRvIHVzZSBMb2dDb250ZXh0IHdpdGhvdXQgYW55IGluc3RhbGxlZCBwcm92aWRlcmApXG4gICAgfVxuICBcbiAgICByZXR1cm4gZm4oKVxuICB9XG59XG4iXX0=

package/lib/esm/logging/context/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./LogContext.js";
+export * from "./LogContextProvider.js";
+export * from "./LogContextContainer.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/esm/logging/context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/logging/context/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA"}

package/lib/esm/logging/context/index.js

@@ -0,0 +1,4 @@
+export * from "./LogContext.js";
+export * from "./LogContextProvider.js";
+export * from "./LogContextContainer.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbG9nZ2luZy9jb250ZXh0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUE7QUFDL0IsY0FBYyx5QkFBeUIsQ0FBQTtBQUN2QyxjQUFjLDBCQUEwQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vTG9nQ29udGV4dC5qc1wiXG5leHBvcnQgKiBmcm9tIFwiLi9Mb2dDb250ZXh0UHJvdmlkZXIuanNcIlxuZXhwb3J0ICogZnJvbSBcIi4vTG9nQ29udGV4dENvbnRhaW5lci5qc1wiXG4iXX0=

package/lib/esm/logging/context/providers/node/NodeContextProvider.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=NodeContextProvider.d.ts.map