allow passing callback to flush

docs/api.md

@@ -964,12 +964,12 @@ console.log(anotherChild.bindings())
 ```
 
 <a id="flush"></a>
-### `logger.flush()`
+### `logger.flush([cb])`
 
 Flushes the content of the buffer when using `pino.destination({
 sync: false })`.
 
-This is an asynchronous, fire and forget, operation.
+This is an asynchronous, best used as fire and forget, operation.
 
 The use case is primarily for asynchronous logging, which may buffer
 log lines while others are being written. The `logger.flush` method can be
@@ -978,6 +978,8 @@ on a long interval, say ten seconds. Such a strategy can provide an
 optimum balance between extremely efficient logging at high demand periods
 and safer logging at low demand periods.
 
+If there is a need to wait for the logs to be flushed, a callback should be used.
+
 * See [`destination` parameter](#destination)
 * See [Asynchronous Logging ⇗](/docs/asynchronous.md)
 

lib/proto.js

@@ -219,7 +219,14 @@ function write (_obj, msg, num) {
 
 function noop () {}
 
-function flush () {
+function flush (cb) {
+ if (cb != null && typeof cb !== 'function') {
+ throw Error('callback must be a function')
+ }
+
  const stream = this[streamSym]
- if ('flush' in stream) stream.flush(noop)
+
+ if ('flush' in stream) {
+ stream.flush(cb || noop)
+ } else if (cb) cb()
 }

package.json

@@ -110,7 +110,7 @@
  "quick-format-unescaped": "^4.0.3",
  "real-require": "^0.2.0",
  "safe-stable-stringify": "^2.3.1",
- "sonic-boom": "^3.1.0",
+ "sonic-boom": "^3.7.0",
  "thread-stream": "^2.0.0"
  },
  "tsd": {

pino.d.ts

@@ -122,8 +122,9 @@ export interface LoggerExtras<Options = LoggerOptions> extends EventEmitter {
 
  /**
  * Flushes the content of the buffer when using pino.destination({ sync: false }).
+ * call the callback when finished
  */
- flush(): void;
+ flush(cb?: (err?: Error) => void): void;
 }
 
 

test/syncfalse.test.js

@@ -1,17 +1,28 @@
 'use strict'
 
 const os = require('os')
-const { createWriteStream } = require('fs')
+const {
+ createWriteStream
+} = require('fs')
+const { readFile } = require('fs').promises
 const { join } = require('path')
 const { test } = require('tap')
 const { fork } = require('child_process')
 const writer = require('flush-write-stream')
-const { once, getPathToNull } = require('./helper')
+const {
+ once,
+ getPathToNull,
+ file,
+ watchFileCreated
+} = require('./helper')
 const { promisify } = require('util')
 
 const sleep = promisify(setTimeout)
 
-test('asynchronous logging', async ({ equal, teardown }) => {
+test('asynchronous logging', async ({
+ equal,
+ teardown
+}) => {
  const now = Date.now
  const hostname = os.hostname
  const proc = process
@@ -63,7 +74,10 @@ test('asynchronous logging', async ({ equal, teardown }) => {
  })
 })
 
-test('sync false with child', async ({ equal, teardown }) => {
+test('sync false with child', async ({
+ equal,
+ teardown
+}) => {
  const now = Date.now
  const hostname = os.hostname
  const proc = process
@@ -87,7 +101,9 @@ test('sync false with child', async ({ equal, teardown }) => {
  })).child({ hello: 'world' })
 
  const dest = createWriteStream(getPathToNull())
- dest.write = function (s) { actual += s }
+ dest.write = function (s) {
+ actual += s
+ }
  const asyncLogger = pino(dest).child({ hello: 'world' })
 
  let i = 500
@@ -121,3 +137,55 @@ test('flush does nothing with sync true (default)', async ({ equal }) => {
  const instance = require('..')()
  equal(instance.flush(), undefined)
 })
+
+test('should still call flush callback even when does nothing with sync true (default)', (t) => {
+ t.plan(3)
+ const instance = require('..')()
+ instance.flush((...args) => {
+ t.ok('flush called')
+ t.same(args, [])
+
+ // next tick to make flush not called more than once
+ process.nextTick(() => {
+ t.ok('flush next tick called')
+ })
+ })
+})
+
+test('should call the flush callback when flushed the data for async logger', async (t) => {
+ 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()
+
+ t.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()
+ t.equal(afterLogData.length, 1)
+
+ await flushPromise()
+
+ // Making sure data is not flushed yet
+ const afterSecondFlush = (await getOutputLogLines())[1]
+ t.equal(afterSecondFlush.msg, 'world')
+})

test/transport/syncfalse.test.js

@@ -6,6 +6,7 @@ const { join } = require('path')
 const { test } = require('tap')
 const { readFile } = require('fs').promises
 const { watchFileCreated, file } = require('../helper')
+const { promisify } = require('util')
 
 const { pid } = process
 const hostname = os.hostname()
@@ -31,3 +32,37 @@ test('thread-stream async flush', async ({ equal, same }) => {
  msg: 'hello'
  })
 })
+
+test('thread-stream async flush should call the passed callback', async (t) => {
+ const outputPath = file()
+ async function getOutputLogLines () {
+ return (await readFile(outputPath)).toString().trim().split('\n').map(JSON.parse)
+ }
+ const transport = pino.transport({
+ target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+ options: { destination: outputPath }
+ })
+ const instance = pino(transport)
+ const flushPromise = promisify(instance.flush).bind(instance)
+
+ instance.info('hello')
+ await flushPromise()
+ await watchFileCreated(outputPath)
+
+ const [firstFlushData] = await getOutputLogLines()
+
+ t.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()
+ t.equal(afterLogData.length, 1)
+
+ await flushPromise()
+
+ // Making sure data is not flushed yet
+ const afterSecondFlush = (await getOutputLogLines())[1]
+ t.equal(afterSecondFlush.msg, 'world')
+})

test/types/pino.test-d.ts

@@ -112,6 +112,7 @@ pino({ base: null });
 if ("pino" in log) console.log(`pino version: ${log.pino}`);
 
 expectType<void>(log.flush());
+log.flush((err?: Error) => undefined);
 log.child({ a: "property" }).info("hello child!");
 log.level = "error";
 log.info("nope");