@withbuddi/buddi 0.1.0-pre.35 → 0.1.0-pre.37

package/node_modules/pino/pino.js

@@ -43,7 +43,8 @@ const {
   hooksSym,
   nestedKeyStrSym,
   mixinMergeStrategySym,
-  msgPrefixSym
+  msgPrefixSym,
+  transportUsesMultistreamSym
 } = symbols
 const { epochTime, nullTime } = time
 const { pid } = process
@@ -130,7 +131,9 @@ function pino (...args) {
   const stringifyFn = stringify.bind({
     [stringifySafeSym]: stringifySafe
   })
-  const stringifiers = redact ? redaction(redact, stringifyFn) : {}
+  const stringifiers = redact
+    ? Object.assign(Object.create(null), redaction(redact, stringifyFn))
+    : Object.create(null)
   const formatOpts = redact
     ? { stringify: stringifiers[redactFmtSym] }
     : { stringify: stringifyFn }
@@ -165,6 +168,28 @@ function pino (...args) {
   assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels)
   const levels = mappings(customLevels, useOnlyCustomLevels)
 
+  if (stream && stream[transportUsesMultistreamSym] === true) {
+    let sampleLabel = typeof level === 'string' ? level : undefined
+    if (!sampleLabel || levels[sampleLabel] === undefined) {
+      sampleLabel = Object.keys(levels)[0]
+    }
+    const sampleNumber = levels[sampleLabel]
+    let ok = false
+    try {
+      const formatted = formatters.level(sampleLabel, sampleNumber)
+      ok = formatted && typeof formatted === 'object' && formatted.level === sampleNumber
+    } catch {
+      ok = false
+    }
+
+    if (!ok) {
+      process.emitWarning(
+        'custom formatters.level detected with multiple transport targets/pipelines; ensure logs include a numeric "level" field or they may be dropped',
+        { code: 'PINO_TRANSPORT_MULTI_TARGETS_LEVEL_FORMATTER' }
+      )
+    }
+  }
+
   if (typeof stream.emit === 'function') {
     stream.emit('message', { code: 'PINO_CONFIG', config: { levels, messageKey, errorKey } })
   }

package/node_modules/pino/test/basic.test.js

@@ -884,3 +884,69 @@ test('grandchild message should inherent parent prefix', async () => {
   const { msg } = await once(stream, 'data')
   assert.equal(msg, 'My name is Bond James Bond')
 })
+
+test('logs an object with an own enumerable __proto__ key', async () => {
+  const stream = sink()
+  const instance = pino(stream)
+  // JSON.parse produces an own enumerable __proto__ key from any untrusted JSON
+  const obj = JSON.parse('{"__proto__":{"x":1},"user":"bob"}')
+  instance.info(obj, 'incoming request')
+  const result = await once(stream, 'data')
+  check(assert.equal.bind(assert), result, 30, 'incoming request')
+  assert.equal(result.user, 'bob')
+})
+
+test('logs a redacted object with an own enumerable __proto__ key', async () => {
+  const stream = sink()
+  const instance = pino({ redact: ['user'] }, stream)
+  const obj = JSON.parse('{"__proto__":{"x":1},"user":"bob"}')
+  instance.info(obj, 'incoming request')
+  const result = await once(stream, 'data')
+  check(assert.equal.bind(assert), result, 30, 'incoming request')
+  assert.equal(result.user, '[Redacted]')
+})
+
+test('logs child bindings with an own enumerable __proto__ key', async () => {
+  const stream = sink()
+  const bindings = JSON.parse('{"__proto__":{"x":1},"reqId":"abc"}')
+  const instance = pino(stream).child(bindings)
+  instance.info('incoming request')
+  const result = await once(stream, 'data')
+  check(assert.equal.bind(assert), result, 30, 'incoming request')
+  assert.equal(result.reqId, 'abc')
+})
+
+test('logs an object with keys named after Object.prototype members', async () => {
+  const stream = sink()
+  const instance = pino(stream)
+  const obj = {
+    toString: 'a',
+    constructor: 'b',
+    valueOf: 'c',
+    hasOwnProperty: 'd',
+    propertyIsEnumerable: 'e',
+    toLocaleString: 'f',
+    isPrototypeOf: 'g'
+  }
+  instance.info(obj, 'incoming request')
+  const result = await once(stream, 'data')
+  check(assert.equal.bind(assert), result, 30, 'incoming request')
+  assert.equal(result.toString, 'a')
+  assert.equal(result.constructor, 'b')
+  assert.equal(result.valueOf, 'c')
+  assert.equal(result.hasOwnProperty, 'd')
+  assert.equal(result.propertyIsEnumerable, 'e')
+  assert.equal(result.toLocaleString, 'f')
+  assert.equal(result.isPrototypeOf, 'g')
+})
+
+test('logs a redacted object with keys named after Object.prototype members', async () => {
+  const stream = sink()
+  const instance = pino({ redact: ['secret'] }, stream)
+  instance.info({ toString: 'a', valueOf: 'b', secret: 'x' }, 'incoming request')
+  const result = await once(stream, 'data')
+  check(assert.equal.bind(assert), result, 30, 'incoming request')
+  assert.equal(result.toString, 'a')
+  assert.equal(result.valueOf, 'b')
+  assert.equal(result.secret, '[Redacted]')
+})

package/node_modules/pino/test/browser-bindings.test.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const test = require('tape')
+const pino = require('../browser')
+
+test('bindings returns an empty object on the root logger', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+
+  same(instance.bindings(), {})
+
+  end()
+})
+
+test('bindings contains child bindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance.child({ foo: 'bar' })
+
+  same(child.bindings(), { foo: 'bar' })
+
+  end()
+})
+
+test('bindings contains bindings from nested children', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance
+    .child({ foo: 'bar' })
+    .child({ a: 2 })
+
+  same(child.bindings(), { foo: 'bar', a: 2 })
+
+  end()
+})
+
+test('child bindings overwrite parent bindings with the same key', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance
+    .child({ foo: 'bar' })
+    .child({ foo: 'baz' })
+
+  same(child.bindings(), { foo: 'baz' })
+
+  end()
+})
+
+test('bindings contains bindings added with setBindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+
+  instance.setBindings({ foo: 'bar' })
+
+  same(instance.bindings(), { foo: 'bar' })
+
+  end()
+})
+
+test('newly set bindings overwrite old bindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+
+  instance.setBindings({ foo: 'bar' })
+  instance.setBindings({ foo: 'baz' })
+
+  same(instance.bindings(), { foo: 'baz' })
+
+  end()
+})
+
+test('setBindings on child merges with child bindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance.child({ child: true })
+
+  child.setBindings({ later: 'yes' })
+
+  same(child.bindings(), {
+    child: true,
+    later: 'yes'
+  })
+
+  end()
+})
+
+test('child inherits bindings set on parent before child creation', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+
+  instance.setBindings({ foo: 'bar' })
+
+  const child = instance.child({})
+
+  same(child.bindings(), { foo: 'bar' })
+
+  end()
+})
+
+test('child does not inherit bindings set on parent after child creation', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance.child({})
+
+  instance.setBindings({ foo: 'bar' })
+
+  same(instance.bindings(), { foo: 'bar' })
+  same(child.bindings(), {})
+
+  end()
+})
+
+test('bindings returns a copy of the bindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  instance.setBindings({ foo: 'bar' })
+
+  const bindings = instance.bindings()
+  bindings.foo = 'baz'
+
+  same(instance.bindings(), { foo: 'bar' })
+
+  end()
+})

