TimeoutOverflowWarning: 2592000000 does not fit into a 32-bit signed integer.
Timeout duration was set to 1.
setTimeout și setInterval acceptă cel mult 2147483647 ms (aproximativ 24,8 zile). Peste această valoare, Node afișează warning-ul și rulează callback-ul după 1 ms, adică imediat. Pentru termene lungi, împarte așteptarea în bucăți mai mici sau salvează termenul și verifică-l periodic.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Timerele din Node (ca și cele din browser) păstrează întârzierea într-un întreg pe 32 de biți cu semn, deci valoarea maximă e 2147483647 ms, puțin peste 24 de zile și 20 de ore. Dacă dai mai mult (de exemplu 30 de zile = 2592000000 ms), Node nu aruncă eroare: afișează TimeoutOverflowWarning și setează întârzierea la 1 ms.
Rezultatul e un bug greu de observat: un memento programat „peste o lună” pleacă imediat, un job de curățenie rulează în buclă, o sesiune expiră pe loc. Mesajul spune valoarea primită și ce a făcut Node cu ea (Timeout duration was set to 1.).
Warning-ul apare doar o dată per valoare, pe stderr, iar într-un server pornit cu PM2 sau Docker se pierde ușor în loguri. Același lucru se întâmplă și cu setInterval, și cu setTimeout din timers/promises.
De ce apare: cauzele frecvente
1Memento programat pe mai mult de 24 de zile
const ZI = 24 * 60 * 60 * 1000;
setTimeout(trimiteMemento, 30 * ZI);const MAX = 2 ** 31 - 1;
function asteaptaLung(ms, fn) {
if (ms > MAX) return setTimeout(() => asteaptaLung(ms - MAX, fn), MAX);
return setTimeout(fn, ms);
}
asteaptaLung(30 * ZI, trimiteMemento);Fiecare timer individual rămâne sub limită, iar lanțul lor acoperă toată durata.
2Termene lungi ținute doar în memorie
setTimeout(() => expiraAbonament(id), 365 * ZI);// salvezi termenul în baza de date
// și verifici o dată pe oră ce a expirat
setInterval(verificaExpirari, 60 * 60 * 1000);Un proces de server se repornește des; un timer de un an nu supraviețuiește. Termenul salvat și verificat periodic e corect și după restart.
3Unitate greșită (secunde înmulțite încă o dată)
const expiraIn = 3600 * 1000; // deja în ms
setTimeout(logout, expiraIn * 1000);const expiraIn = 3600 * 1000;
setTimeout(logout, expiraIn);Înmulțirea dublă cu 1000 transformă o oră în 41 de zile, peste limită. Ține unitatea în numele variabilei (expiraInMs).
Repară eroarea, direct în pagină
Programul programează mementouri, iar cel pentru peste 30 de zile pleacă imediat, cu TimeoutOverflowWarning: 2592000000 does not fit into a 32-bit signed integer. Proiectul oprește programul la orice warning (primele rânduri). Modifică programeaza ca întârzierile mai mari decât limita să fie împărțite în mai mulți timeri, fiecare sub 2 ** 31 - 1 ms.
// Proiectul tratează orice warning ca pe o eroare (ca în CI): îl afișează și oprește cu cod 1.
process.on("warning", (w) => {
console.error(`${w.code ? `[${w.code}] ` : ""}${w.name}: ${w.message}`);
process.exitCode = 1;
});
const ZI = 24 * 60 * 60 * 1000;
const timere = [];
function programeaza(zile, mesaj) {
timere.push(setTimeout(() => console.log(`Memento trimis: ${mesaj}`), zile * ZI));
console.log(`Programat: ${mesaj} (+${zile} zile)`);
}
programeaza(3, "plata facturii");
programeaza(30, "reînnoirea abonamentului");
// demo: oprim programul înainte să treacă zilele
setTimeout(() => {
timere.forEach(clearTimeout);
console.log("Demo încheiat");
}, 50);Programat: plata facturii (+3 zile) Programat: reînnoirea abonamentului (+30 zile) Demo încheiat
Indiciu
Ține minte cât a mai rămas de așteptat; cât timp e peste limită, pornește un timer de MAX ms care, la final, scade MAX și verifică din nou.
Reparația
// Proiectul tratează orice warning ca pe o eroare (ca în CI): îl afișează și oprește cu cod 1.
process.on("warning", (w) => {
console.error(`${w.code ? `[${w.code}] ` : ""}${w.name}: ${w.message}`);
process.exitCode = 1;
});
const ZI = 24 * 60 * 60 * 1000;
const MAX = 2 ** 31 - 1;
const timere = [];
function programeaza(zile, mesaj) {
let ramas = zile * ZI;
const pas = () => {
if (ramas > MAX) {
ramas -= MAX;
timere.push(setTimeout(pas, MAX));
} else {
timere.push(setTimeout(() => console.log(`Memento trimis: ${mesaj}`), ramas));
}
};
pas();
console.log(`Programat: ${mesaj} (+${zile} zile)`);
}
programeaza(3, "plata facturii");
programeaza(30, "reînnoirea abonamentului");
// demo: oprim programul înainte să treacă zilele
setTimeout(() => {
timere.forEach(clearTimeout);
console.log("Demo încheiat");
}, 50);De ce merge
Cele 30 de zile înseamnă 2592000000 ms, peste limita de 2147483647 ms a timerelor, așa că Node reducea întârzierea la 1 ms și mementoul pleca imediat. Funcția pas pornește un timer de cel mult MAX ms și, când acesta expiră, scade din cât a mai rămas și se programează din nou, până când restul încape într-un singur timer. Niciun timer nu mai depășește limita, deci warning-ul dispare. Într-o aplicație reală, termenele atât de lungi se salvează în baza de date și se verifică periodic.
Alte forme ale mesajului
(node:4120) TimeoutOverflowWarning: 2592000000 does not fit into a 32-bit signed integer. Timeout duration was set to 1. (Use `node --trace-warnings ...` to show where the warning was created)TimeoutOverflowWarning: 3600000000 does not fit into a 32-bit signed integer. Timeout duration was set to 1.TimeoutOverflowWarning: 31536000000 does not fit into a 32-bit signed integer. Timeout duration was set to 1.TimeoutNegativeWarning: -100 is a negative number. Timeout duration was set to 1.
Cum o eviți pe viitor
- Nu folosi
setTimeoutpentru termene de zile sau săptămâni; salvează termenul și verifică-l periodic (sau folosește un programator de joburi). - Pune unitatea în numele variabilelor:
intarziereMs,expiraInSecunde. - Tratează warning-urile ca pe erori în CI (
process.on("warning", ...)sau--trace-warnings), ca să le vezi. - Dacă ai totuși nevoie de un timer lung, împarte-l în bucăți de cel mult
2 ** 31 - 1ms.
Întrebări frecvente
De ce limita e 24,8 zile?
2147483647 este cel mai mare număr care încape într-un întreg pe 32 de biți cu semn. În milisecunde, asta înseamnă aproximativ 24 de zile, 20 de ore și 31 de minute.
Și setInterval are aceeași limită?
Da. Un setInterval cu o perioadă prea mare rulează la fiecare milisecundă, ceea ce poate bloca procesul cu apeluri inutile.
Erori înrudite
TypeError [ERR_INVALID_ARG_TYPE]: The "callback" argument must be of type function. Received undefined Ai dat lui setTimeout, setInterval sau setImmediate rezultatul unei funcții în loc de funcția însăși, de obicei scriind setTimeout(trimite(), 1000). Pune funcția fără paranteze, setTimeout(trimite, 1000), sau într-o funcție săgeată: setTimeout(() => trimite("Ana"), 1000). Warning: Detected unsettled top-level await at file:///app/index.js:9 Un await de la nivelul de sus al unui modul ES așteaptă o promisiune care nu se mai rezolvă niciodată, iar Node se oprește cu codul de ieșire 13. De obicei lipsește apelul resolve() în new Promise sau evenimentul așteptat nu mai vine. Asigură-te că promisiunea se rezolvă sau se respinge pe orice drum. MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 comanda listeners added to [EventEmitter]. MaxListeners is 10. Use emitter.setMaxListeners() to increase limit Ai adăugat mai mult de 10 ascultători pentru același eveniment pe același obiect, de obicei pentru că .on() e apelat într-o buclă, la fiecare cerere sau la fiecare apel de funcție. Înregistrează ascultătorul o singură dată, sau scoate-l cu .off() când nu mai e nevoie de el. Mărește limita doar dacă chiar ai nevoie de atâția ascultători. Învață Node.js de la zero, cu exerciții la fiecare lecție
Curs Node.js: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
