@wireio/shared 1.0.18 → 1.0.20

package/lib/esm/logging/LoggingManager.d.ts

@@ -0,0 +1,131 @@
+import type { Appender } from "./Appender.js";
+import { LevelKind } from "./Level.js";
+import { Logger, LoggerOptions } from "./Logger.js";
+import type { LogMetadata, LogRecord } from "./LogRecord.js";
+import { LogContext } from "./context/index.js";
+export type CategoryMatch = RegExp | string;
+export type ThresholdOverride = [match: CategoryMatch, level: LevelKind];
+export interface LoggingManagerState<Record extends LogRecord> {
+    rootLevel: LevelKind;
+    globalMetadata?: LogMetadata;
+    appenders: Array<Appender<Record>>;
+    thresholdOverrides: Array<ThresholdOverride>;
+}
+export type LoggingManagerOptions<Record extends LogRecord> = Partial<LoggingManagerState<Record>>;
+export declare const kEnvThresholdOverrides: ThresholdOverride[];
+/**
+ * Logging manager
+ */
+export declare class LoggingManager<Record extends LogRecord = any> {
+    private readonly loggers;
+    private readonly state;
+    get rootLevel(): LevelKind;
+    get globalMetadata(): LogMetadata;
+    set globalMetadata(newMetadata: LogMetadata);
+    set rootLevel(newRootLevel: LevelKind);
+    get rootThreshold(): number;
+    /**
+     * Get the current handler
+     *
+     * @returns {Appender<Record>}
+     */
+    get appenders(): Array<Appender<Record>>;
+    /**
+     * Global threshold overrides
+     */
+    get thresholdOverrides(): ThresholdOverride[];
+    /**
+     * Update the overrides
+     *
+     * @param newOverrides
+     */
+    set thresholdOverrides(newOverrides: ThresholdOverride[]);
+    /**
+     * Set global appenders
+     *
+     * @param {Array<Appender<Record>>} newAppenders
+     */
+    setAppenders(...newAppenders: Array<Appender<Record> | Appender<Record>[]>): this;
+    /**
+     * Add one or more appenders to existing appender set
+     *
+     * @param {Appender<Record> | Appender<Record>[]} newAppenders
+     * @returns {this<Record>}
+     */
+    addAppenders(...newAppenders: Array<Appender<Record> | Appender<Record>[]>): this;
+    /**
+     * Clear threshold overrides
+     *
+     * @returns {this<Record>}
+     */
+    clearThresholdOverrides(): this;
+    setThresholdOverrides(...overrides: Array<ThresholdOverride>): this;
+    addThresholdOverrides(...overrides: Array<ThresholdOverride>): this;
+    /**
+     * Get applicable current contexts
+     *
+     * @param {string} category
+     * @returns {LogContext[]}
+     */
+    getApplicableCurrentContexts(category: string): LogContext[];
+    /**
+     * Check for any matching threshold overrides
+     *
+     * @param category
+     */
+    determineThresholdOverride(category: string): number;
+    /**
+     * Set the root logging level
+     *
+     * @param {LevelKind} newLevel
+     * @returns {this<Record>}
+     */
+    setRootLevel(newLevel: LevelKind): this;
+    /**
+     * Fire a log event, eventually
+     * invert this by making `Logger` an
+     * `EventEmitter3` and having the `LoggingManager`
+     * subscribe to `record` event
+     *
+     * @param {LogRecord<Record>} record
+     * @internal
+     */
+    fire(record: LogRecord<Record>): void;
+    /**
+     * Get a logger from cache, if the category
+     * does not have an existing logger, then create one.
+     *
+     * @param {string} categoryOrFilename
+     * @param {Partial<LoggerOptions>} inOptions
+     * @returns {Logger}
+     */
+    getLogger(categoryOrFilename: string, inOptions?: Partial<LoggerOptions>): Logger;
+    /**
+     * Configure the logging manager,
+     * this function is additive, so simply calling
+     * `configure` with a single option `rootLevel`,
+     * will not affect other options like `appenders`   *
+     *
+     * @param {LoggingManagerOptions<any>} options
+     * @returns {this<Record>}
+     */
+    configure(options: LoggingManagerOptions<any>): this;
+    private constructor();
+    /**
+     * Singleton instance
+     *
+     * @type {LoggingManager}
+     * @private
+     */
+    private static manager;
+    /**
+     * Get logging manager and optionally provided
+     * configuration options
+     *
+     * @param {LoggingManagerOptions<Record>} options
+     * @returns {LoggingManager<Record>}
+     */
+    static get<Record extends LogRecord = any>(options?: LoggingManagerOptions<Record>): LoggingManager<Record>;
+}
+export declare function getLoggingManager(): LoggingManager;
+//# sourceMappingURL=LoggingManager.d.ts.map