package/node_modules/pino/test/browser-redaction.test.js

@@ -0,0 +1,264 @@
+'use strict'
+// eslint-disable-next-line
+if (typeof $1 !== 'undefined') $1 = arguments.callee.caller.arguments[0]
+
+const test = require('tape')
+const pino = require('../browser')
+
+test('redact option as array redacts specified paths', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.password, '[Redacted]')
+        is(o.username, 'john')
+        end()
+      }
+    },
+    redact: ['password']
+  })
+
+  instance.info({ password: 'secret', username: 'john' })
+})
+
+test('redact option as object with custom censor', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.secret, '***HIDDEN***')
+        is(o.visible, 'data')
+        end()
+      }
+    },
+    redact: {
+      paths: ['secret'],
+      censor: '***HIDDEN***'
+    }
+  })
+
+  instance.info({ secret: 'sensitive', visible: 'data' })
+})
+
+test('redact nested paths', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.user.password, '[Redacted]')
+        is(o.user.name, 'alice')
+        end()
+      }
+    },
+    redact: ['user.password']
+  })
+
+  instance.info({ user: { name: 'alice', password: 'secret123' } })
+})
+
+test('redact with wildcard paths', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.items[0].secret, '[Redacted]')
+        is(o.items[1].secret, '[Redacted]')
+        is(o.items[0].id, 1)
+        is(o.items[1].id, 2)
+        end()
+      }
+    },
+    redact: ['items[*].secret']
+  })
+
+  instance.info({
+    items: [
+      { id: 1, secret: 'a' },
+      { id: 2, secret: 'b' }
+    ]
+  })
+})
+
+test('redact with remove option removes the key entirely', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.removeMe, undefined)
+        is(o.keepMe, 'visible')
+        end()
+      }
+    },
+    redact: {
+      paths: ['removeMe'],
+      remove: true
+    }
+  })
+
+  instance.info({ removeMe: 'gone', keepMe: 'visible' })
+})
+
+test('redact throws on invalid paths option', ({ end, throws }) => {
+  throws(() => {
+    pino({
+      browser: { asObject: true },
+      redact: { paths: 'not-an-array' }
+    })
+  }, /pino – redact must contain an array of strings/)
+  end()
+})
+
+test('redact works with child loggers', ({ end, is }) => {
+  const parent = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.password, '[Redacted]')
+        is(o.childBinding, 'value')
+        end()
+      }
+    },
+    redact: ['password']
+  })
+
+  const child = parent.child({ childBinding: 'value' })
+  child.info({ password: 'secret' })
+})
+
+test('redact multiple paths', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.password, '[Redacted]')
+        is(o.creditCard, '[Redacted]')
+        is(o.ssn, '[Redacted]')
+        is(o.name, 'bob')
+        end()
+      }
+    },
+    redact: ['password', 'creditCard', 'ssn']
+  })
+
+  instance.info({
+    password: 'secret',
+    creditCard: '1234-5678-9012-3456',
+    ssn: '123-45-6789',
+    name: 'bob'
+  })
+})
+
+test('redact with bracket notation for hyphenated keys', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o['api-key'], '[Redacted]')
+        is(o.name, 'test')
+        end()
+      }
+    },
+    redact: ['["api-key"]']
+  })
+
+  instance.info({ 'api-key': 'sensitive', name: 'test' })
+})
+
+test('redact works with asObjectBindingsOnly mode', ({ end, is, deepEqual }) => {
+  const instance = pino({
+    browser: {
+      asObjectBindingsOnly: true,
+      write (o, ...args) {
+        is(o.password, '[Redacted]')
+        is(o.username, 'john')
+        deepEqual(args, ['remaining', 'args'])
+        end()
+      }
+    },
+    redact: ['password']
+  })
+
+  instance.info({ password: 'secret', username: 'john' }, 'remaining', 'args')
+})
+
+test('redact works with asObjectBindingsOnly mode and object message', ({ end, is, ok }) => {
+  const instance = pino({
+    browser: {
+      asObjectBindingsOnly: true,
+      write (o, ...args) {
+        is(o.password, '[Redacted]')
+        is(o.foo, 'bar')
+        ok(o.time)
+        is(args.length, 0)
+        end()
+      }
+    },
+    redact: ['password']
+  })
+
+  instance.info({ password: 'secret', foo: 'bar' })
+})
+
+test('redact with asObjectBindingsOnly and child logger merges multiple bindings', ({ end, is, ok }) => {
+  const parent = pino({
+    browser: {
+      asObjectBindingsOnly: true,
+      write (o, ...args) {
+        is(o.password, '[Redacted]')
+        is(o.parentBinding, 'parent')
+        is(o.childBinding, 'child')
+        is(o.logData, 'value')
+        ok(o.time)
+        end()
+      }
+    },
+    redact: ['password']
+  })
+
+  const child = parent.child({ parentBinding: 'parent' }).child({ childBinding: 'child' })
+  child.info({ logData: 'value', password: 'secret' })
+})
+
+test('formatters.level works with asObject mode', ({ end, is, ok }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.levelLabel, 'info')
+        is(o.levelValue, 30)
+        is(o.msg, 'test message')
+        ok(o.time)
+        end()
+      },
+      formatters: {
+        level (label, number) {
+          return { levelLabel: label, levelValue: number }
+        }
+      }
+    }
+  })
+
+  instance.info('test message')
+})
+
+test('formatters.level with asObject and object message', ({ end, is, ok }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write (o) {
+        is(o.levelLabel, 'warn')
+        is(o.levelValue, 40)
+        is(o.data, 'value')
+        ok(o.time)
+        end()
+      },
+      formatters: {
+        level (label, number) {
+          return { levelLabel: label, levelValue: number }
+        }
+      }
+    }
+  })
+
+  instance.warn({ data: 'value' })
+})

