From the original code snippet, it is using net.Socket.

    socket = net.createConnection(config.loggerPort || 5000, config.loggerHost || 'localhost');

net.createConnection()

A factory function, which creates a new net.Socket, immediately initiates connection with socket.connect(), then returns the net.Socket that starts the connection.

(src: https://nodejs.org/dist/latest-v16.x/docs/api/net.html#netcreateconnection)

Based on net.Socket API:

Event: 'error'

Added in: v0.1.90

• <Error>

Emitted when an error occurs. The 'close' event will be called directly following this event.

(src: https://nodejs.org/dist/latest-v16.x/docs/api/net.html#class-netsocket)

It seems like the behavior did not change and that the 'close' event will still get called.

@jhonatanTeixeira Would you happen to have any references that newer NodeJS requires listening to socket errors?
Nevertheless, it seems good to flush the buffer on 'error' before it calls 'close'.

Just run it on a newer nodejs and try to connect to a tcp destination like logstash for example and you will see it trhows an error. Newer nodejs require all errors thrown inside a promise to be catched, so that cancels the connection

@jhonatanTeixeira I verified. Good find!

It's due to the way EventEmitter works (not Promises in this case).

If there is no listener to the 'error' event, the EventEmitter additionally throws the error, which in turn becomes uncaughtException that terminates the Node.js process. This portion has been overlooked and this PR patches it.

Events

Error events

When an error occurs within an EventEmitter instance, the typical action is for an 'error' event to be emitted. These are treated as special cases within Node.js.

If an EventEmitter does not have at least one listener registered for the 'error' event, and an 'error' event is emitted, the error is thrown, a stack trace is printed, and the Node.js process exits.

const myEmitter = new MyEmitter();
myEmitter.emit('error', new Error('whoops!'));
// Throws and crashes Node.js

To guard against crashing the Node.js process the domain module can be used. (Note, however, that the domain module is deprecated.)

As a best practice, listeners should always be added for the 'error' events.

const myEmitter = new MyEmitter();
myEmitter.on('error', (err) => {
  console.error('whoops! there was an error');
});
myEmitter.emit('error', new Error('whoops!'));
// Prints: whoops! there was an error

(src: https://nodejs.org/docs/latest/api/events.html#error-events)