Node Fetch vs Got vs Undici: Throughput Under Real TLS Churn

// src/http/egress.ts
import { Agent, fetch as undiciFetch } from "undici";

// ✅ One shared agent per process — sized for fan-out
export const egressAgent = new Agent({
 connections: 32,
 pipelining: 1, // keep 1 unless you know the peer is safe
 keepAliveTimeout: 30_000,
 keepAliveMaxTimeout: 60_000,
 connect: { timeout: 5_000, rejectUnauthorized: true },
 bodyTimeout: 30_000,
 headersTimeout: 30_000,
});

export function apiFetch(url: string, init?: RequestInit) {
 return undiciFetch(url, { ...init, dispatcher: egressAgent } as any);
}

// ❌ New Agent/Got instance per request — TLS churn amplifier
export const bad = (url: string) => fetch(url); // default agent OK
export const worse = async (url: string) => {
 const { default: got } = await import("got");
 return got(url); // still OK-ish
};
export const worst = (url: string) =>
 undiciFetch(url, { dispatcher: new Agent() } as any);

// scripts/bench-egress.ts
import { performance } from "node:perf_hooks";
import { apiFetch } from "../src/http/egress.js";

async function run(name: string, n: number, concurrency: number, url: string) {
 const lat: number[] = [];
 let i = 0;
 async function worker() {
 while (i < n) {
 const k = i++;
 const t0 = performance.now();
 const res = await apiFetch(url);
 await res.arrayBuffer();
 lat.push(performance.now() - t0);
 }
 }
 await Promise.all(Array.from({ length: concurrency }, () => worker()));
 lat.sort((a, b) => a - b);
 console.log(name, { p50: lat[Math.floor(n * 0.5)], p99: lat[Math.floor(n * 0.99)] });
}

export async function getWithRetry(url: string, attempts = 3) {
 let last: unknown;
 for (let i = 0; i < attempts; i++) {
 try {
 const res = await apiFetch(url);
 if (res.status >= 500) throw new Error(`upstream_${res.status}`);
 return res;
 } catch (err) {
 last = err;
 await new Promise((r) => setTimeout(r, 50 * 2 ** i));
 }
 }
 throw last;
}