Implement RTT measurement

This commit implements a Round-Trip-Time measurement by measuring the ping-pong delay.
When a ping is sent to a peer `p`, the time is sampled.
When a pong is received, the elapsed time is measured and the round_trip_count and round_trip_sum counter and gauge are emitted.

Signed-off-by: Yacov Manevich <yacov.manevich@avalabs.org>

Author: yacovm

network/peer/metrics.go

@@ -31,6 +31,9 @@ type Metrics struct {
 	ClockSkewCount prometheus.Counter
 	ClockSkewSum   prometheus.Gauge
 
+	RTTCount prometheus.Counter
+	RTTSum   prometheus.Gauge
+
 	NumFailedToParse prometheus.Counter
 	NumSendFailed    *prometheus.CounterVec // op
 
@@ -41,6 +44,14 @@ type Metrics struct {
 
 func NewMetrics(registerer prometheus.Registerer) (*Metrics, error) {
 	m := &Metrics{
+		RTTCount: prometheus.NewCounter(prometheus.CounterOpts{
+			Name: "round_trip_count",
+			Help: "number of RTT samples taken (n)",
+		}),
+		RTTSum: prometheus.NewGauge(prometheus.GaugeOpts{
+			Name: "round_trip_sum",
+			Help: "sum of RTT samples taken (ms)",
+		}),
 		ClockSkewCount: prometheus.NewCounter(prometheus.CounterOpts{
 			Name: "clock_skew_count",
 			Help: "number of handshake timestamps inspected (n)",
@@ -83,6 +94,8 @@ func NewMetrics(registerer prometheus.Registerer) (*Metrics, error) {
 		),
 	}
 	return m, errors.Join(
+		registerer.Register(m.RTTCount),
+		registerer.Register(m.RTTSum),
 		registerer.Register(m.ClockSkewCount),
 		registerer.Register(m.ClockSkewSum),
 		registerer.Register(m.NumFailedToParse),

network/peer/peer.go

@@ -191,6 +191,9 @@ type peer struct {
 	// Must only be accessed atomically
 	lastSent, lastReceived int64
 
+	// lastPingSent is the milliseconds since 1970-01-01 UTC when the last ping was sent
+	lastPingSent int64
+
 	// getPeerListChan signals that we should attempt to send a GetPeerList to
 	// this peer
 	getPeerListChan chan struct{}
@@ -626,6 +629,10 @@ func (p *peer) writeMessage(writer io.Writer, msg message.OutboundMessage) {
 	now := p.Clock.Time()
 	p.storeLastSent(now)
 	p.Metrics.Sent(msg)
+
+	if msg.Op() == message.PingOp {
+		atomic.StoreInt64(&p.lastPingSent, now.UnixMilli())
+	}
 }
 
 func (p *peer) sendNetworkMessages() {
@@ -819,7 +826,17 @@ func (p *peer) getUptime() uint32 {
 	return primaryUptimePercent
 }
 
-func (*peer) handlePong(*p2p.Pong) {}
+func (p *peer) handlePong(*p2p.Pong) {
+	lastPing := atomic.LoadInt64(&p.lastPingSent)
+	if lastPing == 0 {
+		return
+	}
+
+	elapsed := time.Now().UnixMilli() - lastPing
+
+	p.Metrics.RTTCount.Inc()
+	p.Metrics.RTTSum.Add(float64(elapsed))
+}
 
 func (p *peer) handleHandshake(msg *p2p.Handshake) {
 	if p.gotHandshake.Get() {