Update performance metrics to use constants from clientinfo package

- Refactored metric increment calls in libp2p to utilize constants for peer connections, disconnections, and ping tests.
- Enhanced coordination window metrics by adding a mutex for safe access to previous window data across goroutines.
- Introduced a cleanup goroutine to ensure the end time of the last coordination window is recorded on shutdown.

Author: lionakhnazarov

pkg/net/libp2p/libp2p.go

@@ -7,6 +7,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/keep-network/keep-core/pkg/clientinfo"
 	"github.com/keep-network/keep-core/pkg/operator"
 
 	"github.com/ipfs/go-log"
@@ -594,7 +595,7 @@ func buildNotifiee(libp2pHost host.Host, p *provider) libp2pnet.Notifiee {
 					SetGauge(name string, value float64)
 					RecordDuration(name string, duration time.Duration)
 				})
-				recorder.IncrementCounter("peer_connections_total", 1)
+				recorder.IncrementCounter(clientinfo.MetricPeerConnectionsTotal, 1)
 			}
 		}
 
@@ -629,7 +630,7 @@ func buildNotifiee(libp2pHost host.Host, p *provider) libp2pnet.Notifiee {
 					SetGauge(name string, value float64)
 					RecordDuration(name string, duration time.Duration)
 				})
-				recorder.IncrementCounter("peer_disconnections_total", 1)
+				recorder.IncrementCounter(clientinfo.MetricPeerDisconnectionsTotal, 1)
 			}
 		}
 
@@ -658,7 +659,7 @@ func executePingTest(
 	logger.Infof("starting ping test for [%v]", peerMultiaddress)
 
 	if metricsRecorder != nil {
-		metricsRecorder.IncrementCounter("ping_test_total", 1)
+		metricsRecorder.IncrementCounter(clientinfo.MetricPingTestsTotal, 1)
 	}
 
 	ctx, cancelCtx := context.WithTimeout(
@@ -679,15 +680,15 @@ func executePingTest(
 				result.Error,
 			)
 			if metricsRecorder != nil {
-				metricsRecorder.IncrementCounter("ping_test_failed_total", 1)
+				metricsRecorder.IncrementCounter(clientinfo.MetricPingTestFailedTotal, 1)
 			}
 		} else if result.Error == nil && result.RTT == 0 {
 			logger.Warnf(
 				"peer test for [%v] failed without clear reason",
 				peerMultiaddress,
 			)
 			if metricsRecorder != nil {
-				metricsRecorder.IncrementCounter("ping_test_failed_total", 1)
+				metricsRecorder.IncrementCounter(clientinfo.MetricPingTestFailedTotal, 1)
 			}
 		} else {
 			logger.Infof(
@@ -696,15 +697,15 @@ func executePingTest(
 				result.RTT,
 			)
 			if metricsRecorder != nil {
-				metricsRecorder.IncrementCounter("ping_test_success_total", 1)
+				metricsRecorder.IncrementCounter(clientinfo.MetricPingTestSuccessTotal, 1)
 				// Only record duration on successful ping tests
-				metricsRecorder.RecordDuration("ping_test_duration_seconds", time.Since(startTime))
+				metricsRecorder.RecordDuration(clientinfo.MetricPingTestDurationSeconds, time.Since(startTime))
 			}
 		}
 	case <-ctx.Done():
 		logger.Warnf("ping test for [%v] timed out", peerMultiaddress)
 		if metricsRecorder != nil {
-			metricsRecorder.IncrementCounter("ping_test_failed_total", 1)
+			metricsRecorder.IncrementCounter(clientinfo.MetricPingTestFailedTotal, 1)
 		}
 	}
 }

pkg/tbtc/coordination_window_metrics.go

