@wireio/shared 1.0.2 → 1.0.3

package/src/logging/Logger.ts

@@ -1,222 +0,0 @@
-import { assert, getValue, isString, isDefined, isFunction, isNumber } from "../guards/index.js"
-import { Option } from "prelude-ts"
-import { pick } from "lodash"
-import { LevelKind, LevelThresholds } from "./Level.js"
-import type { LoggingManager } from "./LoggingManager.js"
-import type { LogRecord } from "./LogRecord.js"
-import { isLogLevelKind } from "./util.js"
-
-export interface LoggerOptions {
-  categoryInterpolator: CategoryInterpolator
-}
-
-export type CategoryInterpolator = (
-  inCategory: string,
-  options?: LoggerOptions
-) => string
-
-export const filenameCategoryInterpolator: CategoryInterpolator = (
-  filename: string
-) => {
-  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 = Option.of(parts.join(":"))
-    .flatMap((cat) =>
-      Option.of(cat.lastIndexOf(".")).map((index) =>
-        index === -1 ? cat : cat.slice(0, index)
-      )
-    )
-    .getOrElse("unknown")
-  return category
-}
-
-export const defaultLoggerOptions: LoggerOptions = {
-  categoryInterpolator: filenameCategoryInterpolator
-}
-
-export function toLogRecord(
-  logger: Logger,
-  levelOrRecord: LevelKind | LogRecord,
-  args: any[]
-) {
-  const errRecord = Option.ofNullable(
-    args.find((arg) => (isString(arg?.message) && !!arg.stack) || arg instanceof Error)
-  ).match({
-    Some: (err) => ({
-      errorMessage: getValue(() => err.message),
-      errorStack: getValue(() => err.stack)  
-    }),
-    None: () => ({})
-  })
-
-  const recordBase = isString(levelOrRecord)
-    ? ({
-        ...pick(logger, ["category"]),
-        timestamp: Date.now(),
-        message: args[0],
-        level: levelOrRecord,
-        args: args.slice(1)
-      } as LogRecord)
-    : levelOrRecord
-  return {
-    ...recordBase,
-    ...errRecord,
-    timestamp: isNumber(recordBase.timestamp) && recordBase.timestamp > 0 ? recordBase.timestamp : Date.now(),
-  }
-}
-
-export interface LoggerState {
-  overrideLevel?: LevelKind
-}
-
-export class Logger {
-  readonly state: LoggerState = {
-    overrideLevel: null
-  }
-
-  get overrideLevel(): LevelKind {
-    return Option.ofNullable(this.state.overrideLevel)
-      .filter(isLogLevelKind) //Predicate.of<LevelKind>(isString).and(isLogLevelKind))
-      .getOrNull()
-  }
-
-  get overrideThreshold() {
-    return Option.ofNullable(this.overrideLevel)
-      .map((level) => LevelThresholds[level])
-      .getOrNull()
-  }
-
-  setOverrideLevel(inOverrideLevel: LevelKind) {
-    const overrideLevel = (
-      !inOverrideLevel ? null : inOverrideLevel.toLocaleLowerCase()
-    ) as LevelKind
-
-    assert(
-      !isDefined(overrideLevel) || isLogLevelKind(overrideLevel),
-      `Invalid override level, must be a log level, all lower case`
-    )
-
-    Object.assign(this.state, {
-      overrideLevel
-    })
-
-    return this
-  }
-
-  /**
-   * Base logging function
-   *
-   * @param record
-   */
-  log(record: LogRecord):void
-  log(level: LevelKind, message: string, ...args: any[]):void
-  log(levelOrRecord: LevelKind | LogRecord, ...args: any[]) {
-    const record = toLogRecord(this, levelOrRecord, args)
-    this.manager.fire(record)
-  }
-
-  /**
-   * Factory for the log
-   * level functions
-   *
-   * @param {LevelKind} level
-   * @returns {(message: string, ...args: any[]) => void}
-   * @private
-   */
-  private createLevelLogger(level: LevelKind): (message: string, ...args: any[]) => void {
-    const isEnabled = this.createLevelEnabled(level)
-    return (message: string, ...args: any[]) => {
-      if (isEnabled()) {
-        this.log(level, message, ...args)
-      }
-    }
-  }
-
-  /**
-   * Factory for is<Level>Enabled
-   *
-   * @param {LevelKind} level
-   * @returns {() => boolean}
-   * @private
-   */
-  private createLevelEnabled(level: LevelKind): () => boolean {
-    return () => {
-      const { rootThreshold } = this.manager
-
-      const globalOverrideThreshold = this.manager.determineThresholdOverride(this.category)
-      const categoryThresholds = [
-        globalOverrideThreshold,
-        rootThreshold,
-        this.overrideThreshold
-      ].filter(isNumber)
-
-      const categoryThreshold = Math.min(...categoryThresholds)
-
-      const recordThreshold = LevelThresholds[level]
-
-      return recordThreshold >= categoryThreshold
-    }
-  }
-
-  readonly trace = this.createLevelLogger("trace")
-  readonly debug = this.createLevelLogger("debug")
-  readonly info = this.createLevelLogger("info")
-  readonly warn = this.createLevelLogger("warn")
-  readonly error = this.createLevelLogger("error")
-  readonly fatal = this.createLevelLogger("fatal")
-
-  readonly isTraceEnabled = this.createLevelEnabled("trace")
-  readonly isDebugEnabled = this.createLevelEnabled("debug")
-  readonly isInfoEnabled = this.createLevelEnabled("info")
-  readonly isWarnEnabled = this.createLevelEnabled("warn")
-  readonly isErrorEnabled = this.createLevelEnabled("error")
-  readonly isFatalEnabled = this.createLevelEnabled("fatal")
-  
-  assert(test: boolean | (() => boolean), message: string, ...args: any[]) {
-    const isTruthy = isFunction(test) ? test() : test
-    if (isTruthy) {
-      return
-    }
-    
-    this.error(message, ...args)
-}
-  
-  assertFatal(test: boolean | (() => boolean), message: string, exitCode: number = 1) {
-    const isTruthy = 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(
-    readonly manager: LoggingManager,
-    readonly category: string,
-    readonly options: LoggerOptions
-  ) {}
-
-  static hydrateOptions(options: Partial<LoggerOptions> = {}): LoggerOptions {
-    return {
-      ...defaultLoggerOptions,
-      ...options
-    }
-  }
-
-  static interoplateCategory(category: string, options: LoggerOptions) {
-    options = {
-      ...defaultLoggerOptions,
-      ...options
-    }
-    return options.categoryInterpolator(category, options)
-  }
-}

package/src/logging/LoggingManager.ts

@@ -1,306 +0,0 @@
-import { isNumber, isObject, isString } from "../guards/index.js"
-import { Option } from "prelude-ts"
-import { flatten, isEmpty, min, negate } from "lodash"
-import type { Appender } from "./Appender.js"
-import { ConsoleAppender } from "./appenders/ConsoleAppender.js"
-import { Level, LevelKind, LevelThresholds } from "./Level.js"
-import { Logger, LoggerOptions } from "./Logger.js"
-import type { LogRecord } from "./LogRecord.js"
-import { LogContext, LogContextContainer } from "./context/index.js"
-import { flow, get, nth } from "lodash/fp.js"
-
-export type CategoryMatch = RegExp | string
-
-export type ThresholdOverride = [match: CategoryMatch, level: LevelKind]
-
-export interface LoggingManagerState<Record extends LogRecord> {
-  rootLevel: LevelKind
-  appenders: Array<Appender<Record>>
-  thresholdOverrides: Array<ThresholdOverride>
-}
-
-export type LoggingManagerOptions<Record extends LogRecord> = Partial<
-  LoggingManagerState<Record>
->
-
-function parseThresholdOverridePatterns(
-  value: string,
-  level: LevelKind = "debug"
-): ThresholdOverride[] {
-  return value
-    .split(",")
-    .map((s) => [new RegExp(s), level] as ThresholdOverride)
-}
-
-export const kEnvThresholdOverrides = Option.ofNullable(typeof process !== "undefined" && process.env.DEBUG_PATTERNS)
-  .filter(negate(isEmpty))
-  .map(parseThresholdOverridePatterns)
-  .getOrElse([])
-
-/**
- * Logging manager
- */
-export class LoggingManager<Record extends LogRecord = any> {
-  private readonly loggers = new Map<string, Logger>()
-
-  private readonly state: LoggingManagerState<Record> = {
-    appenders: [],
-    rootLevel: Level.info,
-    thresholdOverrides: kEnvThresholdOverrides
-  }
-
-  get rootLevel() {
-    return this.state.rootLevel
-  }
-
-  set rootLevel(newRootLevel: LevelKind) {
-    this.state.rootLevel = newRootLevel
-  }
-
-  get rootThreshold() {
-    return LevelThresholds[this.rootLevel]
-  }
-
-  /**
-   * Get the current handler
-   *
-   * @returns {Appender<Record>}
-   */
-  get appenders(): Array<Appender<Record>> {
-    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:ThresholdOverride[]) {
-    this.state.thresholdOverrides = newOverrides
-  }
-  
-  /**
-   * Set global appenders
-   *
-   * @param {Array<Appender<Record>>} newAppenders
-   */
-  setAppenders(...newAppenders: Array<Appender<Record> | Appender<Record>[]>) {
-    // 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: Array<Appender<Record> | Appender<Record>[]>): this {
-    this.state.appenders.push(...flatten(newAppenders))
-    return this
-  }
-  
-  /**
-   * Clear threshold overrides
-   *
-   * @returns {this<Record>}
-   */
-  clearThresholdOverrides(): this {
-    this.state.thresholdOverrides.length = 0
-    return this
-  }
-
-  setThresholdOverrides(...overrides: Array<ThresholdOverride>) {
-    this.state.thresholdOverrides.length = 0
-    this.state.thresholdOverrides.push(...overrides)
-    return this
-  }
-
-  addThresholdOverrides(...overrides: Array<ThresholdOverride>) {
-    this.state.thresholdOverrides.push(...overrides)
-    return this
-  }
-
-  /**
-   * Get applicable current contexts
-   *
-   * @param {string} category
-   * @returns {LogContext[]}
-   */
-  getApplicableCurrentContexts(category: string): LogContext[] {
-    return LogContextContainer.currentContext().filter(
-      ({ pattern }) => !pattern || pattern.test(category)
-    )
-  }
-
-  /**
-   * Check for any matching threshold overrides
-   *
-   * @param category
-   */
-  determineThresholdOverride(category: string): number {
-    const contexts = this.getApplicableCurrentContexts(category),
-      
-    // FIND CONFIGURED OVERRIDE LEVEL
-      overrideThreshold = Option.ofNullable(
-        this.thresholdOverrides.find(([match]) =>
-          isString(match) ? match === category : (match as RegExp).test(category)
-        )
-      )
-        .map(nth(1))
-        .map((level) => LevelThresholds[level as 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 as number
-  }
-  
-  /**
-   * Set the root logging level
-   *
-   * @param {LevelKind} newLevel
-   * @returns {this<Record>}
-   */
-  setRootLevel(newLevel: LevelKind): this {
-    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: LogRecord<Record>) {
-    const { category } = record,
-      contexts = this.getApplicableCurrentContexts(category),
-      contextAppenders = contexts.flatMap(get("appenders")),
-      appenders = [...this.appenders, ...contextAppenders]
-
-    appenders.forEach((appender) => appender.append(record as 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: string,
-    inOptions: Partial<LoggerOptions> = {}
-  ): Logger {
-    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: LoggingManagerOptions<any>): this {
-    if (Level[options?.rootLevel]) {
-      this.setRootLevel(options.rootLevel)
-    }
-
-    if (options?.appenders) {
-      this.setAppenders(options.appenders)
-    }
-
-    if (options?.thresholdOverrides) {
-      this.addThresholdOverrides(...options.thresholdOverrides)
-    }
-
-    return this
-  }
-
-  private constructor() {
-    this.configure({})
-  }
-  
-  /**
-   * Singleton instance
-   *
-   * @type {LoggingManager}
-   * @private
-   */
-  private static manager: LoggingManager
-  
-  /**
-   * Get logging manager and optionally provided
-   * configuration options
-   *
-   * @param {LoggingManagerOptions<Record>} options
-   * @returns {LoggingManager<Record>}
-   */
-  static get<Record extends LogRecord = any>(
-    options: LoggingManagerOptions<Record> = null
-  ): LoggingManager<Record> {
-    if (!this.manager) {
-      this.manager = new LoggingManager<Record>()
-    }
-
-    if (options) {
-      this.manager.configure(options)
-    }
-
-    return this.manager
-  }
-}
-
-export function getLoggingManager(): LoggingManager {
-  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()
-    }))
-}

package/src/logging/appenders/ConsoleAppender.ts

@@ -1,110 +0,0 @@
-import type { LogRecord } from "../LogRecord"
-import type { Appender } from "../Appender"
-import { Option } from "prelude-ts"
-import type { LevelKind } from "../Level"
-import type { Formatter } from "../Formatter"
-
-const consoleLogBindings = new Map<LevelKind, (...args: any[]) => any>()
-
-function getBoundConsoleFn(level: LevelKind) {
-  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: LevelKind) {
-  if (!consoleLogBindings.has(level)) {
-    consoleLogBindings.set(level, getBoundConsoleFn(level))
-  }
-
-  return consoleLogBindings.get(level)
-}
-
-/**
- * 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 const consoleFormatter: Formatter<Array<any>> = ({
-  level,
-  message,
-  data,
-  args,
-  category,
-  timestamp
-}) => [
-  `[${category}]  (${level})  ${message}`,
-  ...(Array.isArray(args) ? args : [args])
-]
-
-/**
- * Default console config
- * @type {ConsoleAppenderConfig}
- */
-export const kDefaultConsoleAppenderConfig: ConsoleAppenderConfig = {
-  cacheEnabled: true,
-  prettyPrint: true,
-  formatter: consoleFormatter
-}
-
-/**
- * Console appender, the simple default appender used
- * everywhere OOB
- */
-export class ConsoleAppender<Record extends LogRecord>
-  implements Appender<Record>
-{
-  readonly config: ConsoleAppenderConfig
-
-  /**
-   * Handle log records, transform, push to ES
-   *
-   * @param record
-   */
-  append(record: Record): void {
-    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 
-   */
-  protected write(level: LevelKind, ...args: any[]) {
-    Option.ofNullable(console[level])
-        .orCall(() => Option.ofNullable(console.log))
-        .map((fn: Function) => fn.apply(console, args))
-  }
-
-  /**
-   *
-   * @param {Partial<ConsoleAppenderOptions<Record>>} options
-   */
-  constructor(options: Partial<ConsoleAppenderOptions<Record>> = {}) {
-    this.config = {
-      ...kDefaultConsoleAppenderConfig,
-      ...options
-    }
-  }
-}