Add metrics for PeersUpdateManager (#1310)

With this change we should be able to collect and expose the following histograms:

* `management.updatechannel.create.duration.ms`  with `closed` boolean label
* `management.updatechannel.create.duration.micro` with `closed` boolean label
* `management.updatechannel.close.one.duration.ms`
* `management.updatechannel.close.one.duration.micro`
* `management.updatechannel.close.multiple.duration.ms`
* `management.updatechannel.close.multiple.duration.micro`
* `management.updatechannel.close.multiple.channels`
* `management.updatechannel.send.duration.ms` with `found` and `dropped` boolean labels
* `management.updatechannel.send.duration.micro` with `found` and `dropped` boolean labels
* `management.updatechannel.get.all.duration.ms`
* `management.updatechannel.get.all.duration.micro`
* `management.updatechannel.get.all.peers`

management/server/updatechannel.go

@@ -2,10 +2,12 @@ package server
 
 import (
 	"sync"
+	"time"
 
 	log "github.com/sirupsen/logrus"
 
 	"github.com/netbirdio/netbird/management/proto"
+	"github.com/netbirdio/netbird/management/server/telemetry"
 )
 
 const channelBufferSize = 100
@@ -17,26 +19,41 @@ type UpdateMessage struct {
 type PeersUpdateManager struct {
 	// peerChannels is an update channel indexed by Peer.ID
 	peerChannels map[string]chan *UpdateMessage
-	channelsMux  *sync.Mutex
+	// channelsMux keeps the mutex to access peerChannels
+	channelsMux *sync.Mutex
+	// metrics provides method to collect application metrics
+	metrics telemetry.AppMetrics
 }
 
 // NewPeersUpdateManager returns a new instance of PeersUpdateManager
-func NewPeersUpdateManager() *PeersUpdateManager {
+func NewPeersUpdateManager(metrics telemetry.AppMetrics) *PeersUpdateManager {
 	return &PeersUpdateManager{
 		peerChannels: make(map[string]chan *UpdateMessage),
 		channelsMux:  &sync.Mutex{},
+		metrics:      metrics,
 	}
 }
 
 // SendUpdate sends update message to the peer's channel
 func (p *PeersUpdateManager) SendUpdate(peerID string, update *UpdateMessage) {
+	start := time.Now()
+	var found, dropped bool
+
 	p.channelsMux.Lock()
-	defer p.channelsMux.Unlock()
+	defer func() {
+		p.channelsMux.Unlock()
+		if p.metrics != nil {
+			p.metrics.UpdateChannelMetrics().CountSendUpdateDuration(time.Since(start), found, dropped)
+		}
+	}()
+
 	if channel, ok := p.peerChannels[peerID]; ok {
+		found = true
 		select {
 		case channel <- update:
 			log.Debugf("update was sent to channel for peer %s", peerID)
 		default:
+			dropped = true
 			log.Warnf("channel for peer %s is %d full", peerID, len(channel))
 		}
 	} else {
@@ -46,10 +63,20 @@ func (p *PeersUpdateManager) SendUpdate(peerID string, update *UpdateMessage) {
 
 // CreateChannel creates a go channel for a given peer used to deliver updates relevant to the peer.
 func (p *PeersUpdateManager) CreateChannel(peerID string) chan *UpdateMessage {
+	start := time.Now()
+
+	closed := false
+
 	p.channelsMux.Lock()
-	defer p.channelsMux.Unlock()
+	defer func() {
+		p.channelsMux.Unlock()
+		if p.metrics != nil {
+			p.metrics.UpdateChannelMetrics().CountCreateChannelDuration(time.Since(start), closed)
+		}
+	}()
 
 	if channel, ok := p.peerChannels[peerID]; ok {
+		closed = true
 		delete(p.peerChannels, peerID)
 		close(channel)
 	}
@@ -58,6 +85,7 @@ func (p *PeersUpdateManager) CreateChannel(peerID string) chan *UpdateMessage {
 	p.peerChannels[peerID] = channel
 
 	log.Debugf("opened updates channel for a peer %s", peerID)
+
 	return channel
 }
 
@@ -72,8 +100,16 @@ func (p *PeersUpdateManager) closeChannel(peerID string) {
 
 // CloseChannels closes updates channel for each given peer
 func (p *PeersUpdateManager) CloseChannels(peerIDs []string) {
+	start := time.Now()
+
 	p.channelsMux.Lock()
-	defer p.channelsMux.Unlock()
+	defer func() {
+		p.channelsMux.Unlock()
+		if p.metrics != nil {
+			p.metrics.UpdateChannelMetrics().CountCloseChannelsDuration(time.Since(start), len(peerIDs))
+		}
+	}()
+
 	for _, id := range peerIDs {
 		p.closeChannel(id)
 	}
@@ -81,18 +117,37 @@ func (p *PeersUpdateManager) CloseChannels(peerIDs []string) {
 
 // CloseChannel closes updates channel of a given peer
 func (p *PeersUpdateManager) CloseChannel(peerID string) {
+	start := time.Now()
+
 	p.channelsMux.Lock()
-	defer p.channelsMux.Unlock()
+	defer func() {
+		p.channelsMux.Unlock()
+		if p.metrics != nil {
+			p.metrics.UpdateChannelMetrics().CountCloseChannelDuration(time.Since(start))
+		}
+	}()
+
 	p.closeChannel(peerID)
 }
 
 // GetAllConnectedPeers returns a copy of the connected peers map
 func (p *PeersUpdateManager) GetAllConnectedPeers() map[string]struct{} {
+	start := time.Now()
+
 	p.channelsMux.Lock()
-	defer p.channelsMux.Unlock()
+
 	m := make(map[string]struct{})
+
+	defer func() {
+		p.channelsMux.Unlock()
+		if p.metrics != nil {
+			p.metrics.UpdateChannelMetrics().CountGetAllConnectedPeersDuration(time.Since(start), len(m))
+		}
+	}()
+
 	for ID := range p.peerChannels {
 		m[ID] = struct{}{}
 	}
+
 	return m
 }