Rename syncer and endpoint metrics to match Monarch

Rename metrics name and key to match monarch definition.

pkg/neg/metrics/endpoint_metrics.go

@@ -24,8 +24,8 @@ const (
 	endpointState      = "endpoint_state"
 	endpointSliceState = "endpoint_slice_state"
 
-	endpointStateKey      = "neg_sync_endpoint_state"
-	endpointSliceStateKey = "neg_sync_endpoint_slice_state"
+	endpointStateKey      = "syncer_endpoint_state"
+	endpointSliceStateKey = "syncer_endpoint_slice_state"
 )
 
 var (

pkg/neg/metrics/neg_metrics_collector.go

@@ -35,8 +35,8 @@ type SyncerMetricsCollector interface {
 }
 
 type SyncerMetrics struct {
-	// syncerStatusMap tracks the status of each syncer
-	syncerStatusMap map[negtypes.NegSyncerKey]negtypes.Reason
+	// syncerStateMap tracks the status of each syncer
+	syncerStateMap map[negtypes.NegSyncerKey]negtypes.Reason
 	// syncerEndpointStateMap is a map between syncer and endpoint state counts.
 	syncerEndpointStateMap map[negtypes.NegSyncerKey]negtypes.StateCountMap
 	// syncerEndpointSliceStateMap is a map between syncer and endpoint slice state counts.
@@ -54,7 +54,7 @@ type SyncerMetrics struct {
 // NewNEGMetricsCollector initializes SyncerMetrics and starts a go routine to compute and export metrics periodically.
 func NewNegMetricsCollector(exportInterval time.Duration, logger klog.Logger) *SyncerMetrics {
 	return &SyncerMetrics{
-		syncerStatusMap:             make(map[negtypes.NegSyncerKey]negtypes.Reason),
+		syncerStateMap:              make(map[negtypes.NegSyncerKey]negtypes.Reason),
 		syncerEndpointStateMap:      make(map[negtypes.NegSyncerKey]negtypes.StateCountMap),
 		syncerEndpointSliceStateMap: make(map[negtypes.NegSyncerKey]negtypes.StateCountMap),
 		syncerLabelProagationStats:  make(map[negtypes.NegSyncerKey]LabelPropagationStats),
@@ -71,7 +71,7 @@ func FakeSyncerMetrics() *SyncerMetrics {
 // RegisterSyncerMetrics registers syncer related metrics
 func RegisterSyncerMetrics() {
 	prometheus.MustRegister(syncerSyncResult)
-	prometheus.MustRegister(syncerSyncerState)
+	prometheus.MustRegister(syncerState)
 	prometheus.MustRegister(syncerEndpointState)
 	prometheus.MustRegister(syncerEndpointSliceState)
 }
@@ -116,11 +116,11 @@ func (sm *SyncerMetrics) UpdateSyncerStatusInMetrics(key negtypes.NegSyncerKey,
 	syncerSyncResult.WithLabelValues(string(reason)).Inc()
 	sm.mu.Lock()
 	defer sm.mu.Unlock()
-	if sm.syncerStatusMap == nil {
-		sm.syncerStatusMap = make(map[negtypes.NegSyncerKey]negtypes.Reason)
-		sm.logger.V(3).Info("Syncer Metrics failed to initialize correctly, reinitializing syncerStatusMap: %v", sm.syncerStatusMap)
+	if sm.syncerStateMap == nil {
+		sm.syncerStateMap = make(map[negtypes.NegSyncerKey]negtypes.Reason)
+		sm.logger.V(3).Info("Syncer Metrics failed to initialize correctly, reinitializing syncerStatusMap: %v", sm.syncerStateMap)
 	}
-	sm.syncerStatusMap[key] = reason
+	sm.syncerStateMap[key] = reason
 }
 
 func (sm *SyncerMetrics) UpdateSyncerEPMetrics(key negtypes.NegSyncerKey, endpointCount, endpointSliceCount negtypes.StateCountMap) {
@@ -153,7 +153,7 @@ func (sm *SyncerMetrics) SetLabelPropagationStats(key negtypes.NegSyncerKey, lab
 func (sm *SyncerMetrics) DeleteSyncer(key negtypes.NegSyncerKey) {
 	sm.mu.Lock()
 	defer sm.mu.Unlock()
-	delete(sm.syncerStatusMap, key)
+	delete(sm.syncerStateMap, key)
 	delete(sm.syncerEndpointStateMap, key)
 	delete(sm.syncerEndpointSliceStateMap, key)
 	delete(sm.syncerLabelProagationStats, key)
@@ -178,7 +178,7 @@ func (sm *SyncerMetrics) computeSyncerStateMetrics() (*syncerStateCount, int) {
 
 	stateCount := &syncerStateCount{}
 	syncerCount := 0
-	for _, syncerState := range sm.syncerStatusMap {
+	for _, syncerState := range sm.syncerStateMap {
 		stateCount.inc(syncerState)
 		syncerCount++
 	}

pkg/neg/metrics/syncer_metrics.go

@@ -58,8 +58,8 @@ var (
 		[]string{syncResultLabel},
 	)
 
-	// syncerSyncerState tracks the count of syncer in different states
-	syncerSyncerState = prometheus.NewGaugeVec(
+	// syncerState tracks the count of syncer in different states
+	syncerState = prometheus.NewGaugeVec(
 		prometheus.GaugeOpts{
 			Subsystem: negControllerSubsystem,
 			Name:      syncerStateKey,
@@ -127,21 +127,21 @@ func (sc *syncerStateCount) inc(reason negtypes.Reason) {
 }
 
 func PublishSyncerStateMetrics(stateCount *syncerStateCount) {
-	syncerSyncerState.WithLabelValues(EPCountsDiffer).Set(float64(stateCount.epCountsDiffer))
-	syncerSyncerState.WithLabelValues(EPNodeMissing).Set(float64(stateCount.epNodeMissing))
-	syncerSyncerState.WithLabelValues(EPNodeNotFound).Set(float64(stateCount.epNodeNotFound))
-	syncerSyncerState.WithLabelValues(EPPodMissing).Set(float64(stateCount.epPodMissing))
-	syncerSyncerState.WithLabelValues(EPPodNotFound).Set(float64(stateCount.epPodNotFound))
-	syncerSyncerState.WithLabelValues(EPPodTypeAssertionFailed).Set(float64(stateCount.epPodTypeAssertionFailed))
-	syncerSyncerState.WithLabelValues(EPZoneMissing).Set(float64(stateCount.epZoneMissing))
-	syncerSyncerState.WithLabelValues(EPSEndpointCountZero).Set(float64(stateCount.epsEndpointCountZero))
-	syncerSyncerState.WithLabelValues(EPCalculationCountZero).Set(float64(stateCount.epCalculationCountZero))
-	syncerSyncerState.WithLabelValues(InvalidAPIResponse).Set(float64(stateCount.invalidAPIResponse))
-	syncerSyncerState.WithLabelValues(InvalidEPAttach).Set(float64(stateCount.invalidEPAttach))
-	syncerSyncerState.WithLabelValues(InvalidEPDetach).Set(float64(stateCount.invalidEPDetach))
-	syncerSyncerState.WithLabelValues(NegNotFound).Set(float64(stateCount.negNotFound))
-	syncerSyncerState.WithLabelValues(CurrentNegEPNotFound).Set(float64(stateCount.currentNegEPNotFound))
-	syncerSyncerState.WithLabelValues(EPSNotFound).Set(float64(stateCount.epsNotFound))
-	syncerSyncerState.WithLabelValues(OtherError).Set(float64(stateCount.otherError))
-	syncerSyncerState.WithLabelValues(Success).Set(float64(stateCount.success))
+	syncerState.WithLabelValues(EPCountsDiffer).Set(float64(stateCount.epCountsDiffer))
+	syncerState.WithLabelValues(EPNodeMissing).Set(float64(stateCount.epNodeMissing))
+	syncerState.WithLabelValues(EPNodeNotFound).Set(float64(stateCount.epNodeNotFound))
+	syncerState.WithLabelValues(EPPodMissing).Set(float64(stateCount.epPodMissing))
+	syncerState.WithLabelValues(EPPodNotFound).Set(float64(stateCount.epPodNotFound))
+	syncerState.WithLabelValues(EPPodTypeAssertionFailed).Set(float64(stateCount.epPodTypeAssertionFailed))
+	syncerState.WithLabelValues(EPZoneMissing).Set(float64(stateCount.epZoneMissing))
+	syncerState.WithLabelValues(EPSEndpointCountZero).Set(float64(stateCount.epsEndpointCountZero))
+	syncerState.WithLabelValues(EPCalculationCountZero).Set(float64(stateCount.epCalculationCountZero))
+	syncerState.WithLabelValues(InvalidAPIResponse).Set(float64(stateCount.invalidAPIResponse))
+	syncerState.WithLabelValues(InvalidEPAttach).Set(float64(stateCount.invalidEPAttach))
+	syncerState.WithLabelValues(InvalidEPDetach).Set(float64(stateCount.invalidEPDetach))
+	syncerState.WithLabelValues(NegNotFound).Set(float64(stateCount.negNotFound))
+	syncerState.WithLabelValues(CurrentNegEPNotFound).Set(float64(stateCount.currentNegEPNotFound))
+	syncerState.WithLabelValues(EPSNotFound).Set(float64(stateCount.epsNotFound))
+	syncerState.WithLabelValues(OtherError).Set(float64(stateCount.otherError))
+	syncerState.WithLabelValues(Success).Set(float64(stateCount.success))
 }