package/lib/esm/logging/LoggingManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggingManager.d.ts","sourceRoot":"","sources":["../../../src/logging/LoggingManager.ts"],"names":[],"mappings":"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"}

package/lib/esm/logging/LoggingManager.js

@@ -0,0 +1,248 @@
+import { isNumber, isObject, isString } from "../guards/index.js";
+import { Option } from "@3fv/prelude-ts";
+import { flatten, isEmpty, min, negate } from "lodash";
+import { ConsoleAppender } from "./appenders/ConsoleAppender.js";
+import { Level, LevelThresholds } from "./Level.js";
+import { Logger } from "./Logger.js";
+import { LogContextContainer } from "./context/index.js";
+import { flow, get, nth } from "lodash/fp.js";
+function parseThresholdOverridePatterns(value, level = "debug") {
+    return value.split(",").map(s => [new RegExp(s), level]);
+}
+export const kEnvThresholdOverrides = Option.ofNullable(typeof process !== "undefined" && process.env.DEBUG_PATTERNS)
+    .filter(negate(isEmpty))
+    .map(parseThresholdOverridePatterns)
+    .getOrElse([]);
+/**
+ * Logging manager
+ */
+export class LoggingManager {
+    loggers = new Map();
+    state = {
+        appenders: [],
+        globalMetadata: {},
+        rootLevel: Level.info,
+        thresholdOverrides: kEnvThresholdOverrides
+    };
+    get rootLevel() {
+        return this.state.rootLevel;
+    }
+    get globalMetadata() {
+        return this.state.globalMetadata;
+    }
+    set globalMetadata(newMetadata) {
+        this.state.globalMetadata = newMetadata ?? {};
+    }
+    set rootLevel(newRootLevel) {
+        this.state.rootLevel = newRootLevel;
+    }
+    get rootThreshold() {
+        return LevelThresholds[this.rootLevel];
+    }
+    /**
+     * Get the current handler
+     *
+     * @returns {Appender<Record>}
+     */
+    get appenders() {
+        return Option.ofNullable(this.state.appenders)
+            .filter(appenders => appenders.length > 0)
+            .getOrCall(() => {
+            this.state.appenders.push(new ConsoleAppender());
+            return this.state.appenders;
+        });
+    }
+    /**
+     * Global threshold overrides
+     */
+    get thresholdOverrides() {
+        return this.state.thresholdOverrides;
+    }
+    /**
+     * Update the overrides
+     *
+     * @param newOverrides
+     */
+    set thresholdOverrides(newOverrides) {
+        this.state.thresholdOverrides = newOverrides;
+    }
+    /**
+     * Set global appenders
+     *
+     * @param {Array<Appender<Record>>} newAppenders
+     */
+    setAppenders(...newAppenders) {
+        // WE MUTATE DO TO THE LIKELIHOOD OF SOMEONE HOLDING A REF TO THE ARRAY,
+        // CONVERT TO OBSERVABLE AT SOME POINT
+        const persistentAppenders = this.state.appenders;
+        persistentAppenders.length = 0;
+        persistentAppenders.push(...flatten(newAppenders));
+        return this;
+    }
+    /**
+     * Add one or more appenders to existing appender set
+     *
+     * @param {Appender<Record> | Appender<Record>[]} newAppenders
+     * @returns {this<Record>}
+     */
+    addAppenders(...newAppenders) {
+        this.state.appenders.push(...flatten(newAppenders));
+        return this;
+    }
+    /**
+     * Clear threshold overrides
+     *
+     * @returns {this<Record>}
+     */
+    clearThresholdOverrides() {
+        this.state.thresholdOverrides.length = 0;
+        return this;
+    }
+    setThresholdOverrides(...overrides) {
+        this.state.thresholdOverrides.length = 0;
+        this.state.thresholdOverrides.push(...overrides);
+        return this;
+    }
+    addThresholdOverrides(...overrides) {
+        this.state.thresholdOverrides.push(...overrides);
+        return this;
+    }
+    /**
+     * Get applicable current contexts
+     *
+     * @param {string} category
+     * @returns {LogContext[]}
+     */
+    getApplicableCurrentContexts(category) {
+        return LogContextContainer.currentContext().filter(({ pattern }) => !pattern || pattern.test(category));
+    }
+    /**
+     * Check for any matching threshold overrides
+     *
+     * @param category
+     */
+    determineThresholdOverride(category) {
+        const contexts = this.getApplicableCurrentContexts(category), 
+        // FIND CONFIGURED OVERRIDE LEVEL
+        overrideThreshold = Option.ofNullable(this.thresholdOverrides.find(([match]) => isString(match)
+            ? match === category
+            : match.test(category)))
+            .map(nth(1))
+            .map(level => LevelThresholds[level])
+            .getOrNull(), 
+        // FIND `LogContext` OVERRIDE LEVEL
+        contextThresholds = contexts
+            .filter(flow(get("thresholdLevel"), isString))
+            .map(({ thresholdLevel }) => LevelThresholds[thresholdLevel]), 
+        // IF ANY OVERRIDES, GET THE MOST VERBOSE LEVEL
+        override = Option.ofNullable([...contextThresholds, overrideThreshold].filter(isNumber))
+            .filter(negate(isEmpty))
+            .map(min)
+            .getOrNull();
+        return override;
+    }
+    /**
+     * Set the root logging level
+     *
+     * @param {LevelKind} newLevel
+     * @returns {this<Record>}
+     */
+    setRootLevel(newLevel) {
+        this.state.rootLevel = newLevel;
+        return this;
+    }
+    /**
+     * Fire a log event, eventually
+     * invert this by making `Logger` an
+     * `EventEmitter3` and having the `LoggingManager`
+     * subscribe to `record` event
+     *
+     * @param {LogRecord<Record>} record
+     * @internal
+     */
+    fire(record) {
+        const { category } = record, contexts = this.getApplicableCurrentContexts(category), contextAppenders = contexts.flatMap(get("appenders")), appenders = [...this.appenders, ...contextAppenders];
+        appenders.forEach(appender => appender.append(record));
+    }
+    /**
+     * Get a logger from cache, if the category
+     * does not have an existing logger, then create one.
+     *
+     * @param {string} categoryOrFilename
+     * @param {Partial<LoggerOptions>} inOptions
+     * @returns {Logger}
+     */
+    getLogger(categoryOrFilename, inOptions = {}) {
+        const options = Logger.hydrateOptions(inOptions);
+        const category = Logger.interoplateCategory(categoryOrFilename, options);
+        return Option.ofNullable(category)
+            .map(category => this.loggers.get(category))
+            .getOrCall(() => {
+            const logger = new Logger(this, category, options);
+            this.loggers.set(category, logger);
+            return logger;
+        });
+    }
+    /**
+     * Configure the logging manager,
+     * this function is additive, so simply calling
+     * `configure` with a single option `rootLevel`,
+     * will not affect other options like `appenders`   *
+     *
+     * @param {LoggingManagerOptions<any>} options
+     * @returns {this<Record>}
+     */
+    configure(options) {
+        if (Level[options?.rootLevel]) {
+            this.setRootLevel(options.rootLevel);
+        }
+        if (options?.appenders) {
+            this.setAppenders(options.appenders);
+        }
+        if (options?.thresholdOverrides) {
+            this.addThresholdOverrides(...options.thresholdOverrides);
+        }
+        return this;
+    }
+    constructor() {
+        this.configure({});
+    }
+    /**
+     * Singleton instance
+     *
+     * @type {LoggingManager}
+     * @private
+     */
+    static manager;
+    /**
+     * Get logging manager and optionally provided
+     * configuration options
+     *
+     * @param {LoggingManagerOptions<Record>} options
+     * @returns {LoggingManager<Record>}
+     */
+    static get(options = null) {
+        if (!this.manager) {
+            this.manager = new LoggingManager();
+        }
+        if (options) {
+            this.manager.configure(options);
+        }
+        return this.manager;
+    }
+}
+export function getLoggingManager() {
+    return LoggingManager.get();
+}
+if (Option.try(() => process.env.NODE_ENV === "development").getOrElse(false)) {
+    ;
+    [
+        typeof window !== "undefined" && window,
+        typeof global !== "undefined" && global
+    ]
+        .filter(isObject)
+        .map(target => Object.assign(target, {
+        loggingManager: getLoggingManager()
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LoggingManager.js","sourceRoot":"","sources":["../../../src/logging/LoggingManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { isNumber, isObject, isString } from \"../guards/index.js\"\nimport { Option } from \"@3fv/prelude-ts\"\nimport { flatten, isEmpty, min, negate } from \"lodash\"\nimport type { Appender } from \"./Appender.js\"\nimport { ConsoleAppender } from \"./appenders/ConsoleAppender.js\"\nimport { Level, LevelKind, LevelThresholds } from \"./Level.js\"\nimport { Logger, LoggerOptions } from \"./Logger.js\"\nimport type { LogMetadata, LogRecord } from \"./LogRecord.js\"\nimport { LogContext, LogContextContainer } from \"./context/index.js\"\nimport { flow, get, nth } from \"lodash/fp.js\"\n\nexport type CategoryMatch = RegExp | string\n\nexport type ThresholdOverride = [match: CategoryMatch, level: LevelKind]\n\nexport interface LoggingManagerState<Record extends LogRecord> {\n  rootLevel: LevelKind\n  globalMetadata?: LogMetadata\n  appenders: Array<Appender<Record>>\n  thresholdOverrides: Array<ThresholdOverride>\n}\n\nexport type LoggingManagerOptions<Record extends LogRecord> = Partial<\n  LoggingManagerState<Record>\n>\n\nfunction parseThresholdOverridePatterns(\n  value: string,\n  level: LevelKind = \"debug\"\n): ThresholdOverride[] {\n  return value.split(\",\").map(s => [new RegExp(s), level] as ThresholdOverride)\n}\n\nexport const kEnvThresholdOverrides = Option.ofNullable(\n  typeof process !== \"undefined\" && process.env.DEBUG_PATTERNS\n)\n  .filter(negate(isEmpty))\n  .map(parseThresholdOverridePatterns)\n  .getOrElse([])\n\n/**\n * Logging manager\n */\nexport class LoggingManager<Record extends LogRecord = any> {\n  private readonly loggers = new Map<string, Logger>()\n\n  private readonly state: LoggingManagerState<Record> = {\n    appenders: [],\n    globalMetadata: {},\n    rootLevel: Level.info,\n    thresholdOverrides: kEnvThresholdOverrides\n  }\n\n  get rootLevel() {\n    return this.state.rootLevel\n  }\n\n  get globalMetadata() {\n    return this.state.globalMetadata\n  }\n\n  set globalMetadata(newMetadata: LogMetadata) {\n    this.state.globalMetadata = newMetadata ?? {}\n  }\n\n  set rootLevel(newRootLevel: LevelKind) {\n    this.state.rootLevel = newRootLevel\n  }\n\n  get rootThreshold() {\n    return LevelThresholds[this.rootLevel]\n  }\n\n  /**\n   * Get the current handler\n   *\n   * @returns {Appender<Record>}\n   */\n  get appenders(): Array<Appender<Record>> {\n    return Option.ofNullable(this.state.appenders)\n      .filter(appenders => appenders.length > 0)\n      .getOrCall(() => {\n        this.state.appenders.push(new ConsoleAppender())\n        return this.state.appenders\n      })\n  }\n\n  /**\n   * Global threshold overrides\n   */\n  get thresholdOverrides() {\n    return this.state.thresholdOverrides\n  }\n\n  /**\n   * Update the overrides\n   *\n   * @param newOverrides\n   */\n  set thresholdOverrides(newOverrides: ThresholdOverride[]) {\n    this.state.thresholdOverrides = newOverrides\n  }\n\n  /**\n   * Set global appenders\n   *\n   * @param {Array<Appender<Record>>} newAppenders\n   */\n  setAppenders(...newAppenders: Array<Appender<Record> | Appender<Record>[]>) {\n    // WE MUTATE DO TO THE LIKELIHOOD OF SOMEONE HOLDING A REF TO THE ARRAY,\n    // CONVERT TO OBSERVABLE AT SOME POINT\n    const persistentAppenders = this.state.appenders\n    persistentAppenders.length = 0\n    persistentAppenders.push(...flatten(newAppenders))\n\n    return this\n  }\n\n  /**\n   * Add one or more appenders to existing appender set\n   *\n   * @param {Appender<Record> | Appender<Record>[]} newAppenders\n   * @returns {this<Record>}\n   */\n  addAppenders(\n    ...newAppenders: Array<Appender<Record> | Appender<Record>[]>\n  ): this {\n    this.state.appenders.push(...flatten(newAppenders))\n    return this\n  }\n\n  /**\n   * Clear threshold overrides\n   *\n   * @returns {this<Record>}\n   */\n  clearThresholdOverrides(): this {\n    this.state.thresholdOverrides.length = 0\n    return this\n  }\n\n  setThresholdOverrides(...overrides: Array<ThresholdOverride>) {\n    this.state.thresholdOverrides.length = 0\n    this.state.thresholdOverrides.push(...overrides)\n    return this\n  }\n\n  addThresholdOverrides(...overrides: Array<ThresholdOverride>) {\n    this.state.thresholdOverrides.push(...overrides)\n    return this\n  }\n\n  /**\n   * Get applicable current contexts\n   *\n   * @param {string} category\n   * @returns {LogContext[]}\n   */\n  getApplicableCurrentContexts(category: string): LogContext[] {\n    return LogContextContainer.currentContext().filter(\n      ({ pattern }) => !pattern || pattern.test(category)\n    )\n  }\n\n  /**\n   * Check for any matching threshold overrides\n   *\n   * @param category\n   */\n  determineThresholdOverride(category: string): number {\n    const contexts = this.getApplicableCurrentContexts(category),\n      // FIND CONFIGURED OVERRIDE LEVEL\n      overrideThreshold = Option.ofNullable(\n        this.thresholdOverrides.find(([match]) =>\n          isString(match)\n            ? match === category\n            : (match as RegExp).test(category)\n        )\n      )\n        .map(nth(1))\n        .map(level => LevelThresholds[level as Level])\n        .getOrNull(),\n      // FIND `LogContext` OVERRIDE LEVEL\n      contextThresholds = contexts\n        .filter(flow(get(\"thresholdLevel\"), isString))\n        .map(({ thresholdLevel }) => LevelThresholds[thresholdLevel]),\n      // IF ANY OVERRIDES, GET THE MOST VERBOSE LEVEL\n      override = Option.ofNullable(\n        [...contextThresholds, overrideThreshold].filter(isNumber)\n      )\n        .filter(negate(isEmpty))\n        .map(min)\n        .getOrNull()\n\n    return override as number\n  }\n\n  /**\n   * Set the root logging level\n   *\n   * @param {LevelKind} newLevel\n   * @returns {this<Record>}\n   */\n  setRootLevel(newLevel: LevelKind): this {\n    this.state.rootLevel = newLevel\n    return this\n  }\n\n  /**\n   * Fire a log event, eventually\n   * invert this by making `Logger` an\n   * `EventEmitter3` and having the `LoggingManager`\n   * subscribe to `record` event\n   *\n   * @param {LogRecord<Record>} record\n   * @internal\n   */\n  fire(record: LogRecord<Record>) {\n    const { category } = record,\n      contexts = this.getApplicableCurrentContexts(category),\n      contextAppenders = contexts.flatMap(get(\"appenders\")),\n      appenders = [...this.appenders, ...contextAppenders]\n\n    appenders.forEach(appender => appender.append(record as Record))\n  }\n\n  /**\n   * Get a logger from cache, if the category\n   * does not have an existing logger, then create one.\n   *\n   * @param {string} categoryOrFilename\n   * @param {Partial<LoggerOptions>} inOptions\n   * @returns {Logger}\n   */\n  getLogger(\n    categoryOrFilename: string,\n    inOptions: Partial<LoggerOptions> = {}\n  ): Logger {\n    const options = Logger.hydrateOptions(inOptions)\n    const category = Logger.interoplateCategory(categoryOrFilename, options)\n\n    return Option.ofNullable(category)\n      .map(category => this.loggers.get(category))\n      .getOrCall(() => {\n        const logger = new Logger(this, category, options)\n        this.loggers.set(category, logger)\n        return logger\n      })\n  }\n\n  /**\n   * Configure the logging manager,\n   * this function is additive, so simply calling\n   * `configure` with a single option `rootLevel`,\n   * will not affect other options like `appenders`   *\n   *\n   * @param {LoggingManagerOptions<any>} options\n   * @returns {this<Record>}\n   */\n  configure(options: LoggingManagerOptions<any>): this {\n    if (Level[options?.rootLevel]) {\n      this.setRootLevel(options.rootLevel)\n    }\n\n    if (options?.appenders) {\n      this.setAppenders(options.appenders)\n    }\n\n    if (options?.thresholdOverrides) {\n      this.addThresholdOverrides(...options.thresholdOverrides)\n    }\n\n    return this\n  }\n\n  private constructor() {\n    this.configure({})\n  }\n\n  /**\n   * Singleton instance\n   *\n   * @type {LoggingManager}\n   * @private\n   */\n  private static manager: LoggingManager\n\n  /**\n   * Get logging manager and optionally provided\n   * configuration options\n   *\n   * @param {LoggingManagerOptions<Record>} options\n   * @returns {LoggingManager<Record>}\n   */\n  static get<Record extends LogRecord = any>(\n    options: LoggingManagerOptions<Record> = null\n  ): LoggingManager<Record> {\n    if (!this.manager) {\n      this.manager = new LoggingManager<Record>()\n    }\n\n    if (options) {\n      this.manager.configure(options)\n    }\n\n    return this.manager\n  }\n}\n\nexport function getLoggingManager(): LoggingManager {\n  return LoggingManager.get()\n}\n\nif (Option.try(() => process.env.NODE_ENV === \"development\").getOrElse(false)) {\n  ;[\n    typeof window !== \"undefined\" && window,\n    typeof global !== \"undefined\" && global\n  ]\n    .filter(isObject)\n    .map(target =>\n      Object.assign(target, {\n        loggingManager: getLoggingManager()\n      })\n    )\n}\n"]}

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

@@ -0,0 +1,55 @@
+import type { LogRecord } from "../LogRecord";
+import type { Appender } from "../Appender";
+import type { LevelKind } from "../Level";
+import type { Formatter } from "../Formatter";
+/**
+ * Get a cached console bound log function
+ *
+ * @param {LevelKind} level
+ * @returns {(...args: any[]) => any}
+ */
+export declare function getConsoleLogBinding(level: LevelKind): (...args: any[]) => any;
+/**
+ * ConsoleAppender Configuration
+ */
+export interface ConsoleAppenderConfig<Record extends LogRecord = any> {
+    cacheEnabled: boolean;
+    prettyPrint: boolean;
+    formatter?: Formatter<string | Array<any>>;
+}
+/**
+ * Partial of config, used for shortening instead of Partial<...>
+ */
+export type ConsoleAppenderOptions<Record extends LogRecord> = Partial<ConsoleAppenderConfig<Record>>;
+export declare const consoleFormatter: Formatter<Array<any>>;
+/**
+ * Default console config
+ * @type {ConsoleAppenderConfig}
+ */
+export declare const kDefaultConsoleAppenderConfig: ConsoleAppenderConfig;
+/**
+ * Console appender, the simple default appender used
+ * everywhere OOB
+ */
+export declare class ConsoleAppender<Record extends LogRecord> implements Appender<Record> {
+    readonly config: ConsoleAppenderConfig;
+    /**
+     * Handle log records, transform, push to ES
+     *
+     * @param record
+     */
+    append(record: Record): void;
+    /**
+     * Write args to console
+     *
+     * @param level
+     * @param args
+     */
+    protected write(level: LevelKind, ...args: any[]): void;
+    /**
+     *
+     * @param {Partial<ConsoleAppenderOptions<Record>>} options
+     */
+    constructor(options?: Partial<ConsoleAppenderOptions<Record>>);
+}
+//# sourceMappingURL=ConsoleAppender.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleAppender.d.ts","sourceRoot":"","sources":["../../../../src/logging/appenders/ConsoleAppender.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAQ7C;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,aAZG,GAAG,EAAE,KAAK,GAAG,CAkBpE;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,MAAM,SAAS,SAAS,GAAG,GAAG;IACnE,YAAY,EAAE,OAAO,CAAA;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAA;CAC3C;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,MAAM,SAAS,SAAS,IAAI,OAAO,CACpE,qBAAqB,CAAC,MAAM,CAAC,CAC9B,CAAA;AAED,eAAO,MAAM,gBAAgB,EAAE,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAUlD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,6BAA6B,EAAE,qBAI3C,CAAA;AAED;;;GAGG;AACH,qBAAa,eAAe,CAC1B,MAAM,SAAS,SAAS,CACxB,YAAW,QAAQ,CAAC,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAA;IAEtC;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAS5B;;;;;OAKG;IACH,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAMhD;;;OAGG;gBACS,OAAO,GAAE,OAAO,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAM;CAMlE"}

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

@@ -0,0 +1,72 @@
+import { Option } from "@3fv/prelude-ts";
+const consoleLogBindings = new Map();
+function getBoundConsoleFn(level) {
+    return (console[level] ?? console.log).bind(console);
+}
+/**
+ * Get a cached console bound log function
+ *
+ * @param {LevelKind} level
+ * @returns {(...args: any[]) => any}
+ */
+export function getConsoleLogBinding(level) {
+    if (!consoleLogBindings.has(level)) {
+        consoleLogBindings.set(level, getBoundConsoleFn(level));
+    }
+    return consoleLogBindings.get(level);
+}
+export const consoleFormatter = ({ level, message, data, args, category, timestamp }) => [
+    `[${category}]  (${level})  ${message}`,
+    ...(Array.isArray(args) ? args : [args])
+];
+/**
+ * Default console config
+ * @type {ConsoleAppenderConfig}
+ */
+export const kDefaultConsoleAppenderConfig = {
+    cacheEnabled: true,
+    prettyPrint: true,
+    formatter: consoleFormatter
+};
+/**
+ * Console appender, the simple default appender used
+ * everywhere OOB
+ */
+export class ConsoleAppender {
+    config;
+    /**
+     * Handle log records, transform, push to ES
+     *
+     * @param record
+     */
+    append(record) {
+        const { level, message, data, args, category, timestamp } = record;
+        const { formatter = consoleFormatter } = this.config;
+        Option.ofNullable(formatter(record)).map(result => {
+            const args = Array.isArray(result) ? result : [result];
+            this.write(level, ...args);
+        });
+    }
+    /**
+     * Write args to console
+     *
+     * @param level
+     * @param args
+     */
+    write(level, ...args) {
+        Option.ofNullable(console[level])
+            .orCall(() => Option.ofNullable(console.log))
+            .map((fn) => fn.apply(console, args));
+    }
+    /**
+     *
+     * @param {Partial<ConsoleAppenderOptions<Record>>} options
+     */
+    constructor(options = {}) {
+        this.config = {
+            ...kDefaultConsoleAppenderConfig,
+            ...options
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,65 @@
+import type { LogRecord } from "../LogRecord";
+import type { Appender } from "../Appender";
+import { Buffer } from "buffer";
+export interface FileAppenderConfig<Record extends LogRecord = any> {
+    filename: string;
+    /**
+     * For rolling
+     */
+    maxFiles: number;
+    /**
+     * For rolling
+     */
+    maxSize: number;
+    enableRolling: boolean;
+    prettyPrint: boolean;
+    sync: boolean;
+}
+export type FileAppenderOptions<Record extends LogRecord = any> = Partial<FileAppenderConfig<Record>>;
+export declare class FileAppender<Record extends LogRecord> implements Appender<Record> {
+    readonly config: FileAppenderConfig<Record>;
+    private readonly state;
+    get enableRolling(): boolean;
+    isReady(): boolean;
+    /**
+     * Initialize and setup the appender
+     *
+     * @returns {FileAppender<Record>}
+     */
+    setup(): FileAppender<Record>;
+    /**
+     * Only exposed for the sake of tests & examples
+     * DO NOT USE
+     *
+     * This should all be async, but i was in a rush :(
+     *
+     * @returns
+     */
+    rollFile(): void;
+    /**
+     * Close the handler
+     *
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+    get queue(): Buffer<ArrayBufferLike>[];
+    get file(): number;
+    get flushing(): boolean;
+    get filename(): string;
+    /**
+     * Appends the log queue records to the file
+     */
+    private flush;
+    /**
+     * Handle log records, transform, push to ES
+     *
+     * @param record
+     */
+    append(record: Record): void;
+    /**
+     *
+     * @param {Partial<FileAppenderOptions<Record>>} options
+     */
+    constructor(options?: Partial<FileAppenderOptions<Record>>);
+}
+//# sourceMappingURL=FileAppender.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileAppender.d.ts","sourceRoot":"","sources":["../../../../src/logging/appenders/FileAppender.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAsB/B,MAAM,WAAW,kBAAkB,CAAC,MAAM,SAAS,SAAS,GAAG,GAAG;IAChE,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAA;IAEf,aAAa,EAAE,OAAO,CAAA;IACtB,WAAW,EAAE,OAAO,CAAA;IACpB,IAAI,EAAE,OAAO,CAAA;CACd;AAED,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,SAAS,GAAG,GAAG,IAAI,OAAO,CACvE,kBAAkB,CAAC,MAAM,CAAC,CAC3B,CAAA;AAED,qBAAa,YAAY,CACvB,MAAM,SAAS,SAAS,CACxB,YAAW,QAAQ,CAAC,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAA;IAE3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAiBrB;IAED,IAAI,aAAa,YAEhB;IAED,OAAO;IAIP;;;;OAIG;IACH,KAAK,IAAI,YAAY,CAAC,MAAM,CAAC;IA2B7B;;;;;;;OAOG;IACH,QAAQ;IAkDR;;;;OAIG;IACH,KAAK;IAML,IAAI,KAAK,8BAER;IAED,IAAI,IAAI,WAEP;IAED,IAAI,QAAQ,YAEX;IAED,IAAI,QAAQ,WAEX;IAED;;OAEG;IACH,OAAO,CAAC,KAAK;IAoCb;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAsB5B;;;OAGG;gBACS,OAAO,GAAE,OAAO,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAM;CAW/D"}