1. Tasks

• Catching errors on both the frontend and the backend
• Ability to add multiple error handlers including in future
• Large amount of debug information
• Flexible configuration for each project
• High reliability

2. Decision

2.1 Error class

app.Error = function Error(error,lastFn){ if(error && error.name && error.message && error.stack){ ,       this.name=error.name; this.message=error.message; this.stack=error.stack; this.clueData=error.clueData||[]; this._alarmLvl=error._alarmLvl||'trivial'; this._side=error._side || (module ? "backend" : "frontend");//  return; } if(!app.isString(error)) error='unknown error'; this.name='Error'; this.message=error; this._alarmLvl='trivial'; this._side=module ? "backend" : "frontend"; this.clueData=[]; if (Error.captureStackTrace) { Error.captureStackTrace(this, app.isFunction(lastFn)? lastFn : this.constructor); } else { this.stack = (new Error()).stack.split('\n').removeAt(1).join();//       } }; app.Error.prototype = Object.create(Error.prototype); app.Error.prototype.constructor = app.Error; app.Error.prototype.setFatal = function () {//getter/setters    this._alarmLvl='fatal'; return this; }; app.Error.prototype.setTrivial = function () { this._alarmLvl='trivial'; return this; }; app.Error.prototype.setWarning = function () { this._alarmLvl='warning'; return this; }; app.Error.prototype.getAlarmLevel = function () { return this._alarmLvl; }; app.Error.prototype.addClueData = function(name,data){//   var dataObj={}; dataObj[name]=data; this.clueData.push(dataObj); return this; }; 

 socket.on(fullName, function (values) { <...> method(values)//  api .then(<...>) .catch(function (error) {//  throw new app.Error(error)//         .setFatal()// " " .addClueData('api', {//   fullName, values, handshake: socket.handshake }) }); }); 

2.2 Frontend

 app.errorForSending=[]; app.sendError = function (error) {//     app.io.emit('server error send', new app.Error(error)); }; window.onerror = function (message, source, lineno, colno, error) {//     app.errorForSending.push(//    . new app.Error(error) .setFatal());//    ,       }; app.events.on('socket.io ready', ()=> {//    window.onerror = function (message, source, lineno, colno, error) {//  app.sendError(new app.Error(error).setFatal()); }; app.errorForSending.forEach((error)=> {//  ,   app.sendError(error); }); delete app.errorForSending; }); app.events.on('client ready', ()=> {//      window.onerror = function (message, source, lineno, colno, error) { app.sendError(error); }; }); 

 function wrapConsole(name, action) { console['$' + name] = console[name];//   console[name] = function () { console['$' + name](...arguments);//   app.sendError( new app.Error(`From console.${name}: ` + [].join.call(arguments, '' ),//      console[name])//     (     v8) .addClueData('console', {//        consoleMethod: name, arg : Array.create(arguments) })[action]());//    }; } wrapConsole('error', 'setTrivial'); wrapConsole('warn', 'setWarning'); wrapConsole('info', 'setWarning'); 

2.3 Server

• Everything should work as quickly as possible, even if each driver in the process of initialization / error handling, you need to "talk heart to heart" with another server or calculate the answer to the main question of the universe of life and all that;
• A flexible system of spare and duplicate drivers;
• Dynamically run spare drivers, in case of failure of the previous ones;
• Exceptions that occur while drivers are running should be sent to working drivers;
• Catch and handle errors with frontend, as well as node.js falling into the global area.

1. Parallel start for speed
   For these purposes, we use yield [...] (or Promise.all (...)) given that each function from the array should not throw an error otherwise, if there are several functions with errors, we will not be able to process them all
2. Flexible configuration
   All drivers are in the "driver package", which are located in the array by priority. The error is sent immediately to the entire driver package, if the entire package does not work, the system proceeds to the next, etc.
3. Dynamic start
   During initialization, we mark all drivers as “not started”.
   When starting the first driver package, we mark either as “started” or “bad”.
   When sending, in the current package, skip “bad”, send to “started” and start “not started”. Drivers that throw out an error, mark as bad and go on. If all drivers in the current package are marked as bad go to the next package.
4. Sending driver errors to still live drivers
   If errors occur in the error drivers themselves (a bit of tautology), we write them into a special array. After finding the first live driver, we send driver errors through it and the error itself (if the drivers fell while sending an error) and driver errors.
5. We catch errors with front / backend
   Create a special api for frontend and catch the node.js exceptions via process.on ('uncaughtException', fn) and process.on ('unhandledRejection', fn)

3. Conclusion

• Change Disable Driver Disabling Policy
  For example, add the ability to re-check the driver for performance after some time.
• Ability to insert driver code on frontend
  Can be used to collect additional information.
• Logging preset
  DRY for repetitive functions of collecting general information (last downloaded pages, last used api)