pino-testkit 10.4.5

package/lib/levels.js

@@ -0,0 +1,241 @@
+'use strict'
+/* eslint no-prototype-builtins: 0 */
+const {
+  lsCacheSym,
+  levelValSym,
+  useOnlyCustomLevelsSym,
+  streamSym,
+  formattersSym,
+  hooksSym,
+  levelCompSym
+} = require('./symbols')
+const { noop, genLog } = require('./tools')
+const { DEFAULT_LEVELS, SORTING_ORDER } = require('./constants')
+
+const levelMethods = {
+  fatal: (hook) => {
+    const logFatal = genLog(DEFAULT_LEVELS.fatal, hook)
+    return function (...args) {
+      const stream = this[streamSym]
+      logFatal.call(this, ...args)
+      if (typeof stream.flushSync === 'function') {
+        try {
+          stream.flushSync()
+        } catch (e) {
+          // https://github.com/pinojs/pino/pull/740#discussion_r346788313
+        }
+      }
+    }
+  },
+  error: (hook) => genLog(DEFAULT_LEVELS.error, hook),
+  warn: (hook) => genLog(DEFAULT_LEVELS.warn, hook),
+  info: (hook) => genLog(DEFAULT_LEVELS.info, hook),
+  debug: (hook) => genLog(DEFAULT_LEVELS.debug, hook),
+  trace: (hook) => genLog(DEFAULT_LEVELS.trace, hook)
+}
+
+const nums = Object.keys(DEFAULT_LEVELS).reduce((o, k) => {
+  o[DEFAULT_LEVELS[k]] = k
+  return o
+}, {})
+
+const initialLsCache = Object.keys(nums).reduce((o, k) => {
+  o[k] = '{"level":' + Number(k)
+  return o
+}, {})
+
+function genLsCache (instance) {
+  const formatter = instance[formattersSym].level
+  const { labels } = instance.levels
+  const cache = {}
+  for (const label in labels) {
+    const level = formatter(labels[label], Number(label))
+    cache[label] = JSON.stringify(level).slice(0, -1)
+  }
+  instance[lsCacheSym] = cache
+  return instance
+}
+
+function isStandardLevel (level, useOnlyCustomLevels) {
+  if (useOnlyCustomLevels) {
+    return false
+  }
+
+  switch (level) {
+    case 'fatal':
+    case 'error':
+    case 'warn':
+    case 'info':
+    case 'debug':
+    case 'trace':
+      return true
+    default:
+      return false
+  }
+}
+
+function setLevel (level) {
+  const { labels, values } = this.levels
+  if (typeof level === 'number') {
+    if (labels[level] === undefined) throw Error('unknown level value' + level)
+    level = labels[level]
+  }
+  if (values[level] === undefined) throw Error('unknown level ' + level)
+  const preLevelVal = this[levelValSym]
+  const levelVal = this[levelValSym] = values[level]
+  const useOnlyCustomLevelsVal = this[useOnlyCustomLevelsSym]
+  const levelComparison = this[levelCompSym]
+  const hook = this[hooksSym].logMethod
+
+  for (const key in values) {
+    if (levelComparison(values[key], levelVal) === false) {
+      this[key] = noop
+      continue
+    }
+    this[key] = isStandardLevel(key, useOnlyCustomLevelsVal) ? levelMethods[key](hook) : genLog(values[key], hook)
+  }
+
+  this.emit(
+    'level-change',
+    level,
+    levelVal,
+    labels[preLevelVal],
+    preLevelVal,
+    this
+  )
+}
+
+function getLevel (level) {
+  const { levels, levelVal } = this
+  // protection against potential loss of Pino scope from serializers (edge case with circular refs - https://github.com/pinojs/pino/issues/833)
+  return (levels && levels.labels) ? levels.labels[levelVal] : ''
+}
+
+function isLevelEnabled (logLevel) {
+  const { values } = this.levels
+  const logLevelVal = values[logLevel]
+  return logLevelVal !== undefined && this[levelCompSym](logLevelVal, this[levelValSym])
+}
+
+/**
+ * Determine if the given `current` level is enabled by comparing it
+ * against the current threshold (`expected`).
+ *
+ * @param {SORTING_ORDER} direction comparison direction "ASC" or "DESC"
+ * @param {number} current current log level number representation
+ * @param {number} expected threshold value to compare with
+ * @returns {boolean}
+ */
+function compareLevel (direction, current, expected) {
+  if (direction === SORTING_ORDER.DESC) {
+    return current <= expected
+  }
+
+  return current >= expected
+}
+
+/**
+ * Create a level comparison function based on `levelComparison`
+ * it could a default function which compares levels either in "ascending" or "descending" order or custom comparison function
+ *
+ * @param {SORTING_ORDER | Function} levelComparison sort levels order direction or custom comparison function
+ * @returns Function
+ */
+function genLevelComparison (levelComparison) {
+  if (typeof levelComparison === 'string') {
+    return compareLevel.bind(null, levelComparison)
+  }
+
+  return levelComparison
+}
+
+function mappings (customLevels = null, useOnlyCustomLevels = false) {
+  const customNums = customLevels
+    /* eslint-disable */
+    ? Object.keys(customLevels).reduce((o, k) => {
+        o[customLevels[k]] = k
+        return o
+      }, {})
+    : null
+    /* eslint-enable */
+
+  const labels = Object.assign(
+    Object.create(Object.prototype, { Infinity: { value: 'silent' } }),
+    useOnlyCustomLevels ? null : nums,
+    customNums
+  )
+  const values = Object.assign(
+    Object.create(Object.prototype, { silent: { value: Infinity } }),
+    useOnlyCustomLevels ? null : DEFAULT_LEVELS,
+    customLevels
+  )
+  return { labels, values }
+}
+
+function assertDefaultLevelFound (defaultLevel, customLevels, useOnlyCustomLevels) {
+  if (typeof defaultLevel === 'number') {
+    const values = [].concat(
+      Object.keys(customLevels || {}).map(key => customLevels[key]),
+      useOnlyCustomLevels ? [] : Object.keys(nums).map(level => +level),
+      Infinity
+    )
+    if (!values.includes(defaultLevel)) {
+      throw Error(`default level:${defaultLevel} must be included in custom levels`)
+    }
+    return
+  }
+
+  const labels = Object.assign(
+    Object.create(Object.prototype, { silent: { value: Infinity } }),
+    useOnlyCustomLevels ? null : DEFAULT_LEVELS,
+    customLevels
+  )
+  if (!(defaultLevel in labels)) {
+    throw Error(`default level:${defaultLevel} must be included in custom levels`)
+  }
+}
+
+function assertNoLevelCollisions (levels, customLevels) {
+  const { labels, values } = levels
+  for (const k in customLevels) {
+    if (k in values) {
+      throw Error('levels cannot be overridden')
+    }
+    if (customLevels[k] in labels) {
+      throw Error('pre-existing level values cannot be used for new levels')
+    }
+  }
+}
+
+/**
+ * Validates whether `levelComparison` is correct
+ *
+ * @throws Error
+ * @param {SORTING_ORDER | Function} levelComparison - value to validate
+ * @returns
+ */
+function assertLevelComparison (levelComparison) {
+  if (typeof levelComparison === 'function') {
+    return
+  }
+
+  if (typeof levelComparison === 'string' && Object.values(SORTING_ORDER).includes(levelComparison)) {
+    return
+  }
+
+  throw new Error('Levels comparison should be one of "ASC", "DESC" or "function" type')
+}
+
+module.exports = {
+  initialLsCache,
+  genLsCache,
+  levelMethods,
+  getLevel,
+  setLevel,
+  isLevelEnabled,
+  mappings,
+  assertNoLevelCollisions,
+  assertDefaultLevelFound,
+  genLevelComparison,
+  assertLevelComparison
+}

