@wbce/projen-d9 0.0.28 → 0.1.0

package/node_modules/pino/test/multistream.test.js

@@ -0,0 +1,793 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { readFileSync } = require('node:fs')
+const { join } = require('node:path')
+const proxyquire = require('proxyquire')
+const strip = require('strip-ansi')
+const tspl = require('@matteo.collina/tspl')
+
+const writeStream = require('flush-write-stream')
+const pino = require('../')
+const multistream = pino.multistream
+const { file, sink } = require('./helper')
+
+test('sends to multiple streams using string levels', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const streams = [
+    { stream },
+    { level: 'debug', stream },
+    { level: 'trace', stream },
+    { level: 'fatal', stream },
+    { level: 'silent', stream }
+  ]
+  const log = pino({
+    level: 'trace'
+  }, multistream(streams))
+  log.info('info stream')
+  log.debug('debug stream')
+  log.fatal('fatal stream')
+  assert.equal(messageCount, 9)
+})
+
+test('sends to multiple streams using custom levels', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const streams = [
+    { stream },
+    { level: 'debug', stream },
+    { level: 'trace', stream },
+    { level: 'fatal', stream },
+    { level: 'silent', stream }
+  ]
+  const log = pino({
+    level: 'trace'
+  }, multistream(streams))
+  log.info('info stream')
+  log.debug('debug stream')
+  log.fatal('fatal stream')
+  assert.equal(messageCount, 9)
+})
+
+test('sends to multiple streams using optionally predefined levels', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const opts = {
+    levels: {
+      silent: Infinity,
+      fatal: 60,
+      error: 50,
+      warn: 50,
+      info: 30,
+      debug: 20,
+      trace: 10
+    }
+  }
+  const streams = [
+    { stream },
+    { level: 'trace', stream },
+    { level: 'debug', stream },
+    { level: 'info', stream },
+    { level: 'warn', stream },
+    { level: 'error', stream },
+    { level: 'fatal', stream },
+    { level: 'silent', stream }
+  ]
+  const mstream = multistream(streams, opts)
+  const log = pino({
+    level: 'trace'
+  }, mstream)
+  log.trace('trace stream')
+  log.debug('debug stream')
+  log.info('info stream')
+  log.warn('warn stream')
+  log.error('error stream')
+  log.fatal('fatal stream')
+  log.silent('silent stream')
+  assert.equal(messageCount, 24)
+})
+
+test('sends to multiple streams using number levels', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const streams = [
+    { stream },
+    { level: 20, stream },
+    { level: 60, stream }
+  ]
+  const log = pino({
+    level: 'debug'
+  }, multistream(streams))
+  log.info('info stream')
+  log.debug('debug stream')
+  log.fatal('fatal stream')
+  assert.equal(messageCount, 6)
+})
+
+test('level include higher levels', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const log = pino({}, multistream([{ level: 'info', stream }]))
+  log.fatal('message')
+  assert.equal(messageCount, 1)
+})
+
+test('supports multiple arguments', async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const messages = []
+  const stream = writeStream(function (data, enc, cb) {
+    messages.push(JSON.parse(data))
+    if (messages.length === 2) {
+      const msg1 = messages[0]
+      plan.equal(msg1.msg, 'foo bar baz foobar')
+
+      const msg2 = messages[1]
+      plan.equal(msg2.msg, 'foo bar baz foobar barfoo foofoo')
+    }
+    cb()
+  })
+  const log = pino({}, multistream({ stream }))
+  log.info('%s %s %s %s', 'foo', 'bar', 'baz', 'foobar') // apply not invoked
+  log.info('%s %s %s %s %s %s', 'foo', 'bar', 'baz', 'foobar', 'barfoo', 'foofoo') // apply invoked
+
+  await plan
+})
+
+test('supports children', async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const stream = writeStream(function (data, enc, cb) {
+    const input = JSON.parse(data)
+    plan.equal(input.msg, 'child stream')
+    plan.equal(input.child, 'one')
+    cb()
+  })
+  const streams = [
+    { stream }
+  ]
+  const log = pino({}, multistream(streams)).child({ child: 'one' })
+  log.info('child stream')
+
+  await plan
+})
+
+test('supports grandchildren', async (t) => {
+  const plan = tspl(t, { plan: 9 })
+  const messages = []
+  const stream = writeStream(function (data, enc, cb) {
+    messages.push(JSON.parse(data))
+    if (messages.length === 3) {
+      const msg1 = messages[0]
+      plan.equal(msg1.msg, 'grandchild stream')
+      plan.equal(msg1.child, 'one')
+      plan.equal(msg1.grandchild, 'two')
+
+      const msg2 = messages[1]
+      plan.equal(msg2.msg, 'grandchild stream')
+      plan.equal(msg2.child, 'one')
+      plan.equal(msg2.grandchild, 'two')
+
+      const msg3 = messages[2]
+      plan.equal(msg3.msg, 'debug grandchild')
+      plan.equal(msg3.child, 'one')
+      plan.equal(msg3.grandchild, 'two')
+    }
+    cb()
+  })
+  const streams = [
+    { stream },
+    { level: 'debug', stream }
+  ]
+  const log = pino({
+    level: 'debug'
+  }, multistream(streams)).child({ child: 'one' }).child({ grandchild: 'two' })
+  log.info('grandchild stream')
+  log.debug('debug grandchild')
+
+  await plan
+})
+
+test('supports custom levels', (t, end) => {
+  const stream = writeStream(function (data, enc, cb) {
+    assert.equal(JSON.parse(data).msg, 'bar')
+    end()
+  })
+  const log = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, multistream([{ level: 35, stream }]))
+  log.foo('bar')
+})
+
+test('supports pretty print', async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const stream = writeStream(function (data, enc, cb) {
+    plan.equal(strip(data.toString()).match(/INFO.*: pretty print/) != null, true)
+    cb()
+  })
+
+  const safeBoom = proxyquire('pino-pretty/lib/utils/build-safe-sonic-boom.js', {
+    'sonic-boom': function () {
+      plan.ok('sonic created')
+      stream.flushSync = () => {}
+      stream.flush = () => {}
+      return stream
+    }
+  })
+  const nested = proxyquire('pino-pretty/lib/utils/index.js', {
+    './build-safe-sonic-boom.js': safeBoom
+  })
+  const pretty = proxyquire('pino-pretty', {
+    './lib/utils/index.js': nested
+  })
+
+  const log = pino({
+    level: 'debug',
+    name: 'helloName'
+  }, multistream([
+    { stream: pretty() }
+  ]))
+
+  log.info('pretty print')
+
+  await plan
+})
+
+test('emit propagates events to each stream', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const handler = function (data) {
+    plan.equal(data.msg, 'world')
+  }
+  const streams = [sink(), sink(), sink()]
+  streams.forEach(function (s) {
+    s.once('hello', handler)
+  })
+  const stream = multistream(streams)
+  stream.emit('hello', { msg: 'world' })
+
+  await plan
+})
+
+test('children support custom levels', async (t) => {
+  const plan = tspl(t, { plan: 1 })
+  const stream = writeStream(function (data, enc, cb) {
+    plan.equal(JSON.parse(data).msg, 'bar')
+  })
+  const parent = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, multistream([{ level: 35, stream }]))
+  const child = parent.child({ child: 'yes' })
+  child.foo('bar')
+
+  await plan
+})
+
+test('levelVal overrides level', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const streams = [
+    { stream },
+    { level: 'blabla', levelVal: 15, stream },
+    { level: 60, stream }
+  ]
+  const log = pino({
+    level: 'debug'
+  }, multistream(streams))
+  log.info('info stream')
+  log.debug('debug stream')
+  log.fatal('fatal stream')
+  assert.equal(messageCount, 6)
+})
+
+test('forwards metadata', async (t) => {
+  const plan = tspl(t, { plan: 4 })
+  const streams = [
+    {
+      stream: {
+        [Symbol.for('pino.metadata')]: true,
+        write (chunk) {
+          plan.equal(log, this.lastLogger)
+          plan.equal(30, this.lastLevel)
+          plan.deepEqual({ hello: 'world' }, this.lastObj)
+          plan.deepEqual('a msg', this.lastMsg)
+        }
+      }
+    }
+  ]
+
+  const log = pino({
+    level: 'debug'
+  }, multistream(streams))
+
+  log.info({ hello: 'world' }, 'a msg')
+
+  await plan
+})
+
+test('forward name', async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const streams = [
+    {
+      stream: {
+        [Symbol.for('pino.metadata')]: true,
+        write (chunk) {
+          const line = JSON.parse(chunk)
+          plan.equal(line.name, 'helloName')
+          plan.equal(line.hello, 'world')
+        }
+      }
+    }
+  ]
+
+  const log = pino({
+    level: 'debug',
+    name: 'helloName'
+  }, multistream(streams))
+
+  log.info({ hello: 'world' }, 'a msg')
+
+  await plan
+})
+
+test('forward name with child', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const streams = [
+    {
+      stream: {
+        write (chunk) {
+          const line = JSON.parse(chunk)
+          plan.equal(line.name, 'helloName')
+          plan.equal(line.hello, 'world')
+          plan.equal(line.component, 'aComponent')
+        }
+      }
+    }
+  ]
+
+  const log = pino({
+    level: 'debug',
+    name: 'helloName'
+  }, multistream(streams)).child({ component: 'aComponent' })
+
+  log.info({ hello: 'world' }, 'a msg')
+
+  await plan
+})
+
+test('clone generates a new multistream with all stream at the same level', async (t) => {
+  const plan = tspl(t, { plan: 14 })
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const streams = [
+    { stream },
+    { level: 'debug', stream },
+    { level: 'trace', stream },
+    { level: 'fatal', stream }
+  ]
+  const ms = multistream(streams)
+  const clone = ms.clone(30)
+
+  // eslint-disable-next-line eqeqeq
+  plan.equal(clone != ms, true)
+
+  clone.streams.forEach((s, i) => {
+    // eslint-disable-next-line eqeqeq
+    plan.equal(s != streams[i], true)
+    plan.equal(s.stream, streams[i].stream)
+    plan.equal(s.level, 30)
+  })
+
+  const log = pino({
+    level: 'trace'
+  }, clone)
+
+  log.info('info stream')
+  log.debug('debug message not counted')
+  log.fatal('fatal stream')
+  plan.equal(messageCount, 8)
+
+  await plan
+})
+
+test('clone supports add, remove, and end methods correctly', async (t) => {
+  const plan = tspl(t, { plan: 5 })
+  const stream1 = writeStream(function (data, enc, cb) {
+    cb()
+  })
+  const stream2 = writeStream(function (data, enc, cb) {
+    cb()
+  })
+
+  const ms = multistream([{ stream: stream1 }])
+  const clone = ms.clone(30)
+
+  // Verify that adding a stream with a string level doesn't throw and returns the clone
+  const updatedClone = clone.add({ level: 'info', stream: stream2 })
+  plan.equal(updatedClone, clone)
+  plan.equal(clone.streams.length, 2)
+
+  // Verify remove returns the clone and works correctly
+  const stream2Entry = clone.streams.find(s => s.stream === stream2)
+  if (stream2Entry) {
+    const afterRemove = clone.remove(stream2Entry.id)
+    plan.equal(afterRemove, clone)
+    plan.equal(clone.streams.length, 1)
+  } else {
+    plan.fail('stream2 entry not found')
+  }
+
+  // Verify end method is present and can be called without errors
+  plan.equal(typeof clone.end, 'function')
+  clone.end()
+
+  await plan
+})
+
+test('one stream', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const log = pino({
+    level: 'trace'
+  }, multistream({ stream, level: 'fatal' }))
+  log.info('info stream')
+  log.debug('debug stream')
+  log.fatal('fatal stream')
+  assert.equal(messageCount, 1)
+})
+
+test('dedupe', async () => {
+  let messageCount = 0
+  const stream1 = writeStream(function (data, enc, cb) {
+    messageCount -= 1
+    cb()
+  })
+
+  const stream2 = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+
+  const streams = [
+    {
+      stream: stream1,
+      level: 'info'
+    },
+    {
+      stream: stream2,
+      level: 'fatal'
+    }
+  ]
+
+  const log = pino({
+    level: 'trace'
+  }, multistream(streams, { dedupe: true }))
+  log.info('info stream')
+  log.fatal('fatal stream')
+  log.fatal('fatal stream')
+  assert.equal(messageCount, 1)
+})
+
+test('dedupe when logs have different levels', async () => {
+  let messageCount = 0
+  const stream1 = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+
+  const stream2 = writeStream(function (data, enc, cb) {
+    messageCount += 2
+    cb()
+  })
+
+  const streams = [
+    {
+      stream: stream1,
+      level: 'info'
+    },
+    {
+      stream: stream2,
+      level: 'error'
+    }
+  ]
+
+  const log = pino({
+    level: 'trace'
+  }, multistream(streams, { dedupe: true }))
+
+  log.info('info stream')
+  log.warn('warn stream')
+  log.error('error streams')
+  log.fatal('fatal streams')
+  assert.equal(messageCount, 6)
+})
+
+test('dedupe when some streams has the same level', async () => {
+  let messageCount = 0
+  const stream1 = writeStream(function (data, enc, cb) {
+    messageCount -= 1
+    cb()
+  })
+
+  const stream2 = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+
+  const stream3 = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+
+  const streams = [
+    {
+      stream: stream1,
+      level: 'info'
+    },
+    {
+      stream: stream2,
+      level: 'fatal'
+    },
+    {
+      stream: stream3,
+      level: 'fatal'
+    }
+  ]
+
+  const log = pino({
+    level: 'trace'
+  }, multistream(streams, { dedupe: true }))
+  log.info('info stream')
+  log.fatal('fatal streams')
+  log.fatal('fatal streams')
+  assert.equal(messageCount, 3)
+})
+
+test('no stream', async () => {
+  const log = pino({
+    level: 'trace'
+  }, multistream())
+  log.info('info stream')
+  log.debug('debug stream')
+  log.fatal('fatal stream')
+})
+
+test('one stream', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const log = pino({
+    level: 'trace'
+  }, multistream(stream))
+  log.info('info stream')
+  log.debug('debug stream')
+  log.fatal('fatal stream')
+  assert.equal(messageCount, 2)
+})
+
+test('add a stream', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+
+  const log = pino({
+    level: 'trace'
+  }, multistream().add(stream))
+  log.info('info stream')
+  log.debug('debug stream')
+  log.fatal('fatal stream')
+  assert.equal(messageCount, 2)
+})
+
+test('remove a stream', async () => {
+  let messageCount1 = 0
+  let messageCount2 = 0
+  let messageCount3 = 0
+
+  const stream1 = writeStream(function (data, enc, cb) {
+    messageCount1 += 1
+    cb()
+  })
+
+  const stream2 = writeStream(function (data, enc, cb) {
+    messageCount2 += 1
+    cb()
+  })
+
+  const stream3 = writeStream(function (data, enc, cb) {
+    messageCount3 += 1
+    cb()
+  })
+
+  const multi = multistream()
+  const log = pino({ level: 'trace', sync: true }, multi)
+
+  multi.add(stream1)
+  const id1 = multi.lastId
+
+  multi.add(stream2)
+  const id2 = multi.lastId
+
+  multi.add(stream3)
+  const id3 = multi.lastId
+
+  log.info('line')
+  multi.remove(id1)
+
+  log.info('line')
+  multi.remove(id2)
+
+  log.info('line')
+  multi.remove(id3)
+
+  log.info('line')
+  multi.remove(Math.floor(Math.random() * 1000)) // non-existing id
+
+  assert.equal(messageCount1, 1)
+  assert.equal(messageCount2, 2)
+  assert.equal(messageCount3, 3)
+})
+
+test('multistream.add throws if not a stream', async () => {
+  try {
+    pino({
+      level: 'trace'
+    }, multistream().add({}))
+  } catch (_) {
+  }
+})
+
+test('multistream throws if not a stream', async () => {
+  try {
+    pino({
+      level: 'trace'
+    }, multistream({}))
+  } catch (_) {
+  }
+})
+
+test('multistream.write should not throw if one stream fails', async () => {
+  let messageCount = 0
+  const stream = writeStream(function (data, enc, cb) {
+    messageCount += 1
+    cb()
+  })
+  const noopStream = pino.transport({
+    target: join(__dirname, 'fixtures', 'noop-transport.js')
+  })
+  // eslint-disable-next-line
+  noopStream.on('error', function (err) {
+    // something went wrong while writing to noop stream, ignoring!
+  })
+  const log = pino({
+    level: 'trace'
+  },
+  multistream([
+    {
+      level: 'trace',
+      stream
+    },
+    {
+      level: 'debug',
+      stream: noopStream
+    }
+  ])
+  )
+  log.debug('0')
+  noopStream.end()
+  // noop stream is ending, should emit an error but not throw
+  log.debug('1')
+  log.debug('2')
+  assert.equal(messageCount, 3)
+})
+
+test('write routes correctly when the source sets a string lastLevel', async () => {
+  // A source that formats levels as labels (e.g. pino-abstract-transport
+  // relaying lines produced with a `formatters.level` option) assigns the
+  // string label to `lastLevel` via the metadata protocol. multistream must
+  // resolve that label to a numeric value before comparing against the
+  // per-stream levels, otherwise the log line is silently dropped.
+  const received = []
+  const mkStream = (name) => writeStream(function (data, enc, cb) {
+    received.push(name)
+    cb()
+  })
+  const streams = [
+    { level: 'debug', stream: mkStream('debug') },
+    { level: 'error', stream: mkStream('error') }
+  ]
+  const multi = multistream(streams, { levels: pino.levels.values })
+
+  // Emulate the metadata protocol used by pino / pino-abstract-transport,
+  // but with a level label string instead of a number.
+  multi.lastLevel = 'error'
+  multi.lastMsg = 'boom'
+  multi.lastObj = {}
+  multi.lastTime = Date.now()
+  multi.write('{"level":"error","msg":"boom"}\n')
+
+  // An error-level record must reach both the debug (<= error) and error
+  // streams, exactly as it would when lastLevel is the numeric 50.
+  assert.deepStrictEqual(received.sort(), ['debug', 'error'])
+})
+
+test('flushSync', async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const tmp = file()
+  const destination = pino.destination({ dest: tmp, sync: false, minLength: 4096 })
+  const stream = multistream([{ level: 'info', stream: destination }])
+  const log = pino({ level: 'info' }, stream)
+  destination.on('ready', () => {
+    log.info('foo')
+    log.info('bar')
+    stream.flushSync()
+    plan.equal(readFileSync(tmp, { encoding: 'utf-8' }).split('\n').length - 1, 2)
+    log.info('biz')
+    stream.flushSync()
+    plan.equal(readFileSync(tmp, { encoding: 'utf-8' }).split('\n').length - 1, 3)
+  })
+
+  await plan
+})
+
+test('ends all streams', async (t) => {
+  const plan = tspl(t, { plan: 7 })
+  const stream = writeStream(function (data, enc, cb) {
+    plan.ok('message')
+    cb()
+  })
+  stream.flushSync = function () {
+    plan.ok('flushSync')
+  }
+  // stream2 has no flushSync
+  const stream2 = writeStream(function (data, enc, cb) {
+    plan.ok('message2')
+    cb()
+  })
+  const streams = [
+    { stream },
+    { level: 'debug', stream },
+    { level: 'trace', stream: stream2 },
+    { level: 'fatal', stream },
+    { level: 'silent', stream }
+  ]
+  const multi = multistream(streams)
+  const log = pino({
+    level: 'trace'
+  }, multi)
+  log.info('info stream')
+  multi.end()
+
+  await plan
+})