Add ice transport api to get selected pair stats

In use cases like SFU, it is useful to get just the selected candidate
pair stats to have access to current RTT on the peer connection. The
standard has a way to do `GetSelectedCandidatePair` on `ICETransport`,
but does not have a way to get stats of that pair.

Although not in standard, adding a method to `ICETransport` to get
selected candidate pair along similar lines of above method.

go.mod

@@ -5,7 +5,7 @@ go 1.20
 require (
 	github.com/pion/datachannel v1.5.9
 	github.com/pion/dtls/v3 v3.0.3
-	github.com/pion/ice/v4 v4.0.1
+	github.com/pion/ice/v4 v4.0.2
 	github.com/pion/interceptor v0.1.37
 	github.com/pion/logging v0.2.2
 	github.com/pion/randutil v0.1.0

go.sum

@@ -39,8 +39,8 @@ github.com/pion/datachannel v1.5.9 h1:LpIWAOYPyDrXtU+BW7X0Yt/vGtYxtXQ8ql7dFfYUVZ
 github.com/pion/datachannel v1.5.9/go.mod h1:kDUuk4CU4Uxp82NH4LQZbISULkX/HtzKa4P7ldf9izE=
 github.com/pion/dtls/v3 v3.0.3 h1:j5ajZbQwff7Z8k3pE3S+rQ4STvKvXUdKsi/07ka+OWM=
 github.com/pion/dtls/v3 v3.0.3/go.mod h1:weOTUyIV4z0bQaVzKe8kpaP17+us3yAuiQsEAG1STMU=
-github.com/pion/ice/v4 v4.0.1 h1:2d3tPoTR90F3TcGYeXUwucGlXI3hds96cwv4kjZmb9s=
-github.com/pion/ice/v4 v4.0.1/go.mod h1:2dpakjpd7+74L5j3TAe6gvkbI5UIzOgAnkimm9SuHvA=
+github.com/pion/ice/v4 v4.0.2 h1:1JhBRX8iQLi0+TfcavTjPjI6GO41MFn4CeTBX+Y9h5s=
+github.com/pion/ice/v4 v4.0.2/go.mod h1:DCdqyzgtsDNYN6/3U8044j3U7qsJ9KFJC92VnOWHvXg=
 github.com/pion/interceptor v0.1.37 h1:aRA8Zpab/wE7/c0O3fh1PqY0AJI3fCSEM5lRWJVorwI=
 github.com/pion/interceptor v0.1.37/go.mod h1:JzxbJ4umVTlZAf+/utHzNesY8tmRkM2lVmkS82TTj8Y=
 github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=

icegatherer.go

@@ -308,46 +308,12 @@ func (g *ICEGatherer) collectStats(collector *statsReportCollector) {
 		for _, candidatePairStats := range agent.GetCandidatePairsStats() {
 			collector.Collecting()
 
-			state, err := toStatsICECandidatePairState(candidatePairStats.State)
+			stats, err := toICECandidatePairStats(candidatePairStats)
 			if err != nil {
 				g.log.Error(err.Error())
+				continue
 			}
 
-			pairID := newICECandidatePairStatsID(candidatePairStats.LocalCandidateID,
-				candidatePairStats.RemoteCandidateID)
-
-			stats := ICECandidatePairStats{
-				Timestamp: statsTimestampFrom(candidatePairStats.Timestamp),
-				Type:      StatsTypeCandidatePair,
-				ID:        pairID,
-				// TransportID:
-				LocalCandidateID:            candidatePairStats.LocalCandidateID,
-				RemoteCandidateID:           candidatePairStats.RemoteCandidateID,
-				State:                       state,
-				Nominated:                   candidatePairStats.Nominated,
-				PacketsSent:                 candidatePairStats.PacketsSent,
-				PacketsReceived:             candidatePairStats.PacketsReceived,
-				BytesSent:                   candidatePairStats.BytesSent,
-				BytesReceived:               candidatePairStats.BytesReceived,
-				LastPacketSentTimestamp:     statsTimestampFrom(candidatePairStats.LastPacketSentTimestamp),
-				LastPacketReceivedTimestamp: statsTimestampFrom(candidatePairStats.LastPacketReceivedTimestamp),
-				FirstRequestTimestamp:       statsTimestampFrom(candidatePairStats.FirstRequestTimestamp),
-				LastRequestTimestamp:        statsTimestampFrom(candidatePairStats.LastRequestTimestamp),
-				LastResponseTimestamp:       statsTimestampFrom(candidatePairStats.LastResponseTimestamp),
-				TotalRoundTripTime:          candidatePairStats.TotalRoundTripTime,
-				CurrentRoundTripTime:        candidatePairStats.CurrentRoundTripTime,
-				AvailableOutgoingBitrate:    candidatePairStats.AvailableOutgoingBitrate,
-				AvailableIncomingBitrate:    candidatePairStats.AvailableIncomingBitrate,
-				CircuitBreakerTriggerCount:  candidatePairStats.CircuitBreakerTriggerCount,
-				RequestsReceived:            candidatePairStats.RequestsReceived,
-				RequestsSent:                candidatePairStats.RequestsSent,
-				ResponsesReceived:           candidatePairStats.ResponsesReceived,
-				ResponsesSent:               candidatePairStats.ResponsesSent,
-				RetransmissionsReceived:     candidatePairStats.RetransmissionsReceived,
-				RetransmissionsSent:         candidatePairStats.RetransmissionsSent,
-				ConsentRequestsSent:         candidatePairStats.ConsentRequestsSent,
-				ConsentExpiredTimestamp:     statsTimestampFrom(candidatePairStats.ConsentExpiredTimestamp),
-			}
 			collector.Collect(stats.ID, stats)
 		}
 
@@ -409,3 +375,23 @@ func (g *ICEGatherer) collectStats(collector *statsReportCollector) {
 		collector.Done()
 	}(collector, agent)
 }
+
+func (g *ICEGatherer) getSelectedCandidatePairStats() (ICECandidatePairStats, bool) {
+	agent := g.getAgent()
+	if agent == nil {
+		return ICECandidatePairStats{}, false
+	}
+
+	selectedCandidatePairStats, isAvailable := agent.GetSelectedCandidatePairStats()
+	if !isAvailable {
+		return ICECandidatePairStats{}, false
+	}
+
+	stats, err := toICECandidatePairStats(selectedCandidatePairStats)
+	if err != nil {
+		g.log.Error(err.Error())
+		return ICECandidatePairStats{}, false
+	}
+
+	return stats, true
+}

icetransport.go

@@ -70,6 +70,12 @@ func (t *ICETransport) GetSelectedCandidatePair() (*ICECandidatePair, error) {
 	return NewICECandidatePair(&local, &remote), nil
 }
 
+// GetSelectedCandidatePairStats returns the selected candidate pair stats on which packets are sent
+// if there is no selected pair empty stats, false is returned to indicate stats not available
+func (t *ICETransport) GetSelectedCandidatePairStats() (ICECandidatePairStats, bool) {
+	return t.gatherer.getSelectedCandidatePairStats()
+}
+
 // NewICETransport creates a new NewICETransport.
 func NewICETransport(gatherer *ICEGatherer, loggerFactory logging.LoggerFactory) *ICETransport {
 	iceTransport := &ICETransport{

icetransport_test.go

@@ -98,21 +98,29 @@ func TestICETransport_GetSelectedCandidatePair(t *testing.T) {
 	offererSelectedPair, err := offerer.SCTP().Transport().ICETransport().GetSelectedCandidatePair()
 	assert.NoError(t, err)
 	assert.Nil(t, offererSelectedPair)
+	_, statsAvailable := offerer.SCTP().Transport().ICETransport().GetSelectedCandidatePairStats()
+	assert.False(t, statsAvailable)
 
 	answererSelectedPair, err := answerer.SCTP().Transport().ICETransport().GetSelectedCandidatePair()
 	assert.NoError(t, err)
 	assert.Nil(t, answererSelectedPair)
+	_, statsAvailable = answerer.SCTP().Transport().ICETransport().GetSelectedCandidatePairStats()
+	assert.False(t, statsAvailable)
 
 	assert.NoError(t, signalPair(offerer, answerer))
 	peerConnectionConnected.Wait()
 
 	offererSelectedPair, err = offerer.SCTP().Transport().ICETransport().GetSelectedCandidatePair()
 	assert.NoError(t, err)
 	assert.NotNil(t, offererSelectedPair)
+	_, statsAvailable = offerer.SCTP().Transport().ICETransport().GetSelectedCandidatePairStats()
+	assert.True(t, statsAvailable)
 
 	answererSelectedPair, err = answerer.SCTP().Transport().ICETransport().GetSelectedCandidatePair()
 	assert.NoError(t, err)
 	assert.NotNil(t, answererSelectedPair)
+	_, statsAvailable = answerer.SCTP().Transport().ICETransport().GetSelectedCandidatePairStats()
+	assert.True(t, statsAvailable)
 
 	closePairNow(t, offerer, answerer)
 }

stats.go

@@ -1965,6 +1965,46 @@ func toStatsICECandidatePairState(state ice.CandidatePairState) (StatsICECandida
 	}
 }
 
+func toICECandidatePairStats(candidatePairStats ice.CandidatePairStats) (ICECandidatePairStats, error) {
+	state, err := toStatsICECandidatePairState(candidatePairStats.State)
+	if err != nil {
+		return ICECandidatePairStats{}, err
+	}
+
+	return ICECandidatePairStats{
+		Timestamp: statsTimestampFrom(candidatePairStats.Timestamp),
+		Type:      StatsTypeCandidatePair,
+		ID:        newICECandidatePairStatsID(candidatePairStats.LocalCandidateID, candidatePairStats.RemoteCandidateID),
+		// TransportID:
+		LocalCandidateID:            candidatePairStats.LocalCandidateID,
+		RemoteCandidateID:           candidatePairStats.RemoteCandidateID,
+		State:                       state,
+		Nominated:                   candidatePairStats.Nominated,
+		PacketsSent:                 candidatePairStats.PacketsSent,
+		PacketsReceived:             candidatePairStats.PacketsReceived,
+		BytesSent:                   candidatePairStats.BytesSent,
+		BytesReceived:               candidatePairStats.BytesReceived,
+		LastPacketSentTimestamp:     statsTimestampFrom(candidatePairStats.LastPacketSentTimestamp),
+		LastPacketReceivedTimestamp: statsTimestampFrom(candidatePairStats.LastPacketReceivedTimestamp),
+		FirstRequestTimestamp:       statsTimestampFrom(candidatePairStats.FirstRequestTimestamp),
+		LastRequestTimestamp:        statsTimestampFrom(candidatePairStats.LastRequestTimestamp),
+		LastResponseTimestamp:       statsTimestampFrom(candidatePairStats.LastResponseTimestamp),
+		TotalRoundTripTime:          candidatePairStats.TotalRoundTripTime,
+		CurrentRoundTripTime:        candidatePairStats.CurrentRoundTripTime,
+		AvailableOutgoingBitrate:    candidatePairStats.AvailableOutgoingBitrate,
+		AvailableIncomingBitrate:    candidatePairStats.AvailableIncomingBitrate,
+		CircuitBreakerTriggerCount:  candidatePairStats.CircuitBreakerTriggerCount,
+		RequestsReceived:            candidatePairStats.RequestsReceived,
+		RequestsSent:                candidatePairStats.RequestsSent,
+		ResponsesReceived:           candidatePairStats.ResponsesReceived,
+		ResponsesSent:               candidatePairStats.ResponsesSent,
+		RetransmissionsReceived:     candidatePairStats.RetransmissionsReceived,
+		RetransmissionsSent:         candidatePairStats.RetransmissionsSent,
+		ConsentRequestsSent:         candidatePairStats.ConsentRequestsSent,
+		ConsentExpiredTimestamp:     statsTimestampFrom(candidatePairStats.ConsentExpiredTimestamp),
+	}, nil
+}
+
 const (
 	// StatsICECandidatePairStateFrozen means a check for this pair hasn't been
 	// performed, and it can't yet be performed until some other check succeeds,