Sto eseguendo un'applicazione Express.js utilizzando Socket.io per una webapp di chat e ricevo il seguente errore in modo casuale circa 5 volte durante 24 ore. Il processo del nodo è concluso per sempre e si riavvia immediatamente.

Il problema è che il riavvio di Express espelle i miei utenti dalle loro stanze e nessuno lo vuole.

Il web server è proxy da HAProxy. Non ci sono problemi di stabilità dei socket, semplicemente usando i trasporti di websocket e flashsocket. Non posso riprodurlo apposta.

Questo è l'errore con Nodo v0.10.11:

    events.js:72
            throw er; // Unhandled 'error' event
                  ^
    Error: read ECONNRESET     //alternatively it s a 'write'
        at errnoException (net.js:900:11)
        at TCP.onread (net.js:555:19)
    error: Forever detected script exited with code: 8
    error: Forever restarting script for 2 time

EDIT (22-07-2013)

Aggiunti sia il gestore errori client socket.io che il gestore eccezioni non rilevati. Sembra che questo rilevi l'errore:

    process.on('uncaughtException', function (err) {
      console.error(err.stack);
      console.log("Node NOT Exiting...");
    });

Quindi sospetto che non sia un problema Socket.io ma una richiesta HTTP a un altro server che faccio o una connessione MySQL / Redis. Il problema è che lo stack di errori non mi aiuta a identificare il mio problema con il codice. Ecco l'output del registro:

    Error: read ECONNRESET
        at errnoException (net.js:900:11)
        at TCP.onread (net.js:555:19)

Come faccio a sapere quali sono le cause? Come posso ottenere di più dall'errore?

Ok, non molto prolisso ma ecco lo stacktrace con Longjohn:

    Exception caught: Error ECONNRESET
    { [Error: read ECONNRESET]
      code: 'ECONNRESET',
      errno: 'ECONNRESET',
      syscall: 'read',
      __cached_trace__:
       [ { receiver: [Object],
           fun: [Function: errnoException],
           pos: 22930 },
         { receiver: [Object], fun: [Function: onread], pos: 14545 },
         {},
         { receiver: [Object],
           fun: [Function: fireErrorCallbacks],
           pos: 11672 },
         { receiver: [Object], fun: [Function], pos: 12329 },
         { receiver: [Object], fun: [Function: onread], pos: 14536 } ],
      __previous__:
       { [Error]
         id: 1061835,
         location: 'fireErrorCallbacks (net.js:439)',
         __location__: 'process.nextTick',
         __previous__: null,
         __trace_count__: 1,
         __cached_trace__: [ [Object], [Object], [Object] ] } }

Qui servo il file dei criteri del socket flash:

    net = require("net")
    net.createServer( (socket) =>
      socket.write("<?xml version=\"1.0\"?>\n")
      socket.write("<!DOCTYPE cross-domain-policy SYSTEM \"http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd\">\n")
      socket.write("<cross-domain-policy>\n")
      socket.write("<allow-access-from domain=\"*\" to-ports=\"*\"/>\n")
      socket.write("</cross-domain-policy>\n")
      socket.end()
    ).listen(843)

Questa può essere la causa?

Potresti averlo già indovinato: è un errore di connessione.

"ECONNRESET" significa che l'altro lato della conversazione TCP ha chiuso bruscamente la sua estremità della connessione. Ciò è probabilmente dovuto a uno o più errori del protocollo dell'applicazione. Puoi guardare i log del server API per vedere se si lamenta di qualcosa.

Ma poiché stai anche cercando un modo per controllare l'errore e potenzialmente eseguire il debug del problema, dovresti dare un'occhiata a " Come eseguire il debug di un errore di riaggancio del socket in NodeJS? " Che è stato pubblicato su StackOverflow in relazione a una domanda simile.

Soluzione rapida e sporca per lo sviluppo :

Usa longjohn , ottieni tracce stack lunghe che conterranno le operazioni asincrone.

Soluzione pulita e corretta : tecnicamente, nel nodo, ogni volta che si emette un 'error'evento e nessuno lo ascolta, verrà lanciato . Per non farlo cadere, mettici sopra un ascoltatore e gestiscilo da solo. In questo modo è possibile registrare l'errore con ulteriori informazioni.

