@mark1russell7/harness 0.5.0 → 0.6.0

package/image/go-http/Dockerfile

@@ -0,0 +1,14 @@
+# The Go HTTP client of the harness: the http.Transport of Go 1.27.2 at its defaults, with the
+# settings of a cell over them. It runs as a container in the client's network namespace, as the
+# harness's own TCP client does, and prints the same JSON lines. The program uses the standard
+# library only, thus the digest of the builder pins all of its code.
+# lab.ts stages the build context: this folder, under harness/image/go-http.
+FROM golang:1.27.2-alpine@sha256:f92b6ef800e499660581efdabdf25d9d817a9d124eaf900924f0504e7e27e12d AS build
+WORKDIR /src
+COPY harness/image/go-http/go.mod harness/image/go-http/main.go ./
+# the format and the vet of the source come first, as the cargo test of the harness image does
+RUN test -z "$(gofmt -l .)" || { gofmt -d .; exit 1; }
+RUN CGO_ENABLED=0 go vet ./... && CGO_ENABLED=0 go build -trimpath -o /client-go .
+
+FROM alpine:3.22@sha256:5291449c3df73caf6ed85e649dec1b9e818b39a5d8c871e97afc13e9cd5e8fa8
+COPY --from=build /client-go /opt/harness/client-go

package/image/go-http/go.mod

@@ -0,0 +1,3 @@
+module client-go
+
+go 1.27

package/image/go-http/main.go

