@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/pino/test/serializers.test.js

@@ -0,0 +1,257 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const stdSerializers = require('pino-std-serializers')
+
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+const parentSerializers = {
+  test: () => 'parent'
+}
+
+const childSerializers = {
+  test: () => 'child'
+}
+
+test('default err namespace error serializer', async () => {
+  const stream = sink()
+  const parent = pino(stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  assert.equal(typeof o.err, 'object')
+  assert.equal(o.err.type, 'ReferenceError')
+  assert.equal(o.err.message, 'test')
+  assert.equal(typeof o.err.stack, 'string')
+})
+
+test('custom serializer overrides default err namespace error serializer', async () => {
+  const stream = sink()
+  const parent = pino({
+    serializers: {
+      err: (e) => ({
+        t: e.constructor.name,
+        m: e.message,
+        s: e.stack
+      })
+    }
+  }, stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  assert.equal(typeof o.err, 'object')
+  assert.equal(o.err.t, 'ReferenceError')
+  assert.equal(o.err.m, 'test')
+  assert.equal(typeof o.err.s, 'string')
+})
+
+test('custom serializer overrides default err namespace error serializer when nestedKey is on', async () => {
+  const stream = sink()
+  const parent = pino({
+    nestedKey: 'obj',
+    serializers: {
+      err: (e) => {
+        return {
+          t: e.constructor.name,
+          m: e.message,
+          s: e.stack
+        }
+      }
+    }
+  }, stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  assert.equal(typeof o.obj.err, 'object')
+  assert.equal(o.obj.err.t, 'ReferenceError')
+  assert.equal(o.obj.err.m, 'test')
+  assert.equal(typeof o.obj.err.s, 'string')
+})
+
+test('null overrides default err namespace error serializer', async () => {
+  const stream = sink()
+  const parent = pino({ serializers: { err: null } }, stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  assert.equal(typeof o.err, 'object')
+  assert.equal(typeof o.err.type, 'undefined')
+  assert.equal(typeof o.err.message, 'undefined')
+  assert.equal(typeof o.err.stack, 'undefined')
+})
+
+test('undefined overrides default err namespace error serializer', async () => {
+  const stream = sink()
+  const parent = pino({ serializers: { err: undefined } }, stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  assert.equal(typeof o.err, 'object')
+  assert.equal(typeof o.err.type, 'undefined')
+  assert.equal(typeof o.err.message, 'undefined')
+  assert.equal(typeof o.err.stack, 'undefined')
+})
+
+test('serializers override values', async () => {
+  const stream = sink()
+  const parent = pino({ serializers: parentSerializers }, stream)
+  parent.child({}, { serializers: childSerializers })
+
+  parent.fatal({ test: 'test' })
+  const o = await once(stream, 'data')
+  assert.equal(o.test, 'parent')
+})
+
+test('child does not overwrite parent serializers', async () => {
+  const stream = sink()
+  const parent = pino({ serializers: parentSerializers }, stream)
+  const child = parent.child({}, { serializers: childSerializers })
+
+  parent.fatal({ test: 'test' })
+
+  const o = once(stream, 'data')
+  assert.equal((await o).test, 'parent')
+  const o2 = once(stream, 'data')
+  child.fatal({ test: 'test' })
+  assert.equal((await o2).test, 'child')
+})
+
+test('Symbol.for(\'pino.serializers\')', async () => {
+  const stream = sink()
+  const expected = Object.assign({
+    err: stdSerializers.err
+  }, parentSerializers)
+  const parent = pino({ serializers: parentSerializers }, stream)
+  const child = parent.child({ a: 'property' })
+
+  assert.deepEqual(parent[Symbol.for('pino.serializers')], expected)
+  assert.deepEqual(child[Symbol.for('pino.serializers')], expected)
+  assert.equal(parent[Symbol.for('pino.serializers')], child[Symbol.for('pino.serializers')])
+
+  const child2 = parent.child({}, {
+    serializers: {
+      a
+    }
+  })
+
+  function a () {
+    return 'hello'
+  }
+
+  // eslint-disable-next-line eqeqeq
+  assert.equal(child2[Symbol.for('pino.serializers')] != parentSerializers, true)
+  assert.equal(child2[Symbol.for('pino.serializers')].a, a)
+  assert.equal(child2[Symbol.for('pino.serializers')].test, parentSerializers.test)
+})
+
+test('children inherit parent serializers', async () => {
+  const stream = sink()
+  const parent = pino({ serializers: parentSerializers }, stream)
+
+  const child = parent.child({ a: 'property' })
+  child.fatal({ test: 'test' })
+  const o = await once(stream, 'data')
+  assert.equal(o.test, 'parent')
+})
+
+test('children inherit parent Symbol serializers', async () => {
+  const stream = sink()
+  const symbolSerializers = {
+    [Symbol.for('b')]: b
+  }
+  const expected = Object.assign({
+    err: stdSerializers.err
+  }, symbolSerializers)
+  const parent = pino({ serializers: symbolSerializers }, stream)
+
+  assert.deepEqual(parent[Symbol.for('pino.serializers')], expected)
+
+  const child = parent.child({}, {
+    serializers: {
+      [Symbol.for('a')]: a,
+      a
+    }
+  })
+
+  function a () {
+    return 'hello'
+  }
+
+  function b () {
+    return 'world'
+  }
+
+  assert.deepEqual(child[Symbol.for('pino.serializers')].a, a)
+  assert.deepEqual(child[Symbol.for('pino.serializers')][Symbol.for('b')], b)
+  assert.deepEqual(child[Symbol.for('pino.serializers')][Symbol.for('a')], a)
+})
+
+test('children serializers get called', async () => {
+  const stream = sink()
+  const parent = pino({
+    test: 'this'
+  }, stream)
+
+  const child = parent.child({ a: 'property' }, { serializers: childSerializers })
+
+  child.fatal({ test: 'test' })
+  const o = await once(stream, 'data')
+  assert.equal(o.test, 'child')
+})
+
+test('children serializers get called when inherited from parent', async () => {
+  const stream = sink()
+  const parent = pino({
+    test: 'this',
+    serializers: parentSerializers
+  }, stream)
+
+  const child = parent.child({}, { serializers: { test: function () { return 'pass' } } })
+
+  child.fatal({ test: 'fail' })
+  const o = await once(stream, 'data')
+  assert.equal(o.test, 'pass')
+})
+
+test('non-overridden serializers are available in the children', async () => {
+  const stream = sink()
+  const pSerializers = {
+    onlyParent: function () { return 'parent' },
+    shared: function () { return 'parent' }
+  }
+
+  const cSerializers = {
+    shared: function () { return 'child' },
+    onlyChild: function () { return 'child' }
+  }
+
+  const parent = pino({ serializers: pSerializers }, stream)
+
+  const child = parent.child({}, { serializers: cSerializers })
+
+  const o = once(stream, 'data')
+  child.fatal({ shared: 'test' })
+  assert.equal((await o).shared, 'child')
+  const o2 = once(stream, 'data')
+  child.fatal({ onlyParent: 'test' })
+  assert.equal((await o2).onlyParent, 'parent')
+  const o3 = once(stream, 'data')
+  child.fatal({ onlyChild: 'test' })
+  assert.equal((await o3).onlyChild, 'child')
+  const o4 = once(stream, 'data')
+  parent.fatal({ onlyChild: 'test' })
+  assert.equal((await o4).onlyChild, 'test')
+})
+
+test('custom serializer for messageKey', async () => {
+  const stream = sink()
+  const instance = pino({ serializers: { msg: () => '422' } }, stream)
+
+  const o = { num: NaN }
+  instance.info(o, 42)
+
+  const { msg } = await once(stream, 'data')
+  assert.equal(msg, '422')
+})

package/node_modules/pino/test/stdout-protection.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { fork } = require('node:child_process')
+const writer = require('flush-write-stream')
+
+const { once } = require('./helper')
+const pino = require('..')
+
+test('do not use SonicBoom is someone tampered with process.stdout.write', async () => {
+  let actual = ''
+  const child = fork(join(__dirname, 'fixtures', 'stdout-hack-protection.js'), { silent: true })
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+  await once(child, 'close')
+  assert.equal(actual.match(/^hack/) != null, true)
+})
+
+test('do not use SonicBoom is someone has passed process.stdout to pino', async () => {
+  const logger = pino(process.stdout)
+  assert.equal(logger[pino.symbols.streamSym], process.stdout)
+})
+
+test('do not crash if process.stdout has no fd', async (t) => {
+  const fd = process.stdout.fd
+  delete process.stdout.fd
+  t.after(function () { process.stdout.fd = fd })
+  pino()
+})
+
+test('use fd=1 if process.stdout has no fd in pino.destination() (worker case)', async (t) => {
+  const fd = process.stdout.fd
+  delete process.stdout.fd
+  t.after(function () { process.stdout.fd = fd })
+  pino.destination()
+})

package/node_modules/pino/test/syncfalse.test.js

@@ -0,0 +1,186 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const os = require('node:os')
+const { promises: { readFile }, createWriteStream } = require('node:fs')
+const { join } = require('node:path')
+const { fork } = require('node:child_process')
+const writer = require('flush-write-stream')
+const {
+  once,
+  getPathToNull,
+  file,
+  watchFileCreated
+} = require('./helper')
+const { promisify } = require('node:util')
+const tspl = require('@matteo.collina/tspl')
+
+const sleep = promisify(setTimeout)
+
+test('asynchronous logging', async (t) => {
+  const now = Date.now
+  const hostname = os.hostname
+  const proc = process
+  global.process = {
+    __proto__: process,
+    pid: 123456
+  }
+  Date.now = () => 1459875739796
+  os.hostname = () => 'abcdefghijklmnopqr'
+  delete require.cache[require.resolve('../')]
+  const pino = require('../')
+  let expected = ''
+  let actual = ''
+  const normal = pino(writer((s, enc, cb) => {
+    expected += s
+    cb()
+  }))
+
+  const dest = createWriteStream(getPathToNull())
+  dest.write = (s) => {
+    actual += s
+  }
+  const asyncLogger = pino(dest)
+
+  let i = 44
+  while (i--) {
+    normal.info('h')
+    asyncLogger.info('h')
+  }
+
+  const expected2 = expected.split('\n')[0]
+  let actual2 = ''
+
+  const child = fork(join(__dirname, '/fixtures/syncfalse.js'), { silent: true })
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual2 += s
+    cb()
+  }))
+  await once(child, 'close')
+  // Wait for the last write to be flushed
+  await sleep(100)
+  assert.equal(actual, expected)
+  assert.equal(actual2.trim(), expected2)
+
+  t.after(() => {
+    os.hostname = hostname
+    Date.now = now
+    global.process = proc
+  })
+})
+
+test('sync false with child', async (t) => {
+  const now = Date.now
+  const hostname = os.hostname
+  const proc = process
+  global.process = {
+    __proto__: process,
+    pid: 123456
+  }
+  Date.now = function () {
+    return 1459875739796
+  }
+  os.hostname = function () {
+    return 'abcdefghijklmnopqr'
+  }
+  delete require.cache[require.resolve('../')]
+  const pino = require('../')
+  let expected = ''
+  let actual = ''
+  const normal = pino(writer((s, enc, cb) => {
+    expected += s
+    cb()
+  })).child({ hello: 'world' })
+
+  const dest = createWriteStream(getPathToNull())
+  dest.write = function (s) {
+    actual += s
+  }
+  const asyncLogger = pino(dest).child({ hello: 'world' })
+
+  let i = 500
+  while (i--) {
+    normal.info('h')
+    asyncLogger.info('h')
+  }
+
+  asyncLogger.flush()
+
+  const expected2 = expected.split('\n')[0]
+  let actual2 = ''
+
+  const child = fork(join(__dirname, '/fixtures/syncfalse-child.js'), { silent: true })
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual2 += s
+    cb()
+  }))
+  await once(child, 'close')
+  assert.equal(actual, expected)
+  assert.equal(actual2.trim(), expected2)
+
+  t.after(() => {
+    os.hostname = hostname
+    Date.now = now
+    global.process = proc
+  })
+})
+
+test('flush does nothing with sync true (default)', async () => {
+  const instance = require('..')()
+  assert.equal(instance.flush(), undefined)
+})
+
+test('should still call flush callback even when does nothing with sync true (default)', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const instance = require('..')()
+  instance.flush((...args) => {
+    plan.ok('flush called')
+    plan.deepEqual(args, [])
+
+    // next tick to make flush not called more than once
+    process.nextTick(() => {
+      plan.ok('flush next tick called')
+    })
+  })
+
+  await plan
+})
+
+test('should call the flush callback when flushed the data for async logger', async () => {
+  const outputPath = file()
+  async function getOutputLogLines () {
+    return (await readFile(outputPath)).toString().trim().split('\n').map(JSON.parse)
+  }
+
+  const pino = require('../')
+
+  const instance = pino({}, pino.destination({
+    dest: outputPath,
+
+    // to make sure it does not flush on its own
+    minLength: 4096
+  }))
+  const flushPromise = promisify(instance.flush).bind(instance)
+
+  instance.info('hello')
+  await flushPromise()
+  await watchFileCreated(outputPath)
+
+  const [firstFlushData] = await getOutputLogLines()
+
+  assert.equal(firstFlushData.msg, 'hello')
+
+  // should not flush this as no data accumulated that's bigger than min length
+  instance.info('world')
+
+  // Making sure data is not flushed yet
+  const afterLogData = await getOutputLogLines()
+  assert.equal(afterLogData.length, 1)
+
+  await flushPromise()
+
+  // Making sure data is not flushed yet
+  const afterSecondFlush = (await getOutputLogLines())[1]
+  assert.equal(afterSecondFlush.msg, 'world')
+})

