@wireio/shared 1.0.2 → 1.0.3

package/src/logging/appenders/DebugAppender.ts

@@ -1,254 +0,0 @@
-import type { LogRecord } from "../LogRecord"
-import type { Appender } from "../Appender"
-import type { LevelKind } from "../Level"
-import Debug from "debug"
-import {
-  ConsoleAppender, ConsoleAppenderConfig, kDefaultConsoleAppenderConfig
-} from "./ConsoleAppender.js"
-import type { Formatter } from "../Formatter"
-import { isEmpty, negate } from "lodash"
-
-
-// let chalk: any = null
-// if (
-//   typeof process !== "undefined" &&
-//   (process as any).type !== "renderer" &&
-//   (process as any).browser !== true
-// ) {
-//   chalk = require("chalk")
-// }
-
-const useColors = false
-
-const makeColorFn = (fn: (chalk: any, s: string) => string) => {
-  // if (!useColors) {
-  //   return (s: string) => s
-  // }
-  //
-  // return (s: string) => fn(chalk, s)
-  return (s: string) => s
-}
-
-const colorFns: Record<LevelKind, (s: string) => string> = {
-  debug: makeColorFn((c, s) => c.green(s)),
-  error: makeColorFn((c, s) => c.red(s)),
-  fatal: makeColorFn((c, s) => c.bgRed.black(s)),
-  info: makeColorFn((c, s) => c.blue(s)),
-  trace: makeColorFn((c, s) => c.gray(s)),
-  warn: makeColorFn((c, s) => c.yellow(s))
-}
-
-/**
- * DebugAppender Configuration
- */
-export interface DebugAppenderConfig extends ConsoleAppenderConfig {
-  hideDate: boolean
-  timeOnly: boolean
-  useConsole: boolean
-  useStdout: boolean
-  categoryPrefix: string
-}
-
-/**
- * Partial of config, used for shortening instead of Partial<...>
- */
-export type DebugAppenderOptions = Partial<DebugAppenderConfig>
-
-const debuggers = new Map<string, Debug.Debugger>()
-
-//const debugAppPrefix = "app"
-
-function getDebug({categoryPrefix}: DebugAppenderConfig, cat: string) {
-  let debug = debuggers.get(cat)
-  if (!debug) {
-    debug = Debug([categoryPrefix, cat].filter(negate(isEmpty)).join(":"))
-    debuggers.set(cat, debug)
-  }
-
-  return debug
-}
-
-// const timeFormatter = new Intl.DateTimeFormat('en-US', {
-//   timeStyle: "short"
-// })
-
-/**
- *
- * Get ISO date if `hideDate !== true`
- *
- * @param {DebugFormatterContext}
- * @returns
- */
-function getDate({ debugConfig: config }: DebugFormatterContext) {
-  if (config.hideDate) {
-    return ""
-  }
-
-  const date = new Date()
-  return config.timeOnly
-    ? date.toLocaleTimeString("default", {
-        hour12: false
-      })
-    : date.toISOString()
-}
-
-/**
- *
- * Formats args for output, directly based on Debug.formatArgs
- *
- * @param {DebugFormatterContext} context
- * @param {any[]} args
- */
-function formatArgs(
-  context: DebugFormatterContext,
-  record: LogRecord,
-  args: any[]
-) {
-  const { debug } = context
-  const { namespace: name } = debug as any
-
-  const prefix = colorFns[record.level](
-    [
-      getDate(context),
-      Debug.humanize(debug.diff),
-      `(` + record.level.toUpperCase() + `)`,
-      `[${name}]`
-    ]
-      .filter(negate(isEmpty))
-      .join(" ")
-  )
-  const msg = [prefix, args[0]].filter(negate(isEmpty)).join(" ")
-
-  args[0] = msg
-}
-
-/**
- * Context for using `debugFormatter`
- */
-export type DebugFormatterContext = {
-  debugConfig: DebugAppenderConfig
-  debug: Debug.Debugger
-}
-
-/**
- * Uses `debug` package for logging, very useful
- *
- * @param {LogRecord} record to format
- * @param {DebugFormatterContext} context for this formatter
- * @returns
- */
-export const debugFormatter: Formatter<Array<any>, DebugFormatterContext> = (
-  record,
-  { debug, debugConfig: config }
-): any[] => {
-  const { level, message, data, args: argsIn, category, timestamp } = record
-  const args = [message, ...argsIn]
-  args[0] = Debug.coerce(args[0])
-
-  if (typeof args[0] !== "string") {
-    // Anything else let's inspect with %O
-    args.unshift("%O")
-  }
-
-  // Apply any `formatters` transformations
-  let index = 0
-  args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-    // If we encounter an escaped % then don't increase the array index
-    if (match === "%%") {
-      return "%"
-    }
-    index++
-    const formatter = Debug.formatters[format]
-    if (typeof formatter === "function") {
-      const val = args[index]
-      match = formatter.call(debug, val)
-
-      // Now we need to remove `args[index]` since it's inlined in the `format`
-      args.splice(index, 1)
-      index--
-    }
-    return match
-  })
-
-  // Apply env-specific formatting (colors, etc.)
-  formatArgs({ debug, debugConfig: config }, record, args)
-
-  return args
-}
-// [
-//   `[${category}]  (${level})  ${message}`,
-//   ...(Array.isArray(args) ? args : [args])
-// ]
-
-/**
- * Default console config
- * @type {DebugAppenderConfig}
- */
-const defaultConfig: DebugAppenderConfig = {
-  hideDate: false,
-  timeOnly: true,
-  useConsole: false,
-  useStdout: true,
-  categoryPrefix: null,
-  ...kDefaultConsoleAppenderConfig,
-  formatter: debugFormatter
-}
-/**
- * Debug appender, the simple default appender used
- * everywhere OOB
- */
-export class DebugAppender<Record extends LogRecord>
-  extends ConsoleAppender<Record>
-  implements Appender<Record>
-{
-  readonly debugConfig: DebugAppenderConfig
-
-
-  /**
-   * Handle log records, transform, push to ES
-   *
-   * @param record
-   */
-  append(record: Record): void {
-    const { level, message, args: argsIn, category } = record
-
-    // if (!this.levels.includes(level)) {
-    //   super.append(record)
-    //   return
-    // }
-
-    const debug = getDebug(this.debugConfig, category) as any
-    let prevTime = debug.prevTime
-    // Set `diff` timestamp
-    const curr = Number(new Date())
-    const ms = curr - (prevTime || curr)
-    debug.diff = ms
-    debug.prev = prevTime
-    debug.curr = curr
-    debug.prevTime = curr
-    const logFn = debug.log || Debug.log
-    const args = debugFormatter!(record, { debug, debugConfig: this.debugConfig })
-    
-    if (this.debugConfig.useConsole) {
-      super.write(level, ...args)
-    }
-
-    if (this.debugConfig.useStdout) {
-      logFn.apply(debug, args) 
-    }
-  }
-
-  /**
-   *
-   * @param {Partial<DebugAppenderOptions>} options
-   */
-  constructor(options: Partial<Omit<DebugAppenderOptions, "formatter">> = {}) {
-    super({
-      ...defaultConfig,
-      ...options,
-      formatter: debugFormatter
-    })
-
-    this.debugConfig = this.config as DebugAppenderConfig
-  }
-}

