@wireio/shared 1.0.18 → 1.0.20

package/lib/esm/logging/appenders/FileAppender.js

@@ -0,0 +1,214 @@
+import { assign, defaults, padStart } from "lodash";
+import * as Path from "path";
+import * as Fs from "fs";
+import { Option, Future } from "@3fv/prelude-ts";
+import { Buffer } from "buffer";
+import Debug from "debug";
+import Bluebird from "bluebird";
+const FsAsync = Fs.promises;
+const debug = Debug("3fv:logger:FileAppender");
+const osTempDir = process.env.TMP ?? process.env.TEMP ?? "/tmp";
+const tempDir = Fs.mkdtempSync(Path.join(osTempDir, "logger-proxy-example")); //
+const getDefaultConfig = () => ({
+    filename: Path.join(tempDir, "app.log"),
+    prettyPrint: process.env.NODE_ENV !== "production",
+    maxSize: -1,
+    maxFiles: 5,
+    enableRolling: false,
+    sync: false
+});
+function applyConfigDefaults(options) {
+    return defaults(options, getDefaultConfig());
+}
+export class FileAppender {
+    config;
+    state = {
+        archivedFilenames: [],
+        filename: undefined,
+        file: undefined,
+        ready: false,
+        currentSize: 0,
+        flushing: false,
+        queue: []
+    };
+    get enableRolling() {
+        return this.config.enableRolling;
+    }
+    isReady() {
+        return this.state.ready;
+    }
+    /**
+     * Initialize and setup the appender
+     *
+     * @returns {FileAppender<Record>}
+     */
+    setup() {
+        const { state } = this;
+        if (!!state.ready) {
+            return this;
+        }
+        try {
+            const { filename } = this;
+            const file = Fs.openSync(filename, "a");
+            assign(state, {
+                filename,
+                file,
+                ready: true
+            });
+            return this;
+        }
+        catch (err) {
+            assign(state, {
+                error: err,
+                file: undefined,
+                ready: false
+            });
+            throw err;
+        }
+    }
+    /**
+     * Only exposed for the sake of tests & examples
+     * DO NOT USE
+     *
+     * This should all be async, but i was in a rush :(
+     *
+     * @returns
+     */
+    rollFile() {
+        const { state, config } = this;
+        let { file, filename, archivedFilenames } = state;
+        if (!this.isReady() || !file) {
+            debug(`Can not roll file before ready`);
+            return;
+        }
+        if (!this.enableRolling) {
+            return;
+        }
+        const fileCount = archivedFilenames.length + 1;
+        if (config.maxFiles < 1 || fileCount < config.maxFiles) {
+            archivedFilenames.push(filename + "." + padStart(fileCount.toString(10), 4, "0"));
+        }
+        Fs.fdatasyncSync(file);
+        Fs.closeSync(file);
+        file = state.file = undefined;
+        const filenames = [filename, ...archivedFilenames];
+        let dest = filenames.pop();
+        while (filenames.length) {
+            let src = filenames.pop();
+            if (!Fs.existsSync(src)) {
+                debug(`src does not exist, skipping ${src}`);
+            }
+            else {
+                debug(`Moving src (${src}) to dest (${dest})`);
+                if (Fs.existsSync(dest)) {
+                    Fs.unlinkSync(dest);
+                }
+                Fs.renameSync(src, dest);
+                // if (src === filename) {
+                //   Fs.copyFileSync(src, dest)
+                //   Fs.truncateSync(src, 0)
+                // } else {
+                //   Fs.renameSync(src, dest)
+                // }
+            }
+            dest = src;
+        }
+        assign(state, {
+            currentSize: 0,
+            file: Fs.openSync(filename, "a")
+        });
+    }
+    /**
+     * Close the handler
+     *
+     * @returns {Promise<void>}
+     */
+    close() {
+        return this.flush()
+            .onComplete(() => Option.of(this.state.file).map(Fs.closeSync))
+            .toPromise();
+    }
+    get queue() {
+        return this.state.queue;
+    }
+    get file() {
+        return this.state.file;
+    }
+    get flushing() {
+        return this.state.flushing;
+    }
+    get filename() {
+        return (this.state.filename = this.state.filename ?? this.config.filename);
+    }
+    /**
+     * Appends the log queue records to the file
+     */
+    flush() {
+        const { state } = this;
+        return Future.do(async () => {
+            state.flushing = true;
+            try {
+                const { file } = this;
+                if (!file) {
+                    throw Error(`${this.filename} was not opened properly`);
+                }
+                while (this.queue.length) {
+                    const buf = this.queue.shift();
+                    await Bluebird.fromCallback(cb => Fs.appendFile(file, buf, "utf-8", cb));
+                    state.currentSize += buf.byteLength;
+                }
+                const { maxSize } = this.config;
+                if (maxSize > 0 && state.currentSize >= maxSize) {
+                    this.rollFile();
+                }
+                //await Bluebird.fromCallback((cb) => Fs.fdatasync(this.file, cb))
+            }
+            catch (err) {
+                console.error(`Failed to append file ${this.filename}`, err);
+            }
+            finally {
+                this.state.flushing = false;
+                if (this.queue.length) {
+                    queueMicrotask(() => this.flush());
+                }
+            }
+        });
+    }
+    /**
+     * Handle log records, transform, push to ES
+     *
+     * @param record
+     */
+    append(record) {
+        try {
+            const { queue, filename } = this.state;
+            const count = queue.length;
+            if (count > 999) {
+                debug(`Too many log records (${count}) are in the queue without the file (${filename}) opening, skipping %O`, record);
+                return;
+            }
+            const data = this.config.prettyPrint
+                ? JSON.stringify(record, null, 2)
+                : JSON.stringify(record);
+            queue.push(Buffer.from(data + "\n", "utf-8"));
+            this.flush();
+        }
+        catch (err) {
+            console.warn(`Failed to synchronize `, err);
+        }
+    }
+    /**
+     *
+     * @param {Partial<FileAppenderOptions<Record>>} options
+     */
+    constructor(options = {}) {
+        this.config = applyConfigDefaults(options);
+        assign(this.state, {
+            filename: this.config.filename
+        });
+        this.setup();
+        debug(`File appender is ready, logging to ${this.state.filename}`);
+        //      return this
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FileAppender.js","sourceRoot":"","sources":["../../../../src/logging/appenders/FileAppender.ts"],"names":[],"mappings":"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","sourcesContent":["import { assign, defaults, padStart } from \"lodash\"\nimport * as Path from \"path\"\nimport * as Fs from \"fs\"\nimport type { LogRecord } from \"../LogRecord\"\nimport type { Appender } from \"../Appender\"\nimport { Option, Future } from \"@3fv/prelude-ts\"\nimport { Buffer } from \"buffer\"\nimport Debug from \"debug\"\nimport Bluebird from \"bluebird\"\n\nconst FsAsync = Fs.promises\n\nconst debug = Debug(\"3fv:logger:FileAppender\")\nconst osTempDir = process.env.TMP ?? process.env.TEMP ?? \"/tmp\"\nconst tempDir = Fs.mkdtempSync(Path.join(osTempDir, \"logger-proxy-example\")) //\nconst getDefaultConfig = (): FileAppenderConfig => ({\n  filename: Path.join(tempDir, \"app.log\"),\n  prettyPrint: process.env.NODE_ENV !== \"production\",\n  maxSize: -1,\n  maxFiles: 5,\n  enableRolling: false,\n  sync: false\n})\n\nfunction applyConfigDefaults(options: FileAppenderOptions): FileAppenderConfig {\n  return defaults(options, getDefaultConfig())\n}\n\nexport interface FileAppenderConfig<Record extends LogRecord = any> {\n  filename: string\n\n  /**\n   * For rolling\n   */\n  maxFiles: number\n\n  /**\n   * For rolling\n   */\n  maxSize: number\n\n  enableRolling: boolean\n  prettyPrint: boolean\n  sync: boolean\n}\n\nexport type FileAppenderOptions<Record extends LogRecord = any> = Partial<\n  FileAppenderConfig<Record>\n>\n\nexport class FileAppender<\n  Record extends LogRecord\n> implements Appender<Record> {\n  readonly config: FileAppenderConfig<Record>\n\n  private readonly state: {\n    filename: string\n    file: number\n    flushing: boolean\n    queue: Array<Buffer>\n    ready: boolean\n    error?: Error\n    currentSize: number\n    archivedFilenames: string[]\n  } = {\n    archivedFilenames: [],\n    filename: undefined,\n    file: undefined,\n    ready: false,\n    currentSize: 0,\n    flushing: false,\n    queue: []\n  }\n\n  get enableRolling() {\n    return this.config.enableRolling\n  }\n\n  isReady() {\n    return this.state.ready\n  }\n\n  /**\n   * Initialize and setup the appender\n   *\n   * @returns {FileAppender<Record>}\n   */\n  setup(): FileAppender<Record> {\n    const { state } = this\n    if (!!state.ready) {\n      return this\n    }\n\n    try {\n      const { filename } = this\n      const file = Fs.openSync(filename, \"a\")\n\n      assign(state, {\n        filename,\n        file,\n        ready: true\n      })\n\n      return this\n    } catch (err) {\n      assign(state, {\n        error: err,\n        file: undefined,\n        ready: false\n      })\n      throw err\n    }\n  }\n\n  /**\n   * Only exposed for the sake of tests & examples\n   * DO NOT USE\n   *\n   * This should all be async, but i was in a rush :(\n   *\n   * @returns\n   */\n  rollFile() {\n    const { state, config } = this\n    let { file, filename, archivedFilenames } = state\n    if (!this.isReady() || !file) {\n      debug(`Can not roll file before ready`)\n      return\n    }\n\n    if (!this.enableRolling) {\n      return\n    }\n\n    const fileCount = archivedFilenames.length + 1\n    if (config.maxFiles < 1 || fileCount < config.maxFiles) {\n      archivedFilenames.push(\n        filename + \".\" + padStart(fileCount.toString(10), 4, \"0\")\n      )\n    }\n    Fs.fdatasyncSync(file)\n    Fs.closeSync(file)\n    file = state.file = undefined\n    const filenames = [filename, ...archivedFilenames]\n\n    let dest: string = filenames.pop()\n    while (filenames.length) {\n      let src = filenames.pop()\n      if (!Fs.existsSync(src)) {\n        debug(`src does not exist, skipping ${src}`)\n      } else {\n        debug(`Moving src (${src}) to dest (${dest})`)\n        if (Fs.existsSync(dest)) {\n          Fs.unlinkSync(dest)\n        }\n        Fs.renameSync(src, dest)\n        // if (src === filename) {\n        //   Fs.copyFileSync(src, dest)\n        //   Fs.truncateSync(src, 0)\n        // } else {\n        //   Fs.renameSync(src, dest)\n        // }\n      }\n      dest = src\n    }\n\n    assign(state, {\n      currentSize: 0,\n      file: Fs.openSync(filename, \"a\")\n    })\n  }\n\n  /**\n   * Close the handler\n   *\n   * @returns {Promise<void>}\n   */\n  close() {\n    return this.flush()\n      .onComplete(() => Option.of(this.state.file).map(Fs.closeSync))\n      .toPromise()\n  }\n\n  get queue() {\n    return this.state.queue\n  }\n\n  get file() {\n    return this.state.file\n  }\n\n  get flushing() {\n    return this.state.flushing\n  }\n\n  get filename() {\n    return (this.state.filename = this.state.filename ?? this.config.filename)\n  }\n\n  /**\n   * Appends the log queue records to the file\n   */\n  private flush() {\n    const { state } = this\n    return Future.do(async () => {\n      state.flushing = true\n      try {\n        const { file } = this\n        if (!file) {\n          throw Error(`${this.filename} was not opened properly`)\n        }\n        while (this.queue.length) {\n          const buf: Buffer = this.queue.shift()\n\n          await Bluebird.fromCallback(cb =>\n            Fs.appendFile(file, buf, \"utf-8\", cb)\n          )\n\n          state.currentSize += buf.byteLength\n        }\n\n        const { maxSize } = this.config\n        if (maxSize > 0 && state.currentSize >= maxSize) {\n          this.rollFile()\n        }\n\n        //await Bluebird.fromCallback((cb) => Fs.fdatasync(this.file, cb))\n      } catch (err) {\n        console.error(`Failed to append file ${this.filename}`, err)\n      } finally {\n        this.state.flushing = false\n        if (this.queue.length) {\n          queueMicrotask(() => this.flush())\n        }\n      }\n    })\n  }\n\n  /**\n   * Handle log records, transform, push to ES\n   *\n   * @param record\n   */\n  append(record: Record): void {\n    try {\n      const { queue, filename } = this.state\n      const count = queue.length\n      if (count > 999) {\n        debug(\n          `Too many log records (${count}) are in the queue without the file (${filename}) opening, skipping %O`,\n          record\n        )\n        return\n      }\n\n      const data = this.config.prettyPrint\n        ? JSON.stringify(record, null, 2)\n        : JSON.stringify(record)\n      queue.push(Buffer.from(data + \"\\n\", \"utf-8\"))\n      this.flush()\n    } catch (err) {\n      console.warn(`Failed to synchronize `, err)\n    }\n  }\n\n  /**\n   *\n   * @param {Partial<FileAppenderOptions<Record>>} options\n   */\n  constructor(options: Partial<FileAppenderOptions<Record>> = {}) {\n    this.config = applyConfigDefaults(options)\n\n    assign(this.state, {\n      filename: this.config.filename\n    })\n\n    this.setup()\n    debug(`File appender is ready, logging to ${this.state.filename}`)\n    //      return this\n  }\n}\n"]}

