@contrast/agent-bundle 5.46.0 → 5.48.0

package/node_modules/pino/test/custom-levels.test.js

@@ -2,7 +2,9 @@
 
 /* eslint no-prototype-builtins: 0 */
 
-const { test } = require('tap')
+const test = require('node:test')
+const assert = require('node:assert')
+
 const { sink, once } = require('./helper')
 const pino = require('../')
 
@@ -10,7 +12,7 @@ const pino = require('../')
 process.removeAllListeners('warning')
 process.on('warning', () => {})
 
-test('adds additional levels', async ({ equal }) => {
+test('adds additional levels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -21,10 +23,10 @@ test('adds additional levels', async ({ equal }) => {
 
   logger.foo('test')
   const { level } = await once(stream, 'data')
-  equal(level, 35)
+  assert.equal(level, 35)
 })
 
-test('custom levels does not override default levels', async ({ equal }) => {
+test('custom levels does not override default levels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -34,10 +36,10 @@ test('custom levels does not override default levels', async ({ equal }) => {
 
   logger.info('test')
   const { level } = await once(stream, 'data')
-  equal(level, 30)
+  assert.equal(level, 30)
 })
 
-test('default levels can be redefined using custom levels', async ({ equal }) => {
+test('default levels can be redefined using custom levels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -47,14 +49,14 @@ test('default levels can be redefined using custom levels', async ({ equal }) =>
     useOnlyCustomLevels: true
   }, stream)
 
-  equal(logger.hasOwnProperty('info'), true)
+  assert.equal(logger.hasOwnProperty('info'), true)
 
   logger.info('test')
   const { level } = await once(stream, 'data')
-  equal(level, 35)
+  assert.equal(level, 35)
 })
 
-test('custom levels overrides default level label if use useOnlyCustomLevels', async ({ equal }) => {
+test('custom levels overrides default level label if use useOnlyCustomLevels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -64,10 +66,10 @@ test('custom levels overrides default level label if use useOnlyCustomLevels', a
     level: 'foo'
   }, stream)
 
-  equal(logger.hasOwnProperty('info'), false)
+  assert.equal(logger.hasOwnProperty('info'), false)
 })
 
-test('custom levels overrides default level value if use useOnlyCustomLevels', async ({ equal }) => {
+test('custom levels overrides default level value if use useOnlyCustomLevels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -77,10 +79,10 @@ test('custom levels overrides default level value if use useOnlyCustomLevels', a
     level: 35
   }, stream)
 
-  equal(logger.hasOwnProperty('info'), false)
+  assert.equal(logger.hasOwnProperty('info'), false)
 })
 