package/node_modules/pino/test/browser-set-bindings.test.js

@@ -0,0 +1,99 @@
+'use strict'
+const test = require('tape')
+const pino = require('../browser')
+
+test('setBindings is a function on the root logger', ({ end, is }) => {
+  const instance = pino({ browser: {} })
+
+  is(typeof instance.setBindings, 'function')
+  end()
+})
+
+test('setBindings adds bindings to subsequent log calls', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.answer, 42)
+        is(o.msg, 'test')
+      }
+    }
+  })
+
+  instance.setBindings({ answer: 42 })
+  instance.info('test')
+  end()
+})
+
+test('setBindings merges with existing bindings', ({ end, is }) => {
+  let expected
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.a, expected.a)
+        is(o.b, expected.b)
+      }
+    }
+  })
+
+  instance.setBindings({ a: 1 })
+  expected = { a: 1, b: undefined }
+  instance.info('first')
+
+  instance.setBindings({ b: 2 })
+  expected = { a: 1, b: 2 }
+  instance.info('second')
+  end()
+})
+
+test('setBindings on a child logger merges with the child bindings', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.child, true)
+        is(o.later, 'yes')
+        is(o.msg, 'test')
+      }
+    }
+  })
+
+  const child = instance.child({ child: true })
+  child.setBindings({ later: 'yes' })
+  child.info('test')
+  end()
+})
+
+test('setBindings works with customLevels', ({ end, is }) => {
+  const instance = pino({
+    customLevels: { success: 35 },
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.answer, 42)
+        is(o.msg, 'test')
+      }
+    }
+  })
+
+  instance.setBindings({ answer: 42 })
+  instance.success('test')
+  end()
+})
+
+test('setBindings bindings are transmitted', ({ end, same }) => {
+  const instance = pino({
+    browser: {
+      transmit: {
+        send (level, logEvent) {
+          same(logEvent.bindings, [{ answer: 42 }])
+        }
+      }
+    }
+  })
+
+  instance.setBindings({ answer: 42 })
+  instance.info('test')
+  end()
+})

