@wireio/shared 1.0.18 → 1.0.20

package/lib/cjs/logging/LogRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogRecord.d.ts","sourceRoot":"","sources":["../../../src/logging/LogRecord.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAG3C,MAAM,WAAW,WAAW,CAAC,IAAI,SAAS,EAAE,GAAG,GAAG;IAChD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,IAAI,CAAA;CACZ;AAED,MAAM,WAAW,SAAS,CAAC,IAAI,SAAS,EAAE,GAAG,GAAG,CAAE,SAAQ,WAAW,CAAC,IAAI,CAAC;IACzE,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,SAAS,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB"}

package/lib/cjs/logging/LogRecord.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nUmVjb3JkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xvZ2dpbmcvTG9nUmVjb3JkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IExldmVsS2luZCB9IGZyb20gXCIuL0xldmVsLmpzXCJcblxuXG5leHBvcnQgaW50ZXJmYWNlIExvZ01ldGFkYXRhPERhdGEgZXh0ZW5kcyB7fSA9IGFueT4ge1xuICB1cmw/OiBzdHJpbmdcbiAgZW52Pzogc3RyaW5nXG4gIGFwcD86IHN0cmluZ1xuICBkYXRhPzogRGF0YVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIExvZ1JlY29yZDxEYXRhIGV4dGVuZHMge30gPSBhbnk+IGV4dGVuZHMgTG9nTWV0YWRhdGE8RGF0YT4ge1xuICB0aW1lc3RhbXA6IG51bWJlclxuICBjYXRlZ29yeTogc3RyaW5nXG4gIGxldmVsOiBMZXZlbEtpbmRcbiAgbWVzc2FnZTogc3RyaW5nXG4gIGFyZ3M/OiBhbnlbXVxuICB0YWdzPzogc3RyaW5nW11cbiAgZXZlbnQ/OiBzdHJpbmdcbiAgZXJyb3JNZXNzYWdlPzogc3RyaW5nXG4gIGVycm9yU3RhY2s/OiBzdHJpbmdcbn1cblxuIl19

package/lib/cjs/logging/Logger.d.ts.map

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