package/lib/esm/logging/appenders/aws-firehose/AWSFirehoseAppender.d.ts

@@ -0,0 +1,28 @@
+import AWSFirehoseCredentialManager from "./AWSFirehoseCredentialManager.js";
+import { LogRecord } from "../../LogRecord.js";
+import { Appender } from "../../Appender.js";
+export declare class AWSFirehoseAppender<Record extends LogRecord = LogRecord> implements Appender<Record> {
+    readonly credentialEndpointUrl: string;
+    private pendingRecords;
+    private flushDeferred;
+    private flushIntervalMs;
+    readonly credentialManager: AWSFirehoseCredentialManager;
+    constructor(credentialEndpointUrl: string);
+    append(record: Record): void;
+    /**
+     * Create the firehose client and return
+     *
+     * @param {IAWSTemporaryCredentials} credentials
+     * @param {boolean} flush
+     * @returns {Firehose}
+     */
+    private getFirehose;
+    /**
+     * Flush pending records
+     *
+     * @returns {Promise<void>}
+     */
+    private flush;
+}
+export default AWSFirehoseAppender;
+//# sourceMappingURL=AWSFirehoseAppender.d.ts.map

package/lib/esm/logging/appenders/aws-firehose/AWSFirehoseAppender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AWSFirehoseAppender.d.ts","sourceRoot":"","sources":["../../../../../src/logging/appenders/aws-firehose/AWSFirehoseAppender.ts"],"names":[],"mappings":"AASA,OAAO,4BAA4B,MAAM,mCAAmC,CAAA;AAK5E,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAM5C,qBAAa,mBAAmB,CAAC,MAAM,SAAS,SAAS,GAAG,SAAS,CACnE,YAAW,QAAQ,CAAC,MAAM,CAAC;aAQT,qBAAqB,EAAE,MAAM;IAP/C,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,eAAe,CAAQ;IAE/B,SAAgB,iBAAiB,EAAE,4BAA4B,CAAA;gBAG7C,qBAAqB,EAAE,MAAM;IAc/C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAoB5B;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAsBnB;;;;OAIG;YACW,KAAK;CA+EpB;AAED,eAAe,mBAAmB,CAAA"}

