Add Metric to Track Greatest Epoch Final View

module/metrics.go

@@ -48,6 +48,7 @@ type EngineMetrics interface {
 
 type ComplianceMetrics interface {
 	FinalizedHeight(height uint64)
+	CommittedEpochFinalView(view uint64)
 	SealedHeight(height uint64)
 	BlockFinalized(*flow.Block)
 	BlockSealed(*flow.Block)

module/metrics/compliance.go

@@ -19,12 +19,20 @@ type ComplianceCollector struct {
 	sealedPayload            *prometheus.CounterVec
 	lastBlockFinalizedAt     time.Time
 	finalizedBlocksPerSecond prometheus.Summary
+	committedEpochFinalView  prometheus.Gauge
 }
 
 func NewComplianceCollector() *ComplianceCollector {
 
 	cc := &ComplianceCollector{
 
+		committedEpochFinalView: promauto.NewGauge(prometheus.GaugeOpts{
+			Name:      "committed_epoch_final_view",
+			Namespace: namespaceConsensus,
+			Subsystem: subsystemCompliance,
+			Help:      "the final view of the committed epoch with the greatest counter",
+		}),
+
 		finalizedHeight: promauto.NewGauge(prometheus.GaugeOpts{
 			Name:      "finalized_height",
 			Namespace: namespaceConsensus,
@@ -128,3 +136,7 @@ func (cc *ComplianceCollector) BlockSealed(block *flow.Block) {
 func (cc *ComplianceCollector) BlockProposalDuration(duration time.Duration) {
 	cc.blockProposalDuration.Add(duration.Seconds())
 }
+
+func (cc *ComplianceCollector) CommittedEpochFinalView(view uint64) {
+	cc.committedEpochFinalView.Set(float64(view))
+}

module/metrics/noop.go

@@ -44,6 +44,7 @@ func (nc *NoopCollector) BlockProposed(*flow.Block)
 func (nc *NoopCollector) BlockFinalized(*flow.Block)                                             {}
 func (nc *NoopCollector) BlockSealed(*flow.Block)                                                {}
 func (nc *NoopCollector) BlockProposalDuration(duration time.Duration)                           {}
+func (nc *NoopCollector) CommittedEpochFinalView(view uint64)                                    {}
 func (nc *NoopCollector) CacheEntries(resource string, entries uint)                             {}
 func (nc *NoopCollector) CacheHit(resource string)                                               {}
 func (nc *NoopCollector) CacheNotFound(resource string)                                          {}

state/protocol/badger/mutator.go

@@ -11,6 +11,7 @@ import (
 	"github.com/onflow/flow-go/engine"
 	"github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/flow-go/module"
+	"github.com/onflow/flow-go/module/metrics"
 	"github.com/onflow/flow-go/module/trace"
 	"github.com/onflow/flow-go/state"
 	"github.com/onflow/flow-go/state/protocol"
@@ -32,11 +33,13 @@ import (
 // the non-consensus nodes have to perform.
 type FollowerState struct {
 	*State
-	index    storage.Index
-	payloads storage.Payloads
-	tracer   module.Tracer
-	consumer protocol.Consumer
-	cfg      Config
+
+	index             storage.Index
+	payloads          storage.Payloads
+	tracer            module.Tracer
+	consumer          protocol.Consumer
+	cfg               Config
+	complianceMetrics module.ComplianceMetrics
 }
 
 // MutableState implements a mutable protocol state. When extending the
@@ -57,12 +60,13 @@ func NewFollowerState(
 	consumer protocol.Consumer,
 ) (*FollowerState, error) {
 	followerState := &FollowerState{
-		State:    state,
-		index:    index,
-		payloads: payloads,
-		tracer:   tracer,
-		consumer: consumer,
-		cfg:      DefaultConfig(),
+		State:             state,
+		index:             index,
+		payloads:          payloads,
+		tracer:            tracer,
+		consumer:          consumer,
+		cfg:               DefaultConfig(),
+		complianceMetrics: metrics.NewComplianceCollector(),
 	}
 	return followerState, nil
 }
@@ -774,6 +778,9 @@ func (m *FollowerState) handleServiceEvents(block *flow.Block) ([]func(*transact
 					return nil, state.NewInvalidExtensionErrorf("invalid epoch commit: %s", err)
 				}
 
+				// update `committed_epoch_final_view` metric with new final view
+				m.complianceMetrics.CommittedEpochFinalView(setup.FinalView)
+
 				// prevents multiple setup events for same Epoch (including multiple setup events in payload of same block)
 				epochStatus.NextEpoch.CommitID = ev.ID()
 

state/protocol/badger/state.go

@@ -51,6 +51,32 @@ func Bootstrap(
 	}
 	state := newState(metrics, db, headers, seals, results, blocks, setups, commits, statuses)
 
+	phase, err := state.Final().Phase()
+	if err != nil {
+		return nil, fmt.Errorf("could not get epoch phase from state: %w", err)
+	}
+
+	// update metric based of epoch phase
+	switch phase {
+	case flow.EpochPhaseStaking:
+	case flow.EpochPhaseSetup:
+
+		// if we are in Staking or Setup phase, then set the metric value to the current epoch's final view
+		finalView, err := state.Final().Epochs().Current().FinalView()
+		if err != nil {
+			return nil, fmt.Errorf("could not get current epoch final view from state: %w", err)
+		}
+		state.metrics.CommittedEpochFinalView(finalView)
+	case flow.EpochPhaseCommitted:
+
+		// if we are in Committed phase, then set the metric value to the next epoch's final view
+		finalView, err := state.Final().Epochs().Next().FinalView()
+		if err != nil {
+			return nil, fmt.Errorf("could not get next epoch final view from state: %w", err)
+		}
+		state.metrics.CommittedEpochFinalView(finalView)
+	}
+
 	if err := isValidRootSnapshot(root); err != nil {
 		return nil, fmt.Errorf("cannot bootstrap invalid root snapshot: %w", err)
 	}