730 lines
16 KiB
JavaScript
730 lines
16 KiB
JavaScript
'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('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('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
|
|
})
|