package/lib/esm/logging/appenders/aws-firehose/AWSFirehoseAppender.js

@@ -0,0 +1,138 @@
+import { FirehoseClient, PutRecordBatchCommand } from "@aws-sdk/client-firehose";
+import { ExpiredTokenException, } from "@aws-sdk/client-sts";
+import AWSFirehoseCredentialManager from "./AWSFirehoseCredentialManager.js";
+import { getInternalLogger } from "../../InternalLogger.js";
+import { pick } from "lodash";
+import { Deferred } from "../../../helpers/index.js";
+const LogQueueMaxRecords = 10000;
+const log = getInternalLogger();
+export class AWSFirehoseAppender {
+    credentialEndpointUrl;
+    pendingRecords = Array();
+    flushDeferred;
+    flushIntervalMs = 1000;
+    credentialManager;
+    constructor(credentialEndpointUrl) {
+        this.credentialEndpointUrl = credentialEndpointUrl;
+        this.credentialManager = new AWSFirehoseCredentialManager(credentialEndpointUrl);
+        this.credentialManager.on("received", () => {
+            log.info("Credentials received, initializing firehose client");
+            if (!this.pendingRecords.length || !!this.flushDeferred) {
+                log.debug("Nothing to flush upon credential receipt OR flush already in progress");
+                return;
+            }
+            this.flush()
+                .catch((e) => {
+                log.error(`Error flushing logs after credential receipt: ${e.message}`, e);
+            });
+        });
+    }
+    append(record) {
+        const pendingCount = this.pendingRecords.length + 1, removeCount = LogQueueMaxRecords - pendingCount;
+        if (removeCount < 0) {
+            this.pendingRecords.splice(0, Math.abs(removeCount));
+        }
+        this.pendingRecords.push({
+            timestamp: Date.now(),
+            ...record,
+            app: record.app?.length > 0 ? record.app : "UNKNOWN",
+            env: record.env?.length > 0 ? record.env : "UNKNOWN",
+            url: typeof window === "undefined" ? "local://" : window.location.href,
+        });
+        this.flush();
+    }
+    /**
+     * Create the firehose client and return
+     *
+     * @param {IAWSTemporaryCredentials} credentials
+     * @param {boolean} flush
+     * @returns {Firehose}
+     */
+    getFirehose() {
+        const creds = this.credentialManager.getCredentials();
+        if (!creds) {
+            log.warn("No credentials available for flush");
+            return null;
+        }
+        const { region, streamName } = creds;
+        if (!region || !streamName) {
+            throw new Error("Region or stream name not available");
+        }
+        const client = new FirehoseClient({
+            region: creds.region,
+            credentials: pick(creds, "accessKeyId", "secretAccessKey", "sessionToken"),
+        });
+        return client;
+    }
+    /**
+     * Flush pending records
+     *
+     * @returns {Promise<void>}
+     */
+    async flush() {
+        if (!!this.flushDeferred) {
+            log.debug("Flush already in progress, skipping");
+            return;
+        }
+        if (!this.pendingRecords.length) {
+            log.debug("No pending records to flush");
+            return;
+        }
+        const creds = this.credentialManager.getCredentials();
+        if (!creds) {
+            log.warn("No credentials available for flush");
+            return;
+        }
+        const { streamName } = creds, client = this.getFirehose();
+        if (!client) {
+            log.warn("No firehose client available, skipping flush");
+            return;
+        }
+        const deferred = this.flushDeferred = new Deferred();
+        try {
+            while (this.pendingRecords.length) {
+                const chunkSize = Math.min(this.pendingRecords.length, 10), records = this.pendingRecords.splice(0, chunkSize), recordJsons = records.map(record => JSON.stringify(record));
+                if (log.isDebugEnabled())
+                    log.debug("Records", records);
+                const textEncoder = new TextEncoder(), batch = recordJsons.map(jsonStr => ({
+                    Data: textEncoder.encode(jsonStr)
+                }));
+                log.info(`Pushing ${records.length} records to firehose`);
+                const cmd = new PutRecordBatchCommand({
+                    DeliveryStreamName: streamName,
+                    Records: batch,
+                });
+                const resp = await client.send(cmd);
+                const failed = resp.FailedPutCount || 0;
+                if (failed) {
+                    const rr = resp.RequestResponses || [];
+                    for (let i = 0; i < rr.length; i++) {
+                        if (rr[i].ErrorCode) {
+                            log.warn(`Record failed: ${rr[i].ErrorCode} ${rr[i].ErrorMessage}`);
+                            //this.pendingRecords.unshift(records[i])
+                        }
+                    }
+                    log.info(`PutRecordBatch failed=${failed}; requeued failed records`);
+                }
+                else {
+                    log.info(`PutRecordBatch ok count=${records.length}`);
+                }
+            }
+        }
+        catch (err) {
+            log.error("Failed to push logs", err);
+            if (err.code === ExpiredTokenException) {
+                this.credentialManager.forceUpdateCredentials();
+            }
+            deferred.reject(err);
+        }
+        finally {
+            this.flushDeferred = null;
+            // if (this.pendingRecords.length)
+            //   this.flush()
+        }
+        return deferred.promise;
+    }
+}
+export default AWSFirehoseAppender;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AWSFirehoseAppender.js","sourceRoot":"","sources":["../../../../../src/logging/appenders/aws-firehose/AWSFirehoseAppender.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable typescript/no-explicit-any */\nimport { isString } from '../../../guards/primitive.js'\nimport { FirehoseClient, PutRecordBatchCommand, PutRecordBatchInput } from \"@aws-sdk/client-firehose\"\nimport {\n  Credentials as IAWSTemporaryCredentials,\n  ExpiredTokenException,\n} from \"@aws-sdk/client-sts\"\nimport { Level } from \"../../Level.js\"\n\nimport AWSFirehoseCredentialManager from \"./AWSFirehoseCredentialManager.js\"\nimport { getInternalLogger } from \"../../InternalLogger.js\"\nimport { getValue, guard } from \"../../../guards/index.js\"\nimport { isEmpty, pick } from \"lodash\"\nimport { Deferred } from \"../../../helpers/index.js\"\nimport { LogRecord } from \"../../LogRecord.js\"\nimport { Appender } from \"../../Appender.js\"\n\nconst LogQueueMaxRecords = 10000\n\nconst log = getInternalLogger()\n\nexport class AWSFirehoseAppender<Record extends LogRecord = LogRecord>\n  implements Appender<Record> {\n  private pendingRecords = Array<LogRecord>()\n  private flushDeferred: Deferred<void>\n  private flushIntervalMs = 1000;\n\n  public readonly credentialManager: AWSFirehoseCredentialManager\n\n  constructor(\n    public readonly credentialEndpointUrl: string) {\n    this.credentialManager = new AWSFirehoseCredentialManager(credentialEndpointUrl)\n    this.credentialManager.on(\"received\", () => {\n      log.info(\"Credentials received, initializing firehose client\")\n      if (!this.pendingRecords.length || !!this.flushDeferred) {\n        log.debug(\"Nothing to flush upon credential receipt OR flush already in progress\")\n        return\n      }\n      this.flush()\n        .catch((e: Error) => {\n          log.error(`Error flushing logs after credential receipt: ${e.message}`, e)\n        })\n    })\n  }\n  append(record: Record): void {\n    const\n      pendingCount = this.pendingRecords.length + 1,\n      removeCount = LogQueueMaxRecords - pendingCount\n\n    if (removeCount < 0) {\n      this.pendingRecords.splice(0, Math.abs(removeCount))\n    }\n\n    this.pendingRecords.push({\n      timestamp: Date.now(),\n      ...record,\n      app: record.app?.length > 0 ? record.app : \"UNKNOWN\",\n      env: record.env?.length > 0 ? record.env : \"UNKNOWN\",\n      url: typeof window === \"undefined\" ? \"local://\" : window.location.href,\n    })\n\n    this.flush()\n  }\n\n  /**\n   * Create the firehose client and return\n   *\n   * @param {IAWSTemporaryCredentials} credentials\n   * @param {boolean} flush\n   * @returns {Firehose}\n   */\n  private getFirehose(): FirehoseClient {\n    const creds = this.credentialManager.getCredentials()\n\n    if (!creds) {\n      log.warn(\"No credentials available for flush\")\n      return null\n    }\n\n    const { region, streamName } = creds\n\n    if (!region || !streamName) {\n      throw new Error(\"Region or stream name not available\")\n    }\n\n    const client = new FirehoseClient({\n      region: creds.region,\n      credentials: pick(creds, \"accessKeyId\", \"secretAccessKey\", \"sessionToken\"),\n    })\n\n    return client\n  }\n\n  /**\n   * Flush pending records\n   *\n   * @returns {Promise<void>}\n   */\n  private async flush(): Promise<void> {\n    if (!!this.flushDeferred) {\n      log.debug(\"Flush already in progress, skipping\")\n      return\n    }\n\n    if (!this.pendingRecords.length) {\n      log.debug(\"No pending records to flush\")\n      return\n    }\n    const creds = this.credentialManager.getCredentials()\n    if (!creds) {\n      log.warn(\"No credentials available for flush\")\n      return\n    }\n    const { streamName } = creds,\n      client = this.getFirehose()\n    if (!client) {\n      log.warn(\"No firehose client available, skipping flush\")\n      return\n    }\n\n    const deferred = this.flushDeferred = new Deferred<void>()\n    try {\n      while (this.pendingRecords.length) {\n        const\n          chunkSize = Math.min(this.pendingRecords.length, 10),\n          records = this.pendingRecords.splice(0, chunkSize),\n          recordJsons = records.map(record => JSON.stringify(record))\n\n        if (log.isDebugEnabled())\n          log.debug(\"Records\", records)\n\n        const\n          textEncoder = new TextEncoder(),\n          batch: PutRecordBatchInput[\"Records\"] = recordJsons.map(jsonStr => ({\n            Data: textEncoder.encode(jsonStr)\n          }))\n\n        log.info(`Pushing ${records.length} records to firehose`)\n\n        const cmd = new PutRecordBatchCommand({\n          DeliveryStreamName: streamName,\n          Records: batch,\n        })\n\n        const resp = await client.send(cmd)\n        const failed = resp.FailedPutCount || 0\n        if (failed) {\n          const rr = resp.RequestResponses || []\n          for (let i = 0; i < rr.length; i++) {\n            if (rr[i].ErrorCode) {\n              log.warn(`Record failed: ${rr[i].ErrorCode} ${rr[i].ErrorMessage}`)\n              //this.pendingRecords.unshift(records[i])\n            }\n          }\n          log.info(`PutRecordBatch failed=${failed}; requeued failed records`)\n        } else {\n          log.info(`PutRecordBatch ok count=${records.length}`)\n        }\n\n      }\n    } catch (err) {\n      log.error(\"Failed to push logs\", err)\n      if (err.code === ExpiredTokenException) {\n        this.credentialManager.forceUpdateCredentials()\n      }\n      deferred.reject(err)\n    } finally {\n      this.flushDeferred = null\n\n      // if (this.pendingRecords.length)\n      //   this.flush()\n    }\n\n    return deferred.promise\n  }\n\n\n}\n\nexport default AWSFirehoseAppender\n"]}

