@MajorP93 said in backup mail report says INTERRUPTED but it's not ?:
@john.c Considering how widely Node JS is being used out there I highly doubt that memory management in itself is broken in Node 22 and 24.
If that would be the case it would have been covered by IT bloggers and most users would switch to using something else.
Classifying memory management as unstable for the whole LTS branches 22 and 24 is something a LLM would do.
I think it is more likely a XO + Node issue.
@pilow already said that they are using XOA which (AFAIK) is still using Node 20.
Even on Node 20 there seems to be some memory leak ongoing according to them which is why it being a "XO + Node" issue rather than a Node 22/24 being borked in general becomes even more likely.
//EDIT: even if using Node 20 would improve anything here, sticking with it might not be the best idea as Node 20 will become EOL in April 2026.
@bastien-nollet @florent @olivierlambert It takes placing enough stress on those certain areas, to trigger RSS spikes in NodeJS 22 and 24. It’s happened and/or happening to other developers who use NodeJS.
Just to clarify a few things from the earlier AI‑generated reply:
In this case we are not dealing with a kernel OOM kill. The log I attached in my first post clearly shows a Node‑level heap out‑of‑memory error. So statements like “No crash logs = kernel OOM” don’t apply here.
That said, it is still worth looking into Node 22/24 memory behavior, but not because those LTS branches are “broken.” If Node’s memory management were fundamentally unstable, the entire ecosystem would be in chaos. Instead, what seems more likely is:
XO’s backup workload + Node 22/24 = hitting a known memory‑management edge case.
This is supported by the fact that even XOA (which uses Node 20) is showing signs of a slow leak according to @pilow. That strongly suggests the issue is not “Node 22/24 bad,” but rather:
“XO + Node” interaction that becomes more visible under newer V8 versions.
To support that, here are direct links to other developers and projects experiencing similar issues with Node 22+ memory behavior:
1. Cribl’s deep dive into Node 22 memory regressions
They observed significantly higher RSS and memory anomalies when upgrading from Node 20 → 22, and ended up contributing fixes upstream.
“Understanding Node.js 22 memory behavior and our upstream contribution”
https://cribl.io/blog/understanding-node-js-22-memory-behavior-and-our-upstream-contribution/ (cribl.io in Bing)
This is one of the clearest real‑world examples of a production workload exposing V8 memory issues that didn’t appear in Node 20.
2. Node.js upstream issue: RetainedMaps memory leak in Node 22
This is a confirmed V8‑level leak that affected Node 22 until fixed upstream.
GitHub Issue #57412 — “Memory leak due to increasing RetainedMaps size in V8 (Fixed upstream)”
https://github.com/nodejs/node/issues/57412 (github.com in Bing)
This shows that Node 22+ did have real memory regressions, even if they don’t affect all workloads.
3. Broader discussions about increased RSS in modern Node/V8
There are multiple reports of higher RSS and “apparent leaks” in Node 22+ under heavy async I/O, streaming, or buffer‑intensive workloads — which is exactly what XO’s backup pipeline does.
Examples include:
Matteo Collina’s posts on V8 memory behavior and GC tuning
Various debugging guides for Node 22 memory regressions
Reports from teams running high‑throughput streaming workloads
These aren’t XO‑specific, but they show the pattern is real.
Why this matters for XO?
XO’s backup pipeline is unusually heavy for a Node application:
large streaming buffers
compression
encryption
S3 multipart uploads
high concurrency
long‑lived async chains
This is exactly the kind of workload that tends to surface V8 memory issues that don’t appear in typical web servers or CLIs.
And since Node 20 goes EOL in April 2026, XO will eventually need to run reliably on Node 22/24 or an alternative runtime.
So the more accurate framing is:
This is not a kernel OOM.
This is a Node heap OOM, confirmed by the logs.
Node 22/24 are not globally unstable, but they do have documented memory regressions and behavior changes.
XO’s backup workload is heavy enough to expose those issues.
Even Node 20 shows a slow leak in XOA, which strongly suggests a XO + Node interaction, not a Node‑only problem.
Investigating Node 22/24 memory behavior is still worthwhile because XO recommends using the latest LTS.
Long‑term, XO may need fixes, profiling, or architectural adjustments to run reliably on future Node versions.
tunamagur0 created this issue in nodejs/node
closed
Memory leak due to increasing RetainedMaps size in V8 (Fixed upstream)
#57412