@@ -111,6 +111,12 @@ func (cwm *coordinationWindowMetrics) recordWindowStart(window *coordinationWind
 	cwm.mu.Lock()
 	defer cwm.mu.Unlock()
 
+	cwm.initializeWindowIfNeeded(window)
+}
+
+// initializeWindowIfNeeded initializes window metrics if they don't exist.
+// This function assumes the caller already holds cwm.mu.Lock().
+func (cwm *coordinationWindowMetrics) initializeWindowIfNeeded(window *coordinationWindow) {
 	windowIndex := window.index()
 	if windowIndex == 0 {
 		// Invalid window, skip
@@ -152,6 +158,11 @@ func (cwm *coordinationWindowMetrics) recordWindowEnd(window *coordinationWindow
 		return
 	}
 
+	// Don't overwrite EndTime if it's already been set
+	if !wm.EndTime.IsZero() {
+		return
+	}
+
 	wm.EndTime = time.Now()
 	wm.Duration = wm.EndTime.Sub(wm.StartTime)
 
@@ -162,9 +173,6 @@ func (cwm *coordinationWindowMetrics) recordWindowEnd(window *coordinationWindow
 			clientinfo.MetricCoordinationWindowDurationSeconds,
 			wm.Duration,
 		)
-
-		// Record window-level gauges
-		cwm.recordWindowGauges(windowIndex, wm)
 	}
 }
 
@@ -191,7 +199,8 @@ func (cwm *coordinationWindowMetrics) recordWalletCoordination(
 	wm, exists := cwm.windows[windowIndex]
 	if !exists {
 		// Window not initialized, initialize it now
-		cwm.recordWindowStart(window)
+		// Note: we already hold the lock, so use the lock-free helper
+		cwm.initializeWindowIfNeeded(window)
 		wm = cwm.windows[windowIndex]
 	}
 
@@ -246,37 +255,6 @@ func (cwm *coordinationWindowMetrics) recordWalletCoordination(
 	wm.WalletCoordinationDetails = append(wm.WalletCoordinationDetails, detail)
 }
 
-// recordWindowGauges records gauge metrics for a specific window.
-func (cwm *coordinationWindowMetrics) recordWindowGauges(
-	windowIndex uint64,
-	wm *windowMetrics,
-) {
-	// Record window-level gauges with window index suffix
-	// These allow tracking individual window metrics
-	windowSuffix := fmt.Sprintf("_window_%d", windowIndex)
-
-	cwm.performanceMetrics.SetGauge(
-		clientinfo.MetricCoordinationWindowWalletsCoordinated+windowSuffix,
-		float64(wm.WalletsCoordinated),
-	)
-	cwm.performanceMetrics.SetGauge(
-		clientinfo.MetricCoordinationWindowWalletsSuccessful+windowSuffix,
-		float64(wm.WalletsSuccessful),
-	)
-	cwm.performanceMetrics.SetGauge(
-		clientinfo.MetricCoordinationWindowWalletsFailed+windowSuffix,
-		float64(wm.WalletsFailed),
-	)
-	cwm.performanceMetrics.SetGauge(
-		clientinfo.MetricCoordinationWindowTotalFaults+windowSuffix,
-		float64(wm.TotalFaults),
-	)
-	cwm.performanceMetrics.SetGauge(
-		clientinfo.MetricCoordinationWindowCoordinationBlock+windowSuffix,
-		float64(wm.CoordinationBlock),
-	)
-}
-
 // GetWindowMetrics returns metrics for a specific window.
 func (cwm *coordinationWindowMetrics) GetWindowMetrics(windowIndex uint64) (*windowMetrics, bool) {
 	cwm.mu.RLock()
@@ -287,9 +265,8 @@ func (cwm *coordinationWindowMetrics) GetWindowMetrics(windowIndex uint64) (*win
 		return nil, false
 	}
 
-	// Return a copy to avoid race conditions
-	wmCopy := *wm
-	return &wmCopy, true
+	// Return a deep copy to avoid race conditions
+	return wm.deepCopy(), true
 }
 
 // GetRecentWindows returns metrics for the most recent N windows.
@@ -317,12 +294,11 @@ func (cwm *coordinationWindowMetrics) GetRecentWindows(limit int) []*windowMetri
 		indices = indices[:limit]
 	}
 
-	// Return copies
+	// Return deep copies
 	result := make([]*windowMetrics, 0, len(indices))
 	for _, idx := range indices {
 		wm := cwm.windows[idx]
-		wmCopy := *wm
-		result = append(result, &wmCopy)
+		result = append(result, wm.deepCopy())
 	}
 
 	return result
@@ -376,8 +352,7 @@ func (cwm *coordinationWindowMetrics) GetSummary() WindowMetricsSummary {
 		summary.TotalWalletsFailed += wm.WalletsFailed
 		summary.TotalFaults += wm.TotalFaults
 
-		wmCopy := *wm
-		summary.Windows = append(summary.Windows, &wmCopy)
+		summary.Windows = append(summary.Windows, wm.deepCopy())
 	}
 
 	return summary