package/lib/esm/logging/appenders/aws-firehose/AWSFirehoseCredentialManager.d.ts

@@ -0,0 +1,29 @@
+import EventEmitter3 from "eventemitter3";
+export interface AWSCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string;
+    streamName: string;
+    region: string;
+    expiration: string;
+}
+export interface AWSFirehoseCredentialManagerEventMap {
+    received: (creds: AWSCredentials) => void;
+    expired: () => void;
+}
+export declare class AWSFirehoseCredentialManager extends EventEmitter3<AWSFirehoseCredentialManagerEventMap> {
+    readonly credentialEndpointUrl: string;
+    private refreshTimer;
+    private loadDeferred;
+    constructor(credentialEndpointUrl: string);
+    forceUpdateCredentials(): void;
+    getCredentials(): AWSCredentials;
+    hasCredentials(): boolean;
+    private load;
+    scheduleRefresh(credsOrMillis: AWSCredentials | number): void;
+    getStreamName(): string;
+    getRegion(): string;
+    destroy(): void;
+}
+export default AWSFirehoseCredentialManager;
+//# sourceMappingURL=AWSFirehoseCredentialManager.d.ts.map

package/lib/esm/logging/appenders/aws-firehose/AWSFirehoseCredentialManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AWSFirehoseCredentialManager.d.ts","sourceRoot":"","sources":["../../../../../src/logging/appenders/aws-firehose/AWSFirehoseCredentialManager.ts"],"names":[],"mappings":"AAGA,OAAO,aAAa,MAAM,eAAe,CAAA;AAMzC,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,oCAAoC;IACnD,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAA;IACzC,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,qBAAa,4BAA6B,SAAQ,aAAa,CAAC,oCAAoC,CAAC;aAMjF,qBAAqB,EAAE,MAAM;IAJ/C,OAAO,CAAC,YAAY,CAAuC;IAC3D,OAAO,CAAC,YAAY,CAAkC;gBAGpC,qBAAqB,EAAE,MAAM;IAK/C,sBAAsB,IAAI,IAAI;IAS9B,cAAc,IAAI,cAAc;IAmBhC,cAAc,IAAI,OAAO;YAIX,IAAI;IAyBlB,eAAe,CAAC,aAAa,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI;IA4B7D,aAAa,IAAI,MAAM;IAIvB,SAAS,IAAI,MAAM;IAInB,OAAO,IAAI,IAAI;CAMhB;AAGD,eAAe,4BAA4B,CAAA"}

