Add metrics for gas price / usage

Log errors instead of returning if there is a mismatch between the number of
transactions and receipts (this would mean an issue at dev time instead of
runtime)

core/blockchain.go

@@ -81,6 +81,8 @@ var (
 	acceptorQueueGauge           = metrics.NewRegisteredGauge("chain/acceptor/queue/size", nil)
 	acceptorWorkTimer            = metrics.NewRegisteredCounter("chain/acceptor/work", nil)
 	acceptorWorkCount            = metrics.NewRegisteredCounter("chain/acceptor/work/count", nil)
+	blockGasPriceGauge           = metrics.NewRegisteredGauge("chain/block/gas/price", nil)
+	blockTotalFeesGauge          = metrics.NewRegisteredGauge("chain/block/fees", nil)
 	processedBlockGasUsedCounter = metrics.NewRegisteredCounter("chain/block/gas/used/processed", nil)
 	acceptedBlockGasUsedCounter  = metrics.NewRegisteredCounter("chain/block/gas/used/accepted", nil)
 	badBlockCounter              = metrics.NewRegisteredCounter("chain/block/bad/count", nil)
@@ -1053,9 +1055,47 @@ func (bc *BlockChain) Accept(block *types.Block) error {
 	bc.addAcceptorQueue(block)
 	acceptedBlockGasUsedCounter.Inc(int64(block.GasUsed()))
 	acceptedTxsCounter.Inc(int64(len(block.Transactions())))
+	if baseFee := block.BaseFee(); baseFee != nil {
+		blockGasPriceGauge.Update(baseFee.Int64())
+	}
+	total, err := TotalFees(block, bc.GetReceiptsByHash(block.Hash()))
+	if err != nil {
+		log.Debug(fmt.Sprintf("TotalFees %s", err))
+	} else {
+		blockTotalFeesGauge.Update(total.Int64())
+	}
 	return nil
 }
 
+// TotalFees computes total consumed fees in ETH. Block transactions and receipts have to have the same order.
+func TotalFees(block *types.Block, receipts []*types.Receipt) (*big.Int, error) {
+	baseFee := block.BaseFee()
+	feesWei := new(big.Int)
+	if len(block.Transactions()) != len(receipts) {
+		return nil, errors.New("mismatch between total number of transactions and receipts")
+	}
+	for i, tx := range block.Transactions() {
+		var minerFee *big.Int
+		if baseFee == nil {
+			// legacy block, no baseFee
+			minerFee = tx.GasPrice()
+		} else {
+			minerFee = new(big.Int).Add(baseFee, tx.EffectiveGasTipValue(baseFee))
+		}
+		feesWei.Add(feesWei, new(big.Int).Mul(new(big.Int).SetUint64(receipts[i].GasUsed), minerFee))
+	}
+	return feesWei, nil
+}
+
+func TotalFeesFloat(block *types.Block, receipts []*types.Receipt) *big.Float {
+	total, err := TotalFees(block, receipts)
+	if err != nil {
+		log.Debug(fmt.Sprintf("TotalFees %s", err))
+		return new(big.Float).SetFloat64(0)
+	}
+	return new(big.Float).Quo(new(big.Float).SetInt(total), new(big.Float).SetInt(big.NewInt(params.Ether)))
+}
+
 func (bc *BlockChain) Reject(block *types.Block) error {
 	bc.chainmu.Lock()
 	defer bc.chainmu.Unlock()

miner/worker.go

@@ -369,7 +369,7 @@ func (w *worker) handleResult(env *environment, block *types.Block, createdAt ti
 	}
 
 	log.Info("Commit new mining work", "number", block.Number(), "hash", hash, "timestamp", block.Time(), "uncles", 0, "txs", env.tcount,
-		"gas", block.GasUsed(), "fees", totalFees(block, receipts), "elapsed", common.PrettyDuration(time.Since(env.start)))
+		"gas", block.GasUsed(), "fees", core.TotalFeesFloat(block, receipts), "elapsed", common.PrettyDuration(time.Since(env.start)))
 
 	// Note: the miner no longer emits a NewMinedBlock event. Instead the caller
 	// is responsible for running any additional verification and then inserting
@@ -387,15 +387,6 @@ func copyReceipts(receipts []*types.Receipt) []*types.Receipt {
 	return result
 }
 
-// totalFees computes total consumed fees in ETH. Block transactions and receipts have to have the same order.
-func totalFees(block *types.Block, receipts []*types.Receipt) *big.Float {
-	feesWei := new(big.Int)
-	for i, tx := range block.Transactions() {
-		feesWei.Add(feesWei, new(big.Int).Mul(new(big.Int).SetUint64(receipts[i].GasUsed), tx.GasPrice()))
-	}
-	return new(big.Float).Quo(new(big.Float).SetInt(feesWei), new(big.Float).SetInt(big.NewInt(params.Ether)))
-}
-
 // enforcePredicates takes a set of pending transactions (grouped by sender, and ordered by nonce)
 // and returns the subset of those transactions (following the same grouping) that satisfy predicateContext.
 // Any transaction that fails predicate verification will be removed from the tx pool and excluded