package/lib/cjs/logging/Logger.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.defaultLoggerOptions = exports.filenameCategoryInterpolator = void 0;
+exports.toLogRecord = toLogRecord;
+const index_js_1 = require("../guards/index.js");
+const prelude_ts_1 = require("@3fv/prelude-ts");
+const lodash_1 = require("lodash");
+const Level_js_1 = require("./Level.js");
+const util_js_1 = require("./util.js");
+const filenameCategoryInterpolator = (filename) => {
+    const allParts = filename.replaceAll("\\", "/").split("/");
+    const rootIndex = Math.max(...["src", "lib"].map(name => allParts.indexOf(name)));
+    const parts = rootIndex === -1 ? [allParts.pop()] : allParts.slice(rootIndex + 1);
+    const category = prelude_ts_1.Option.of(parts.join(":"))
+        .flatMap(cat => prelude_ts_1.Option.of(cat.lastIndexOf(".")).map(index => index === -1 ? cat : cat.slice(0, index)))
+        .getOrElse("unknown");
+    return category;
+};
+exports.filenameCategoryInterpolator = filenameCategoryInterpolator;
+exports.defaultLoggerOptions = {
+    categoryInterpolator: exports.filenameCategoryInterpolator,
+    overrideAppenders: []
+};
+function toLogRecord(logger, levelOrRecord, args) {
+    const globalMetadata = logger.manager.globalMetadata;
+    let metadata = {
+        ...globalMetadata
+    };
+    if ((0, index_js_1.isString)(levelOrRecord) && (0, lodash_1.isObject)(args[0])) {
+        metadata = { ...metadata, ...args.shift() };
+    }
+    if (globalMetadata?.data)
+        metadata.data = {
+            ...globalMetadata.data,
+            ...metadata.data
+        };
+    const errRecord = prelude_ts_1.Option.ofNullable(args.find(arg => ((0, index_js_1.isString)(arg?.message) && !!arg.stack) || arg instanceof Error)).match({
+        Some: err => ({
+            errorMessage: (0, index_js_1.getValue)(() => err.message),
+            errorStack: (0, index_js_1.getValue)(() => err.stack)
+        }),
+        None: () => ({})
+    });
+    const recordBase = (0, index_js_1.isString)(levelOrRecord)
+        ? {
+            ...(0, lodash_1.pick)(logger, ["category"]),
+            timestamp: Date.now(),
+            message: args[0],
+            level: levelOrRecord,
+            args: args.slice(1)
+        }
+        : levelOrRecord;
+    const record = {
+        ...recordBase,
+        ...errRecord,
+        ...metadata,
+        timestamp: (0, index_js_1.isNumber)(recordBase.timestamp) && recordBase.timestamp > 0
+            ? recordBase.timestamp
+            : Date.now()
+    };
+    if (metadata.data) {
+        record.data = {
+            ...metadata.data,
+            ...(recordBase.data ?? {})
+        };
+    }
+    return record;
+}
+class Logger {
+    manager;
+    category;
+    options;
+    state = {
+        overrideLevel: null
+    };
+    get overrideLevel() {
+        return prelude_ts_1.Option.ofNullable(this.state.overrideLevel)
+            .filter(util_js_1.isLogLevelKind) //Predicate.of<LevelKind>(isString).and(isLogLevelKind))
+            .getOrNull();
+    }
+    get overrideThreshold() {
+        return prelude_ts_1.Option.ofNullable(this.overrideLevel)
+            .map(level => Level_js_1.LevelThresholds[level])
+            .getOrNull();
+    }
+    setOverrideLevel(inOverrideLevel) {
+        const overrideLevel = (!inOverrideLevel ? null : inOverrideLevel.toLocaleLowerCase());
+        (0, index_js_1.assert)(!(0, index_js_1.isDefined)(overrideLevel) || (0, util_js_1.isLogLevelKind)(overrideLevel), `Invalid override level, must be a log level, all lower case`);
+        Object.assign(this.state, {
+            overrideLevel
+        });
+        return this;
+    }
+    log(levelOrRecord, ...args) {
+        const record = toLogRecord(this, levelOrRecord, args);
+        if (this.options.overrideAppenders.length) {
+            this.options.overrideAppenders.forEach(appender => appender.append(record));
+        }
+        else {
+            this.manager.fire(record);
+        }
+    }
+    /**
+     * Factory for the log
+     * level functions
+     *
+     * @param {LevelKind} level
+     * @returns {(message: string, ...args: any[]) => void}
+     * @private
+     */
+    createLevelLogger(level) {
+        const isEnabled = this.createLevelEnabled(level);
+        return (message, ...args) => {
+            if (isEnabled()) {
+                this.log(level, message, ...args);
+            }
+        };
+    }
+    /**
+     * Factory for is<Level>Enabled
+     *
+     * @param {LevelKind} level
+     * @returns {() => boolean}
+     * @private
+     */
+    createLevelEnabled(level) {
+        return () => {
+            const { rootThreshold } = this.manager;
+            const globalOverrideThreshold = this.manager.determineThresholdOverride(this.category);
+            const categoryThresholds = (0, index_js_1.isNumber)(this.overrideThreshold)
+                ? [this.overrideThreshold]
+                : [globalOverrideThreshold, rootThreshold].filter(index_js_1.isNumber);
+            const categoryThreshold = Math.min(...categoryThresholds);
+            const recordThreshold = Level_js_1.LevelThresholds[level];
+            return recordThreshold >= categoryThreshold;
+        };
+    }
+    trace = this.createLevelLogger("trace");
+    debug = this.createLevelLogger("debug");
+    info = this.createLevelLogger("info");
+    warn = this.createLevelLogger("warn");
+    error = this.createLevelLogger("error");
+    fatal = this.createLevelLogger("fatal");
+    isTraceEnabled = this.createLevelEnabled("trace");
+    isDebugEnabled = this.createLevelEnabled("debug");
+    isInfoEnabled = this.createLevelEnabled("info");
+    isWarnEnabled = this.createLevelEnabled("warn");
+    isErrorEnabled = this.createLevelEnabled("error");
+    isFatalEnabled = this.createLevelEnabled("fatal");
+    assert(test, message, ...args) {
+        const isTruthy = (0, index_js_1.isFunction)(test) ? test() : test;
+        if (isTruthy) {
+            return;
+        }
+        this.error(message, ...args);
+    }
+    assertFatal(test, message, exitCode = 1) {
+        const isTruthy = (0, index_js_1.isFunction)(test) ? test() : test;
+        if (isTruthy) {
+            return;
+        }
+        this.fatal("FATAL ASSERTION: ", message);
+        if (typeof process !== "undefined") {
+            process.exit(exitCode);
+        }
+        else {
+            console.error("FATAL ASSERTION: `process` is not defined, probably in a web browser");
+        }
+    }
+    constructor(manager, category, options) {
+        this.manager = manager;
+        this.category = category;
+        this.options = options;
+    }
+    static hydrateOptions(options = {}) {
+        return {
+            ...exports.defaultLoggerOptions,
+            ...options
+        };
+    }
+    static interoplateCategory(category, options) {
+        options = {
+            ...exports.defaultLoggerOptions,
+            ...options
+        };
+        return options.categoryInterpolator(category, options);
+    }
+}
+exports.Logger = Logger;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Logger.js","sourceRoot":"","sources":["../../../src/logging/Logger.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  assert,\n  getValue,\n  isString,\n  isDefined,\n  isFunction,\n  isNumber\n} from \"../guards/index.js\"\nimport { Option } from \"@3fv/prelude-ts\"\nimport { cloneDeep, isObject, pick } from \"lodash\"\nimport { LevelKind, LevelThresholds } from \"./Level.js\"\nimport type { LoggingManager } from \"./LoggingManager.js\"\nimport type { LogMetadata, LogRecord } from \"./LogRecord.js\"\nimport { isLogLevelKind } from \"./util.js\"\nimport type { Appender } from \"./Appender.js\"\n\nexport interface LoggerOptions {\n  categoryInterpolator: CategoryInterpolator\n  overrideAppenders: Array<Appender<LogRecord>>\n}\n\nexport type CategoryInterpolator = (\n  inCategory: string,\n  options?: LoggerOptions\n) => string\n\nexport const filenameCategoryInterpolator: CategoryInterpolator = (\n  filename: string\n) => {\n  const allParts = filename.replaceAll(\"\\\\\", \"/\").split(\"/\")\n  const rootIndex = Math.max(\n    ...[\"src\", \"lib\"].map(name => allParts.indexOf(name))\n  )\n  const parts =\n    rootIndex === -1 ? [allParts.pop()] : allParts.slice(rootIndex + 1)\n  const category = Option.of(parts.join(\":\"))\n    .flatMap(cat =>\n      Option.of(cat.lastIndexOf(\".\")).map(index =>\n        index === -1 ? cat : cat.slice(0, index)\n      )\n    )\n    .getOrElse(\"unknown\")\n  return category\n}\n\nexport const defaultLoggerOptions: LoggerOptions = {\n  categoryInterpolator: filenameCategoryInterpolator,\n  overrideAppenders: []\n}\n\nexport function toLogRecord(\n  logger: Logger,\n  levelOrRecord: LevelKind | LogRecord,\n  args: any[]\n) {\n  const globalMetadata = logger.manager.globalMetadata\n  let metadata: LogMetadata = {\n    ...globalMetadata\n  }\n  if (isString(levelOrRecord) && isObject(args[0])) {\n    metadata = { ...metadata, ...args.shift() }\n  }\n\n  if (globalMetadata?.data)\n    metadata.data = {\n      ...globalMetadata.data,\n      ...metadata.data\n    }\n\n  const errRecord = Option.ofNullable(\n    args.find(\n      arg => (isString(arg?.message) && !!arg.stack) || arg instanceof Error\n    )\n  ).match({\n    Some: err => ({\n      errorMessage: getValue(() => err.message),\n      errorStack: getValue(() => err.stack)\n    }),\n    None: () => ({})\n  })\n\n  const recordBase = isString(levelOrRecord)\n    ? ({\n        ...pick(logger, [\"category\"]),\n        timestamp: Date.now(),\n        message: args[0],\n        level: levelOrRecord,\n        args: args.slice(1)\n      } as LogRecord)\n    : levelOrRecord\n\n  const record = {\n    ...recordBase,\n    ...errRecord,\n    ...metadata,\n    timestamp:\n      isNumber(recordBase.timestamp) && recordBase.timestamp > 0\n        ? recordBase.timestamp\n        : Date.now()\n  }\n\n  if (metadata.data) {\n    record.data = {\n      ...metadata.data,\n      ...(recordBase.data ?? {})\n    }\n  }\n\n  return record\n}\n\nexport interface LoggerState {\n  overrideLevel?: LevelKind\n}\n\nexport class Logger {\n  readonly state: LoggerState = {\n    overrideLevel: null\n  }\n\n  get overrideLevel(): LevelKind {\n    return Option.ofNullable(this.state.overrideLevel)\n      .filter(isLogLevelKind) //Predicate.of<LevelKind>(isString).and(isLogLevelKind))\n      .getOrNull()\n  }\n\n  get overrideThreshold() {\n    return Option.ofNullable(this.overrideLevel)\n      .map(level => LevelThresholds[level])\n      .getOrNull()\n  }\n\n  setOverrideLevel(inOverrideLevel: LevelKind) {\n    const overrideLevel = (\n      !inOverrideLevel ? null : inOverrideLevel.toLocaleLowerCase()\n    ) as LevelKind\n\n    assert(\n      !isDefined(overrideLevel) || isLogLevelKind(overrideLevel),\n      `Invalid override level, must be a log level, all lower case`\n    )\n\n    Object.assign(this.state, {\n      overrideLevel\n    })\n\n    return this\n  }\n\n  /**\n   * Base logging function\n   *\n   * @param record\n   */\n  log(record: LogRecord): void\n  log(level: LevelKind, message: string, ...args: any[]): void\n  log(\n    level: LevelKind,\n    metadata: LogMetadata,\n    message: string,\n    ...args: any[]\n  ): void\n  log(levelOrRecord: LevelKind | LogRecord, ...args: any[]) {\n    const record = toLogRecord(this, levelOrRecord, args)\n    if (this.options.overrideAppenders.length) {\n      this.options.overrideAppenders.forEach(appender =>\n        appender.append(record)\n      )\n    } else {\n      this.manager.fire(record)\n    }\n  }\n\n  /**\n   * Factory for the log\n   * level functions\n   *\n   * @param {LevelKind} level\n   * @returns {(message: string, ...args: any[]) => void}\n   * @private\n   */\n  private createLevelLogger(\n    level: LevelKind\n  ): (message: string, ...args: any[]) => void {\n    const isEnabled = this.createLevelEnabled(level)\n    return (message: string, ...args: any[]) => {\n      if (isEnabled()) {\n        this.log(level, message, ...args)\n      }\n    }\n  }\n\n  /**\n   * Factory for is<Level>Enabled\n   *\n   * @param {LevelKind} level\n   * @returns {() => boolean}\n   * @private\n   */\n  private createLevelEnabled(level: LevelKind): () => boolean {\n    return () => {\n      const { rootThreshold } = this.manager\n\n      const globalOverrideThreshold = this.manager.determineThresholdOverride(\n        this.category\n      )\n      const categoryThresholds = isNumber(this.overrideThreshold)\n        ? [this.overrideThreshold]\n        : [globalOverrideThreshold, rootThreshold].filter(isNumber)\n\n      const categoryThreshold = Math.min(...categoryThresholds)\n\n      const recordThreshold = LevelThresholds[level]\n\n      return recordThreshold >= categoryThreshold\n    }\n  }\n\n  readonly trace = this.createLevelLogger(\"trace\")\n  readonly debug = this.createLevelLogger(\"debug\")\n  readonly info = this.createLevelLogger(\"info\")\n  readonly warn = this.createLevelLogger(\"warn\")\n  readonly error = this.createLevelLogger(\"error\")\n  readonly fatal = this.createLevelLogger(\"fatal\")\n\n  readonly isTraceEnabled = this.createLevelEnabled(\"trace\")\n  readonly isDebugEnabled = this.createLevelEnabled(\"debug\")\n  readonly isInfoEnabled = this.createLevelEnabled(\"info\")\n  readonly isWarnEnabled = this.createLevelEnabled(\"warn\")\n  readonly isErrorEnabled = this.createLevelEnabled(\"error\")\n  readonly isFatalEnabled = this.createLevelEnabled(\"fatal\")\n\n  assert(test: boolean | (() => boolean), message: string, ...args: any[]) {\n    const isTruthy = isFunction(test) ? test() : test\n    if (isTruthy) {\n      return\n    }\n\n    this.error(message, ...args)\n  }\n\n  assertFatal(\n    test: boolean | (() => boolean),\n    message: string,\n    exitCode: number = 1\n  ) {\n    const isTruthy = isFunction(test) ? test() : test\n    if (isTruthy) {\n      return\n    }\n\n    this.fatal(\"FATAL ASSERTION: \", message)\n    if (typeof process !== \"undefined\") {\n      process.exit(exitCode)\n    } else {\n      console.error(\n        \"FATAL ASSERTION: `process` is not defined, probably in a web browser\"\n      )\n    }\n  }\n\n  constructor(\n    readonly manager: LoggingManager,\n    readonly category: string,\n    readonly options: LoggerOptions\n  ) {}\n\n  static hydrateOptions(options: Partial<LoggerOptions> = {}): LoggerOptions {\n    return {\n      ...defaultLoggerOptions,\n      ...options\n    }\n  }\n\n  static interoplateCategory(category: string, options: LoggerOptions) {\n    options = {\n      ...defaultLoggerOptions,\n      ...options\n    }\n    return options.categoryInterpolator(category, options)\n  }\n}\n"]}