@@ -0,0 +1,324 @@
+// Command client-go is the Go client of the HTTP cells: the http.Transport of Go 1.27.2 at its
+// defaults, with each setting that a cell gives over them. Each event is a JSON line with `ev` and
+// `t`, the CLOCK_MONOTONIC time in nanoseconds, as the TCP client of the harness writes them.
+//
+//	client-go HOST PORT --mode idle|inflight|gap [--gap-ms N] [--method GET|POST] [--hold-ms N]
+//	          [--bytes N] [--go PATH] [--max-s N] [--linger-ms N]
+//	          [--idle-conn-timeout-ms N] [--max-idle-per-host N] [--dial-timeout-ms N]
+//	          [--keepalive-ms N] [--keepalive-interval-ms N] [--keepalive-count N] [--timeout-ms N]
+//
+// The first request is GET /, and the end of its reply is the ready line. Then the client holds
+// the connection idle (idle), sends the second request when the file --go appears (inflight), or
+// sends it after the gap (gap).
+//
+// A wrapper on each connection writes what the read loop of the transport reads: an end of file,
+// or an error. The trace of the transport writes which connection each request goes on, whether
+// the transport reused it, and each new try of a request on a new connection.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptrace"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+var out sync.Mutex
+
+// now gives the time on CLOCK_MONOTONIC in nanoseconds: the clock of the prober.
+func now() int64 {
+	var ts syscall.Timespec
+	syscall.Syscall(syscall.SYS_CLOCK_GETTIME, 1, uintptr(unsafe.Pointer(&ts)), 0)
+	return ts.Nano()
+}
+
+// emitAt writes one line with the time t.
+func emitAt(ev string, t int64, fields map[string]any) {
+	line := map[string]any{"ev": ev, "t": t}
+	for key, value := range fields {
+		line[key] = value
+	}
+	bytes, _ := json.Marshal(line)
+	out.Lock()
+	os.Stdout.Write(append(bytes, '\n'))
+	out.Unlock()
+}
+
+// emit writes one line with the time now.
+func emit(ev string, fields map[string]any) { emitAt(ev, now(), fields) }
+
+var names = map[syscall.Errno]string{
+	syscall.ECONNRESET:   "ECONNRESET",
+	syscall.ECONNREFUSED: "ECONNREFUSED",
+	syscall.ETIMEDOUT:    "ETIMEDOUT",
+	syscall.EHOSTUNREACH: "EHOSTUNREACH",
+	syscall.ENETUNREACH:  "ENETUNREACH",
+	syscall.EPIPE:        "EPIPE",
+	syscall.ECONNABORTED: "ECONNABORTED",
+}
+
+// errnoOf gives the name of the error of a socket, EOF for an end of file, or TIMEOUT for a
+// deadline of Go.
+func errnoOf(err error) string {
+	var errno syscall.Errno
+	if errors.As(err, &errno) {
+		if name, ok := names[errno]; ok {
+			return name
+		}
+		return fmt.Sprintf("E%d", int(errno))
+	}
+	if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+		return "EOF"
+	}
+	var timeout interface{ Timeout() bool }
+	if errors.As(err, &timeout) && timeout.Timeout() {
+		return "TIMEOUT"
+	}
+	return "ERROR"
+}
+
+// traced is a connection that writes what its reads end with, and its close.
+type traced struct {
+	net.Conn
+	local  string
+	mu     sync.Mutex
+	closed bool
+}
+
+func (c *traced) Read(p []byte) (int, error) {
+	n, err := c.Conn.Read(p)
+	if err != nil {
+		c.mu.Lock()
+		closed := c.closed
+		c.mu.Unlock()
+		// a read after the close of the client itself is not an event of the peer
+		if !closed {
+			if errors.Is(err, io.EOF) {
+				emit("eof", map[string]any{"local": c.local})
+			} else {
+				emit("conn-error", map[string]any{"local": c.local, "errno": errnoOf(err), "message": err.Error()})
+			}
+		}
+	}
+	return n, err
+}
+
+func (c *traced) Close() error {
+	c.mu.Lock()
+	first := !c.closed
+	c.closed = true
+	c.mu.Unlock()
+	if first {
+		emit("closed", map[string]any{"local": c.local})
+	}
+	return c.Conn.Close()
+}
+
+// dial gives the DialContext of the transport: the dialer, and a wrapper on each connection.
+func dial(d *net.Dialer) func(ctx context.Context, network, addr string) (net.Conn, error) {
+	var mu sync.Mutex
+	count := 0
+	return func(ctx context.Context, network, addr string) (net.Conn, error) {
+		start := now()
+		conn, err := d.DialContext(ctx, network, addr)
+		if err != nil {
+			emit("dial-error", map[string]any{"errno": errnoOf(err), "message": err.Error(), "ns": now() - start})
+			return nil, err
+		}
+		mu.Lock()
+		count++
+		n := count
+		mu.Unlock()
+		local := conn.LocalAddr().String()
+		emit("conn", map[string]any{"n": n, "local": local})
+		if n == 1 {
+			emit("connected", map[string]any{"local": local})
+		}
+		return &traced{Conn: conn, local: local}, nil
+	}
+}
+
+// request sends request i and waits for its outcome. It tells whether a reply came.
+func request(client *http.Client, base string, i int, method, path string) bool {
+	attempts := 0
+	trace := &httptrace.ClientTrace{
+		GotConn: func(info httptrace.GotConnInfo) {
+			attempts++
+			ev := "request"
+			if attempts > 1 {
+				ev = "retry"
+			}
+			emit(ev, map[string]any{
+				"i":       i,
+				"local":   info.Conn.LocalAddr().String(),
+				"reused":  info.Reused,
+				"idle_ns": info.IdleTime.Nanoseconds(),
+			})
+		},
+		WroteRequest: func(info httptrace.WroteRequestInfo) {
+			fields := map[string]any{"i": i}
+			if info.Err != nil {
+				fields["errno"] = errnoOf(info.Err)
+			}
+			emit("wrote", fields)
+		},
+		GotFirstResponseByte: func() { emit("first-byte", map[string]any{"i": i}) },
+	}
+	var body io.Reader
+	if method == "POST" {
+		body = strings.NewReader("x")
+	}
+	req, err := http.NewRequestWithContext(httptrace.WithClientTrace(context.Background(), trace), method, base+path, body)
+	if err != nil {
+		emit("fail", map[string]any{"why": err.Error()})
+		os.Exit(1)
+	}
+	// the stamp comes before the call: the transport writes the request after it
+	at := now()
+	emitAt("sent", at, map[string]any{"i": i})
+	resp, err := client.Do(req)
+	if err != nil {
+		emit("error", map[string]any{"i": i, "errno": errnoOf(err), "message": err.Error()})
+		return false
+	}
+	emit("response", map[string]any{"i": i, "status": resp.StatusCode})
+	n, err := io.Copy(io.Discard, resp.Body)
+	resp.Body.Close()
+	if err != nil {
+		emit("error", map[string]any{"i": i, "errno": errnoOf(err), "message": err.Error()})
+		return false
+	}
+	if i == 1 {
+		emit("ready", map[string]any{"reply": resp.Status})
+	} else {
+		emit("data", map[string]any{"i": i, "n": n})
+		emit("replied", map[string]any{"i": i, "n": map[string]any{"value": n, "unit": "B"}})
+	}
+	return true
+}
+
+func milliseconds(ms float64) time.Duration { return time.Duration(ms * float64(time.Millisecond)) }
+
+func main() {
+	usage := "client-go HOST PORT --mode idle|inflight|gap"
+	if len(os.Args) < 3 {
+		emit("fail", map[string]any{"why": usage})
+		os.Exit(1)
+	}
+	host, port := os.Args[1], os.Args[2]
+	flags := flag.NewFlagSet("client-go", flag.ExitOnError)
+	mode := flags.String("mode", "", "idle, inflight or gap")
+	gapMs := flags.Float64("gap-ms", 0, "the gap after the first reply, in gap mode")
+	method := flags.String("method", "GET", "the method of the second request")
+	holdMs := flags.Int("hold-ms", 0, "the second request asks the server to hold its reply")
+	size := flags.Int("bytes", 0, "the second request asks for a body of this length")
+	goPath := flags.String("go", "/tmp/go", "the file that starts the second request, in inflight mode")
+	maxS := flags.Float64("max-s", 60, "the deadline of the client")
+	lingerMs := flags.Float64("linger-ms", 500, "the wait after the second request, before the exit")
+	idleMs := flags.Float64("idle-conn-timeout-ms", 0, "Transport.IdleConnTimeout")
+	maxIdle := flags.Int("max-idle-per-host", 0, "Transport.MaxIdleConnsPerHost")
+	dialMs := flags.Float64("dial-timeout-ms", 0, "Dialer.Timeout")
+	keepAliveMs := flags.Float64("keepalive-ms", 0, "Dialer.KeepAlive, negative for off")
+	intervalMs := flags.Float64("keepalive-interval-ms", 0, "KeepAliveConfig.Interval")
+	probes := flags.Int("keepalive-count", 0, "KeepAliveConfig.Count")
+	timeoutMs := flags.Float64("timeout-ms", 0, "Client.Timeout")
+	flags.Parse(os.Args[3:])
+	given := map[string]bool{}
+	flags.Visit(func(f *flag.Flag) { given[f.Name] = true })
+	if *mode != "idle" && *mode != "inflight" && *mode != "gap" {
+		emit("fail", map[string]any{"why": usage})
+		os.Exit(1)
+	}
+
+	// the dialer of http.DefaultTransport (src/net/http/transport.go:47-53), with the settings of the cell
+	dialer := &net.Dialer{Timeout: 30 * time.Second, KeepAlive: 30 * time.Second}
+	if given["dial-timeout-ms"] {
+		dialer.Timeout = milliseconds(*dialMs)
+	}
+	if given["keepalive-ms"] {
+		dialer.KeepAlive = milliseconds(*keepAliveMs)
+	}
+	if given["keepalive-interval-ms"] || given["keepalive-count"] {
+		dialer.KeepAliveConfig = net.KeepAliveConfig{
+			Enable:   dialer.KeepAlive >= 0,
+			Idle:     dialer.KeepAlive,
+			Interval: milliseconds(*intervalMs),
+			Count:    *probes,
+		}
+	}
+	transport := http.DefaultTransport.(*http.Transport).Clone()
+	transport.DialContext = dial(dialer)
+	if given["idle-conn-timeout-ms"] {
+		transport.IdleConnTimeout = milliseconds(*idleMs)
+	}
+	if given["max-idle-per-host"] {
+		transport.MaxIdleConnsPerHost = *maxIdle
+	}
+	client := &http.Client{Transport: transport}
+	if given["timeout-ms"] {
+		client.Timeout = milliseconds(*timeoutMs)
+	}
+
+	bootID, _ := os.ReadFile("/proc/sys/kernel/random/boot_id")
+	settings := map[string]any{}
+	settings["IdleConnTimeout_ms"] = transport.IdleConnTimeout.Milliseconds()
+	settings["MaxIdleConnsPerHost"] = transport.MaxIdleConnsPerHost
+	settings["DialTimeout_ms"] = dialer.Timeout.Milliseconds()
+	settings["KeepAlive_ms"] = dialer.KeepAlive.Milliseconds()
+	settings["KeepAliveInterval_ms"] = dialer.KeepAliveConfig.Interval.Milliseconds()
+	settings["KeepAliveCount"] = dialer.KeepAliveConfig.Count
+	settings["ClientTimeout_ms"] = client.Timeout.Milliseconds()
+	start := map[string]any{}
+	start["boot_id"] = strings.TrimSpace(string(bootID))
+	start["mode"] = *mode
+	start["client"] = "go-nethttp"
+	start["go"] = runtime.Version()
+	start["settings"] = settings
+	emit("start", start)
+	go func() {
+		time.Sleep(time.Duration(*maxS * float64(time.Second)))
+		emit("deadline", nil)
+		os.Exit(0)
+	}()
+
+	base := "http://" + net.JoinHostPort(host, port)
+	second := "/"
+	if *holdMs > 0 {
+		second = fmt.Sprintf("/hold?ms=%d", *holdMs)
+	} else if *size > 0 {
+		second = fmt.Sprintf("/big?bytes=%d", *size)
+	}
+	if !request(client, base, 1, "GET", "/") {
+		os.Exit(1)
+	}
+	switch *mode {
+	case "idle":
+		// the connection stays in the pool until it ends, or until the deadline
+		select {}
+	case "inflight":
+		for {
+			if _, err := os.Stat(*goPath); err == nil {
+				break
+			}
+			time.Sleep(2 * time.Millisecond)
+		}
+	case "gap":
+		time.Sleep(milliseconds(*gapMs))
+	}
+	request(client, base, 2, *method, second)
+	emit("done", map[string]any{"i": 2})
+	time.Sleep(milliseconds(*lingerMs))
+	os.Exit(0)
+}