package/lib/meta.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = { version: '10.4.5' }

package/lib/multistream.js

@@ -0,0 +1,203 @@
+'use strict'
+
+const metadata = Symbol.for('pino.metadata')
+const { DEFAULT_LEVELS } = require('./constants')
+
+const DEFAULT_INFO_LEVEL = DEFAULT_LEVELS.info
+
+function multistream (streamsArray, opts) {
+  streamsArray = streamsArray || []
+  opts = opts || { dedupe: false }
+
+  const streamLevels = Object.create(DEFAULT_LEVELS)
+  streamLevels.silent = Infinity
+  if (opts.levels && typeof opts.levels === 'object') {
+    Object.keys(opts.levels).forEach(i => {
+      streamLevels[i] = opts.levels[i]
+    })
+  }
+
+  const res = {
+    write,
+    add,
+    remove,
+    emit,
+    flushSync,
+    end,
+    minLevel: 0,
+    lastId: 0,
+    streams: [],
+    clone,
+    [metadata]: true,
+    streamLevels
+  }
+
+  if (Array.isArray(streamsArray)) {
+    streamsArray.forEach(add, res)
+  } else {
+    add.call(res, streamsArray)
+  }
+
+  // clean this object up
+  // or it will stay allocated forever
+  // as it is closed on the following closures
+  streamsArray = null
+
+  return res
+
+  // we can exit early because the streams are ordered by level
+  function write (data) {
+    let dest
+    const level = this.lastLevel
+    const { streams } = this
+    // for handling situation when several streams has the same level
+    let recordedLevel = 0
+    let stream
+
+    // if dedupe set to true we send logs to the stream with the highest level
+    // therefore, we have to change sorting order
+    for (let i = initLoopVar(streams.length, opts.dedupe); checkLoopVar(i, streams.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)) {
+      dest = streams[i]
+      if (dest.level <= level) {
+        if (recordedLevel !== 0 && recordedLevel !== dest.level) {
+          break
+        }
+        stream = dest.stream
+        if (stream[metadata]) {
+          const { lastTime, lastMsg, lastObj, lastLogger } = this
+          stream.lastLevel = level
+          stream.lastTime = lastTime
+          stream.lastMsg = lastMsg
+          stream.lastObj = lastObj
+          stream.lastLogger = lastLogger
+        }
+        stream.write(data)
+        if (opts.dedupe) {
+          recordedLevel = dest.level
+        }
+      } else if (!opts.dedupe) {
+        break
+      }
+    }
+  }
+
+  function emit (...args) {
+    for (const { stream } of this.streams) {
+      if (typeof stream.emit === 'function') {
+        stream.emit(...args)
+      }
+    }
+  }
+
+  function flushSync () {
+    for (const { stream } of this.streams) {
+      if (typeof stream.flushSync === 'function') {
+        stream.flushSync()
+      }
+    }
+  }
+
+  function add (dest) {
+    if (!dest) {
+      return res
+    }
+
+    // Check that dest implements either StreamEntry or DestinationStream
+    const isStream = typeof dest.write === 'function' || dest.stream
+    const stream_ = dest.write ? dest : dest.stream
+    // This is necessary to provide a meaningful error message, otherwise it throws somewhere inside write()
+    if (!isStream) {
+      throw Error('stream object needs to implement either StreamEntry or DestinationStream interface')
+    }
+
+    const { streams, streamLevels } = this
+
+    let level
+    if (typeof dest.levelVal === 'number') {
+      level = dest.levelVal
+    } else if (typeof dest.level === 'string') {
+      level = streamLevels[dest.level]
+    } else if (typeof dest.level === 'number') {
+      level = dest.level
+    } else {
+      level = DEFAULT_INFO_LEVEL
+    }
+
+    const dest_ = {
+      stream: stream_,
+      level,
+      levelVal: undefined,
+      id: ++res.lastId
+    }
+
+    streams.unshift(dest_)
+    streams.sort(compareByLevel)
+
+    this.minLevel = streams[0].level
+
+    return res
+  }
+
+  function remove (id) {
+    const { streams } = this
+    const index = streams.findIndex(s => s.id === id)
+
+    if (index >= 0) {
+      streams.splice(index, 1)
+      streams.sort(compareByLevel)
+      this.minLevel = streams.length > 0 ? streams[0].level : -1
+    }
+
+    return res
+  }
+
+  function end () {
+    for (const { stream } of this.streams) {
+      if (typeof stream.flushSync === 'function') {
+        stream.flushSync()
+      }
+      stream.end()
+    }
+  }
+
+  function clone (level) {
+    const streams = new Array(this.streams.length)
+
+    for (let i = 0; i < streams.length; i++) {
+      streams[i] = {
+        level,
+        stream: this.streams[i].stream
+      }
+    }
+
+    return {
+      write,
+      add,
+      remove,
+      minLevel: level,
+      streams,
+      clone,
+      emit,
+      flushSync,
+      [metadata]: true
+    }
+  }
+}
+
+function compareByLevel (a, b) {
+  return a.level - b.level
+}
+
+function initLoopVar (length, dedupe) {
+  return dedupe ? length - 1 : 0
+}
+
+function adjustLoopVar (i, dedupe) {
+  return dedupe ? i - 1 : i + 1
+}
+
+function checkLoopVar (i, length, dedupe) {
+  return dedupe ? i >= 0 : i < length
+}
+
+module.exports = multistream

