Summary

Bun's fetch retains the backing ArrayBuffer of unconsumed response bodies indefinitely. The Bun transport's makeFetchTransport calls fetch() but never consumes the response body, causing a memory leak when sending Sentry envelopes.

This is the same class of bug that was fixed for the Cloudflare transport in #18545. We improve on that fix by using void response.text().catch(() => {}) instead of await response.text(): the void approach drains the body asynchronously, adding zero latency to Sentry envelope sends. We don't need the response content, just need to trigger the drain so Bun releases the backing ArrayBuffer.

Bun fetch memory leak: documented and ongoing

Bun has a well-documented history of fetch response bodies not being garbage collected. Despite multiple fixes across releases, the core problem persists for the simplest case (unconsumed bodies):

Merged fixes (proving the problem exists)

Still-open issues

Root cause (from #10763): Bun holds a strong reference to the ReadableStream backing the response body. If never consumed, the strong ref prevents GC.

Improvement over the Cloudflare transport fix (#18545)

The Cloudflare transport fix in #18545 used await response.text(), which blocks the transport until the body is fully read. This adds unnecessary latency to every Sentry envelope send.

Our fix uses void response.text().catch(() => {}) instead:

• No added latency: the transport returns immediately with status code and headers
• Body still drains: the promise runs in the background, releasing the ArrayBuffer once complete
• No async needed: the .then() callback stays synchronous, matching the original signature
• Defensive .catch(() => {}): if the drain fails for any reason, it doesn't crash the transport

This is a strictly better pattern for any transport where we don't need the response body content.

Production evidence (heap snapshots)

We observed this leak in production on a Bun service running @sentry/bun:

After applying this fix, the leak was eliminated.

Reproduction

// repro.js — run with: bun run repro.js
// Watch RSS grow unboundedly because response bodies are never consumed

const server = Bun.serve({
  port: 3456,
  fetch() {
    return new Response("x".repeat(8192));
  },
});

let i = 0;
setInterval(async () => {
  const res = await fetch("http://localhost:3456");
  // NOT consuming res.text() or res.arrayBuffer() — just discard
  void res;
  if (++i % 100 === 0) {
    Bun.gc(true);
    console.log(
      `Requests: ${i}, RSS: ${(process.memoryUsage.rss() / 1024 / 1024).toFixed(1)}MB`
    );
  }
}, 10);

Expected: RSS stays flat. Observed on Bun 1.3.x: RSS grows linearly.

This PR was generated with the assistance of Claude Code and reviewed by a human.