txpool metrics (#1619)

Author: paologalligit

txpool/metrics.go

@@ -10,7 +10,8 @@ import (
 )
 
 var (
-	metricTxPoolGauge            = metrics.LazyLoadGaugeVec("txpool_current_tx_count", []string{"source", "type"})
+	metricTxPoolGauge            = metrics.LazyLoadGaugeVec("txpool_current_tx_count", []string{"source", "type", "status"})
+	metricTxPoolWashedCounter    = metrics.LazyLoadCounterVec("txpool_washed_tx_count", []string{"source", "type"})
 	metricBadTxGauge             = metrics.LazyLoadGaugeVec("bad_tx_count", []string{"source"})
 	metricTxPoolExecutablesGauge = metrics.LazyLoadGauge("txpool_executable_tx_count")
 	metricTxPoolAllGauge         = metrics.LazyLoadGauge("txpool_all_tx_count")

txpool/tx_object.go

@@ -20,14 +20,22 @@ import (
 	"github.com/vechain/thor/v2/tx"
 )
 
+type txSource string
+
+const (
+	txSourceLocal  txSource = "local"
+	txSourceRemote txSource = "remote"
+	txSourceFill   txSource = "fill"
+)
+
 type TxObject struct {
 	*tx.Transaction
 	resolved *runtime.ResolvedTransaction
 
-	timeAdded      int64
-	localSubmitted bool          // tx is submitted locally on this node, or synced remotely from p2p.
-	payer          *thor.Address // payer of the tx, either origin, delegator, or on-chain delegation payer
-	cost           *big.Int      // total tx cost the payer needs to pay before execution(gas price * gas)
+	timeAdded int64
+	source    txSource      // where the tx came from: local, remote or fill.
+	payer     *thor.Address // payer of the tx, either origin, delegator, or on-chain delegation payer
+	cost      *big.Int      // total tx cost the payer needs to pay before execution(gas price * gas)
 
 	// basic unit of tip price for the validator, before GALACTICA it's the overallGasPrice(provedWork included) and validator
 	// gets <reward-ratio>% of the tip, after GALACTICA it's the effective priority fee per gas and validator gets 100% of the tip
@@ -37,19 +45,31 @@ type TxObject struct {
 }
 
 func ResolveTx(tx *tx.Transaction, localSubmitted bool) (*TxObject, error) {
+	source := txSourceRemote
+	if localSubmitted {
+		source = txSourceLocal
+	}
+	return resolveTxWithSource(tx, source)
+}
+
+func resolveTxWithSource(tx *tx.Transaction, source txSource) (*TxObject, error) {
 	resolved, err := runtime.ResolveTransaction(tx)
 	if err != nil {
 		return nil, err
 	}
 
 	return &TxObject{
-		Transaction:    tx,
-		resolved:       resolved,
-		timeAdded:      time.Now().UnixNano(),
-		localSubmitted: localSubmitted,
+		Transaction: tx,
+		resolved:    resolved,
+		timeAdded:   time.Now().UnixNano(),
+		source:      source,
 	}, nil
 }
 
+func (o *TxObject) localSubmitted() bool {
+	return o.source == txSourceLocal
+}
+
 func (o *TxObject) Origin() thor.Address {
 	return o.resolved.Origin
 }

txpool/tx_object_map.go

@@ -180,9 +180,11 @@ func (m *txObjectMap) ToTxs() tx.Transactions {
 	return txs
 }
 
-func (m *txObjectMap) Fill(txObjs []*TxObject) {
+func (m *txObjectMap) Fill(txObjs []*TxObject) []*TxObject {
 	m.lock.Lock()
 	defer m.lock.Unlock()
+
+	inserted := make([]*TxObject, 0, len(txObjs))
 	for _, txObj := range txObjs {
 		if _, found := m.mapByHash[txObj.Hash()]; found {
 			continue
@@ -194,8 +196,10 @@ func (m *txObjectMap) Fill(txObjs []*TxObject) {
 		}
 		m.mapByHash[txObj.Hash()] = txObj
 		m.mapByID[txObj.ID()] = txObj
+		inserted = append(inserted, txObj)
 		// skip cost check and accumulation
 	}
+	return inserted
 }
 
 func (m *txObjectMap) Len() int {

txpool/tx_object_map_test.go

@@ -175,16 +175,19 @@ func TestPendingCost(t *testing.T) {
 	state := stater.NewState(best.Root())
 
 	baseFee := galactica.CalcBaseFee(best.Header, forkConfig)
-	txObj1.executable, err = txObj1.Executable(chain, state, best.Header, forkConfig, baseFee)
+	exec1, err := txObj1.Executable(chain, state, best.Header, forkConfig, baseFee)
 	assert.Nil(t, err)
+	txObj1.executable = exec1
 	assert.True(t, txObj1.executable)
 
-	txObj2.executable, err = txObj2.Executable(chain, state, best.Header, forkConfig, baseFee)
+	exec2, err := txObj2.Executable(chain, state, best.Header, forkConfig, baseFee)
 	assert.Nil(t, err)
+	txObj2.executable = exec2
 	assert.True(t, txObj2.executable)
 
-	txObj3.executable, err = txObj3.Executable(chain, state, best.Header, forkConfig, baseFee)
+	exec3, err := txObj3.Executable(chain, state, best.Header, forkConfig, baseFee)
 	assert.Nil(t, err)
+	txObj3.executable = exec3
 	assert.True(t, txObj3.executable)
 
 	// Creating a new txObjectMap