Measure bloom filter AppGossip hit rate

This commit adds a metric to measure the bloom filter hit rate % for the gossip pull queries.

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

Author: yacovm

network/p2p/gossip/gossip.go

@@ -101,6 +101,7 @@ type Metrics struct {
 	tracking                *prometheus.GaugeVec
 	trackingLifetimeAverage prometheus.Gauge
 	topValidators           *prometheus.GaugeVec
+	bloomFilterHitRate      prometheus.Histogram
 }
 
 // NewMetrics returns a common set of metrics
@@ -109,6 +110,12 @@ func NewMetrics(
 	namespace string,
 ) (Metrics, error) {
 	m := Metrics{
+		bloomFilterHitRate: prometheus.NewHistogram(prometheus.HistogramOpts{
+			Namespace: namespace,
+			Name:      "bloomfilter_hit_rate",
+			Help:      "Hit rate (%) of the bloom filter sent by pull gossip",
+			Buckets:   prometheus.LinearBuckets(0, 25, 5),
+		}),
 		count: prometheus.NewCounterVec(
 			prometheus.CounterOpts{
 				Namespace: namespace,
@@ -148,6 +155,7 @@ func NewMetrics(
 		),
 	}
 	err := errors.Join(
+		metrics.Register(m.bloomFilterHitRate),
 		metrics.Register(m.count),
 		metrics.Register(m.bytes),
 		metrics.Register(m.tracking),

network/p2p/gossip/gossip_test.go

@@ -57,6 +57,8 @@ func TestGossiperGossip(t *testing.T) {
 		responder              []*testTx // what the peer we're requesting gossip from has
 		expectedPossibleValues []*testTx // possible values we can have
 		expectedLen            int
+		expectedObserved       bool
+		expectedObservedVal    uint64
 	}{
 		{
 			name: "no gossip - no one knows anything",
@@ -75,13 +77,16 @@ func TestGossiperGossip(t *testing.T) {
 			responder:              []*testTx{{id: ids.ID{0}}},
 			expectedPossibleValues: []*testTx{{id: ids.ID{0}}},
 			expectedLen:            1,
+			expectedObservedVal:    100,
+			expectedObserved:       true,
 		},
 		{
 			name:                   "gossip - requester knows nothing",
 			targetResponseSize:     1024,
 			responder:              []*testTx{{id: ids.ID{0}}},
 			expectedPossibleValues: []*testTx{{id: ids.ID{0}}},
 			expectedLen:            1,
+			expectedObserved:       true,
 		},
 		{
 			name:                   "gossip - requester knows less than responder",
@@ -90,13 +95,16 @@ func TestGossiperGossip(t *testing.T) {
 			responder:              []*testTx{{id: ids.ID{0}}, {id: ids.ID{1}}},
 			expectedPossibleValues: []*testTx{{id: ids.ID{0}}, {id: ids.ID{1}}},
 			expectedLen:            2,
+			expectedObservedVal:    50,
+			expectedObserved:       true,
 		},
 		{
 			name:                   "gossip - target response size exceeded",
 			targetResponseSize:     32,
 			responder:              []*testTx{{id: ids.ID{0}}, {id: ids.ID{1}}, {id: ids.ID{2}}},
 			expectedPossibleValues: []*testTx{{id: ids.ID{0}}, {id: ids.ID{1}}, {id: ids.ID{2}}},
 			expectedLen:            2,
+			expectedObserved:       true,
 		},
 	}
 
@@ -123,6 +131,12 @@ func TestGossiperGossip(t *testing.T) {
 
 			metrics, err := NewMetrics(prometheus.NewRegistry(), "")
 			require.NoError(err)
+
+			testHistogram := &testHistogram{
+				Histogram: metrics.bloomFilterHitRate,
+			}
+			metrics.bloomFilterHitRate = testHistogram
+
 			marshaller := testMarshaller{}
 			handler := NewHandler[*testTx](
 				logging.NoLog{},
@@ -175,6 +189,8 @@ func TestGossiperGossip(t *testing.T) {
 
 			require.Len(requestSet.txs, tt.expectedLen)
 			require.Subset(tt.expectedPossibleValues, maps.Values(requestSet.txs))
+			require.Equal(tt.expectedObserved, testHistogram.observed)
+			require.Equal(tt.expectedObservedVal, testHistogram.observedVal)
 
 			// we should not receive anything that we already had before we
 			// requested the gossip
@@ -611,3 +627,58 @@ type testValidatorSet struct {
 func (t testValidatorSet) Has(_ context.Context, nodeID ids.NodeID) bool {
 	return t.validators.Contains(nodeID)
 }
+
+func TestComputeBloomFilterHitPercentage(t *testing.T) {
+	tests := []struct {
+		name       string
+		hits       uint64
+		misses     uint64
+		percentage uint64
+		ok         bool
+	}{
+		{
+			name:       "no hits",
+			hits:       0,
+			misses:     10,
+			percentage: 0,
+			ok:         true,
+		},
+		{
+			name:       "no misses",
+			hits:       10,
+			misses:     0,
+			percentage: 100,
+			ok:         true,
+		},
+		{
+			name:       "some hits",
+			hits:       5,
+			misses:     5,
+			percentage: 50,
+			ok:         true,
+		},
+		{
+			name: "nothing",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := computeBloomFilterHitPercentage(tt.hits, tt.misses, logging.NoLog{})
+			require.Equal(t, tt.ok, ok)
+			require.Equal(t, tt.percentage, got)
+		})
+	}
+}
+
+type testHistogram struct {
+	prometheus.Histogram
+	observedVal uint64
+	observed    bool
+}
+
+func (t *testHistogram) Observe(value float64) {
+	t.Histogram.Observe(value)
+	t.observedVal = uint64(value)
+	t.observed = true
+}

network/p2p/gossip/handler.go

@@ -14,6 +14,8 @@ import (
 	"github.com/ava-labs/avalanchego/snow/engine/common"
 	"github.com/ava-labs/avalanchego/utils/bloom"
 	"github.com/ava-labs/avalanchego/utils/logging"
+
+	safemath "github.com/ava-labs/avalanchego/utils/math"
 )
 
 var _ p2p.Handler = (*Handler[*testTx])(nil)
@@ -50,13 +52,16 @@ func (h Handler[T]) AppRequest(_ context.Context, _ ids.NodeID, _ time.Time, req
 		return nil, p2p.ErrUnexpected
 	}
 
+	var hits, misses uint64
+
 	responseSize := 0
 	gossipBytes := make([][]byte, 0)
 	h.set.Iterate(func(gossipable T) bool {
 		gossipID := gossipable.GossipID()
 
 		// filter out what the requesting peer already knows about
 		if bloom.Contains(filter, gossipID[:], salt[:]) {
+			hits++
 			return true
 		}
 
@@ -70,13 +75,19 @@ func (h Handler[T]) AppRequest(_ context.Context, _ ids.NodeID, _ time.Time, req
 		// size
 		gossipBytes = append(gossipBytes, bytes)
 		responseSize += len(bytes)
+		misses++
 
 		return responseSize <= h.targetResponseSize
 	})
 	if err != nil {
 		return nil, p2p.ErrUnexpected
 	}
 
+	hitsPercentage, ok := computeBloomFilterHitPercentage(hits, misses, h.log)
+	if ok {
+		h.metrics.bloomFilterHitRate.Observe(float64(hitsPercentage))
+	}
+
 	if err := h.metrics.observeMessage(sentPullLabels, len(gossipBytes), responseSize); err != nil {
 		return nil, p2p.ErrUnexpected
 	}
@@ -124,3 +135,31 @@ func (h Handler[_]) AppGossip(_ context.Context, nodeID ids.NodeID, gossipBytes
 		)
 	}
 }
+
+func computeBloomFilterHitPercentage(hits uint64, misses uint64, log logging.Logger) (uint64, bool) {
+	total, err := safemath.Add(hits, misses)
+	if err != nil {
+		log.Warn("failed to calculate total hits and misses",
+			zap.Uint64("hits", hits),
+			zap.Uint64("misses", misses),
+			zap.Error(err),
+		)
+		return 0, false
+	}
+
+	hitsOneHundred, err := safemath.Mul(hits, 100)
+	if err != nil {
+		log.Warn("failed to calculate hit ratio",
+			zap.Uint64("hits", hits),
+			zap.Uint64("misses", misses),
+			zap.Error(err),
+		)
+		return 0, false
+	}
+
+	if total > 0 {
+		return hitsOneHundred / total, true
+	}
+
+	return 0, false
+}