package/node_modules/pino/test/timestamp-nano.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const test = require('node:test')
+const assert = require('node:assert')
+
+const { sink, once } = require('./helper')
+
+test('pino.stdTimeFunctions.isoTimeNano returns RFC 3339 timestamps', async () => {
+  // Mock Date.now at module initialization time
+  const now = Date.now
+  Date.now = () => new Date('2025-08-01T15:03:45.000000000Z').getTime()
+
+  // Mock process.hrtime.bigint at module initialization time
+  const hrTimeBigint = process.hrtime.bigint
+  process.hrtime.bigint = () => 100000000000000n
+
+  const pino = require('../')
+
+  const opts = {
+    timestamp: pino.stdTimeFunctions.isoTimeNano
+  }
+  const stream = sink()
+
+  // Mock process.hrtime.bigint at invocation time, add 1 day to the timestamp
+  process.hrtime.bigint = () => 100000000000000n + 86400012345678n
+
+  const instance = pino(opts, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.equal(result.time, '2025-08-02T15:03:45.012345678Z')
+
+  Date.now = now
+  process.hrtime.bigint = hrTimeBigint
+})

package/node_modules/pino/test/timestamp.test.js

@@ -0,0 +1,124 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const test = require('node:test')
+const assert = require('node:assert')
+
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+test('pino exposes standard time functions', async () => {
+  assert.ok(pino.stdTimeFunctions)
+  assert.ok(pino.stdTimeFunctions.epochTime)
+  assert.ok(pino.stdTimeFunctions.unixTime)
+  assert.ok(pino.stdTimeFunctions.nullTime)
+  assert.ok(pino.stdTimeFunctions.isoTime)
+  assert.ok(pino.stdTimeFunctions.isoTimeNano)
+})
+
+test('pino accepts external time functions', async () => {
+  const opts = {
+    timestamp: () => ',"time":"none"'
+  }
+  const stream = sink()
+  const instance = pino(opts, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.equal(result.time, 'none')
+})
+
+test('pino accepts external time functions with custom label', async () => {
+  const opts = {
+    timestamp: () => ',"custom-time-label":"none"'
+  }
+  const stream = sink()
+  const instance = pino(opts, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('custom-time-label'), true)
+  assert.equal(result['custom-time-label'], 'none')
+})
+
+test('inserts timestamp by default', async ({ ok, equal }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  assert.equal(result.msg, 'foobar')
+})
+
+test('omits timestamp when timestamp option is false', async () => {
+  const stream = sink()
+  const instance = pino({ timestamp: false }, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), false)
+  assert.equal(result.msg, 'foobar')
+})
+
+test('inserts timestamp when timestamp option is true', async ({ ok, equal }) => {
+  const stream = sink()
+  const instance = pino({ timestamp: true }, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  assert.equal(result.msg, 'foobar')
+})
+
+test('child inserts timestamp by default', async ({ ok, equal }) => {
+  const stream = sink()
+  const logger = pino(stream)
+  const instance = logger.child({ component: 'child' })
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  assert.equal(result.msg, 'foobar')
+})
+
+test('child omits timestamp with option', async () => {
+  const stream = sink()
+  const logger = pino({ timestamp: false }, stream)
+  const instance = logger.child({ component: 'child' })
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), false)
+  assert.equal(result.msg, 'foobar')
+})
+
+test('pino.stdTimeFunctions.unixTime returns seconds based timestamps', async () => {
+  const opts = {
+    timestamp: pino.stdTimeFunctions.unixTime
+  }
+  const stream = sink()
+  const instance = pino(opts, stream)
+  const now = Date.now
+  Date.now = () => 1531069919686
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.equal(result.time, 1531069920)
+  Date.now = now
+})
+
+test('pino.stdTimeFunctions.isoTime returns ISO 8601 timestamps', async () => {
+  const opts = {
+    timestamp: pino.stdTimeFunctions.isoTime
+  }
+  const stream = sink()
+  const instance = pino(opts, stream)
+  const ms = 1531069919686
+  const now = Date.now
+  Date.now = () => ms
+  const iso = new Date(ms).toISOString()
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.equal(result.time, iso)
+  Date.now = now
+})

package/node_modules/pino/test/transport/big.test.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { createReadStream } = require('node:fs')
+const { promisify } = require('node:util')
+const stream = require('node:stream')
+const execa = require('execa')
+const split = require('split2')
+
+const { file } = require('../helper')
+
+const pipeline = promisify(stream.pipeline)
+const { Writable } = stream
+const sleep = promisify(setTimeout)
+
+const skip = process.env.CI || process.env.CITGM
+
+test('eight million lines', { skip }, async () => {
+  const destination = file()
+  await execa(process.argv[0], [join(__dirname, '..', 'fixtures', 'transport-many-lines.js'), destination])
+
+  if (process.platform !== 'win32') {
+    try {
+      await execa('sync') // Wait for the file to be written to disk
+    } catch {
+      // Just a fallback, this should be unreachable
+    }
+  }
+  await sleep(1_000) // It seems that sync is not enough (even in POSIX systems)
+
+  const toWrite = 8 * 1_000_000
+  let count = 0
+  await pipeline(createReadStream(destination), split(), new Writable({
+    write (chunk, enc, cb) {
+      count++
+      cb()
+    }
+  }))
+  assert.equal(count, toWrite)
+})