Per avere un listener per un gruppo di chiamate è possibile utilizzare domini e rilevare anche altri errori in fase di esecuzione. Assicurati che ogni operazione asincrona relativa a http (Server / Client) sia in un contesto di dominio diverso rispetto alle altre parti del codice, il dominio ascolterà automaticamente gli erroreventi e lo propagherà al proprio gestore. Quindi ascolti solo quel gestore e ottieni i dati di errore. Ottieni anche maggiori informazioni gratuitamente.

EDIT (22-07-2013)

Come ho scritto sopra:

"ECONNRESET" significa che l'altro lato della conversazione TCP ha chiuso bruscamente la sua estremità della connessione. Ciò è probabilmente dovuto a uno o più errori del protocollo dell'applicazione. Puoi guardare i log del server API per vedere se si lamenta di qualcosa.

Quale potrebbe essere anche il caso: in momenti casuali, l'altro lato è sovraccarico e di conseguenza semplicemente uccide la connessione. In tal caso, dipende da cosa ti stai connettendo esattamente ...

Ma una cosa è certa: hai davvero un errore di lettura sulla tua connessione TCP che causa l'eccezione. Puoi vederlo guardando il codice di errore che hai pubblicato nella tua modifica, che lo conferma.

Un semplice server tcp che avevo per servire il file dei criteri flash lo stava causando. Ora posso rilevare l'errore utilizzando un gestore:

# serving the flash policy file
net = require("net")

net.createServer((socket) =>
  //just added
  socket.on("error", (err) =>
    console.log("Caught flash policy server socket error: ")
    console.log(err.stack)
  )

  socket.write("<?xml version=\"1.0\"?>\n")
  socket.write("<!DOCTYPE cross-domain-policy SYSTEM \"http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd\">\n")
  socket.write("<cross-domain-policy>\n")
  socket.write("<allow-access-from domain=\"*\" to-ports=\"*\"/>\n")
  socket.write("</cross-domain-policy>\n")
  socket.end()
).listen(843)

Ho avuto un problema simile in cui le app hanno iniziato a errori dopo un aggiornamento di Node. Credo che questo possa essere ricondotto alla versione del nodo v0.9.10 di questo articolo:

• net: non sopprimere ECONNRESET (Ben Noordhuis)

Le versioni precedenti non avrebbero commesso errori in caso di interruzioni dal client. Un'interruzione della connessione dal client genera l'errore ECONNRESET in Node. Credo che questa sia la funzionalità prevista per Node, quindi la correzione (almeno per me) è stata quella di gestire l'errore, che credo tu abbia fatto in eccezioni non rilevate. Anche se lo gestisco nel gestore net.socket.

Puoi dimostrarlo:

Crea un semplice server socket e ottieni Nodo v0.9.9 e v0.9.10.

require('net')
    .createServer( function(socket) 
    {
           // no nothing
    })
    .listen(21, function()
     {
           console.log('Socket ON')
    })

Avviarlo utilizzando v0.9.9 e quindi provare a FTP su questo server. Sto usando FTP e la porta 21 solo perché sono su Windows e ho un client FTP, ma nessun client Telnet a portata di mano.

Quindi dal lato client, basta interrompere la connessione. (Sto solo facendo Ctrl-C)

Dovresti vedere NESSUN ERRORE quando usi Nodo v0.9.9 ed ERRORE quando usi Nodo v.0.9.10 e successivi.

In produzione, utilizzo v.0.10. qualcosa e dà ancora l'errore. Ancora una volta, penso che questo sia inteso e la soluzione è gestire l'errore nel tuo codice.

Ho avuto lo stesso problema oggi. Dopo alcune ricerche ho trovato --abort-on-uncaught-exceptionun'opzione node.js molto utile . Non solo fornisce una traccia dello stack di errori molto più dettagliata e utile, ma salva anche il file core in caso di crash dell'applicazione consentendo un ulteriore debug.

Stavo affrontando lo stesso problema ma l'ho mitigato inserendo:

server.timeout = 0;

prima server.listen. serverè un server HTTP qui. Il timeout predefinito è di 2 minuti secondo la documentazione dell'API .

Un altro caso possibile (ma raro) potrebbe essere se si dispone di comunicazioni da server a server e si è impostato server.maxConnectionssu un valore molto basso.

