diff --git a/vms/platformvm/block/executor/acceptor.go b/vms/platformvm/block/executor/acceptor.go index cc2bcef0521..a6066308e26 100644 --- a/vms/platformvm/block/executor/acceptor.go +++ b/vms/platformvm/block/executor/acceptor.go @@ -70,15 +70,15 @@ func (a *acceptor) ApricotAtomicBlock(b *block.ApricotAtomicBlock) error { blkID := b.ID() defer a.free(blkID) - if err := a.commonAccept(b); err != nil { - return err - } - blkState, ok := a.blkIDToState[blkID] if !ok { return fmt.Errorf("%w %s", errMissingBlockState, blkID) } + if err := a.commonAccept(blkState); err != nil { + return err + } + // Update the state to reflect the changes made in [onAcceptState]. if err := blkState.onAcceptState.Apply(a.state); err != nil { return err @@ -132,11 +132,7 @@ func (a *acceptor) optionBlock(b block.Block, blockType string) error { }() // Note that the parent must be accepted first. - if err := a.commonAccept(parentState.statelessBlock); err != nil { - return err - } - - if err := a.commonAccept(b); err != nil { + if err := a.commonAccept(parentState); err != nil { return err } @@ -150,6 +146,11 @@ func (a *acceptor) optionBlock(b block.Block, blockType string) error { if !ok { return fmt.Errorf("%w %s", errMissingBlockState, blkID) } + + if err := a.commonAccept(blkState); err != nil { + return err + } + if err := blkState.onAcceptState.Apply(a.state); err != nil { return err } @@ -219,15 +220,15 @@ func (a *acceptor) standardBlock(b block.Block, blockType string) error { blkID := b.ID() defer a.free(blkID) - if err := a.commonAccept(b); err != nil { - return err - } - blkState, ok := a.blkIDToState[blkID] if !ok { return fmt.Errorf("%w %s", errMissingBlockState, blkID) } + if err := a.commonAccept(blkState); err != nil { + return err + } + // Update the state to reflect the changes made in [onAcceptState]. if err := blkState.onAcceptState.Apply(a.state); err != nil { return err @@ -264,17 +265,18 @@ func (a *acceptor) standardBlock(b block.Block, blockType string) error { return nil } -func (a *acceptor) commonAccept(b block.Block) error { - blkID := b.ID() +func (a *acceptor) commonAccept(b *blockState) error { + blk := b.statelessBlock + blkID := blk.ID() - if err := a.metrics.MarkAccepted(b); err != nil { + if err := a.metrics.MarkAccepted(b.metrics); err != nil { return fmt.Errorf("failed to accept block %s: %w", blkID, err) } a.backend.lastAccepted = blkID a.state.SetLastAccepted(blkID) - a.state.SetHeight(b.Height()) - a.state.AddStatelessBlock(b) + a.state.SetHeight(blk.Height()) + a.state.AddStatelessBlock(blk) a.validators.OnAcceptedBlockID(blkID) return nil } diff --git a/vms/platformvm/block/executor/acceptor_test.go b/vms/platformvm/block/executor/acceptor_test.go index b3f1482c1f8..c8605443c60 100644 --- a/vms/platformvm/block/executor/acceptor_test.go +++ b/vms/platformvm/block/executor/acceptor_test.go @@ -113,12 +113,6 @@ func TestAcceptorVisitAtomicBlock(t *testing.T) { ) require.NoError(err) - // Set expected calls on the state. - // We should error after [commonAccept] is called. - s.EXPECT().SetLastAccepted(blk.ID()).Times(1) - s.EXPECT().SetHeight(blk.Height()).Times(1) - s.EXPECT().AddStatelessBlock(blk).Times(1) - err = acceptor.ApricotAtomicBlock(blk) require.ErrorIs(err, errMissingBlockState) @@ -127,8 +121,12 @@ func TestAcceptorVisitAtomicBlock(t *testing.T) { childID := ids.GenerateTestID() atomicRequests := make(map[ids.ID]*atomic.Requests) acceptor.backend.blkIDToState[blk.ID()] = &blockState{ + statelessBlock: blk, onAcceptState: onAcceptState, atomicRequests: atomicRequests, + metrics: metrics.Block{ + Block: blk, + }, } // Give [blk] a child. childOnAcceptState := state.NewMockDiff(ctrl) @@ -196,12 +194,6 @@ func TestAcceptorVisitStandardBlock(t *testing.T) { ) require.NoError(err) - // Set expected calls on the state. - // We should error after [commonAccept] is called. - s.EXPECT().SetLastAccepted(blk.ID()).Times(1) - s.EXPECT().SetHeight(blk.Height()).Times(1) - s.EXPECT().AddStatelessBlock(blk).Times(1) - err = acceptor.BanffStandardBlock(blk) require.ErrorIs(err, errMissingBlockState) @@ -211,12 +203,16 @@ func TestAcceptorVisitStandardBlock(t *testing.T) { atomicRequests := make(map[ids.ID]*atomic.Requests) calledOnAcceptFunc := false acceptor.backend.blkIDToState[blk.ID()] = &blockState{ - onAcceptState: onAcceptState, + statelessBlock: blk, + onAcceptState: onAcceptState, onAcceptFunc: func() { calledOnAcceptFunc = true }, atomicRequests: atomicRequests, + metrics: metrics.Block{ + Block: blk, + }, } // Give [blk] a child. childOnAcceptState := state.NewMockDiff(ctrl) @@ -308,10 +304,6 @@ func TestAcceptorVisitCommitBlock(t *testing.T) { parentStatelessBlk.EXPECT().Height().Return(blk.Height()-1).Times(1), s.EXPECT().SetHeight(blk.Height()-1).Times(1), s.EXPECT().AddStatelessBlock(parentState.statelessBlock).Times(1), - - s.EXPECT().SetLastAccepted(blkID).Times(1), - s.EXPECT().SetHeight(blk.Height()).Times(1), - s.EXPECT().AddStatelessBlock(blk).Times(1), ) err = acceptor.ApricotCommitBlock(blk) @@ -322,12 +314,16 @@ func TestAcceptorVisitCommitBlock(t *testing.T) { // Set [blk]'s state in the map as though it had been verified. acceptor.backend.blkIDToState[parentID] = parentState acceptor.backend.blkIDToState[blkID] = &blockState{ - onAcceptState: parentState.onCommitState, - onAcceptFunc: parentState.onAcceptFunc, + statelessBlock: blk, + onAcceptState: parentState.onCommitState, + onAcceptFunc: parentState.onAcceptFunc, inputs: parentState.inputs, timestamp: parentOnCommitState.GetTimestamp(), atomicRequests: parentState.atomicRequests, + metrics: metrics.Block{ + Block: blk, + }, } batch := databasemock.NewBatch(ctrl) @@ -418,10 +414,6 @@ func TestAcceptorVisitAbortBlock(t *testing.T) { parentStatelessBlk.EXPECT().Height().Return(blk.Height()-1).Times(1), s.EXPECT().SetHeight(blk.Height()-1).Times(1), s.EXPECT().AddStatelessBlock(parentState.statelessBlock).Times(1), - - s.EXPECT().SetLastAccepted(blkID).Times(1), - s.EXPECT().SetHeight(blk.Height()).Times(1), - s.EXPECT().AddStatelessBlock(blk).Times(1), ) err = acceptor.ApricotAbortBlock(blk) @@ -432,12 +424,16 @@ func TestAcceptorVisitAbortBlock(t *testing.T) { // Set [blk]'s state in the map as though it had been verified. acceptor.backend.blkIDToState[parentID] = parentState acceptor.backend.blkIDToState[blkID] = &blockState{ - onAcceptState: parentState.onAbortState, - onAcceptFunc: parentState.onAcceptFunc, + statelessBlock: blk, + onAcceptState: parentState.onAbortState, + onAcceptFunc: parentState.onAcceptFunc, inputs: parentState.inputs, timestamp: parentOnAbortState.GetTimestamp(), atomicRequests: parentState.atomicRequests, + metrics: metrics.Block{ + Block: blk, + }, } batch := databasemock.NewBatch(ctrl) diff --git a/vms/platformvm/block/executor/block_state.go b/vms/platformvm/block/executor/block_state.go index 5f6801d3c14..0e87839626b 100644 --- a/vms/platformvm/block/executor/block_state.go +++ b/vms/platformvm/block/executor/block_state.go @@ -10,6 +10,7 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/vms/platformvm/block" + "github.com/ava-labs/avalanchego/vms/platformvm/metrics" "github.com/ava-labs/avalanchego/vms/platformvm/state" ) @@ -32,4 +33,5 @@ type blockState struct { timestamp time.Time atomicRequests map[ids.ID]*atomic.Requests verifiedHeights set.Set[uint64] + metrics metrics.Block } diff --git a/vms/platformvm/block/executor/verifier.go b/vms/platformvm/block/executor/verifier.go index 6616fd58bad..7ba14d8628f 100644 --- a/vms/platformvm/block/executor/verifier.go +++ b/vms/platformvm/block/executor/verifier.go @@ -13,6 +13,8 @@ import ( "github.com/ava-labs/avalanchego/utils/set" "github.com/ava-labs/avalanchego/vms/components/gas" "github.com/ava-labs/avalanchego/vms/platformvm/block" + "github.com/ava-labs/avalanchego/vms/platformvm/config" + "github.com/ava-labs/avalanchego/vms/platformvm/metrics" "github.com/ava-labs/avalanchego/vms/platformvm/state" "github.com/ava-labs/avalanchego/vms/platformvm/status" "github.com/ava-labs/avalanchego/vms/platformvm/txs" @@ -72,7 +74,7 @@ func (v *verifier) BanffProposalBlock(b *block.BanffProposalBlock) error { } feeCalculator := state.PickFeeCalculator(v.txExecutorBackend.Config, onDecisionState) - inputs, atomicRequests, onAcceptFunc, err := v.processStandardTxs( + inputs, atomicRequests, onAcceptFunc, gasConsumed, err := v.processStandardTxs( b.Transactions, feeCalculator, onDecisionState, @@ -96,6 +98,7 @@ func (v *verifier) BanffProposalBlock(b *block.BanffProposalBlock) error { b, b.Tx, onDecisionState, + gasConsumed, onCommitState, onAbortState, feeCalculator, @@ -178,6 +181,7 @@ func (v *verifier) ApricotProposalBlock(b *block.ApricotProposalBlock) error { b, b.Tx, nil, + 0, onCommitState, onAbortState, feeCalculator, @@ -262,6 +266,12 @@ func (v *verifier) ApricotAtomicBlock(b *block.ApricotAtomicBlock) error { timestamp: atomicExecutor.OnAccept.GetTimestamp(), atomicRequests: atomicExecutor.AtomicRequests, verifiedHeights: set.Of(v.pChainHeight), + metrics: calculateBlockMetrics( + v.txExecutorBackend.Config, + b, + atomicExecutor.OnAccept, + 0, + ), } return nil } @@ -361,6 +371,12 @@ func (v *verifier) abortBlock(b block.Block) error { onAcceptState: onAbortState, timestamp: onAbortState.GetTimestamp(), verifiedHeights: set.Of(v.pChainHeight), + metrics: calculateBlockMetrics( + v.txExecutorBackend.Config, + b, + onAbortState, + 0, + ), } return nil } @@ -379,6 +395,12 @@ func (v *verifier) commitBlock(b block.Block) error { onAcceptState: onCommitState, timestamp: onCommitState.GetTimestamp(), verifiedHeights: set.Of(v.pChainHeight), + metrics: calculateBlockMetrics( + v.txExecutorBackend.Config, + b, + onCommitState, + 0, + ), } return nil } @@ -388,6 +410,7 @@ func (v *verifier) proposalBlock( b block.Block, tx *txs.Tx, onDecisionState state.Diff, + gasConsumed gas.Gas, onCommitState state.Diff, onAbortState state.Diff, feeCalculator fee.Calculator, @@ -433,6 +456,12 @@ func (v *verifier) proposalBlock( timestamp: onAbortState.GetTimestamp(), atomicRequests: atomicRequests, verifiedHeights: set.Of(v.pChainHeight), + metrics: calculateBlockMetrics( + v.txExecutorBackend.Config, + b, + onCommitState, + gasConsumed, + ), } return nil } @@ -444,7 +473,7 @@ func (v *verifier) standardBlock( feeCalculator fee.Calculator, onAcceptState state.Diff, ) error { - inputs, atomicRequests, onAcceptFunc, err := v.processStandardTxs( + inputs, atomicRequests, onAcceptFunc, gasConsumed, err := v.processStandardTxs( txs, feeCalculator, onAcceptState, @@ -467,6 +496,12 @@ func (v *verifier) standardBlock( inputs: inputs, atomicRequests: atomicRequests, verifiedHeights: set.Of(v.pChainHeight), + metrics: calculateBlockMetrics( + v.txExecutorBackend.Config, + b, + onAcceptState, + gasConsumed, + ), } return nil } @@ -475,11 +510,15 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculato set.Set[ids.ID], map[ids.ID]*atomic.Requests, func(), + gas.Gas, error, ) { // Complexity is limited first to avoid processing too large of a block. - timestamp := diff.GetTimestamp() - isEtna := v.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) + var ( + timestamp = diff.GetTimestamp() + isEtna = v.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) + gasConsumed gas.Gas + ) if isEtna { var blockComplexity gas.Dimensions for _, tx := range txs { @@ -487,26 +526,27 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculato if err != nil { txID := tx.ID() v.MarkDropped(txID, err) - return nil, nil, nil, err + return nil, nil, nil, 0, err } blockComplexity, err = blockComplexity.Add(&txComplexity) if err != nil { - return nil, nil, nil, err + return nil, nil, nil, 0, err } } - blockGas, err := blockComplexity.ToGas(v.txExecutorBackend.Config.DynamicFeeConfig.Weights) + var err error + gasConsumed, err = blockComplexity.ToGas(v.txExecutorBackend.Config.DynamicFeeConfig.Weights) if err != nil { - return nil, nil, nil, err + return nil, nil, nil, 0, err } // If this block exceeds the available capacity, ConsumeGas will return // an error. feeState := diff.GetFeeState() - feeState, err = feeState.ConsumeGas(blockGas) + feeState, err = feeState.ConsumeGas(gasConsumed) if err != nil { - return nil, nil, nil, err + return nil, nil, nil, 0, err } // Updating the fee state prior to executing the transactions is fine @@ -530,11 +570,11 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculato if err := tx.Unsigned.Visit(&txExecutor); err != nil { txID := tx.ID() v.MarkDropped(txID, err) // cache tx as dropped - return nil, nil, nil, err + return nil, nil, nil, 0, err } // ensure it doesn't overlap with current input batch if inputs.Overlaps(txExecutor.Inputs) { - return nil, nil, nil, ErrConflictingBlockTxs + return nil, nil, nil, 0, ErrConflictingBlockTxs } // Add UTXOs to batch inputs.Union(txExecutor.Inputs) @@ -575,13 +615,13 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculato ) potentialAccruedFees, err := math.Add(accruedFees, potentialCost) if err != nil { - return nil, nil, nil, err + return nil, nil, nil, 0, err } // Invariant: Proposal transactions do not impact SoV state. sovIterator, err := diff.GetActiveSubnetOnlyValidatorsIterator() if err != nil { - return nil, nil, nil, err + return nil, nil, nil, 0, err } var sovsToDeactivate []state.SubnetOnlyValidator @@ -603,13 +643,13 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculato for _, sov := range sovsToDeactivate { sov.EndAccumulatedFee = 0 if err := diff.PutSubnetOnlyValidator(sov); err != nil { - return nil, nil, nil, err + return nil, nil, nil, 0, err } } } if err := v.verifyUniqueInputs(parentID, inputs); err != nil { - return nil, nil, nil, err + return nil, nil, nil, 0, err } if numFuncs := len(funcs); numFuncs == 1 { @@ -622,5 +662,37 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator fee.Calculato } } - return inputs, atomicRequests, onAcceptFunc, nil + return inputs, atomicRequests, onAcceptFunc, gasConsumed, nil +} + +func calculateBlockMetrics( + config *config.Config, + blk block.Block, + s state.Chain, + gasConsumed gas.Gas, +) metrics.Block { + var ( + gasState = s.GetFeeState() + validatorExcess = s.GetSoVExcess() + ) + return metrics.Block{ + Block: blk, + + GasConsumed: gasConsumed, + GasState: gasState, + GasPrice: gas.CalculatePrice( + config.DynamicFeeConfig.MinPrice, + gasState.Excess, + config.DynamicFeeConfig.ExcessConversionConstant, + ), + + ActiveSoVs: s.NumActiveSubnetOnlyValidators(), + ValidatorExcess: validatorExcess, + ValidatorPrice: gas.CalculatePrice( + config.ValidatorFeeConfig.MinPrice, + validatorExcess, + config.ValidatorFeeConfig.ExcessConversionConstant, + ), + AccruedValidatorFees: s.GetAccruedFees(), + } } diff --git a/vms/platformvm/block/executor/verifier_test.go b/vms/platformvm/block/executor/verifier_test.go index 8606f42127c..00b5d99a695 100644 --- a/vms/platformvm/block/executor/verifier_test.go +++ b/vms/platformvm/block/executor/verifier_test.go @@ -246,6 +246,11 @@ func TestVerifierVisitAtomicBlock(t *testing.T) { mempool.EXPECT().Remove([]*txs.Tx{apricotBlk.Tx}).Times(1) onAccept.EXPECT().AddTx(apricotBlk.Tx, status.Committed).Times(1) onAccept.EXPECT().GetTimestamp().Return(timestamp).Times(1) + // Allow metrics to be calculated. + onAccept.EXPECT().GetFeeState().Return(gas.State{}).Times(1) + onAccept.EXPECT().GetSoVExcess().Return(gas.Gas(0)).Times(1) + onAccept.EXPECT().NumActiveSubnetOnlyValidators().Return(0).Times(1) + onAccept.EXPECT().GetAccruedFees().Return(uint64(0)).Times(1) blk := manager.NewBlock(apricotBlk) require.NoError(blk.Verify(context.Background())) @@ -411,6 +416,11 @@ func TestVerifierVisitCommitBlock(t *testing.T) { gomock.InOrder( parentStatelessBlk.EXPECT().Height().Return(uint64(1)).Times(1), parentOnCommitState.EXPECT().GetTimestamp().Return(timestamp).Times(1), + // Allow metrics to be calculated. + parentOnCommitState.EXPECT().GetFeeState().Return(gas.State{}).Times(1), + parentOnCommitState.EXPECT().GetSoVExcess().Return(gas.Gas(0)).Times(1), + parentOnCommitState.EXPECT().NumActiveSubnetOnlyValidators().Return(0).Times(1), + parentOnCommitState.EXPECT().GetAccruedFees().Return(uint64(0)).Times(1), ) // Verify the block. @@ -478,6 +488,11 @@ func TestVerifierVisitAbortBlock(t *testing.T) { gomock.InOrder( parentStatelessBlk.EXPECT().Height().Return(uint64(1)).Times(1), parentOnAbortState.EXPECT().GetTimestamp().Return(timestamp).Times(1), + // Allow metrics to be calculated. + parentOnAbortState.EXPECT().GetFeeState().Return(gas.State{}).Times(1), + parentOnAbortState.EXPECT().GetSoVExcess().Return(gas.Gas(0)).Times(1), + parentOnAbortState.EXPECT().NumActiveSubnetOnlyValidators().Return(0).Times(1), + parentOnAbortState.EXPECT().GetAccruedFees().Return(uint64(0)).Times(1), ) // Verify the block. diff --git a/vms/platformvm/metrics/metrics.go b/vms/platformvm/metrics/metrics.go index 82b51dc8c34..abf0f73eb99 100644 --- a/vms/platformvm/metrics/metrics.go +++ b/vms/platformvm/metrics/metrics.go @@ -11,16 +11,46 @@ import ( "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/utils/metric" "github.com/ava-labs/avalanchego/utils/wrappers" + "github.com/ava-labs/avalanchego/vms/components/gas" "github.com/ava-labs/avalanchego/vms/platformvm/block" ) +const ( + ResourceLabel = "resource" + GasLabel = "gas" + ValidatorsLabel = "validators" +) + +var ( + gasLabels = prometheus.Labels{ + ResourceLabel: GasLabel, + } + validatorsLabels = prometheus.Labels{ + ResourceLabel: ValidatorsLabel, + } +) + var _ Metrics = (*metrics)(nil) +type Block struct { + Block block.Block + + GasConsumed gas.Gas + GasState gas.State + GasPrice gas.Price + + ActiveSoVs int + ValidatorExcess gas.Gas + ValidatorPrice gas.Price + AccruedValidatorFees uint64 +} + type Metrics interface { metric.APIInterceptor // Mark that the given block was accepted. - MarkAccepted(block.Block) error + MarkAccepted(Block) error + // Mark that a validator set was created. IncValidatorSetsCreated() // Mark that a validator set was cached. @@ -30,6 +60,7 @@ type Metrics interface { // Mark that we computed a validator diff at a height with the given // difference from the top. AddValidatorSetsHeightDiff(uint64) + // Mark that this much stake is staked on the node. SetLocalStake(uint64) // Mark that this much stake is staked in the network. @@ -64,6 +95,37 @@ func New(registerer prometheus.Registerer) (Metrics, error) { Help: "Amount (in nAVAX) of AVAX staked on the Primary Network", }), + gasConsumed: prometheus.NewCounter(prometheus.CounterOpts{ + Name: "gas_consumed", + Help: "Cumulative amount of gas consumed by transactions", + }), + gasCapacity: prometheus.NewGauge(prometheus.GaugeOpts{ + Name: "gas_capacity", + Help: "Minimum amount of gas that can be consumed in the next block", + }), + activeSoVs: prometheus.NewGauge(prometheus.GaugeOpts{ + Name: "active_sovs", + Help: "Number of active Subnet only Validators", + }), + excess: prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Name: "excess", + Help: "Excess usage of a resource over the target usage", + }, + []string{ResourceLabel}, + ), + price: prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Name: "price", + Help: "Price (in nAVAX) of a resource", + }, + []string{ResourceLabel}, + ), + accruedValidatorFees: prometheus.NewGauge(prometheus.GaugeOpts{ + Name: "accrued_validator_fees", + Help: "The total cost of running an active SoV since Etna activation", + }), + validatorSetsCached: prometheus.NewCounter(prometheus.CounterOpts{ Name: "validator_sets_cached", Help: "Total number of validator sets cached", @@ -92,6 +154,13 @@ func New(registerer prometheus.Registerer) (Metrics, error) { registerer.Register(m.localStake), registerer.Register(m.totalStake), + registerer.Register(m.gasConsumed), + registerer.Register(m.gasCapacity), + registerer.Register(m.activeSoVs), + registerer.Register(m.excess), + registerer.Register(m.price), + registerer.Register(m.accruedValidatorFees), + registerer.Register(m.validatorSetsCreated), registerer.Register(m.validatorSetsCached), registerer.Register(m.validatorSetsHeightDiff), @@ -106,19 +175,38 @@ type metrics struct { blockMetrics *blockMetrics + // Staking metrics timeUntilUnstake prometheus.Gauge timeUntilSubnetUnstake *prometheus.GaugeVec localStake prometheus.Gauge totalStake prometheus.Gauge + gasConsumed prometheus.Counter + gasCapacity prometheus.Gauge + activeSoVs prometheus.Gauge + excess *prometheus.GaugeVec + price *prometheus.GaugeVec + accruedValidatorFees prometheus.Gauge + + // Validator set diff metrics validatorSetsCached prometheus.Counter validatorSetsCreated prometheus.Counter validatorSetsHeightDiff prometheus.Gauge validatorSetsDuration prometheus.Gauge } -func (m *metrics) MarkAccepted(b block.Block) error { - return b.Visit(m.blockMetrics) +func (m *metrics) MarkAccepted(b Block) error { + m.gasConsumed.Add(float64(b.GasConsumed)) + m.gasCapacity.Set(float64(b.GasState.Capacity)) + m.excess.With(gasLabels).Set(float64(b.GasState.Excess)) + m.price.With(gasLabels).Set(float64(b.GasPrice)) + + m.activeSoVs.Set(float64(b.ActiveSoVs)) + m.excess.With(validatorsLabels).Set(float64(b.ValidatorExcess)) + m.price.With(validatorsLabels).Set(float64(b.ValidatorPrice)) + m.accruedValidatorFees.Set(float64(b.AccruedValidatorFees)) + + return b.Block.Visit(m.blockMetrics) } func (m *metrics) IncValidatorSetsCreated() { diff --git a/vms/platformvm/metrics/no_op.go b/vms/platformvm/metrics/no_op.go index 770e30c961a..0a47f06c2fa 100644 --- a/vms/platformvm/metrics/no_op.go +++ b/vms/platformvm/metrics/no_op.go @@ -10,7 +10,6 @@ import ( "github.com/gorilla/rpc/v2" "github.com/ava-labs/avalanchego/ids" - "github.com/ava-labs/avalanchego/vms/platformvm/block" ) var Noop Metrics = noopMetrics{} @@ -21,7 +20,7 @@ func (noopMetrics) MarkOptionVoteWon() {} func (noopMetrics) MarkOptionVoteLost() {} -func (noopMetrics) MarkAccepted(block.Block) error { +func (noopMetrics) MarkAccepted(Block) error { return nil }