package/src/logging/appenders/FileAppender.ts

@@ -1,281 +0,0 @@
-import { assign, defaults, padStart } from "lodash"
-import * as Path from "path"
-import * as Fs from "fs"
-import type { LogRecord } from "../LogRecord"
-import type { Appender } from "../Appender"
-import { Option, Future } from "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 = (): FileAppenderConfig => ({
-  filename: Path.join(tempDir, "app.log"),
-  prettyPrint: process.env.NODE_ENV !== "production",
-  maxSize: -1,
-  maxFiles: 5,
-  enableRolling: false,
-  sync: false
-})
-
-function applyConfigDefaults(options: FileAppenderOptions): FileAppenderConfig {
-  return defaults(options, getDefaultConfig())
-}
-
-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 class FileAppender<Record extends LogRecord>
-  implements Appender<Record>
-{
-  readonly config: FileAppenderConfig<Record>
-
-  private readonly state: {
-    filename: string
-    file: number
-    flushing: boolean
-    queue: Array<Buffer>
-    ready: boolean
-    error?: Error
-    currentSize: number
-    archivedFilenames: string[]
-  } = {
-    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(): FileAppender<Record> {
-    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: string = 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
-   */
-  private 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: Buffer = 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: Record): void {
-    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: Partial<FileAppenderOptions<Record>> = {}) {
-    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
-  }
-}

package/src/logging/appenders/aws-firehose/AWSFirehoseAppender.ts

@@ -1,176 +0,0 @@
-/* eslint-disable typescript/no-explicit-any */
-import { isString } from '../../../guards/primitive.js'
-import { FirehoseClient, PutRecordBatchCommand, PutRecordBatchInput } from "@aws-sdk/client-firehose"
-import {
-  Credentials as IAWSTemporaryCredentials,
-  ExpiredTokenException,
-} from "@aws-sdk/client-sts"
-import { Level } from "../../Level.js"
-
-import AWSFirehoseCredentialManager from "./AWSFirehoseCredentialManager.js"
-import { getInternalLogger } from "../../InternalLogger.js"
-import { getValue, guard } from "../../../guards/index.js"
-import { pick } from "lodash"
-import { Deferred } from "../../../helpers/index.js"
-import { LogRecord } from "../../LogRecord.js"
-import { Appender } from "../../Appender.js"
-
-const LogQueueMaxRecords = 10000
-
-const log = getInternalLogger(import.meta.filename)
-
-
-export class AWSFirehoseAppender<Record extends LogRecord = LogRecord>
-  implements Appender<Record> {
-  private pendingRecords = Array<LogRecord>()
-  private flushDeferred: Deferred<void>
-  private flushIntervalMs = 1000;
-
-  constructor(public readonly credentialManager: AWSFirehoseCredentialManager = new AWSFirehoseCredentialManager()) {
-    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: Error) => {
-          log.error(`Error flushing logs after credential receipt: ${e.message}`, e)
-        })
-    })
-  }
-  append(record: Record): void {
-    const
-      pendingCount = this.pendingRecords.length + 1,
-      removeCount = LogQueueMaxRecords - pendingCount
-
-    if (removeCount < 0) {
-      this.pendingRecords.splice(0, Math.abs(removeCount))
-    }
-
-    this.pendingRecords.push({
-      ...record,
-      app: "web",
-      timestamp: Date.now(),
-      env: typeof process === "undefined" ? "WEB" : process.env.WIRE_ENV ?? "SHARED",
-      url: typeof window === "undefined" ? "local://node" : window.location.href,
-    })
-
-    this.flush()
-  }
-
-  /**
-   * Create the firehose client and return
-   *
-   * @param {IAWSTemporaryCredentials} credentials
-   * @param {boolean} flush
-   * @returns {Firehose}
-   */
-  private getFirehose(): FirehoseClient {
-    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>}
-   */
-  private async flush(): Promise<void> {
-    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<void>()
-    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))
-
-        // log.info("Record JSONs", recordJsons)
-
-        const
-          textEncoder = new TextEncoder(),
-          batch: PutRecordBatchInput["Records"] = 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