-test('custom levels are inherited by children', async ({ equal }) => {
+test('custom levels are inherited by children', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -90,12 +92,12 @@ test('custom levels are inherited by children', async ({ equal }) => {
 
   logger.child({ childMsg: 'ok' }).foo('test')
   const { msg, childMsg, level } = await once(stream, 'data')
-  equal(level, 35)
-  equal(childMsg, 'ok')
-  equal(msg, 'test')
+  assert.equal(level, 35)
+  assert.equal(childMsg, 'ok')
+  assert.equal(msg, 'test')
 })
 
-test('custom levels can be specified on child bindings', async ({ equal }) => {
+test('custom levels can be specified on child bindings', async () => {
   const stream = sink()
   const logger = pino(stream).child({
     childMsg: 'ok'
@@ -107,12 +109,12 @@ test('custom levels can be specified on child bindings', async ({ equal }) => {
 
   logger.foo('test')
   const { msg, childMsg, level } = await once(stream, 'data')
-  equal(level, 35)
-  equal(childMsg, 'ok')
-  equal(msg, 'test')
+  assert.equal(level, 35)
+  assert.equal(childMsg, 'ok')
+  assert.equal(msg, 'test')
 })
 
-test('customLevels property child bindings does not get logged', async ({ equal }) => {
+test('customLevels property child bindings does not get logged', async () => {
   const stream = sink()
   const logger = pino(stream).child({
     childMsg: 'ok'
@@ -124,94 +126,106 @@ test('customLevels property child bindings does not get logged', async ({ equal
 
   logger.foo('test')
   const { customLevels } = await once(stream, 'data')
-  equal(customLevels, undefined)
+  assert.equal(customLevels, undefined)
 })
 
-test('throws when specifying pre-existing parent labels via child bindings', async ({ throws }) => {
+test('throws when specifying pre-existing parent labels via child bindings', async () => {
   const stream = sink()
-  throws(() => pino({
-    customLevels: {
-      foo: 35
-    }
-  }, stream).child({}, {
-    customLevels: {
-      foo: 45
-    }
-  }), 'levels cannot be overridden')
+  assert.throws(
+    () => pino({
+      customLevels: {
+        foo: 35
+      }
+    }, stream).child({}, {
+      customLevels: {
+        foo: 45
+      }
+    }),
+    /levels cannot be overridden/
+  )
 })
 
-test('throws when specifying pre-existing parent values via child bindings', async ({ throws }) => {
+test('throws when specifying pre-existing parent values via child bindings', async () => {
   const stream = sink()
-  throws(() => pino({
-    customLevels: {
-      foo: 35
-    }
-  }, stream).child({}, {
-    customLevels: {
-      bar: 35
-    }
-  }), 'pre-existing level values cannot be used for new levels')
+  assert.throws(
+    () => pino({
+      customLevels: {
+        foo: 35
+      }
+    }, stream).child({}, {
+      customLevels: {
+        bar: 35
+      }
+    }),
+    /pre-existing level values cannot be used for new levels/
+  )
 })
 
-test('throws when specifying core values via child bindings', async ({ throws }) => {
+test('throws when specifying core values via child bindings', async () => {
   const stream = sink()
-  throws(() => pino(stream).child({}, {
-    customLevels: {
-      foo: 30
-    }
-  }), 'pre-existing level values cannot be used for new levels')
+  assert.throws(
+    () => pino(stream).child({}, {
+      customLevels: {
+        foo: 30
+      }
+    }),
+    /pre-existing level values cannot be used for new levels/
+  )
 })
 
-test('throws when useOnlyCustomLevels is set true without customLevels', async ({ throws }) => {
+test('throws when useOnlyCustomLevels is set true without customLevels', async () => {
   const stream = sink()
-  throws(() => pino({
-    useOnlyCustomLevels: true
-  }, stream), 'customLevels is required if useOnlyCustomLevels is set true')
+  assert.throws(
+    () => pino({
+      useOnlyCustomLevels: true
+    }, stream),
+    /customLevels is required if useOnlyCustomLevels is set true/
+  )
 })
 
-test('custom level on one instance does not affect other instances', async ({ equal }) => {
+test('custom level on one instance does not affect other instances', async () => {
   pino({
     customLevels: {
       foo: 37
     }
   })
-  equal(typeof pino().foo, 'undefined')
+  assert.equal(typeof pino().foo, 'undefined')
 })
 
-test('setting level below or at custom level will successfully log', async ({ equal }) => {
+test('setting level below or at custom level will successfully log', async () => {
   const stream = sink()
   const instance = pino({ customLevels: { foo: 35 } }, stream)
   instance.level = 'foo'
   instance.info('nope')
   instance.foo('bar')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'bar')
+  assert.equal(msg, 'bar')
 })
 
-test('custom level below level threshold will not log', async ({ equal }) => {
+test('custom level below level threshold will not log', async () => {
   const stream = sink()
   const instance = pino({ customLevels: { foo: 15 } }, stream)
   instance.level = 'info'
   instance.info('bar')
   instance.foo('nope')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'bar')
+  assert.equal(msg, 'bar')
 })
 
-test('does not share custom level state across siblings', async ({ doesNotThrow }) => {
+test('does not share custom level state across siblings', async () => {
   const stream = sink()
   const logger = pino(stream)
   logger.child({}, {
     customLevels: { foo: 35 }
   })
-  doesNotThrow(() => {
+  assert.doesNotThrow(() => {
     logger.child({}, {
       customLevels: { foo: 35 }
     })
   })
 })
 
-test('custom level does not affect the levels serializer', async ({ equal }) => {
+test('custom level does not affect the levels serializer', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -227,10 +241,10 @@ test('custom level does not affect the levels serializer', async ({ equal }) =>
 
   logger.foo('test')
   const { priority } = await once(stream, 'data')
-  equal(priority, 35)
+  assert.equal(priority, 35)
 })
 
-test('When useOnlyCustomLevels is set to true, the level formatter should only get custom levels', async ({ equal }) => {
+test('When useOnlyCustomLevels is set to true, the level formatter should only get custom levels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -240,8 +254,8 @@ test('When useOnlyCustomLevels is set to true, the level formatter should only g
     level: 42,
     formatters: {
       level (label, number) {
-        equal(label, 'answer')
-        equal(number, 42)
+        assert.equal(label, 'answer')
+        assert.equal(number, 42)
         return { level: number }
       }
     }
@@ -249,5 +263,5 @@ test('When useOnlyCustomLevels is set to true, the level formatter should only g
 
   logger.answer('test')
   const { level } = await once(stream, 'data')
-  equal(level, 42)
+  assert.equal(level, 42)
 })

package/node_modules/pino/test/diagnostics.test.js

@@ -0,0 +1,107 @@
+'use strict'
+
+const test = require('node:test')
+const os = require('node:os')
+const diagChan = require('node:diagnostics_channel')
+const { AsyncLocalStorage } = require('node:async_hooks')
+const { Writable } = require('node:stream')
+const tspl = require('@matteo.collina/tspl')
+const pino = require('../pino')
+
+const hostname = os.hostname()
+const { pid } = process
+const AS_JSON_START = 'tracing:pino_asJson:start'
+const AS_JSON_END = 'tracing:pino_asJson:end'
+
+// Skip tests if diagnostics_channel.tracingChannel is not available (Node < 18.19)
+const skip = typeof diagChan.tracingChannel !== 'function'
+
+test.beforeEach(ctx => {
+  ctx.pino = {
+    ts: 1757512800000, // 2025-09-10T10:00:00.000-05:00
+    now: Date.now
+  }
+
+  Date.now = () => ctx.pino.ts
+
+  ctx.pino.dest = new Writable({
+    objectMode: true,
+    write (data, enc, cb) {
+      cb()
+    }
+  })
+})
+
+test.afterEach(ctx => {
+  Date.now = ctx.pino.now
+})
+
+test('asJson emits events', { skip }, async (t) => {
+  const plan = tspl(t, { plan: 8 })
+  const { dest } = t.pino
+  const logger = pino({}, dest)
+  const expectedArguments = [
+    {},
+    'testing',
+    30,
+    `,"time":${t.pino.ts}`
+  ]
+
+  let startEvent
+  diagChan.subscribe(AS_JSON_START, startHandler)
+  diagChan.subscribe(AS_JSON_END, endHandler)
+
+  logger.info('testing')
+  await plan
+
+  diagChan.unsubscribe(AS_JSON_START, startHandler)
+  diagChan.unsubscribe(AS_JSON_END, endHandler)
+
+  function startHandler (event) {
+    startEvent = event
+    plan.equal(Object.prototype.toString.call(event.instance), '[object Pino]')
+    plan.equal(event.instance === logger, true)
+    plan.deepStrictEqual(Array.from(event.arguments ?? []), expectedArguments)
+  }
+
+  function endHandler (event) {
+    plan.equal(Object.prototype.toString.call(event.instance), '[object Pino]')
+    plan.equal(event.instance === logger, true)
+    plan.deepStrictEqual(Array.from(event.arguments ?? []), expectedArguments)
+    plan.equal(
+      event.result,
+      `{"level":30,"time":${t.pino.ts},"pid":${pid},"hostname":"${hostname}","msg":"testing"}\n`
+    )
+
+    plan.equal(event.arguments === startEvent.arguments, true, 'same event object is supplied to both events')
+  }
+})
+
+test('asJson context is not lost', { skip }, async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const { dest } = t.pino
+  const logger = pino({}, dest)
+  const asyncLocalStorage = new AsyncLocalStorage()
+  const localStore = { foo: 'bar' }
+
+  diagChan.subscribe(AS_JSON_START, startHandler)
+  diagChan.subscribe(AS_JSON_END, endHandler)
+
+  asyncLocalStorage.run(localStore, () => {
+    logger.info('testing')
+  })
+  await plan
+
+  diagChan.unsubscribe(AS_JSON_START, startHandler)
+  diagChan.unsubscribe(AS_JSON_END, endHandler)
+
+  function startHandler () {
+    const store = asyncLocalStorage.getStore()
+    plan.equal(store === localStore, true)
+  }
+
+  function endHandler () {
+    const store = asyncLocalStorage.getStore()
+    plan.equal(store === localStore, true)
+  }
+})

package/node_modules/pino/test/error-key.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+
+const { sink, once } = require('./helper')
+const stdSerializers = require('pino-std-serializers')
+const pino = require('../')
+
+test('set the errorKey with error serializer', async () => {
+  const stream = sink()
+  const errorKey = 'error'
+  const instance = pino({
+    errorKey,
+    serializers: { [errorKey]: stdSerializers.err }
+  }, stream)
+  instance.error(new ReferenceError('test'))
+  const o = await once(stream, 'data')
+  assert.equal(typeof o[errorKey], 'object')
+  assert.equal(o[errorKey].type, 'ReferenceError')
+  assert.equal(o[errorKey].message, 'test')
+  assert.equal(typeof o[errorKey].stack, 'string')
+})
+
+test('set the errorKey without error serializer', async () => {
+  const stream = sink()
+  const errorKey = 'error'
+  const instance = pino({
+    errorKey
+  }, stream)
+  instance.error(new ReferenceError('test'))
+  const o = await once(stream, 'data')
+  assert.equal(typeof o[errorKey], 'object')
+  assert.equal(o[errorKey].type, 'ReferenceError')
+  assert.equal(o[errorKey].message, 'test')
+  assert.equal(typeof o[errorKey].stack, 'string')
+})