package/lib/cjs/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/cjs/logging/LoggingManager.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingManager = exports.kEnvThresholdOverrides = void 0;
+exports.getLoggingManager = getLoggingManager;
+const index_js_1 = require("../guards/index.js");
+const prelude_ts_1 = require("@3fv/prelude-ts");
+const lodash_1 = require("lodash");
+const ConsoleAppender_js_1 = require("./appenders/ConsoleAppender.js");
+const Level_js_1 = require("./Level.js");
+const Logger_js_1 = require("./Logger.js");
+const index_js_2 = require("./context/index.js");
+const fp_js_1 = require("lodash/fp.js");
+function parseThresholdOverridePatterns(value, level = "debug") {
+    return value.split(",").map(s => [new RegExp(s), level]);
+}
+exports.kEnvThresholdOverrides = prelude_ts_1.Option.ofNullable(typeof process !== "undefined" && process.env.DEBUG_PATTERNS)
+    .filter((0, lodash_1.negate)(lodash_1.isEmpty))
+    .map(parseThresholdOverridePatterns)
+    .getOrElse([]);
+/**
+ * Logging manager
+ */
+class LoggingManager {
+    loggers = new Map();
+    state = {
+        appenders: [],
+        globalMetadata: {},
+        rootLevel: Level_js_1.Level.info,
+        thresholdOverrides: exports.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 Level_js_1.LevelThresholds[this.rootLevel];
+    }
+    /**
+     * Get the current handler
+     *
+     * @returns {Appender<Record>}
+     */
+    get appenders() {
+        return prelude_ts_1.Option.ofNullable(this.state.appenders)
+            .filter(appenders => appenders.length > 0)
+            .getOrCall(() => {
+            this.state.appenders.push(new ConsoleAppender_js_1.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(...(0, lodash_1.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(...(0, lodash_1.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 index_js_2.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 = prelude_ts_1.Option.ofNullable(this.thresholdOverrides.find(([match]) => (0, index_js_1.isString)(match)
+            ? match === category
+            : match.test(category)))
+            .map((0, fp_js_1.nth)(1))
+            .map(level => Level_js_1.LevelThresholds[level])
+            .getOrNull(), 
+        // FIND `LogContext` OVERRIDE LEVEL
+        contextThresholds = contexts
+            .filter((0, fp_js_1.flow)((0, fp_js_1.get)("thresholdLevel"), index_js_1.isString))
+            .map(({ thresholdLevel }) => Level_js_1.LevelThresholds[thresholdLevel]), 
+        // IF ANY OVERRIDES, GET THE MOST VERBOSE LEVEL
+        override = prelude_ts_1.Option.ofNullable([...contextThresholds, overrideThreshold].filter(index_js_1.isNumber))
+            .filter((0, lodash_1.negate)(lodash_1.isEmpty))
+            .map(lodash_1.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((0, fp_js_1.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_js_1.Logger.hydrateOptions(inOptions);
+        const category = Logger_js_1.Logger.interoplateCategory(categoryOrFilename, options);
+        return prelude_ts_1.Option.ofNullable(category)
+            .map(category => this.loggers.get(category))
+            .getOrCall(() => {
+            const logger = new Logger_js_1.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_js_1.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;
+    }
+}
+exports.LoggingManager = LoggingManager;
+function getLoggingManager() {
+    return LoggingManager.get();
+}
+if (prelude_ts_1.Option.try(() => process.env.NODE_ENV === "development").getOrElse(false)) {
+    ;
+    [
+        typeof window !== "undefined" && window,
+        typeof global !== "undefined" && global
+    ]
+        .filter(index_js_1.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/cjs/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/cjs/logging/appenders/ConsoleAppender.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleAppender = exports.kDefaultConsoleAppenderConfig = exports.consoleFormatter = void 0;
+exports.getConsoleLogBinding = getConsoleLogBinding;
+const prelude_ts_1 = require("@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}
+ */
+function getConsoleLogBinding(level) {
+    if (!consoleLogBindings.has(level)) {
+        consoleLogBindings.set(level, getBoundConsoleFn(level));
+    }
+    return consoleLogBindings.get(level);
+}
+const consoleFormatter = ({ level, message, data, args, category, timestamp }) => [
+    `[${category}]  (${level})  ${message}`,
+    ...(Array.isArray(args) ? args : [args])
+];
+exports.consoleFormatter = consoleFormatter;
+/**
+ * Default console config
+ * @type {ConsoleAppenderConfig}
+ */
+exports.kDefaultConsoleAppenderConfig = {
+    cacheEnabled: true,
+    prettyPrint: true,
+    formatter: exports.consoleFormatter
+};
+/**
+ * Console appender, the simple default appender used
+ * everywhere OOB
+ */
+class ConsoleAppender {
+    config;
+    /**
+     * Handle log records, transform, push to ES
+     *
+     * @param record
+     */
+    append(record) {
+        const { level, message, data, args, category, timestamp } = record;
+        const { formatter = exports.consoleFormatter } = this.config;
+        prelude_ts_1.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) {
+        prelude_ts_1.Option.ofNullable(console[level])
+            .orCall(() => prelude_ts_1.Option.ofNullable(console.log))
+            .map((fn) => fn.apply(console, args));
+    }
+    /**
+     *
+     * @param {Partial<ConsoleAppenderOptions<Record>>} options
+     */
+    constructor(options = {}) {
+        this.config = {
+            ...exports.kDefaultConsoleAppenderConfig,
+            ...options
+        };
+    }
+}
+exports.ConsoleAppender = ConsoleAppender;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/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"}