package/lib/esm/logging/appenders/aws-firehose/AWSFirehoseCredentialManager.js

@@ -0,0 +1,98 @@
+import { Deferred } from "../../../helpers/index.js";
+import { getInternalLogger } from "../../InternalLogger.js";
+import EventEmitter3 from "eventemitter3";
+const CRED_BUFFER_PADDING_MS = 3 * 60 * 1000; // 3 minutes
+const log = getInternalLogger();
+export class AWSFirehoseCredentialManager extends EventEmitter3 {
+    credentialEndpointUrl;
+    refreshTimer = null;
+    loadDeferred = null;
+    constructor(credentialEndpointUrl) {
+        super();
+        this.credentialEndpointUrl = credentialEndpointUrl;
+    }
+    forceUpdateCredentials() {
+        if (this.loadDeferred && !this.loadDeferred.isSettled()) {
+            this.loadDeferred.reject(new Error("force update"));
+        }
+        this.loadDeferred = null;
+        this.scheduleRefresh(1);
+    }
+    getCredentials() {
+        if (this.loadDeferred && this.loadDeferred.isFulfilled()) {
+            const creds = this.loadDeferred.getResult(), expMs = Date.parse(creds.expiration);
+            if (expMs <= Date.now()) {
+                log.info("Credentials expired");
+                this.loadDeferred = null;
+                this.scheduleRefresh(1);
+                this.emit("expired");
+                return null;
+            }
+            return creds;
+        }
+        this.scheduleRefresh(1);
+        return null;
+    }
+    hasCredentials() {
+        return this.getCredentials() != null;
+    }
+    async load() {
+        if (this.loadDeferred && !this.loadDeferred.isRejected())
+            return this.loadDeferred.promise;
+        const deferred = this.loadDeferred = new Deferred();
+        try {
+            const r = await fetch(this.credentialEndpointUrl, {
+                method: "GET",
+                credentials: "include",
+            });
+            if (!r.ok)
+                throw new Error(`creds http ${r.status}`);
+            const creds = await r.json();
+            this.scheduleRefresh(creds);
+            log.info(`Got creds, expire=${creds.expiration}, stream=${creds.streamName}, region=${creds.region}`);
+            deferred.resolve(creds);
+            this.emit("received", creds);
+            return deferred.promise;
+        }
+        catch (e) {
+            deferred.reject(e);
+            this.loadDeferred = null;
+            throw e;
+        }
+    }
+    scheduleRefresh(credsOrMillis) {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        if (!credsOrMillis)
+            return;
+        let refreshInMs;
+        if (typeof credsOrMillis === "number") {
+            refreshInMs = credsOrMillis;
+        }
+        else {
+            const creds = credsOrMillis, expMs = Date.parse(creds.expiration);
+            refreshInMs = expMs - Date.now() - CRED_BUFFER_PADDING_MS;
+        }
+        refreshInMs = Math.max(100, refreshInMs);
+        this.refreshTimer = setTimeout(() => {
+            this.loadDeferred = null;
+            this.load().catch((e) => log.error(`refresh failed: ${e.message}`, e));
+        }, refreshInMs);
+    }
+    getStreamName() {
+        return this.getCredentials()?.streamName;
+    }
+    getRegion() {
+        return this.getCredentials()?.region;
+    }
+    destroy() {
+        this.scheduleRefresh(null);
+        if (!this.loadDeferred.isSettled())
+            this.loadDeferred.reject(new Error("destroyed"));
+        this.loadDeferred = null;
+    }
+}
+export default AWSFirehoseCredentialManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AWSFirehoseCredentialManager.js","sourceRoot":"","sources":["../../../../../src/logging/appenders/aws-firehose/AWSFirehoseCredentialManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { FirehoseClient, PutRecordBatchCommand } from \"@aws-sdk/client-firehose\"\nimport { Deferred } from \"../../../helpers/index.js\"\nimport { getInternalLogger } from \"../../InternalLogger.js\"\nimport EventEmitter3 from \"eventemitter3\"\n\nconst CRED_BUFFER_PADDING_MS = 3 * 60 * 1000 // 3 minutes\n\nconst log = getInternalLogger()\n\nexport interface AWSCredentials {\n  accessKeyId: string\n  secretAccessKey: string\n  sessionToken: string\n  streamName: string\n  region: string\n  expiration: string\n}\n\nexport interface AWSFirehoseCredentialManagerEventMap {\n  received: (creds: AWSCredentials) => void\n  expired: () => void\n}\n\nexport class AWSFirehoseCredentialManager extends EventEmitter3<AWSFirehoseCredentialManagerEventMap> {\n\n  private refreshTimer: ReturnType<typeof setTimeout> = null;\n  private loadDeferred: Deferred<AWSCredentials> = null;\n\n  constructor(\n    public readonly credentialEndpointUrl: string,\n  ) {\n    super()\n  }\n\n  forceUpdateCredentials(): void {\n    if (this.loadDeferred && !this.loadDeferred.isSettled()) {\n      this.loadDeferred.reject(new Error(\"force update\"))\n    }\n\n    this.loadDeferred = null\n    this.scheduleRefresh(1)\n  }\n\n  getCredentials(): AWSCredentials {\n    if (this.loadDeferred && this.loadDeferred.isFulfilled()) {\n      const creds = this.loadDeferred.getResult(),\n        expMs = Date.parse(creds.expiration)\n\n      if (expMs <= Date.now()) {\n        log.info(\"Credentials expired\")\n        this.loadDeferred = null\n        this.scheduleRefresh(1)\n        this.emit(\"expired\")\n        return null\n      }\n      return creds\n    }\n\n    this.scheduleRefresh(1)\n    return null\n  }\n\n  hasCredentials(): boolean {\n    return this.getCredentials() != null\n  }\n\n  private async load(): Promise<AWSCredentials> {\n    if (this.loadDeferred && !this.loadDeferred.isRejected())\n      return this.loadDeferred.promise\n\n    const deferred = this.loadDeferred = new Deferred<AWSCredentials>()\n    try {\n      const r = await fetch(this.credentialEndpointUrl, {\n        method: \"GET\",\n        credentials: \"include\",\n      })\n      if (!r.ok) throw new Error(`creds http ${r.status}`)\n      const creds: AWSCredentials = await r.json()\n\n\n      this.scheduleRefresh(creds)\n      log.info(`Got creds, expire=${creds.expiration}, stream=${creds.streamName}, region=${creds.region}`)\n      deferred.resolve(creds)\n      this.emit(\"received\", creds)\n      return deferred.promise\n    } catch (e) {\n      deferred.reject(e)\n      this.loadDeferred = null\n      throw e\n    }\n  }\n  scheduleRefresh(credsOrMillis: AWSCredentials | number): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n      this.refreshTimer = null\n    }\n    if (!credsOrMillis)\n      return\n\n    let refreshInMs: number\n    if (typeof credsOrMillis === \"number\") {\n      refreshInMs = credsOrMillis\n    } else {\n      const\n        creds = credsOrMillis,\n        expMs = Date.parse(creds.expiration)\n\n      refreshInMs = expMs - Date.now() - CRED_BUFFER_PADDING_MS\n\n    }\n\n    refreshInMs = Math.max(100, refreshInMs)\n\n    this.refreshTimer = setTimeout(() => {\n      this.loadDeferred = null\n      this.load().catch((e: Error) => log.error(`refresh failed: ${e.message}`, e))\n    }, refreshInMs)\n  }\n\n  getStreamName(): string {\n    return this.getCredentials()?.streamName\n  }\n\n  getRegion(): string {\n    return this.getCredentials()?.region\n  }\n\n  destroy(): void {\n    this.scheduleRefresh(null)\n    if (!this.loadDeferred.isSettled())\n      this.loadDeferred.reject(new Error(\"destroyed\"))\n    this.loadDeferred = null\n  }\n}\n\n\nexport default AWSFirehoseCredentialManager\n"]}

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

@@ -0,0 +1,4 @@
+export * from "./aws-firehose/AWSFirehoseAppender.js";
+export * from "./ConsoleAppender.js";
+export * from "./push/PushLogRecordsAppender.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/logging/appenders/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA;AACrD,cAAc,sBAAsB,CAAA;AACpC,cAAc,kCAAkC,CAAA"}

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

@@ -0,0 +1,4 @@
+export * from "./aws-firehose/AWSFirehoseAppender.js";
+export * from "./ConsoleAppender.js";
+export * from "./push/PushLogRecordsAppender.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbG9nZ2luZy9hcHBlbmRlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1Q0FBdUMsQ0FBQTtBQUNyRCxjQUFjLHNCQUFzQixDQUFBO0FBQ3BDLGNBQWMsa0NBQWtDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9hd3MtZmlyZWhvc2UvQVdTRmlyZWhvc2VBcHBlbmRlci5qc1wiXG5leHBvcnQgKiBmcm9tIFwiLi9Db25zb2xlQXBwZW5kZXIuanNcIlxuZXhwb3J0ICogZnJvbSBcIi4vcHVzaC9QdXNoTG9nUmVjb3Jkc0FwcGVuZGVyLmpzXCJcbiJdfQ==