package/node_modules/pino/test/caller.test.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const loop = require('./fixtures/caller-loop.js')
+
+test('returns a callstack of absolute paths', () => {
+  const callers = loop(7).map(fileName => fileName.substring(__dirname.length))
+
+  // default callstack size is 10, but the top 2 are dropped
+  assert.equal(callers.length, 8)
+  assert.match(callers[0], /^[/\\]fixtures[/\\]caller-loop\.js$/)
+  assert.match(callers[1], /^[/\\]fixtures[/\\]caller-loop\.js$/)
+  assert.match(callers[2], /^[/\\]fixtures[/\\]caller-loop\.js$/)
+  assert.match(callers[3], /^[/\\]fixtures[/\\]caller-loop\.js$/)
+  assert.match(callers[4], /^[/\\]fixtures[/\\]caller-loop\.js$/)
+  assert.match(callers[5], /^[/\\]fixtures[/\\]caller-loop\.js$/)
+  assert.match(callers[6], /^[/\\]fixtures[/\\]caller-loop\.js$/)
+  assert.match(callers[7], /^[/\\]caller\.test\.js$/)
+})

package/node_modules/pino/test/escaping.test.js

@@ -36,6 +36,23 @@ testEscape('\\r', '\r')
 testEscape('\\t', '\t')
 testEscape('\\b', '\b')
 
