pino-testkit 10.4.5

package/test/transport/core.transpiled.test.ts

@@ -0,0 +1,114 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import * as os from 'node:os'
+import { join } from 'node:path'
+import fs from 'node:fs'
+import * as url from 'node:url'
+
+import { watchFileCreated } from '../helper'
+import pino from '../../'
+
+const readFile = fs.promises.readFile
+
+const { pid } = process
+const hostname = os.hostname()
+
+// A subset of the test from core.test.js, we don't need all of them to check for compatibility
+function runTests (esVersion: string): void {
+  test(`(ts -> ${esVersion}) pino.transport with file`, async (t) => {
+    const destination = join(
+      os.tmpdir(),
+      '_' + Math.random().toString(36).substr(2, 9)
+    )
+    const transport = pino.transport({
+      target: join(__dirname, '..', 'fixtures', 'ts', `to-file-transport.${esVersion}.cjs`),
+      options: { destination }
+    })
+    t.after(transport.end.bind(transport))
+    const instance = pino(transport)
+    instance.info('hello')
+    await watchFileCreated(destination)
+    const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+    delete result.time
+    assert.deepEqual(result, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'hello'
+    })
+  })
+
+  test(`(ts -> ${esVersion}) pino.transport with file URL`, async (t) => {
+    const destination = join(
+      os.tmpdir(),
+      '_' + Math.random().toString(36).substr(2, 9)
+    )
+    const transport = pino.transport({
+      target: url.pathToFileURL(join(__dirname, '..', 'fixtures', 'ts', `to-file-transport.${esVersion}.cjs`)).href,
+      options: { destination }
+    })
+    t.after(transport.end.bind(transport))
+    const instance = pino(transport)
+    instance.info('hello')
+    await watchFileCreated(destination)
+    const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+    delete result.time
+    assert.deepEqual(result, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'hello'
+    })
+  })
+
+  test(`(ts -> ${esVersion}) pino.transport with two files`, async (t) => {
+    const dest1 = join(
+      os.tmpdir(),
+      '_' + Math.random().toString(36).substr(2, 9)
+    )
+    const dest2 = join(
+      os.tmpdir(),
+      '_' + Math.random().toString(36).substr(2, 9)
+    )
+    const transport = pino.transport({
+      targets: [{
+        level: 'info',
+        target: join(__dirname, '..', 'fixtures', 'ts', `to-file-transport.${esVersion}.cjs`),
+        options: { destination: dest1 }
+      }, {
+        level: 'info',
+        target: join(__dirname, '..', 'fixtures', 'ts', `to-file-transport.${esVersion}.cjs`),
+        options: { destination: dest2 }
+      }]
+    })
+
+    t.after(transport.end.bind(transport))
+
+    const instance = pino(transport)
+    instance.info('hello')
+
+    await Promise.all([watchFileCreated(dest1), watchFileCreated(dest2)])
+
+    const result1 = JSON.parse(await readFile(dest1, { encoding: 'utf8' }))
+    delete result1.time
+    assert.deepEqual(result1, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'hello'
+    })
+    const result2 = JSON.parse(await readFile(dest2, { encoding: 'utf8' }))
+    delete result2.time
+    assert.deepEqual(result2, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'hello'
+    })
+  })
+}
+
+runTests('es5')
+runTests('es6')
+runTests('es2017')
+runTests('esnext')

package/test/transport/crash.test.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { once } = require('node:events')
+const { setImmediate: immediate } = require('node:timers/promises')
+
+const pino = require('../../')
+
+test('pino.transport emits error if the worker exits with 0 unexpectably', async (t) => {
+  // This test will take 10s, because flushSync waits for 10s
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'crashing-transport.js'),
+    sync: true
+  })
+  t.after(transport.end.bind(transport))
+
+  await once(transport, 'ready')
+
+  let maybeError
+  transport.on('error', (err) => {
+    maybeError = err
+  })
+
+  const logger = pino(transport)
+  for (let i = 0; i < 100000; i++) {
+    logger.info('hello')
+  }
+
+  await once(transport.worker, 'exit')
+
+  await immediate()
+
+  assert.equal(maybeError.message, 'the worker has exited')
+})

package/test/transport/module-link.test.js

