add more logs

scroll-tech · Oct 17, 2024 · e1fa9ee · e1fa9ee
1 parent c88cc48
commit e1fa9ee
Show file tree

Hide file tree

Showing 5 changed files with 37 additions and 8 deletions.
diff --git a/eth/fetcher/tx_fetcher.go b/eth/fetcher/tx_fetcher.go
@@ -795,6 +795,10 @@ func (f *TxFetcher) scheduleFetches(timer *mclock.Timer, timeout chan struct{},
 		})
 
 		log.Debug("Scheduling transaction retrieval", "peer", peer, "len(f.announces[peer])", len(f.announces[peer]), "len(hashes)", len(hashes))
+		for _, hash := range hashes {
+			log.Info("Scheduling transaction retrieval", "peer", peer, "len(f.announces[peer])", len(f.announces[peer]), "len(hashes)", len(hashes), "hash", hash)
+		}
+
 		peerAnnounceTxsLenGauge.Update(int64(len(f.announces[peer])))
 		peerRetrievalTxsLenGauge.Update(int64(len(hashes)))
 

diff --git a/eth/handler.go b/eth/handler.go
@@ -519,12 +519,18 @@ func (h *handler) BroadcastTransactions(txs types.Transactions) {
 		directCount += len(hashes)
 		peer.AsyncSendTransactions(hashes)
 		log.Debug("Transactions being broadcasted to", "peer", peer.String(), "len", len(hashes))
+		for _, hash := range hashes {
+			log.Info("Transactions being broadcasted to", "peer", peer.String(), "len", len(hashes), "hash", hash)
+		}
 	}
 	for peer, hashes := range annos {
 		annoPeers++
 		annoCount += len(hashes)
 		peer.AsyncSendPooledTransactionHashes(hashes)
 		log.Debug("Transactions being announced to", "peer", peer.String(), "len", len(hashes))
+		for _, hash := range hashes {
+			log.Info("Transactions being announced to", "peer", peer.String(), "len", len(hashes), "hash", hash)
+		}
 	}
 	log.Debug("Transaction broadcast", "txs", len(txs),
 		"announce packs", annoPeers, "announced hashes", annoCount,

diff --git a/eth/protocols/eth/broadcast.go b/eth/protocols/eth/broadcast.go
@@ -106,9 +106,12 @@ func (p *Peer) broadcastTransactions() {
 				done = make(chan struct{})
 				go func() {
 					log.Debug("Sending transactions", "count", len(txs))
+					for _, tx := range txs {
+						log.Info("Sending transactions", "count", len(txs), "tx", tx.Hash().Hex())
+					}
 					broadcastSendTxsLenGauge.Update(int64(len(txs)))
 					if err := p.SendTransactions(txs); err != nil {
-						log.Debug("Sending transactions", "count", len(txs), "err", err)
+						log.Error("Sending transactions", "count", len(txs), "err", err)
 						broadcastSendTxsFailMeter.Mark(1)
 						fail <- err
 						return
@@ -181,9 +184,12 @@ func (p *Peer) announceTransactions() {
 				done = make(chan struct{})
 				go func() {
 					log.Debug("Sending transaction announcements", "count", len(pending))
+					for _, tx := range pending {
+						log.Info("Sending transaction announcements", "count", len(pending), "tx", tx.Hex())
+					}
 					broadcastAnnoTxsLenGauge.Update(int64(len(pending)))
 					if err := p.sendPooledTransactionHashes(pending); err != nil {
-						log.Debug("Sending transaction announcements", "count", len(pending), "err", err)
+						log.Error("Sending transaction announcements", "count", len(pending), "err", err)
 						broadcastAnnoTxsFailMeter.Mark(1)
 						fail <- err
 						return

diff --git a/eth/protocols/eth/handlers.go b/eth/protocols/eth/handlers.go
@@ -338,12 +338,15 @@ func handleNewPooledTransactionHashes(backend Backend, msg Decoder, peer *Peer)
 	}
 	ann := new(NewPooledTransactionHashesPacket)
 	if err := msg.Decode(ann); err != nil {
-		log.Debug("Failed to decode `NewPooledTransactionHashesPacket`", "peer", peer.String(), "err", err)
+		log.Error("Failed to decode `NewPooledTransactionHashesPacket`", "peer", peer.String(), "err", err)
 		newPooledTxHashesFailMeter.Mark(1)
 		return fmt.Errorf("%w: message %v: %v", errDecode, msg, err)
 	}
 	// Schedule all the unknown hashes for retrieval
 	log.Debug("handleNewPooledTransactionHashes", "peer", peer.String(), "len(ann)", len(*ann))
+	for _, hash := range *ann {
+		log.Info("handleNewPooledTransactionHashes", "peer", peer.String(), "len(ann)", len(*ann), "hash", hash.Hex())
+	}
 	newPooledTxHashesLenGauge.Update(int64(len(*ann)))
 	for _, hash := range *ann {
 		peer.markTransaction(hash)
@@ -355,12 +358,15 @@ func handleGetPooledTransactions66(backend Backend, msg Decoder, peer *Peer) err
 	// Decode the pooled transactions retrieval message
 	var query GetPooledTransactionsPacket66
 	if err := msg.Decode(&query); err != nil {
-		log.Debug("Failed to decode `GetPooledTransactionsPacket66`", "peer", peer.String(), "err", err)
+		log.Error("Failed to decode `GetPooledTransactionsPacket66`", "peer", peer.String(), "err", err)
 		getPooledTxsFailMeter.Mark(1)
 		return fmt.Errorf("%w: message %v: %v", errDecode, msg, err)
 	}
 	hashes, txs := answerGetPooledTransactions(backend, query.GetPooledTransactionsPacket, peer)
 	log.Debug("handleGetPooledTransactions", "peer", peer.String(), "RequestId", query.RequestId, "len(query)", len(query.GetPooledTransactionsPacket), "retrieved", len(hashes))
+	for _, hash := range hashes {
+		log.Info("handleGetPooledTransactions", "peer", peer.String(), "RequestId", query.RequestId, "len(query)", len(query.GetPooledTransactionsPacket), "retrieved", len(hashes), "hash", hash.Hex())
+	}
 	getPooledTxsQueryLenGauge.Update(int64(len(query.GetPooledTransactionsPacket)))
 	getPooledTxsRetrievedLenGauge.Update(int64(len(hashes)))
 	return peer.ReplyPooledTransactionsRLP(query.RequestId, hashes, txs)
@@ -403,16 +409,19 @@ func handleTransactions(backend Backend, msg Decoder, peer *Peer) error {
 	var txs TransactionsPacket
 	if err := msg.Decode(&txs); err != nil {
 		handleTxsFailMeter.Mark(1)
-		log.Debug("Failed to decode `TransactionsPacket`", "peer", peer.String(), "err", err)
+		log.Error("Failed to decode `TransactionsPacket`", "peer", peer.String(), "err", err)
 		return fmt.Errorf("%w: message %v: %v", errDecode, msg, err)
 	}
 	log.Debug("handleTransactions", "peer", peer.String(), "len(txs)", len(txs))
+	for _, tx := range txs {
+		log.Info("handleTransactions", "peer", peer.String(), "len(txs)", len(txs), "tx", tx.Hash().Hex())
+	}
 	handleTxsLenGauge.Update(int64(len(txs)))
 	for i, tx := range txs {
 		// Validate and mark the remote transaction
 		if tx == nil {
 			handleTxsNilMeter.Mark(1)
-			log.Debug("handleTransactions: transaction is nil", "peer", peer.String(), "i", i)
+			log.Error("handleTransactions: transaction is nil", "peer", peer.String(), "i", i)
 			return fmt.Errorf("%w: transaction %d is nil", errDecode, i)
 		}
 		peer.markTransaction(tx.Hash())
@@ -429,7 +438,7 @@ func handlePooledTransactions66(backend Backend, msg Decoder, peer *Peer) error
 	var txs PooledTransactionsPacket66
 	if err := msg.Decode(&txs); err != nil {
 		pooledTxs66FailMeter.Mark(1)
-		log.Debug("Failed to decode `PooledTransactionsPacket66`", "peer", peer.String(), "err", err)
+		log.Error("Failed to decode `PooledTransactionsPacket66`", "peer", peer.String(), "err", err)
 		return fmt.Errorf("%w: message %v: %v", errDecode, msg, err)
 	}
 	log.Debug("handlePooledTransactions66", "peer", peer.String(), "len(txs)", len(txs.PooledTransactionsPacket))
@@ -438,7 +447,7 @@ func handlePooledTransactions66(backend Backend, msg Decoder, peer *Peer) error
 		// Validate and mark the remote transaction
 		if tx == nil {
 			pooledTxs66NilMeter.Mark(1)
-			log.Debug("handlePooledTransactions: transaction is nil", "peer", peer.String(), "i", i)
+			log.Error("handlePooledTransactions: transaction is nil", "peer", peer.String(), "i", i)
 			return fmt.Errorf("%w: transaction %d is nil", errDecode, i)
 		}
 		peer.markTransaction(tx.Hash())

diff --git a/eth/protocols/eth/peer.go b/eth/protocols/eth/peer.go
@@ -426,6 +426,10 @@ func (p *Peer) RequestTxs(hashes []common.Hash) error {
 	id := rand.Uint64()
 
 	log.Debug("Requesting transactions", "RequestId", id, "Peer.id", p.id, "count", len(hashes))
+	for _, hash := range hashes {
+		log.Info("Requesting transaction", "RequestId", id, "Peer.id", p.id, "count", len(hashes), "hash", hash)
+	}
+
 	peerRequestTxsCntGauge.Update(int64(len(hashes)))
 
 	requestTracker.Track(p.id, p.version, GetPooledTransactionsMsg, PooledTransactionsMsg, id)