Problem

When uploading a large body, the server can close the connection before
the client finishes writing. Node.js emits an error event on the socket
with code EPIPE. Since Axios had no error listener on the socket, this
became an uncaughtException and crashed the process on Linux/macOS.

Fixes #10558

Root cause

In lib/adapters/http.js, the handleRequestSocket callback set up
keep-alive but never attached a socket-level error handler.

Solution

Attach a single error listener per socket using a Symbol guard to avoid
leaking listeners on keep-alive connections that are reused across requests.

The error is forwarded via req.destroy(err), which triggers the existing
handleRequestError handler, so the promise rejects cleanly instead of
crashing the process.

Testing

• Verified crash on Linux (Node.js v24, via Docker)
• Verified clean rejection after fix on Linux
• Verified listener presence on Windows via manual EPIPE emission

Notes

• The fetch adapter is not affected (handled internally by the Fetch API)

• Windows does not exhibit the crash due to socketErrorListener in
  Node's _http_client, but the fix is still necessary for Linux/macOS
  production environments

  Before

After

I've used this .js script to test the issue in windows environment:

const http = require("node:http");
const axios = require("axios");

const server = http.createServer((req, res) => {
  req.on("error", () => {});
  res.on("error", () => {});
  setTimeout(() => {
    res.end();
    res.socket.destroy();
  }, 50);
});

async function main() {
  await new Promise((resolve) => server.listen(resolve));
  const endpoint = "http://127.0.0.1:" + server.address().port;
  console.log("Server listening:", endpoint);

  const bigBody = Buffer.alloc(10 * 1024 * 1024, "a");

  const axiosInstance = axios.create();

  axiosInstance.interceptors.request.use((config) => {
    config.transport = {
      request: (options, callback) => {
        const req = http.request(options, callback);

        req.on("socket", (socket) => {
          socket.once("connect", () => {
            setTimeout(() => {
              console.log("\n--- Manually emitting EPIPE on socket ---");

              const errorListeners = socket.listeners("error");
              console.log(
                `Socket has ${errorListeners.length} error listener(s):`,
                errorListeners.map((fn) => fn.name)
              );

              if (errorListeners.length === 0) {
                console.log(
                  "NO error listener found — this would crash the process on Linux!"
                );
              } else {
                console.log(
                  "Error listener found — fix is working correctly."
                );
              }

              socket.emit("error", Object.assign(new Error("write EPIPE"), {
                errno: -32,
                code: "EPIPE",
                syscall: "write",
              }));
            }, 10);
          });
        });

        return req;
      },
    };
    return config;
  });

  try {
    await axiosInstance.post(endpoint, bigBody);
  } catch (e) {
    console.log("\nResult:", e.message);
    console.log("isAxiosError:", e.isAxiosError);
  }

  server.close();
}

main().catch((e) => {
  console.error("Unhandled crash — fix is NOT working:", e.message);
  process.exit(1);
});

Summary by cubic

Prevents Node processes from crashing on Linux/macOS by handling socket error events (e.g., EPIPE) in the Node http adapter. Errors are now forwarded to the active keep‑alive request and cleanly reject in axios instead of triggering uncaughtException.

Description

• Summary of changes

  • Added a guarded socket error listener via SOCKET_ERROR_HANDLED in the Node http adapter.
  • Tracked the active request per socket with SOCKET_CURRENT_REQUEST and forward errors using currentReq.destroy(err).
  • Cleaned up both guards on socket close.

• Reasoning

  • Fixes Failed requests can sometimes crash the Node.js process with EPIPE. #10558 where EPIPE/ECONNRESET on keep‑alive sockets caused uncaughtException. Ensures the right request is rejected.

• Additional context

  • Internal reliability fix in lib/adapters/http.js; no API changes. fetch adapter is unaffected.

Testing

• No tests added.
• Recommend an adapter test that simulates a mid‑upload socket error on a reused keep‑alive socket and asserts the promise rejects with the socket error (e.g., EPIPE) without process crash.

^{Written for commit 85b4662. Summary will update on new commits.}