console: do not emit error events

Fixes: #831Fixes: #947
Ref: #9470
PR-URL: #9744
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Sakthipriyan Vairamani <thechargingvolcano@gmail.com>

Author: addaleax

lib/console.js

@@ -2,9 +2,9 @@
 
 constutil=require('util');
 
-functionConsole(stdout,stderr){
+functionConsole(stdout,stderr,ignoreErrors=true){
 if(!(thisinstanceofConsole)){
-returnnewConsole(stdout,stderr);
+returnnewConsole(stdout,stderr,ignoreErrors);
 }
 if(!stdout||typeofstdout.write!=='function'){
 thrownewTypeError('Console expects a writable stream instance');
@@ -24,8 +24,14 @@ function Console(stdout, stderr) {
 Object.defineProperty(this,'_stdout',prop);
 prop.value=stderr;
 Object.defineProperty(this,'_stderr',prop);
+prop.value=ignoreErrors;
+Object.defineProperty(this,'_ignoreErrors',prop);
 prop.value=newMap();
 Object.defineProperty(this,'_times',prop);
+prop.value=createWriteErrorHandler(stdout);
+Object.defineProperty(this,'_stdoutErrorHandler',prop);
+prop.value=createWriteErrorHandler(stderr);
+Object.defineProperty(this,'_stderrErrorHandler',prop);
 
 // bind the prototype functions to this Console instance
 varkeys=Object.keys(Console.prototype);
@@ -35,20 +41,60 @@ function Console(stdout, stderr) {
 }
 }
 
+// Make a function that can serve as the callback passed to `stream.write()`.
+functioncreateWriteErrorHandler(stream){
+return(err)=>{
+// This conditional evaluates to true if and only if there was an error
+// that was not already emitted (which happens when the _write callback
+// is invoked asynchronously).
+if(err&&!stream._writableState.errorEmitted){
+// If there was an error, it will be emitted on `stream` as
+// an `error` event. Adding a `once` listener will keep that error
+// from becoming an uncaught exception, but since the handler is
+// removed after the event, non-console.* writes won’t be affected.
+stream.once('error',noop);
+}
+};
+}
+
+functionwrite(ignoreErrors,stream,string,errorhandler){
+if(!ignoreErrors)returnstream.write(string);
+
+// There may be an error occurring synchronously (e.g. for files or TTYs
+// on POSIX systems) or asynchronously (e.g. pipes on POSIX systems), so
+// handle both situations.
+try{
+// Add and later remove a noop error handler to catch synchronous errors.
+stream.once('error',noop);
+
+stream.write(string,errorhandler);
+}catch(e){
+// Sorry, there’s no proper way to pass along the error here.
+}finally{
+stream.removeListener('error',noop);
+}
+}
+
 
 // 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=functionlog(...args){
-this._stdout.write(`${util.format.apply(null,args)}\n`);
+write(this._ignoreErrors,
+this._stdout,
+`${util.format.apply(null,args)}\n`,
+this._stdoutErrorHandler);
 };
 
 
 Console.prototype.info=Console.prototype.log;
 
 
 Console.prototype.warn=functionwarn(...args){
-this._stderr.write(`${util.format.apply(null,args)}\n`);
+write(this._ignoreErrors,
+this._stderr,
+`${util.format.apply(null,args)}\n`,
+this._stderrErrorHandler);
 };
 
 
@@ -57,7 +103,7 @@ Console.prototype.error = Console.prototype.warn;
 
 Console.prototype.dir=functiondir(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`);
 };
 
 
@@ -99,3 +145,5 @@ Console.prototype.assert = function assert(expression, ...args) {
 
 module.exports=newConsole(process.stdout,process.stderr);
 module.exports.Console=Console;
+
+functionnoop(){}

test/parallel/test-console-async-write-error.js

@@ -0,0 +1,17 @@
+'use strict';
+constcommon=require('../common');
+const{ Console }=require('console');
+const{ Writable }=require('stream');
+constassert=require('assert');
+
+constout=newWritable({
+write: common.mustCall((chunk,enc,callback)=>{
+process.nextTick(callback,newError('foobar'));
+})
+});
+
+constc=newConsole(out,out,true);
+
+assert.doesNotThrow(()=>{
+c.log('abc');
+});

test/parallel/test-console-sync-write-error.js

@@ -0,0 +1,47 @@
+'use strict';
+constcommon=require('../common');
+const{ Console }=require('console');
+const{ Writable }=require('stream');
+constassert=require('assert');
+
+{
+constout=newWritable({
+write: common.mustCall((chunk,enc,callback)=>{
+callback(newError('foobar'));
+})
+});
+
+constc=newConsole(out,out,true);
+
+assert.doesNotThrow(()=>{
+c.log('abc');
+});
+}
+
+{
+constout=newWritable({
+write: common.mustCall((chunk,enc,callback)=>{
+thrownewError('foobar');
+})
+});
+
+constc=newConsole(out,out,true);
+
+assert.doesNotThrow(()=>{
+c.log('abc');
+});
+}
+
+{
+constout=newWritable({
+write: common.mustCall((chunk,enc,callback)=>{
+setImmediate(()=>callback(newError('foobar')));
+})
+});
+
+constc=newConsole(out,out,true);
+
+assert.doesNotThrow(()=>{
+c.log('abc');
+});
+}