console: do not emit error events

Author: addaleax

lib/_stream_writable.js

@@ -87,7 +87,7 @@ function WritableState(options, stream) {
 
   // the callback that's passed to _write(chunk,cb)
   this.onwrite = function(er) {
-    onwrite(stream, er);
+    return onwrite(stream, er);
   };
 
   // the callback that the user supplies to write(chunk,encoding,cb)
@@ -337,10 +337,14 @@ function doWrite(stream, state, writev, len, chunk, encoding, cb) {
 
 function onwriteError(stream, state, sync, er, cb) {
   --state.pendingcb;
-  if (sync)
+
+  if (sync) {
     process.nextTick(cb, er);
-  else
-    cb(er);
+  } else {
+    if (cb(er) === doNotEmitErrorEvent) {
+      return doNotEmitErrorEvent;
+    }
+  }
 
   stream._writableState.errorEmitted = true;
   stream.emit('error', er);
@@ -361,7 +365,7 @@ function onwrite(stream, er) {
   onwriteStateUpdate(state);
 
   if (er)
-    onwriteError(stream, state, sync, er, cb);
+    return onwriteError(stream, state, sync, er, cb);
   else {
     // Check if we're actually ready to finish, but don't emit yet
     var finished = needFinish(state);
@@ -555,3 +559,7 @@ function CorkedRequest(state) {
     }
   };
 }
+
+
+const doNotEmitErrorEvent = Symbol('doNotEmitErrorEvent');
+Writable.doNotEmitErrorEvent = doNotEmitErrorEvent;

lib/console.js

@@ -1,10 +1,11 @@
 'use strict';
 
 const util = require('util');
+const { doNotEmitErrorEvent } = require('stream').Writable;
 
-function Console(stdout, stderr) {
+function Console(stdout, stderr, ignoreErrors) {
   if (!(this instanceof Console)) {
-    return new Console(stdout, stderr);
+    return new Console(stdout, stderr, ignoreErrors);
   }
   if (!stdout || typeof stdout.write !== 'function') {
     throw new TypeError('Console expects a writable stream instance');
@@ -24,6 +25,8 @@ function Console(stdout, stderr) {
   Object.defineProperty(this, '_stdout', prop);
   prop.value = stderr;
   Object.defineProperty(this, '_stderr', prop);
+  prop.value = ignoreErrors === undefined ? true : !!ignoreErrors;
+  Object.defineProperty(this, '_ignoreErrors', prop);
   prop.value = new Map();
   Object.defineProperty(this, '_times', prop);
 
@@ -35,20 +38,32 @@ function Console(stdout, stderr) {
   }
 }
 
+function write(ignoreErrors, stream, string) {
+  if (!ignoreErrors) return stream.write(string);
+
+  try {
+    stream.write(string, (err) => {
+      return doNotEmitErrorEvent;
+    });
+  } catch (e) {
+    // Sorry, there’s proper way to pass along the error here.
+  }
+}
+
 
 // As of v8 5.0.71.32, the combination of rest param, template string
 // and .apply(null, args) benchmarks consistently faster than using
 // the spread operator when calling util.format.
 Console.prototype.log = function log(...args) {
-  this._stdout.write(`${util.format.apply(null, args)}\n`);
+  write(this._ignoreErrors, this._stdout, `${util.format.apply(null, args)}\n`);
 };
 
 
 Console.prototype.info = Console.prototype.log;
 
 
 Console.prototype.warn = function warn(...args) {
-  this._stderr.write(`${util.format.apply(null, args)}\n`);
+  write(this._ignoreErrors, this._stderr, `${util.format.apply(null, args)}\n`);
 };
 
 
@@ -57,7 +72,7 @@ Console.prototype.error = Console.prototype.warn;
 
 Console.prototype.dir = function dir(object, options) {
   options = Object.assign({customInspect: false}, options);
-  this._stdout.write(`${util.inspect(object, options)}\n`);
+  write(this._ignoreErrors, this._stdout, `${util.inspect(object, options)}\n`);
 };
 
 

lib/net.js

@@ -463,12 +463,15 @@ Socket.prototype.destroySoon = function() {
     this.once('finish', this.destroy);
 };
 
-
 Socket.prototype._destroy = function(exception, cb) {
   debug('destroy');
 
   function fireErrorCallbacks(self) {
-    if (cb) cb(exception);
+    if (cb) {
+      if (cb(exception) === stream.Writable.doNotEmitErrorEvent)
+        return;
+    }
+
     if (exception && !self._writableState.errorEmitted) {
       process.nextTick(emitErrorNT, self, exception);
       self._writableState.errorEmitted = true;