package/image/node-http/Dockerfile

@@ -0,0 +1,12 @@
+# The Node HTTP clients of the harness: the http.Agent of Node 24.21.0, and an HTTP/1.1 Client of
+# undici 8.12.2. Each runs as a container in the client's network namespace, as the harness's own
+# TCP client does, and prints the same JSON lines. The digest of the image and an npm lockfile pin
+# them. The image is apart from the ioredis image, thus the cells of ioredis keep their image.
+# lab.ts stages the build context: this folder, under harness/image/node-http. The lockfile is
+# npm-lock.json here, because npm leaves each package-lock.json out of a published tarball.
+FROM node:24.21.0-alpine@sha256:ebfe2f90462722a7a4de65e91990e97fe0d401c70e0e762c5b53302f905ec1c1
+WORKDIR /opt/harness/node-http
+COPY harness/image/node-http/package.json ./
+COPY harness/image/node-http/npm-lock.json ./package-lock.json
+RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
+COPY harness/image/node-http/lines.mjs harness/image/node-http/client-agent.mjs harness/image/node-http/client-undici.mjs ./

package/image/node-http/client-agent.mjs

@@ -0,0 +1,163 @@
+// client-agent HOST PORT --mode idle|inflight|gap [--gap-ms N] [--method GET|POST] [--hold-ms N]
+//              [--bytes N] [--go PATH] [--max-s N] [--linger-ms N]
+//              [--timeout-ms N] [--keepalive-msecs N] [--buffer-ms N]
+//
+// The client of the HTTP cells that uses the http.Agent of Node 24.21.0. Without an agent flag it
+// uses http.globalAgent: keep-alive on, a free socket timeout of 5 s, LIFO
+// (lib/internal/http.js:263-265). With a flag, it uses a new Agent with the same options and the
+// flag. Each event is a JSON line, as the TCP client of the harness writes them.
+//
+// The first request is GET /, and the end of its reply is the `ready` line. Then the client holds
+// the connection idle (idle), sends the second request when the file --go appears (inflight), or
+// sends it after the gap (gap). For each request it writes the connection that it went on (the
+// local address and port), whether the agent reused the socket, and the outcome. For each socket it
+// writes the connect, the end of file, the timeout of the agent, and the close.
+
+import http from "node:http";
+import { bootId, commandLine, emit, now, pathOf, sleep, waitFor } from "./lines.mjs";
+
+const usage = "client-agent HOST PORT --mode idle|inflight|gap";
+const cli = commandLine(usage);
+const mode = cli.flag("--mode");
+if (mode !== "idle" && mode !== "inflight" && mode !== "gap") {
+  emit("fail", { why: usage });
+  process.exit(1);
+}
+const method = cli.flag("--method") ?? "GET";
+const second = pathOf({ hold: cli.number("--hold-ms"), bytes: cli.number("--bytes") });
+const max = cli.number("--max-s", 60) * 1000;
+const linger = cli.number("--linger-ms", 500);
+
+// the options of http.globalAgent, and each flag over them
+const custom = cli.has("--timeout-ms") || cli.has("--keepalive-msecs") || cli.has("--buffer-ms");
+const options = { keepAlive: true, scheduling: "lifo", timeout: 5000 };
+if (cli.has("--timeout-ms")) options.timeout = cli.number("--timeout-ms");
+if (cli.has("--keepalive-msecs")) options.keepAliveMsecs = cli.number("--keepalive-msecs");
+if (cli.has("--buffer-ms")) options.agentKeepAliveTimeoutBuffer = cli.number("--buffer-ms");
+const agent = custom ? new http.Agent(options) : http.globalAgent;
+
+emit("start", {
+  boot_id: bootId(),
+  mode,
+  client: "node-http-agent",
+  node: process.version,
+  agent: {
+    global: !custom,
+    keepAlive: agent.keepAlive,
+    timeout: agent.options.timeout ?? 0,
+    keepAliveMsecs: agent.keepAliveMsecs,
+    agentKeepAliveTimeoutBuffer: agent.agentKeepAliveTimeoutBuffer,
+    scheduling: agent.scheduling,
+  },
+});
+
+setTimeout(() => {
+  emit("deadline");
+  process.exit(0);
+}, max);
+
+// the sockets of the agent, each with its number, its local address, and what happened to it
+const sockets = new Map();
+const isFree = (socket) => Object.values(agent.freeSockets).some((list) => list.includes(socket));
+
+/** This function follows a socket of the agent, one time. */
+const track = (socket) => {
+  const known = sockets.get(socket);
+  if (known !== undefined) return known;
+  const entry = { n: sockets.size + 1, local: null, timedOut: false, pooled: false };
+  sockets.set(socket, entry);
+  const connected = () => {
+    entry.local = `${socket.localAddress}:${socket.localPort}`;
+    emit("conn", { n: entry.n, local: entry.local });
+    if (entry.n === 1) emit("connected", { local: entry.local });
+  };
+  if (socket.connecting) socket.once("connect", connected);
+  else connected();
+  // the listeners of the agent come first: after its free handler, the socket is in the pool or destroyed
+  socket.on("free", () => {
+    entry.pooled = isFree(socket);
+    emit(entry.pooled ? "pooled" : "not-pooled", { local: entry.local });
+  });
+  socket.on("timeout", () => {
+    entry.timedOut = entry.pooled;
+  });
+  socket.on("end", () => emit("eof", { local: entry.local }));
+  socket.on("error", (error) => emit("conn-error", { local: entry.local, errno: error.code ?? "ERROR", message: error.message }));
+  socket.on("close", (hadError) => {
+    // the agent destroys a free socket on its own timeout, or on any read: an end of file or a
+    // reset from the peer (lib/_http_agent.js:101-112). The guard hides the end event
+    const by = entry.timedOut ? "client-timer" : hadError ? "error" : entry.pooled ? "peer" : "client";
+    if (by === "peer") emit("eof", { local: entry.local, free: true });
+    emit("closed", { local: entry.local, by });
+  });
+  return entry;
+};
+
+/** This function sends request `i` and waits for its outcome. */
+const request = (i, how, path) =>
+  new Promise((resolve) => {
+    const at = now();
+    const req = http.request({
+      host: cli.host,
+      port: cli.port,
+      method: how,
+      path,
+      agent,
+      headers: how === "POST" ? { "content-length": "1" } : {},
+    });
+    emit("sent", { i }, at);
+    let ended = false;
+    const end = (ok) => {
+      if (ended) return;
+      ended = true;
+      resolve(ok);
+    };
+    req.on("socket", (socket) => {
+      const entry = track(socket);
+      entry.pooled = false;
+      entry.timedOut = false;
+      const show = () => emit("request", { i, local: entry.local, reused: req.reusedSocket });
+      if (socket.connecting) socket.once("connect", show);
+      else show();
+    });
+    req.on("response", (res) => {
+      emit("response", { i, status: res.statusCode, local: `${res.socket.localAddress}:${res.socket.localPort}` });
+      let n = 0;
+      res.on("data", (chunk) => {
+        n += chunk.length;
+        if (i > 1) emit("data", { i, n: chunk.length });
+      });
+      res.on("end", () => {
+        if (i === 1) emit("ready", { reply: `HTTP ${res.statusCode}` });
+        else emit("replied", { i, n: { value: n, unit: "B" } });
+        end(true);
+      });
+      res.on("error", (error) => {
+        emit("error", { i, errno: error.code ?? "ERROR", message: error.message });
+        end(false);
+      });
+    });
+    req.on("error", (error) => {
+      emit("error", { i, errno: error.code ?? "ERROR", message: error.message });
+      end(false);
+    });
+    req.end(how === "POST" ? "x" : undefined);
+  });
+
+const finish = async () => {
+  emit("done", { i: 2 });
+  await sleep(linger);
+  process.exit(0);
+};
+
+if (!(await request(1, "GET", "/"))) process.exit(1);
+if (mode === "inflight") {
+  await waitFor(cli.flag("--go") ?? "/tmp/go");
+  await request(2, method, second);
+  await finish();
+} else if (mode === "gap") {
+  await sleep(cli.number("--gap-ms", 0));
+  await request(2, method, second);
+  await finish();
+}
+// idle: the connection stays in the pool until it ends, or until the deadline

