support rcmgr tracing in itests

itest/echo_test.go

@@ -11,13 +11,13 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func createEchos(t *testing.T, count int, makeOpts ...func() libp2p.Option) []*Echo {
+func createEchos(t *testing.T, count int, makeOpts ...func(int) libp2p.Option) []*Echo {
 	result := make([]*Echo, 0, count)
 
 	for i := 0; i < count; i++ {
 		opts := make([]libp2p.Option, 0, len(makeOpts))
 		for _, makeOpt := range makeOpts {
-			opts = append(opts, makeOpt())
+			opts = append(opts, makeOpt(i))
 		}
 
 		h, err := libp2p.New(opts...)

itest/rcmgr_test.go

@@ -3,6 +3,7 @@ package itest
 import (
 	"context"
 	"fmt"
+	"os"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -14,25 +15,38 @@ import (
 	"github.com/libp2p/go-libp2p-core/peer"
 )
 
-func makeRcmgrOption(t *testing.T, limiter *rcmgr.BasicLimiter) func() libp2p.Option {
-	return func() libp2p.Option {
-		mgr, err := rcmgr.NewResourceManager(limiter)
+func makeRcmgrOption(t *testing.T, limiter *rcmgr.BasicLimiter, test string) func(int) libp2p.Option {
+	return func(i int) libp2p.Option {
+		var opts []rcmgr.Option
+
+		if os.Getenv("LIBP2P_TEST_RCMGR_TRACE") == "1" {
+			opts = append(opts, rcmgr.WithTrace(fmt.Sprintf("%s-%d.json.gz", test, i)))
+		}
+
+		mgr, err := rcmgr.NewResourceManager(limiter, opts...)
 		if err != nil {
 			t.Fatal(err)
 		}
 		return libp2p.ResourceManager(mgr)
 	}
 }
 
+func closeRcmgrs(echos []*Echo) {
+	for _, e := range echos {
+		e.Host.Network().ResourceManager().Close()
+	}
+}
+
 func TestResourceManagerConnInbound(t *testing.T) {
 	// this test checks that we can not exceed the inbound conn limit at system level
 	// we specify: 1 conn per peer, 3 conns total, and we try to create 4 conns
 	limiter := rcmgr.NewDefaultLimiter()
 	limiter.SystemLimits = limiter.SystemLimits.WithConnLimit(3, 1024, 1024)
 	limiter.DefaultPeerLimits = limiter.DefaultPeerLimits.WithConnLimit(1, 16, 16)
 
-	echos := createEchos(t, 5, makeRcmgrOption(t, limiter))
+	echos := createEchos(t, 5, makeRcmgrOption(t, limiter, "TestResourceManagerConnInbound"))
 	defer closeEchos(echos)
+	defer closeRcmgrs(echos)
 
 	for i := 1; i < 4; i++ {
 		err := echos[i].Host.Connect(context.Background(), peer.AddrInfo{ID: echos[0].Host.ID()})
@@ -61,8 +75,9 @@ func TestResourceManagerConnOutbound(t *testing.T) {
 	limiter := rcmgr.NewDefaultLimiter()
 	limiter.SystemLimits = limiter.SystemLimits.WithConnLimit(1024, 3, 1024)
 	limiter.DefaultPeerLimits = limiter.DefaultPeerLimits.WithConnLimit(16, 1, 16)
-	echos := createEchos(t, 5, makeRcmgrOption(t, limiter))
+	echos := createEchos(t, 5, makeRcmgrOption(t, limiter, "TestResourceManagerConnOutbound"))
 	defer closeEchos(echos)
+	defer closeRcmgrs(echos)
 
 	for i := 1; i < 4; i++ {
 		err := echos[0].Host.Connect(context.Background(), peer.AddrInfo{ID: echos[i].Host.ID()})
@@ -90,8 +105,9 @@ func TestResourceManagerServiceInbound(t *testing.T) {
 	// we specify: 3 streams for the service, and we try to create 4 streams
 	limiter := rcmgr.NewDefaultLimiter()
 	limiter.DefaultServiceLimits = limiter.DefaultServiceLimits.WithStreamLimit(3, 1024, 1024)
-	echos := createEchos(t, 5, makeRcmgrOption(t, limiter))
+	echos := createEchos(t, 5, makeRcmgrOption(t, limiter, "TestResourceManagerServiceInbound"))
 	defer closeEchos(echos)
+	defer closeRcmgrs(echos)
 
 	ready := new(chan struct{})
 	echos[0].BeforeDone = waitForChannel(ready, time.Minute)
@@ -139,8 +155,9 @@ func TestResourceManagerServicePeerInbound(t *testing.T) {
 	limiter.ServicePeerLimits = map[string]rcmgr.Limit{
 		EchoService: limiter.DefaultPeerLimits.WithStreamLimit(2, 1024, 1024),
 	}
-	echos := createEchos(t, 5, makeRcmgrOption(t, limiter))
+	echos := createEchos(t, 5, makeRcmgrOption(t, limiter, "TestResourceManagerServicePeerInbound"))
 	defer closeEchos(echos)
+	defer closeRcmgrs(echos)
 
 	count := new(int32)
 	ready := new(chan struct{})