@@ -393,6 +368,53 @@ type WindowMetricsSummary struct {
 	Windows                 []*windowMetrics `json:"windows"`
 }
 
+// deepCopy creates a deep copy of windowMetrics, properly copying all maps and slices.
+func (wm *windowMetrics) deepCopy() *windowMetrics {
+	if wm == nil {
+		return nil
+	}
+
+	wmCopy := &windowMetrics{
+		WindowIndex:               wm.WindowIndex,
+		CoordinationBlock:         wm.CoordinationBlock,
+		StartTime:                 wm.StartTime,
+		EndTime:                   wm.EndTime,
+		Duration:                  wm.Duration,
+		ActivePhaseEndBlock:       wm.ActivePhaseEndBlock,
+		EndBlock:                  wm.EndBlock,
+		WalletsCoordinated:        wm.WalletsCoordinated,
+		WalletsSuccessful:         wm.WalletsSuccessful,
+		WalletsFailed:             wm.WalletsFailed,
+		TotalProceduresStarted:    wm.TotalProceduresStarted,
+		TotalProceduresCompleted:  wm.TotalProceduresCompleted,
+		TotalFaults:               wm.TotalFaults,
+		Leaders:                   make(map[string]uint64, len(wm.Leaders)),
+		ActionTypes:               make(map[string]uint64, len(wm.ActionTypes)),
+		FaultsByType:              make(map[string]uint64, len(wm.FaultsByType)),
+		FaultsByCulprit:           make(map[string]uint64, len(wm.FaultsByCulprit)),
+		WalletCoordinationDetails: make([]walletCoordinationDetail, len(wm.WalletCoordinationDetails)),
+	}
+
+	// Deep copy maps
+	for k, v := range wm.Leaders {
+		wmCopy.Leaders[k] = v
+	}
+	for k, v := range wm.ActionTypes {
+		wmCopy.ActionTypes[k] = v
+	}
+	for k, v := range wm.FaultsByType {
+		wmCopy.FaultsByType[k] = v
+	}
+	for k, v := range wm.FaultsByCulprit {
+		wmCopy.FaultsByCulprit[k] = v
+	}
+
+	// Deep copy slice
+	copy(wmCopy.WalletCoordinationDetails, wm.WalletCoordinationDetails)
+
+	return wmCopy
+}
+
 // String returns a string representation of window metrics for logging.
 func (wm *windowMetrics) String() string {
 	return fmt.Sprintf(

pkg/tbtc/node.go

@@ -1022,15 +1022,19 @@ func (n *node) runCoordinationLayer(
 	coordinationResultChan := make(chan *coordinationResult)
 
 	// Track the previous window to record its end when a new one starts
+	// Use a mutex to safely access from multiple goroutines
+	var previousWindowMu sync.Mutex
 	var previousWindow *coordinationWindow
 
 	// Prepare a callback function that will be called every time a new
 	// coordination window is detected.
 	onWindowFn := func(window *coordinationWindow) {
+		previousWindowMu.Lock()
 		// Record end of previous window if it exists
 		if previousWindow != nil && n.windowMetricsTracker != nil {
 			n.windowMetricsTracker.recordWindowEnd(previousWindow)
 		}
+		previousWindowMu.Unlock()
 
 		// Track coordination window detection
 		if n.performanceMetrics != nil {
@@ -1042,7 +1046,9 @@ func (n *node) runCoordinationLayer(
 			n.windowMetricsTracker.recordWindowStart(window)
 		}
 
+		previousWindowMu.Lock()
 		previousWindow = window
+		previousWindowMu.Unlock()
 
 		// Fetch all wallets controlled by the node. It is important to
 		// get the wallets every time the window is triggered as the
@@ -1085,6 +1091,17 @@ func (n *node) runCoordinationLayer(
 		}
 	}()
 
+	// Start a cleanup goroutine to record the end time of the last window on shutdown
+	go func() {
+		<-ctx.Done()
+		// Record end time for the active window if it exists and hasn't been ended yet
+		previousWindowMu.Lock()
+		if previousWindow != nil && n.windowMetricsTracker != nil {
+			n.windowMetricsTracker.recordWindowEnd(previousWindow)
+		}
+		previousWindowMu.Unlock()
+	}()
+
 	return nil
 }