package/image/node-http/client-undici.mjs

@@ -0,0 +1,141 @@
+// client-undici HOST PORT --mode idle|inflight|gap [--gap-ms N] [--method GET|POST] [--hold-ms N]
+//               [--bytes N] [--go PATH] [--max-s N] [--linger-ms N]
+//               [--keepalive-timeout-ms N] [--keepalive-max-timeout-ms N] [--keepalive-threshold-ms N]
+//               [--headers-timeout-ms N] [--body-timeout-ms N] [--connect-timeout-ms N]
+//               [--keepalive-initial-delay-ms N]
+//
+// The client of the HTTP cells that uses an HTTP/1.1 Client of undici 8.12.2, at its defaults
+// with each flag over them. Each event is a JSON line, as the TCP client of the harness writes them.
+//
+// The workload is the workload of client-agent.mjs. A connector around the connector of undici
+// follows each socket. The channel undici:client:sendHeaders tells which socket each request goes
+// on. The disconnect event of the client tells why a socket ended: an end of file (other side
+// closed), a reset, or the keep-alive timer of the client (socket idle timeout).
+
+import diagnostics from "node:diagnostics_channel";
+import { Client, buildConnector } from "undici";
+import { bootId, commandLine, emit, now, pathOf, sleep, waitFor } from "./lines.mjs";
+
+const usage = "client-undici HOST PORT --mode idle|inflight|gap";
+const cli = commandLine(usage);
+const mode = cli.flag("--mode");
+if (mode !== "idle" && mode !== "inflight" && mode !== "gap") {
+  emit("fail", { why: usage });
+  process.exit(1);
+}
+const method = cli.flag("--method") ?? "GET";
+const second = pathOf({ hold: cli.number("--hold-ms"), bytes: cli.number("--bytes") });
+const max = cli.number("--max-s", 60) * 1000;
+const linger = cli.number("--linger-ms", 500);
+
+// the options of the client: undici's defaults, and each flag over them
+const options = {};
+const set = (option, name) => {
+  if (cli.has(name)) options[option] = cli.number(name);
+};
+set("keepAliveTimeout", "--keepalive-timeout-ms");
+set("keepAliveMaxTimeout", "--keepalive-max-timeout-ms");
+set("keepAliveTimeoutThreshold", "--keepalive-threshold-ms");
+set("headersTimeout", "--headers-timeout-ms");
+set("bodyTimeout", "--body-timeout-ms");
+const connect = {};
+if (cli.has("--connect-timeout-ms")) connect.timeout = cli.number("--connect-timeout-ms");
+if (cli.has("--keepalive-initial-delay-ms")) connect.keepAliveInitialDelay = cli.number("--keepalive-initial-delay-ms");
+
+emit("start", { boot_id: bootId(), mode, client: "undici", node: process.version, options, connect });
+
+setTimeout(() => {
+  emit("deadline");
+  process.exit(0);
+}, max);
+
+// the sockets of the client, each with its number, its local address, and its use
+const sockets = new Map();
+let current = null;
+
+/** This function follows a socket of the client, one time. */
+const track = (socket) => {
+  const known = sockets.get(socket);
+  if (known !== undefined) return known;
+  const entry = { n: sockets.size + 1, local: `${socket.localAddress}:${socket.localPort}`, used: false };
+  sockets.set(socket, entry);
+  current = entry;
+  emit("conn", { n: entry.n, local: entry.local });
+  if (entry.n === 1) emit("connected", { local: entry.local });
+  socket.on("end", () => emit("eof", { local: entry.local }));
+  socket.on("error", (error) =>
+    // undici destroys a socket with an error of its own when it closes the socket itself
+    OWN.has(error.code)
+      ? emit("client-close", { local: entry.local, errno: error.code, message: error.message })
+      : emit("conn-error", { local: entry.local, errno: error.code ?? "ERROR", message: error.message }),
+  );
+  socket.on("close", () => emit("closed", { local: entry.local }));
+  return entry;
+};
+
+// the errors of undici for a close by the client itself: no reuse, its keep-alive timer, its deadlines
+const OWN = new Set(["UND_ERR_INFO", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT", "UND_ERR_CONNECT_TIMEOUT"]);
+
+// the default connector of undici with the connect options, around a function that follows each socket
+const connector = buildConnector(connect);
+let requestIndex = 0;
+const client = new Client(`http://${cli.host}:${cli.port}`, {
+  ...options,
+  connect: (opts, callback) =>
+    connector(opts, (error, socket) => {
+      if (error === null && socket !== undefined && socket !== null) track(socket);
+      callback(error, socket);
+    }),
+});
+
+diagnostics.subscribe("undici:client:sendHeaders", ({ socket }) => {
+  const entry = track(socket);
+  emit("request", { i: requestIndex, local: entry.local, reused: entry.used });
+  entry.used = true;
+});
+client.on("disconnect", (_origin, _targets, error) => {
+  // UND_ERR_INFO is a close by the client: no reuse (reset), or its keep-alive timer (socket idle timeout)
+  const by = OWN.has(error?.code) ? "client" : "peer";
+  emit("disconnect", { local: current?.local ?? null, by, errno: error?.code ?? null, message: error?.message ?? null });
+});
+
+/** This function sends request `i` and waits for its outcome. */
+const request = async (i, how, path) => {
+  requestIndex = i;
+  const at = now();
+  const pending = client.request({ path, method: how, body: how === "POST" ? "x" : undefined });
+  emit("sent", { i }, at);
+  try {
+    const { statusCode, body } = await pending;
+    emit("response", { i, status: statusCode });
+    let n = 0;
+    for await (const chunk of body) {
+      n += chunk.length;
+      if (i > 1) emit("data", { i, n: chunk.length });
+    }
+    if (i === 1) emit("ready", { reply: `HTTP ${statusCode}` });
+    else emit("replied", { i, n: { value: n, unit: "B" } });
+    return true;
+  } catch (error) {
+    emit("error", { i, errno: error.code ?? "ERROR", cause: error.cause?.code ?? null, message: error.message });
+    return false;
+  }
+};
+
+const finish = async () => {
+  emit("done", { i: 2 });
+  await sleep(linger);
+  process.exit(0);
+};
+
+if (!(await request(1, "GET", "/"))) process.exit(1);
+if (mode === "inflight") {
+  await waitFor(cli.flag("--go") ?? "/tmp/go");
+  await request(2, method, second);
+  await finish();
+} else if (mode === "gap") {
+  await sleep(cli.number("--gap-ms", 0));
+  await request(2, method, second);
+  await finish();
+}
+// idle: the connection stays open until it ends, or until the deadline