@@ -0,0 +1,241 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const os = require('node:os')
+const { join } = require('node:path')
+const { readFile, symlink, unlink, mkdir, writeFile } = require('node:fs').promises
+const { once } = require('node:events')
+const execa = require('execa')
+const rimraf = require('rimraf')
+
+const { isWin, isYarnPnp, watchFileCreated, file } = require('../helper')
+const pino = require('../../')
+
+const { pid } = process
+const hostname = os.hostname()
+
+async function installTransportModule (target) {
+  if (isYarnPnp) {
+    return
+  }
+  try {
+    await uninstallTransportModule()
+  } catch {}
+
+  if (!target) {
+    target = join(__dirname, '..', '..')
+  }
+
+  await symlink(
+    join(__dirname, '..', 'fixtures', 'transport'),
+    join(target, 'node_modules', 'transport')
+  )
+}
+
+async function uninstallTransportModule () {
+  if (isYarnPnp) {
+    return
+  }
+  await unlink(join(__dirname, '..', '..', 'node_modules', 'transport'))
+}
+
+// TODO make this test pass on Windows
+test('pino.transport with package', { skip: isWin }, async (t) => {
+  const destination = file()
+
+  await installTransportModule()
+
+  const transport = pino.transport({
+    target: 'transport',
+    options: { destination }
+  })
+
+  t.after(async () => {
+    await uninstallTransportModule()
+    transport.end()
+  })
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+// TODO make this test pass on Windows
+test('pino.transport with package as a target', { skip: isWin }, async (t) => {
+  const destination = file()
+
+  await installTransportModule()
+
+  const transport = pino.transport({
+    targets: [{
+      target: 'transport',
+      options: { destination }
+    }]
+  })
+  t.after(async () => {
+    await uninstallTransportModule()
+    transport.end()
+  })
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+// TODO make this test pass on Windows
+test('pino({ transport })', { skip: isWin || isYarnPnp }, async (t) => {
+  const folder = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  t.after(() => {
+    rimraf.sync(folder)
+  })
+
+  const destination = join(folder, 'output')
+
+  await mkdir(join(folder, 'node_modules'), { recursive: true })
+
+  // Link pino
+  await symlink(
+    join(__dirname, '..', '..'),
+    join(folder, 'node_modules', 'pino')
+  )
+
+  await installTransportModule(folder)
+
+  const toRun = join(folder, 'index.js')
+
+  const toRunContent = `
+    const pino = require('pino')
+    const logger = pino({
+      transport: {
+        target: 'transport',
+        options: { destination: '${destination}' }
+      }
+    })
+    logger.info('hello')
+  `
+
+  await writeFile(toRun, toRunContent)
+
+  const child = execa(process.argv[0], [toRun])
+
+  await once(child, 'close')
+
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  assert.deepEqual(result, {
+    pid: child.pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+// TODO make this test pass on Windows
+test('pino({ transport }) from a wrapped dependency', { skip: isWin || isYarnPnp }, async (t) => {
+  const folder = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  const wrappedFolder = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  const destination = join(folder, 'output')
+
+  await mkdir(join(folder, 'node_modules'), { recursive: true })
+  await mkdir(join(wrappedFolder, 'node_modules'), { recursive: true })
+
+  t.after(() => {
+    rimraf.sync(wrappedFolder)
+    rimraf.sync(folder)
+  })
+
+  // Link pino
+  await symlink(
+    join(__dirname, '..', '..'),
+    join(wrappedFolder, 'node_modules', 'pino')
+  )
+
+  // Link get-caller-file
+  await symlink(
+    join(__dirname, '..', '..', 'node_modules', 'get-caller-file'),
+    join(wrappedFolder, 'node_modules', 'get-caller-file')
+  )
+
+  // Link wrapped
+  await symlink(
+    wrappedFolder,
+    join(folder, 'node_modules', 'wrapped')
+  )
+
+  await installTransportModule(folder)
+
+  const pkgjsonContent = {
+    name: 'pino'
+  }
+
+  await writeFile(join(wrappedFolder, 'package.json'), JSON.stringify(pkgjsonContent))
+
+  const wrapped = join(wrappedFolder, 'index.js')
+
+  const wrappedContent = `
+    const pino = require('pino')
+    const getCaller = require('get-caller-file')
+
+    module.exports = function build () {
+      const logger = pino({
+        transport: {
+          caller: getCaller(),
+          target: 'transport',
+          options: { destination: '${destination}' }
+        }
+      })
+      return logger
+    }
+  `
+
+  await writeFile(wrapped, wrappedContent)
+
+  const toRun = join(folder, 'index.js')
+
+  const toRunContent = `
+    const logger = require('wrapped')()
+    logger.info('hello')
+  `
+
+  await writeFile(toRun, toRunContent)
+
+  const child = execa(process.argv[0], [toRun])
+
+  await once(child, 'close')
+
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  assert.deepEqual(result, {
+    pid: child.pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})

package/test/transport/native-type-stripping.test.mjs

@@ -0,0 +1,151 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import * as os from 'node:os'
+import { join } from 'node:path'
+import fs from 'node:fs'
+import * as url from 'node:url'
+
+import { watchFileCreated } from '../helper.js'
+
+const readFile = fs.promises.readFile
+
+const { pid } = process
+const hostname = os.hostname()
+
+// Check if Node.js supports native type stripping (Node.js 22+)
+function supportsTypeStripping () {
+  const major = parseInt(process.versions.node.split('.')[0], 10)
+  return major >= 22
+}
+
+// Only run these tests on Node.js 22+
+const skipTests = !supportsTypeStripping()
+const skipMessage = 'Native TypeScript type stripping not supported (requires Node.js 22+)'
+
+test('pino.transport with native TypeScript file', { skip: skipTests ? skipMessage : false }, async (t) => {
+  const destination = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  // We need to dynamically import pino to ensure worker thread inherits flags
+  const { default: pino } = await import('../../pino.js')
+
+  const transport = pino.transport({
+    target: join(import.meta.dirname || url.fileURLToPath(new URL('.', import.meta.url)), '..', 'fixtures', 'ts', 'to-file-transport-native.mts'),
+    options: { destination }
+  })
+
+  t.after(() => {
+    transport.end()
+    try {
+      fs.unlinkSync(destination)
+    } catch {}
+  })
+
+  const instance = pino(transport)
+  instance.info('hello from native TypeScript transport')
+
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+  delete result.time
+
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello from native TypeScript transport'
+  })
+})
+
+test('pino.transport with native TypeScript file URL', { skip: skipTests ? skipMessage : false }, async (t) => {
+  const destination = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  const { default: pino } = await import('../../pino.js')
+
+  const transport = pino.transport({
+    target: url.pathToFileURL(join(import.meta.dirname || url.fileURLToPath(new URL('.', import.meta.url)), '..', 'fixtures', 'ts', 'to-file-transport-native.mts')).href,
+    options: { destination }
+  })
+
+  t.after(() => {
+    transport.end()
+    try {
+      fs.unlinkSync(destination)
+    } catch {}
+  })
+
+  const instance = pino(transport)
+  instance.info('hello from file URL transport')
+
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+  delete result.time
+
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello from file URL transport'
+  })
+})
+
+test('pino.transport with multiple native TypeScript targets', { skip: skipTests ? skipMessage : false }, async (t) => {
+  const dest1 = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const dest2 = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  const { default: pino } = await import('../../pino.js')
+  const fixtureDir = join(import.meta.dirname || url.fileURLToPath(new URL('.', import.meta.url)), '..', 'fixtures', 'ts')
+
+  const transport = pino.transport({
+    targets: [{
+      level: 'info',
+      target: join(fixtureDir, 'to-file-transport-native.mts'),
+      options: { destination: dest1 }
+    }, {
+      level: 'info',
+      target: join(fixtureDir, 'to-file-transport-native.mts'),
+      options: { destination: dest2 }
+    }]
+  })
+
+  t.after(() => {
+    transport.end()
+    try {
+      fs.unlinkSync(dest1)
+      fs.unlinkSync(dest2)
+    } catch {}
+  })
+
+  const instance = pino(transport)
+  instance.info('hello from multiple targets')
+
+  await Promise.all([watchFileCreated(dest1), watchFileCreated(dest2)])
+
+  const result1 = JSON.parse(await readFile(dest1, { encoding: 'utf8' }))
+  delete result1.time
+  assert.deepEqual(result1, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello from multiple targets'
+  })
+
+  const result2 = JSON.parse(await readFile(dest2, { encoding: 'utf8' }))
+  delete result2.time
+  assert.deepEqual(result2, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello from multiple targets'
+  })
+})

package/test/transport/node-options.test.js

@@ -0,0 +1,116 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { EventEmitter } = require('node:events')
+const { join } = require('node:path')
+const { pathToFileURL } = require('node:url')
+const proxyquire = require('proxyquire')
+
+function buildTransportWithFakeThreadStream () {
+  let lastCtorOpts
+
+  class FakeThreadStream extends EventEmitter {
+    constructor (opts) {
+      super()
+      this._closed = false
+      lastCtorOpts = opts
+    }
+
+    unref () {}
+    ref () {}
+    flushSync () {}
+    end () {
+      this._closed = true
+      this.emit('close')
+    }
+
+    get closed () {
+      return this._closed
+    }
+  }
+
+  const transport = proxyquire('../../lib/transport', {
+    'thread-stream': FakeThreadStream
+  })
+
+  return {
+    transport,
+    getLastCtorOpts () {
+      return lastCtorOpts
+    }
+  }
+}
+
+test('pino.transport sanitizes missing absolute preload in NODE_OPTIONS', () => {
+  const previous = process.env.NODE_OPTIONS
+  const missing = join(__dirname, '..', 'fixtures', 'missing-preload.js')
+  process.env.NODE_OPTIONS = `--require ${missing} --trace-warnings`
+
+  const { transport, getLastCtorOpts } = buildTransportWithFakeThreadStream()
+  transport({ target: join(__dirname, '..', 'fixtures', 'to-file-transport.js') })
+
+  assert.equal(getLastCtorOpts().workerOpts.env.NODE_OPTIONS, '--trace-warnings')
+
+  if (previous === undefined) {
+    delete process.env.NODE_OPTIONS
+  } else {
+    process.env.NODE_OPTIONS = previous
+  }
+})
+
+test('pino.transport sanitizes missing file:// preload in NODE_OPTIONS', () => {
+  const previous = process.env.NODE_OPTIONS
+  const missingFileUrl = pathToFileURL(join(__dirname, '..', 'fixtures', 'missing-import.mjs')).href
+  process.env.NODE_OPTIONS = `--import=${missingFileUrl}`
+
+  const { transport, getLastCtorOpts } = buildTransportWithFakeThreadStream()
+  transport({ target: join(__dirname, '..', 'fixtures', 'to-file-transport.js') })
+
+  assert.equal(getLastCtorOpts().workerOpts.env.NODE_OPTIONS, '')
+
+  if (previous === undefined) {
+    delete process.env.NODE_OPTIONS
+  } else {
+    process.env.NODE_OPTIONS = previous
+  }
+})
+
+test('pino.transport keeps relative preload flags in NODE_OPTIONS', () => {
+  const previous = process.env.NODE_OPTIONS
+  process.env.NODE_OPTIONS = '--require ./relative-preload.js'
+
+  const { transport, getLastCtorOpts } = buildTransportWithFakeThreadStream()
+  transport({ target: join(__dirname, '..', 'fixtures', 'to-file-transport.js') })
+
+  assert.equal(getLastCtorOpts().workerOpts.env, undefined)
+
+  if (previous === undefined) {
+    delete process.env.NODE_OPTIONS
+  } else {
+    process.env.NODE_OPTIONS = previous
+  }
+})
+
+test('pino.transport does not override explicit worker.env', () => {
+  const previous = process.env.NODE_OPTIONS
+  process.env.NODE_OPTIONS = `--require ${join(__dirname, '..', 'fixtures', 'missing-preload.js')}`
+
+  const explicitEnv = { NODE_OPTIONS: '--trace-warnings' }
+
+  const { transport, getLastCtorOpts } = buildTransportWithFakeThreadStream()
+  transport({
+    target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+    worker: {
+      env: explicitEnv
+    }
+  })
+
+  assert.equal(getLastCtorOpts().workerOpts.env, explicitEnv)
+
+  if (previous === undefined) {
+    delete process.env.NODE_OPTIONS
+  } else {
+    process.env.NODE_OPTIONS = previous
+  }
+})