+test('correctly escape child binding keys', async () => {
+  const stream = sink()
+  const key = 'x"}\n{"level":60,"msg":"forged"}\n{"swallow'
+  const instance = pino(stream).child({ [key]: true })
+
+  instance.info('hello')
+  const result = await once(stream, 'data')
+  delete result.time
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello',
+    [key]: true
+  })
+})
+
 const toEscape = [
   '\u0000', // NUL  Null character
   '\u0001', // SOH  Start of Heading

package/node_modules/pino/test/fixtures/caller-loop.js

@@ -0,0 +1,6 @@
+const getCallers = require('../../lib/caller.js')
+
+module.exports = function loop (count) {
+  if (count <= 0) return getCallers()
+  return loop(count - 1)
+}

package/node_modules/pino/test/fixtures/ts/transpile.cjs

@@ -7,7 +7,7 @@ const existsSync = fs.existsSync
 const stat = fs.promises.stat
 
 // Hardcoded parameters
-const esVersions = ['es5', 'es6', 'es2017', 'esnext']
+const esVersions = ['es6', 'es2017', 'esnext']
 const filesToTranspile = ['to-file-transport.ts']
 
 async function transpile () {
@@ -23,8 +23,8 @@ async function transpile () {
       const shouldTranspile = !existsSync(targetFileName) || (await stat(targetFileName)).mtimeMs < sourceStat.mtimeMs
 
       if (shouldTranspile) {
-        await execa('tsc', ['--target', esVersion, '--module', 'commonjs', sourceFileName])
-        await execa('mv', [intermediateFileName, targetFileName])
+        await execa('tsc', [ '--ignoreConfig', '--types', 'node', '--target', esVersion, '--module', 'commonjs', sourceFileName ])
+        await execa('mv', [ intermediateFileName, targetFileName ])
       }
     }
   }

package/node_modules/pino/test/helper.js

@@ -88,14 +88,18 @@ function watchForWrite (filename, testString) {
     const threshold = TIMEOUT / INTERVAL
     let counter = 0
     const interval = setInterval(() => {
-      if (readFileSync(filename).includes(testString)) {
+      const exists = existsSync(filename)
+      if (exists && readFileSync(filename).includes(testString)) {
         clearInterval(interval)
         resolve()
       } else if (counter <= threshold) {
         counter++
       } else {
         clearInterval(interval)
-        reject(new Error(`'${testString}' hasn't been written to ${filename} within ${TIMEOUT} ms.`))
+        reject(new Error(
+          `'${testString}' hasn't been written to ${filename} within ${TIMEOUT} ms. ` +
+          (exists ? 'File exists, but content is still incomplete.' : 'File not yet created.')
+        ))
       }
     }, INTERVAL)
   })