Enable container-level goroutine-leak checks for the HTTP suite

Disable connection keep-alive so the HTTP transport's per-connection goroutines
are torn down promptly instead of lingering in idle pools past a spec:

- Client: set Request.Close on the unary client (used only in tests) so net/http
  closes the connection after reading each response.
- Server: set fiber DisableKeepalive on the unary test servers so they close
  connections after each response. Stream/websocket servers keep keep-alive, as
  disabling it severs the upgraded connection.
- Close the response bodies of the Eventually health-poll loops (pollHealth) so
  those polling connections are released rather than pinned in net/http's pool.

Exempt the fasthttp worker-pool janitor in the shared leak checker: it sleeps for
MaxIdleWorkerDuration (10s) between cleanup passes and only observes its stop
signal after the in-progress sleep returns, so it outlives its server far longer
than the assertion's polling window. This matches the existing updateServerDate
exemption; a genuinely leaked server is still caught by its other goroutines.

With these, the unary BeforeSuite and stream BeforeAll now run ShouldNotLeakGoroutines.
Per-spec checking stays disabled: several specs stand up their own per-spec server
and exchange websocket streams whose connections cannot be guaranteed to drain
within the per-spec window.

Author: pjdotson

freighter/go/http/http_suite_test.go

@@ -10,6 +10,7 @@
 package http_test
 
 import (
+	"net/http"
 	"testing"
 
 	. "github.com/onsi/ginkgo/v2"
@@ -18,10 +19,22 @@ import (
 
 func TestHTTP(t *testing.T) {
 	RegisterFailHandler(Fail)
-	// freighter's HTTP transport keeps net/http idle keep-alive connections and
-	// fasthttp server-worker goroutines alive past a spec's end; they are not
-	// guaranteed to drain within the per-spec window, so per-spec goroutine-leak
-	// checking is not applicable to this suite.
+	// Per-spec leak checking is not registered: several specs stand up their own
+	// per-spec fiber server and exchange websocket streams, whose connections cannot be
+	// guaranteed to drain within the per-spec window. The BeforeSuite and BeforeAll
+	// container-level checks still verify that the suite-wide servers are fully torn
+	// down at teardown.
 	//nolint:leak
 	RunSpecs(t, "HTTP Suite")
 }
+
+// pollHealth issues a GET to url and closes the response body, returning any error. The
+// Eventually health-check loops use it so their polling connections are released rather
+// than left pinned in net/http's idle pool.
+func pollHealth(url string) error {
+	res, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	return res.Body.Close()
+}

freighter/go/http/recovery_wire_test.go

@@ -11,7 +11,6 @@ package http_test
 
 import (
 	"context"
-	"net/http"
 	"time"
 
 	"github.com/gofiber/fiber/v3"
@@ -51,8 +50,7 @@ var _ = Describe("Recovery (wire)", func() {
 		}()
 		DeferCleanup(func() { Expect(app.Shutdown()).To(Succeed()) })
 		Eventually(func(g Gomega) {
-			_, err := http.Get("http://" + addr.String() + "/health")
-			g.Expect(err).To(Succeed())
+			g.Expect(pollHealth("http://" + addr.String() + "/health")).To(Succeed())
 		}).WithPolling(time.Millisecond).Should(Succeed())
 
 		client := MustSucceed(fhttp.NewUnaryClient[test.Request, test.Response]())

freighter/go/http/router_test.go

@@ -11,7 +11,6 @@ package http_test
 
 import (
 	"context"
-	"net/http"
 	"time"
 
 	"github.com/gofiber/fiber/v3"
@@ -109,7 +108,7 @@ var _ = Describe("Router", func() {
 	Describe("BindTo", func() {
 		It("should register a unary route on the bound fiber app", func(specCtx SpecContext) {
 			addr := address.Newf("localhost:%d", MustSucceed(net.FindOpenPort()))
-			app := fiber.New(fiber.Config{})
+			app := fiber.New(fiber.Config{DisableKeepalive: true})
 			router := MustSucceed(fhttp.NewRouter())
 			server := fhttp.NewUnaryServer[test.Request, test.Response](router, "/echo")
 			server.BindHandler(func(_ context.Context, req test.Request) (test.Response, error) {
@@ -125,8 +124,7 @@ var _ = Describe("Router", func() {
 			DeferCleanup(func() { Expect(app.Shutdown()).To(Succeed()) })
 
 			Eventually(func(g Gomega) {
-				_, err := http.Get("http://" + addr.String() + "/echo")
-				g.Expect(err).To(Succeed())
+				g.Expect(pollHealth("http://" + addr.String() + "/echo")).To(Succeed())
 			}).WithPolling(time.Millisecond).Should(Succeed())
 
 			client := MustSucceed(fhttp.NewUnaryClient[test.Request, test.Response](
@@ -166,8 +164,7 @@ var _ = Describe("Router", func() {
 			}()
 
 			Eventually(func(g Gomega) {
-				_, err := http.Get("http://" + addr.String() + "/anything")
-				g.Expect(err).To(Succeed())
+				g.Expect(pollHealth("http://" + addr.String() + "/anything")).To(Succeed())
 			}).WithPolling(time.Millisecond).Should(Succeed())
 
 			client := MustSucceed(fhttp.NewStreamClient[test.Request, test.Response](
@@ -185,7 +182,7 @@ var _ = Describe("Router", func() {
 	Describe("Use", func() {
 		It("should install middleware on every server registered before the call", func(specCtx SpecContext) {
 			addr := address.Newf("localhost:%d", MustSucceed(net.FindOpenPort()))
-			app := fiber.New(fiber.Config{})
+			app := fiber.New(fiber.Config{DisableKeepalive: true})
 			router := MustSucceed(fhttp.NewRouter())
 
 			var calls int
@@ -210,8 +207,7 @@ var _ = Describe("Router", func() {
 			}()
 			DeferCleanup(func() { Expect(app.Shutdown()).To(Succeed()) })
 			Eventually(func(g Gomega) {
-				_, err := http.Get("http://" + addr.String() + "/anything")
-				g.Expect(err).To(Succeed())
+				g.Expect(pollHealth("http://" + addr.String() + "/anything")).To(Succeed())
 			}).WithPolling(time.Millisecond).Should(Succeed())
 
 			client := MustSucceed(fhttp.NewUnaryClient[test.Request, test.Response](
@@ -226,7 +222,7 @@ var _ = Describe("Router", func() {
 
 		It("should not install middleware on servers registered after the call", func(specCtx SpecContext) {
 			addr := address.Newf("localhost:%d", MustSucceed(net.FindOpenPort()))
-			app := fiber.New(fiber.Config{})
+			app := fiber.New(fiber.Config{DisableKeepalive: true})
 			router := MustSucceed(fhttp.NewRouter())
 
 			var calls int
@@ -251,8 +247,7 @@ var _ = Describe("Router", func() {
 			}()
 			DeferCleanup(func() { Expect(app.Shutdown()).To(Succeed()) })
 			Eventually(func(g Gomega) {
-				_, err := http.Get("http://" + addr.String() + "/anything")
-				g.Expect(err).To(Succeed())
+				g.Expect(pollHealth("http://" + addr.String() + "/anything")).To(Succeed())
 			}).WithPolling(time.Millisecond).Should(Succeed())
 
 			client := MustSucceed(fhttp.NewUnaryClient[test.Request, test.Response](
@@ -270,7 +265,7 @@ var _ = Describe("Router", func() {
 
 		It("should chain multiple middlewares in registration order", func(specCtx SpecContext) {
 			addr := address.Newf("localhost:%d", MustSucceed(net.FindOpenPort()))
-			app := fiber.New(fiber.Config{})
+			app := fiber.New(fiber.Config{DisableKeepalive: true})
 			router := MustSucceed(fhttp.NewRouter())
 
 			var order []string
@@ -305,8 +300,7 @@ var _ = Describe("Router", func() {
 			}()
 			DeferCleanup(func() { Expect(app.Shutdown()).To(Succeed()) })
 			Eventually(func(g Gomega) {
-				_, err := http.Get("http://" + addr.String() + "/anything")
-				g.Expect(err).To(Succeed())
+				g.Expect(pollHealth("http://" + addr.String() + "/anything")).To(Succeed())
 			}).WithPolling(time.Millisecond).Should(Succeed())
 
 			client := MustSucceed(fhttp.NewUnaryClient[test.Request, test.Response](

freighter/go/http/stream_test.go

@@ -35,11 +35,8 @@ var _ = Describe("Stream", Ordered, Serial, func() {
 		app    *fiber.App
 	)
 
-	// freighter's HTTP transport keeps net/http idle keep-alive connections and
-	// fasthttp server-worker goroutines alive past this container's lifetime, so a
-	// leak check here is not applicable.
-	//nolint:leak
 	BeforeAll(func() {
+		ShouldNotLeakGoroutines()
 		addr = address.Newf("localhost:%d", MustSucceed(net.FindOpenPort()))
 		app = fiber.New(fiber.Config{})
 		router := MustSucceed(fhttp.NewRouter(fhttp.RouterConfig{
@@ -60,8 +57,7 @@ var _ = Describe("Stream", Ordered, Serial, func() {
 			})).To(Succeed())
 		}()
 		Eventually(func(g Gomega) {
-			_, err := http.Get("http://" + addr.String() + "/health")
-			g.Expect(err).To(Succeed())
+			g.Expect(pollHealth("http://" + addr.String() + "/health")).To(Succeed())
 		}).WithPolling(1 * time.Millisecond).Should(Succeed())
 	})
 

freighter/go/http/unary_client.go

@@ -145,6 +145,10 @@ func (u *unaryClient[RQ, RS]) Send(
 				return freighter.Context{}, err
 			}
 			setRequestCtx(httpReq, inCtx)
+			// This client is only used in tests; disable connection keep-alive so the
+			// underlying connection (and its net/http reader/writer goroutines) is torn
+			// down when the response is read rather than lingering in the idle pool.
+			httpReq.Close = true
 			httpReq.Header.Set(fiber.HeaderContentType, u.encoder.ContentType())
 			httpReq.Header.Set(fiber.HeaderAccept, u.acceptHeader)
 

freighter/go/http/unary_test.go

@@ -57,13 +57,10 @@ func (failingEncoder) EncodeStream(context.Context, io.Writer, any) error {
 	return errFailingEncoderEncodeFail
 }
 
-// The suite-wide fiber (fasthttp) server started here keeps server-worker goroutines
-// alive for the lifetime of the process, so a BeforeSuite leak check is not applicable.
-//
-//nolint:leak
 var _ = BeforeSuite(func() {
+	ShouldNotLeakGoroutines()
 	unaryAddr = address.Newf("localhost:%d", MustSucceed(net.FindOpenPort()))
-	unaryApp = fiber.New(fiber.Config{})
+	unaryApp = fiber.New(fiber.Config{DisableKeepalive: true})
 	router := MustSucceed(fhttp.NewRouter())
 	unaryApp.Get("/health", func(ctx fiber.Ctx) error {
 		return ctx.SendStatus(fiber.StatusOK)
@@ -103,8 +100,7 @@ var _ = BeforeSuite(func() {
 		})).To(Succeed())
 	}()
 	Eventually(func(g Gomega) {
-		_, err := http.Get("http://" + unaryAddr.String() + "/health")
-		g.Expect(err).To(Succeed())
+		g.Expect(pollHealth("http://" + unaryAddr.String() + "/health")).To(Succeed())
 	}).WithPolling(1 * time.Millisecond).Should(Succeed())
 })
 

x/go/testutil/leak.go

@@ -87,6 +87,16 @@ func assertNoLeakedGoroutines(snapshot []gleak.Goroutine) {
 		args,
 		gleak.IgnoringCreator("github.com/valyala/fasthttp.updateServerDate"),
 	)
+	// Every fasthttp server starts a worker-pool janitor that sleeps for
+	// MaxIdleWorkerDuration (10s) between cleanup passes. On server shutdown it is
+	// signaled to stop, but the signal is only observed after the in-progress sleep
+	// returns, so it can outlive its server by up to 10s. That is far longer than the
+	// leak assertion's polling window, so ignore it; a genuinely leaked server is still
+	// caught by its other (acceptor/connection) goroutines.
+	args = append(
+		args,
+		gleak.IgnoringCreator("github.com/valyala/fasthttp.(*workerPool).Start"),
+	)
 	assertion := gomega.Eventually(gleak.Goroutines)
 	assertion.ShouldNot(gleak.HaveLeaked(args...))
 }