events.js:154
      throw er; // Unhandled 'error' event
      ^
Error: connect ETIMEDOUT 23.96.96.142:443
    at Object.exports._errnoException (util.js:890:11)
    at exports._exceptionWithHostPort (util.js:913:20)
    at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1061:14)

  // if we get an error, we send a 500
  if (app.config.dump_errors) 
    app.use(dumpErrors);
  else 
    app.use(cleanErrors);

  function dumpErrors(err, req, res, next) {
    if (err === 'isRedirect') {
      debug('redirecting - ' + req.path + ' -> ' + res._headers.location);
      return;
    }

    debug('dumpErrors - 500 - errMiddleware!!');
    
    var errStr = (err.stack) ? err.stack : err.toString();
    if (req.errLog) 
      req.errLog.error(debug(errStr));
    else 
      debug(errStr);
    res.status(500).send('<h1>500 Server Error</h1><h3><pre>' + errStr + '</pre></h3>');
  }

  function cleanErrors(err, req, res, next) {
    
  // does error handling in production where we don't want to show the error to the end user

var lifecycle = require('./lifecycle');

     lifecycle
        .restart(config.restart)
        .bail(config.bail)

    lifecycle.on('bail', function(err) { app.log.error('lifecycle bail: ' + (err.stack || err)); });

var util = require('util');
var events = require('events');
var cluster = require('cluster');
var os = require('os');
var debug = requireFromRoot('lib/framework/debug')('lifecycle');

// Lifecycle
function Lifecycle() {
  this._main = undefined;
  this._restart = true;
  this._bail = true;
  this._workers = os.cpus().length;
  this._config = {};
}

// HBL: Idiomatic node.js inheritance
// In general though, composition works better than inheritance, and is easier to understand later.
util.inherits(Lifecycle, events.EventEmitter);

Lifecycle.prototype.bail = accessor('_bail');
Lifecycle.prototype.restart = accessor('_restart');
Lifecycle.prototype.workers = accessor('_workers');

Lifecycle.prototype.start = function(startFn) {
  this._main = startFn;
  if (this._bail) this._bailOnError();
  this._balanceCluster();
};


Lifecycle.prototype._bailOnError = function(fn) {
  process.on('uncaughtException', onException);

  var me = this;
  function onException(err) {
    var exit = fn ? fn(err) : true;
    me.emit('bail', err);

    console.error('lifecycle bail:', err.stack || err);
    debug('lifecycle bail: ' + (err.stack || err));

    if (exit) process.exit();
  }
};

Lifecycle.prototype._balanceCluster = function() {
  var self = this;

  return cluster.isMaster? startMaster() : startWorker();

  function startMaster() {
    var workerCount = self._workers;

    if (self._restart) {
      cluster.on('exit', onWorkerExit);
      cluster.on('death', onWorkerDeath);
    }

    while(workerCount--) cluster.fork();
  }

  function startWorker() {
    self._main(/*_.clone(self._config)*/);
  }

  function onWorkerExit(worker) {
    console.log('lifecycle:balance - worker exit, forking replacement');
    debug('lifecycle:balance - worker exit, forking replacement');
    cluster.fork();
  }

  function onWorkerDeath(worker) {
    console.error('lifecycle:balance - worker death, forking replacement');
    debug('lifecycle:balance - worker death, forking replacement');
    cluster.fork();
  }
};

// Exports
module.exports = new Lifecycle();

// Utils
function accessor(key) {
  return function(val) {
    if (arguments.length === 0) return this[key];
    this[key] = val;
    return this;
  };
}

  var request = https.request(options, function (res) {

    res.on('data', function (d) {
      ...accumulate data
    });
    res.on('end', function () {
      ...parse, catch parsing errors
    });
  });
  request.end();

var req = https.request(options, (res) => {
  console.log('statusCode: ', res.statusCode);
  console.log('headers: ', res.headers);

  res.on('data', (d) => {
    process.stdout.write(d);
  });
});
req.end();

req.on('error', (e) => {
  console.error(e);
});