Nel core lib net.js del nodo chiamerà clientHandle.close()che causerà anche l'errore ECONNRESET:

if (self.maxConnections && self._connections >= self.maxConnections) {
  clientHandle.close(); // causes ECONNRESET on the other end
  return;
}

Sì, la pubblicazione del file delle politiche può sicuramente causare l'arresto anomalo.

Per ripetere, aggiungi un ritardo al codice:

net.createServer( function(socket) 
{
    for (i=0; i<1000000000; i++) ;
    socket.write("<?xml version=\"1.0\"?>\n");
…

... e utilizzare telnetper connettersi alla porta. Se si disconnette telnet prima della scadenza del ritardo, si verificherà un arresto anomalo (eccezione non rilevata) quando socket.write genera un errore.

Per evitare il crash qui, basta aggiungere un gestore di errori prima di leggere / scrivere il socket:

net.createServer(function(socket)
{
    for(i=0; i<1000000000; i++);
    socket.on('error', function() { console.log("error"); });
    socket.write("<?xml version=\"1.0\"?>\n");
}

Quando provi la disconnessione sopra, otterrai solo un messaggio di registro invece di un arresto anomalo.

E quando hai finito, ricorda di rimuovere il ritardo.

Ricevo anche errore ECONNRESET durante il mio sviluppo, il modo in cui lo risolvo non usando nodemon per avviare il mio server, ma solo "node server.js"per avviare il mio server risolto il mio problema.

È strano, ma ha funzionato per me, ora non vedo più l'errore ECONNRESET.

Ho avuto anche questo errore ed è stato in grado di risolverlo dopo giorni di debug e analisi:

la mia soluzione

Per me VirtualBox (per Docker) era il problema. Avevo configurato Port Forwarding sulla mia macchina virtuale e l'errore si verificava solo sulla porta inoltrata.

conclusioni generali

Le seguenti osservazioni possono farti risparmiare giorni di lavoro che ho dovuto investire:

• Per me il problema si è verificato solo sulle connessioni da localhost a localhost su una porta. -> controllare la modifica di una di queste costanti risolve il problema.
• Per me il problema si è verificato solo sulla mia macchina -> lascia che qualcun altro lo provi.
• Per me il problema si è verificato solo dopo un po 'e non è stato possibile riprodurlo in modo affidabile
• Il mio problema non può essere verificato con nessuno dei nodi o esprime (debug-) strumenti. -> non perdere tempo su questo

-> capire se qualcosa è in disordine con la tua rete (impostazioni), come macchine virtuali, firewall ecc., Questa è probabilmente la causa del problema.

Ho risolto il problema semplicemente collegandomi a una rete diversa . Questo è uno dei possibili problemi.

Come discusso in precedenza, ECONNRESET significa che la conversazione TCP ha bruscamente chiuso la sua estremità della connessione.

La tua connessione Internet potrebbe impedirti di collegarti ad alcuni server. Nel mio caso, stavo cercando di connettermi a mLab (servizio di database cloud che ospita database MongoDB). E il mio ISP lo sta bloccando.

Ho risolto questo problema con:

• Disattiva la mia connessione wifi / ethernet e accendi.
• Ho digitato: npm updatenel terminale per aggiornare npm.
• Ho provato a disconnettermi dalla sessione e ad accedere di nuovo

Dopo di che ho provato lo stesso comando npm e la cosa buona è che ha funzionato. Non ero sicuro che fosse così semplice.

Sto usando CENTOS 7

Ho avuto lo stesso problema e sembra che il problema fosse la versione Node.js.

Ho installato la versione precedente di Node.js (10.14.2) e tutto era ok usando nvm (ti permette di installare diverse versioni di Node.js e passare rapidamente da una versione all'altra).

Non è una soluzione "pulita", ma può servirti temporaneamente.

L'ho appena capito, almeno nel mio caso d'uso.

Stavo arrivando ECONNRESET. Si è scoperto che il modo in cui il mio client è stato impostato, colpiva il server con una chiamata API un sacco di volte molto rapidamente - e doveva colpire l'endpoint solo una volta.

Quando l'ho risolto, l'errore era sparito.

Prova ad aggiungere queste opzioni a socket.io:

const options = { transports: ['websocket'], pingTimeout: 3000, pingInterval: 5000 };

Spero che questo ti possa aiutare!