package/lib/proto.js

@@ -0,0 +1,256 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const { EventEmitter } = require('node:events')
+const {
+  lsCacheSym,
+  levelValSym,
+  setLevelSym,
+  getLevelSym,
+  chindingsSym,
+  mixinSym,
+  asJsonSym,
+  writeSym,
+  mixinMergeStrategySym,
+  timeSym,
+  timeSliceIndexSym,
+  streamSym,
+  serializersSym,
+  formattersSym,
+  errorKeySym,
+  messageKeySym,
+  useOnlyCustomLevelsSym,
+  needsMetadataGsym,
+  redactFmtSym,
+  stringifySym,
+  formatOptsSym,
+  stringifiersSym,
+  msgPrefixSym,
+  hooksSym
+} = require('./symbols')
+const {
+  getLevel,
+  setLevel,
+  isLevelEnabled,
+  mappings,
+  initialLsCache,
+  genLsCache,
+  assertNoLevelCollisions
+} = require('./levels')
+const {
+  asChindings,
+  asJson,
+  buildFormatters,
+  stringify,
+  noop
+} = require('./tools')
+const {
+  version
+} = require('./meta')
+const redaction = require('./redaction')
+
+// note: use of class is satirical
+// https://github.com/pinojs/pino/pull/433#pullrequestreview-127703127
+const constructor = class Pino {}
+const prototype = {
+  constructor,
+  child,
+  bindings,
+  setBindings,
+  flush,
+  isLevelEnabled,
+  version,
+  get level () { return this[getLevelSym]() },
+  set level (lvl) { this[setLevelSym](lvl) },
+  get levelVal () { return this[levelValSym] },
+  set levelVal (n) { throw Error('levelVal is read-only') },
+  get msgPrefix () { return this[msgPrefixSym] },
+  get [Symbol.toStringTag] () { return 'Pino' },
+  [lsCacheSym]: initialLsCache,
+  [writeSym]: write,
+  [asJsonSym]: asJson,
+  [getLevelSym]: getLevel,
+  [setLevelSym]: setLevel
+}
+
+Object.setPrototypeOf(prototype, EventEmitter.prototype)
+
+// exporting and consuming the prototype object using factory pattern fixes scoping issues with getters when serializing
+module.exports = function () {
+  return Object.create(prototype)
+}
+
+const resetChildingsFormatter = bindings => bindings
+function child (bindings, options) {
+  if (!bindings) {
+    throw Error('missing bindings for child Pino')
+  }
+  const serializers = this[serializersSym]
+  const formatters = this[formattersSym]
+  const instance = Object.create(this)
+
+  // If an `options` object was not supplied, we can improve
+  // the performance of child creation by skipping
+  // the checks for set options and simply return
+  // a baseline instance.
+  if (options == null) {
+    if (instance[formattersSym].bindings !== resetChildingsFormatter) {
+      instance[formattersSym] = buildFormatters(
+        formatters.level,
+        resetChildingsFormatter,
+        formatters.log
+      )
+    }
+
+    instance[chindingsSym] = asChindings(instance, bindings)
+
+    if (this.onChild !== noop) {
+      this.onChild(instance)
+    }
+
+    return instance
+  }
+
+  if (options.hasOwnProperty('serializers') === true) {
+    instance[serializersSym] = Object.create(null)
+
+    for (const k in serializers) {
+      instance[serializersSym][k] = serializers[k]
+    }
+    const parentSymbols = Object.getOwnPropertySymbols(serializers)
+    /* eslint no-var: off */
+    for (var i = 0; i < parentSymbols.length; i++) {
+      const ks = parentSymbols[i]
+      instance[serializersSym][ks] = serializers[ks]
+    }
+
+    for (const bk in options.serializers) {
+      instance[serializersSym][bk] = options.serializers[bk]
+    }
+    const bindingsSymbols = Object.getOwnPropertySymbols(options.serializers)
+    for (var bi = 0; bi < bindingsSymbols.length; bi++) {
+      const bks = bindingsSymbols[bi]
+      instance[serializersSym][bks] = options.serializers[bks]
+    }
+  } else instance[serializersSym] = serializers
+  if (options.hasOwnProperty('formatters')) {
+    const { level, bindings: chindings, log } = options.formatters
+    instance[formattersSym] = buildFormatters(
+      level || formatters.level,
+      chindings || resetChildingsFormatter,
+      log || formatters.log
+    )
+  } else {
+    instance[formattersSym] = buildFormatters(
+      formatters.level,
+      resetChildingsFormatter,
+      formatters.log
+    )
+  }
+  if (options.hasOwnProperty('customLevels') === true) {
+    assertNoLevelCollisions(this.levels, options.customLevels)
+    instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym])
+    genLsCache(instance)
+  }
+
+  // redact must place before asChindings and only replace if exist
+  if ((typeof options.redact === 'object' && options.redact !== null) || Array.isArray(options.redact)) {
+    instance.redact = options.redact // replace redact directly
+    const stringifiers = redaction(instance.redact, stringify)
+    const formatOpts = { stringify: stringifiers[redactFmtSym] }
+    instance[stringifySym] = stringify
+    instance[stringifiersSym] = stringifiers
+    instance[formatOptsSym] = formatOpts
+  }
+
+  if (typeof options.msgPrefix === 'string') {
+    instance[msgPrefixSym] = (this[msgPrefixSym] || '') + options.msgPrefix
+  }
+
+  instance[chindingsSym] = asChindings(instance, bindings)
+  if ((options.level !== undefined && options.level !== this.level) || options.hasOwnProperty('customLevels')) {
+    const childLevel = options.level || this.level
+    instance[setLevelSym](childLevel)
+  }
+  this.onChild(instance)
+  return instance
+}
+
+function bindings () {
+  const chindings = this[chindingsSym]
+  const chindingsJson = `{${chindings.substr(1)}}` // at least contains ,"pid":7068,"hostname":"myMac"
+  const bindingsFromJson = JSON.parse(chindingsJson)
+  delete bindingsFromJson.pid
+  delete bindingsFromJson.hostname
+  return bindingsFromJson
+}
+
+function setBindings (newBindings) {
+  const chindings = asChindings(this, newBindings)
+  this[chindingsSym] = chindings
+}
+
+/**
+ * Default strategy for creating `mergeObject` from arguments and the result from `mixin()`.
+ * Fields from `mergeObject` have higher priority in this strategy.
+ *
+ * @param {Object} mergeObject The object a user has supplied to the logging function.
+ * @param {Object} mixinObject The result of the `mixin` method.
+ * @return {Object}
+ */
+function defaultMixinMergeStrategy (mergeObject, mixinObject) {
+  return Object.assign(mixinObject, mergeObject)
+}
+
+function write (_obj, msg, num) {
+  const t = this[timeSym]()
+  const mixin = this[mixinSym]
+  const errorKey = this[errorKeySym]
+  const messageKey = this[messageKeySym]
+  const mixinMergeStrategy = this[mixinMergeStrategySym] || defaultMixinMergeStrategy
+  let obj
+  const streamWriteHook = this[hooksSym].streamWrite
+
+  if (_obj === undefined || _obj === null) {
+    obj = {}
+  } else if (_obj instanceof Error) {
+    obj = { [errorKey]: _obj }
+    if (msg === undefined) {
+      msg = _obj.message
+    }
+  } else {
+    obj = _obj
+    if (msg === undefined && _obj[messageKey] === undefined && _obj[errorKey]) {
+      msg = _obj[errorKey].message
+    }
+  }
+
+  if (mixin) {
+    obj = mixinMergeStrategy(obj, mixin(obj, num, this))
+  }
+
+  const s = this[asJsonSym](obj, msg, num, t)
+
+  const stream = this[streamSym]
+  if (stream[needsMetadataGsym] === true) {
+    stream.lastLevel = num
+    stream.lastObj = obj
+    stream.lastMsg = msg
+    stream.lastTime = t.slice(this[timeSliceIndexSym])
+    stream.lastLogger = this // for child loggers
+  }
+  stream.write(streamWriteHook ? streamWriteHook(s) : s)
+}
+
+function flush (cb) {
+  if (cb != null && typeof cb !== 'function') {
+    throw Error('callback must be a function')
+  }
+
+  const stream = this[streamSym]
+
+  if (typeof stream.flush === 'function') {
+    stream.flush(cb || noop)
+  } else if (cb) cb()
+}