Use log.WithError static analysis from #11143 and fix all violations

BUILD.bazel

@@ -122,6 +122,7 @@ nogo(
         "//tools/analyzers/gocognit:go_default_library",
         "//tools/analyzers/ineffassign:go_default_library",
         "//tools/analyzers/interfacechecker:go_default_library",
+        "//tools/analyzers/logruswitherror:go_default_library",
         "//tools/analyzers/maligned:go_default_library",
         "//tools/analyzers/nop:go_default_library",
         "//tools/analyzers/properpermissions:go_default_library",

beacon-chain/blockchain/metrics.go

@@ -198,7 +198,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 	for i, validator := range postState.Validators() {
 		bal, err := postState.BalanceAtIndex(types.ValidatorIndex(i))
 		if err != nil {
-			log.Errorf("Could not load validator balance: %v", err)
+			log.WithError(err).Error("Could not load validator balance")
 			continue
 		}
 		if validator.Slashed {

beacon-chain/blockchain/receive_block.go

@@ -122,7 +122,7 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []interfaces.Sig
 		// log.Fatalf will prevent defer from being called
 		span.End()
 		// Exit run time if the node failed to verify weak subjectivity checkpoint.
-		log.Fatalf("Could not verify weak subjectivity checkpoint: %v", err)
+		log.WithError(err).Fatal("Could not verify weak subjectivity checkpoint")
 	}
 
 	return nil
@@ -146,7 +146,7 @@ func (s *Service) handlePostBlockOperations(b interfaces.BeaconBlock) error {
 
 	// Add block attestations to the fork choice pool to compute head.
 	if err := s.cfg.AttPool.SaveBlockAttestations(b.Body().Attestations()); err != nil {
-		log.Errorf("Could not save block attestations for fork choice: %v", err)
+		log.WithError(err).Error("Could not save block attestations for fork choice")
 		return nil
 	}
 	// Mark block exits as seen so we don't include same ones in future blocks.

beacon-chain/blockchain/service.go

@@ -391,12 +391,12 @@ func (s *Service) onExecutionChainStart(ctx context.Context, genesisTime time.Ti
 	preGenesisState := s.cfg.ChainStartFetcher.PreGenesisState()
 	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.cfg.ChainStartFetcher.ChainStartEth1Data())
 	if err != nil {
-		log.Fatalf("Could not initialize beacon chain: %v", err)
+		log.WithError(err).Fatal("Could not initialize beacon chain")
 	}
 	// We start a counter to genesis, if needed.
 	gRoot, err := initializedState.HashTreeRoot(s.ctx)
 	if err != nil {
-		log.Fatalf("Could not hash tree root genesis state: %v", err)
+		log.WithError(err).Fatal("Could not hash tree root genesis state")
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
 
@@ -469,7 +469,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	s.cfg.StateGen.SaveFinalizedState(0 /*slot*/, genesisBlkRoot, genesisState)
 
 	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, genesisState, genesisBlkRoot); err != nil {
-		log.Fatalf("Could not process genesis block for fork choice: %v", err)
+		log.WithError(err).Fatal("Could not process genesis block for fork choice")
 	}
 	s.cfg.ForkChoiceStore.SetOriginRoot(genesisBlkRoot)
 	// Set genesis as fully validated
@@ -502,11 +502,11 @@ func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db d
 
 	gState, err := db.GenesisState(ctx)
 	if err != nil {
-		log.Fatalf("Could not retrieve genesis state: %v", err)
+		log.WithError(err).Fatal("Could not retrieve genesis state")
 	}
 	gRoot, err := gState.HashTreeRoot(ctx)
 	if err != nil {
-		log.Fatalf("Could not hash tree root genesis state: %v", err)
+		log.WithError(err).Fatal("Could not hash tree root genesis state")
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
 }

beacon-chain/cache/depositcache/pending_deposits.go

@@ -100,7 +100,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 
 	depRoot, err := hash.HashProto(d)
 	if err != nil {
-		log.Errorf("Could not remove deposit %v", err)
+		log.WithError(err).Error("Could not remove deposit")
 		return
 	}
 
@@ -111,7 +111,7 @@ func (dc *DepositCache) RemovePendingDeposit(ctx context.Context, d *ethpb.Depos
 	for i, ctnr := range dc.pendingDeposits {
 		h, err := hash.HashProto(ctnr.Deposit)
 		if err != nil {
-			log.Errorf("Could not hash deposit %v", err)
+			log.WithError(err).Error("Could not hash deposit")
 			continue
 		}
 		if h == depRoot {

beacon-chain/core/blocks/deposit.go

@@ -176,7 +176,7 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verif
 			}
 			if err := verifyDepositDataSigningRoot(deposit.Data, domain); err != nil {
 				// Ignore this error as in the spec pseudo code.
-				log.Debugf("Skipping deposit: could not verify deposit data signature: %v", err)
+				log.WithError(err).Debug("Skipping deposit: could not verify deposit data signature")
 				return beaconState, newValidator, nil
 			}
 		}

beacon-chain/core/helpers/sync_committee.go

@@ -46,7 +46,7 @@ func IsCurrentPeriodSyncCommittee(
 		// Fill in the cache on miss.
 		go func() {
 			if err := syncCommitteeCache.UpdatePositionsInCommittee(root, st); err != nil {
-				log.Errorf("Could not fill sync committee cache on miss: %v", err)
+				log.WithError(err).Error("Could not fill sync committee cache on miss")
 			}
 		}()
 
@@ -110,7 +110,7 @@ func CurrentPeriodSyncSubcommitteeIndices(
 		// Fill in the cache on miss.
 		go func() {
 			if err := syncCommitteeCache.UpdatePositionsInCommittee(root, st); err != nil {
-				log.Errorf("Could not fill sync committee cache on miss: %v", err)
+				log.WithError(err).Error("Could not fill sync committee cache on miss")
 			}
 		}()
 

beacon-chain/deterministic-genesis/service.go

@@ -63,43 +63,43 @@ func (s *Service) Start() {
 	if s.cfg.GenesisPath != "" {
 		data, err := os.ReadFile(s.cfg.GenesisPath)
 		if err != nil {
-			log.Fatalf("Could not read pre-loaded state: %v", err)
+			log.WithError(err).Fatal("Could not read pre-loaded state")
 		}
 		genesisState := &ethpb.BeaconState{}
 		if err := genesisState.UnmarshalSSZ(data); err != nil {
-			log.Fatalf("Could not unmarshal pre-loaded state: %v", err)
+			log.WithError(err).Fatal("Could not unmarshal pre-loaded state")
 		}
 		genesisTrie, err := v1.InitializeFromProto(genesisState)
 		if err != nil {
-			log.Fatalf("Could not get state trie: %v", err)
+			log.WithError(err).Fatal("Could not get state trie")
 		}
 		if err := s.saveGenesisState(s.ctx, genesisTrie); err != nil {
-			log.Fatalf("Could not save interop genesis state %v", err)
+			log.WithError(err).Fatal("Could not save interop genesis state")
 		}
 		return
 	}
 
 	// Save genesis state in db
 	genesisState, _, err := interop.GenerateGenesisState(s.ctx, s.cfg.GenesisTime, s.cfg.NumValidators)
 	if err != nil {
-		log.Fatalf("Could not generate interop genesis state: %v", err)
+		log.WithError(err).Fatal("Could not generate interop genesis state")
 	}
 	genesisTrie, err := v1.InitializeFromProto(genesisState)
 	if err != nil {
-		log.Fatalf("Could not get state trie: %v", err)
+		log.WithError(err).Fatal("Could not get state trie")
 	}
 	if s.cfg.GenesisTime == 0 {
 		// Generated genesis time; fetch it
 		s.cfg.GenesisTime = genesisTrie.GenesisTime()
 	}
 	gRoot, err := genesisTrie.HashTreeRoot(s.ctx)
 	if err != nil {
-		log.Fatalf("Could not hash tree root genesis state: %v", err)
+		log.WithError(err).Fatal("Could not hash tree root genesis state")
 	}
 	go slots.CountdownToGenesis(s.ctx, time.Unix(int64(s.cfg.GenesisTime), 0), s.cfg.NumValidators, gRoot)
 
 	if err := s.saveGenesisState(s.ctx, genesisTrie); err != nil {
-		log.Fatalf("Could not save interop genesis state %v", err)
+		log.WithError(err).Fatal("Could not save interop genesis state")
 	}
 }
 

beacon-chain/execution/log_processing.go

@@ -184,7 +184,7 @@ func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethtypes.Lo
 			DepositCount: uint64(len(s.chainStartData.ChainstartDeposits)),
 		}
 		if err := s.processDeposit(ctx, eth1Data, deposit); err != nil {
-			log.Errorf("Invalid deposit processed: %v", err)
+			log.WithError(err).Error("Invalid deposit processed")
 			validData = false
 		}
 	} else {
@@ -236,7 +236,7 @@ func (s *Service) ProcessChainStart(genesisTime uint64, eth1BlockHash [32]byte,
 	for i := range s.chainStartData.ChainstartDeposits {
 		proof, err := s.depositTrie.MerkleProof(i)
 		if err != nil {
-			log.Errorf("unable to generate deposit proof %v", err)
+			log.WithError(err).Error("unable to generate deposit proof")
 		}
 		s.chainStartData.ChainstartDeposits[i].Proof = proof
 	}

beacon-chain/execution/rpc_connection.go

@@ -51,7 +51,7 @@ func (s *Service) pollConnectionStatus(ctx context.Context) {
 	logCounter := 0
 	errorLogger := func(err error, msg string) {
 		if logCounter > logThreshold {
-			log.Errorf("%s: %v", msg, err)
+			log.WithError(err).Error(msg)
 			logCounter = 0
 		}
 		logCounter++
@@ -114,7 +114,7 @@ func (s *Service) checkDefaultEndpoint(ctx context.Context) {
 
 	currClient := s.rpcClient
 	if err := s.setupExecutionClientConnections(ctx, primaryEndpoint); err != nil {
-		log.Debugf("Primary endpoint not ready: %v", err)
+		log.WithError(err).Debug("Primary endpoint not ready")
 		return
 	}
 	// Close previous client, if connection was successful.

beacon-chain/execution/service.go

@@ -552,7 +552,7 @@ func (s *Service) initPOWService() {
 	logCounter := 0
 	errorLogger := func(err error, msg string) {
 		if logCounter > logThreshold {
-			log.Errorf("%s: %v", msg, err)
+			log.WithError(err).Error(msg)
 			logCounter = 0
 		}
 		logCounter++

beacon-chain/node/node.go

@@ -345,7 +345,7 @@ func (b *BeaconNode) Close() {
 	log.Info("Stopping beacon node")
 	b.services.StopAll()
 	if err := b.db.Close(); err != nil {
-		log.Errorf("Failed to close database: %v", err)
+		log.WithError(err).Error("Failed to close database")
 	}
 	b.collector.unregister()
 	b.cancel()

beacon-chain/p2p/addr_factory.go

@@ -23,7 +23,7 @@ func withRelayAddrs(relay string) config.AddrsFactory {
 			}
 			relayAddr, err := ma.NewMultiaddr(relay + "/p2p-circuit" + a.String())
 			if err != nil {
-				log.Errorf("Failed to create multiaddress for relay node: %v", err)
+				log.WithError(err).Error("Failed to create multiaddress for relay node")
 			} else {
 				relayAddrs = append(relayAddrs, relayAddr)
 			}

beacon-chain/p2p/broadcaster.go

@@ -186,7 +186,7 @@ func (s *Service) broadcastSyncCommittee(ctx context.Context, subnet uint64, sMs
 	// In the event our sync message is outdated and beyond the
 	// acceptable threshold, we exit early and do not broadcast it.
 	if err := altair.ValidateSyncMessageTime(sMsg.Slot, s.genesisTime, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
-		log.Warnf("Sync Committee Message is too old to broadcast, discarding it. %v", err)
+		log.WithError(err).Warn("Sync Committee Message is too old to broadcast, discarding it")
 		return
 	}
 

beacon-chain/p2p/discovery.go

@@ -49,7 +49,7 @@ func (s *Service) RefreshENR() {
 	}
 	currentBitV, err := attBitvector(s.dv5Listener.Self().Record())
 	if err != nil {
-		log.Errorf("Could not retrieve att bitfield: %v", err)
+		log.WithError(err).Error("Could not retrieve att bitfield")
 		return
 	}
 	// Compare current epoch with our fork epochs
@@ -67,7 +67,7 @@ func (s *Service) RefreshENR() {
 		}
 		currentBitS, err := syncBitvector(s.dv5Listener.Self().Record())
 		if err != nil {
-			log.Errorf("Could not retrieve sync bitfield: %v", err)
+			log.WithError(err).Error("Could not retrieve sync bitfield")
 			return
 		}
 		if bytes.Equal(bitV, currentBitV) && bytes.Equal(bitS, currentBitS) &&
@@ -356,7 +356,7 @@ func parseGenericAddrs(addrs []string) (enodeString, multiAddrString []string) {
 			multiAddrString = append(multiAddrString, addr)
 			continue
 		}
-		log.Errorf("Invalid address of %s provided: %v", addr, err)
+		log.WithError(err).Errorf("Invalid address of %s provided", addr)
 	}
 	return enodeString, multiAddrString
 }

beacon-chain/p2p/gossip_scoring_params.go

@@ -196,13 +196,13 @@ func defaultAggregateTopicParams(activeValidators uint64) *pubsub.TopicScorePara
 	aggPerSlot := aggregatorsPerSlot(activeValidators)
 	firstMessageCap, err := decayLimit(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot*2/gossipSubD))
 	if err != nil {
-		log.Warnf("skipping initializing topic scoring: %v", err)
+		log.WithError(err).Warn("skipping initializing topic scoring")
 		return nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	meshThreshold, err := decayThreshold(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot)/dampeningFactor)
 	if err != nil {
-		log.Warnf("skipping initializing topic scoring: %v", err)
+		log.WithError(err).Warn("skipping initializing topic scoring")
 		return nil
 	}
 	meshWeight := -scoreByWeight(aggregateWeight, meshThreshold)
@@ -238,13 +238,13 @@ func defaultSyncContributionTopicParams() *pubsub.TopicScoreParams {
 	aggPerSlot := params.BeaconConfig().SyncCommitteeSubnetCount * params.BeaconConfig().TargetAggregatorsPerSyncSubcommittee
 	firstMessageCap, err := decayLimit(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot*2/gossipSubD))
 	if err != nil {
-		log.Warnf("skipping initializing topic scoring: %v", err)
+		log.WithError(err).Warn("skipping initializing topic scoring")
 		return nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	meshThreshold, err := decayThreshold(scoreDecay(1*oneEpochDuration()), float64(aggPerSlot)/dampeningFactor)
 	if err != nil {
-		log.Warnf("skipping initializing topic scoring: %v", err)
+		log.WithError(err).Warn("skipping initializing topic scoring")
 		return nil
 	}
 	meshWeight := -scoreByWeight(syncContributionWeight, meshThreshold)
@@ -306,14 +306,14 @@ func defaultAggregateSubnetTopicParams(activeValidators uint64) *pubsub.TopicSco
 	// Determine expected first deliveries based on the message rate.
 	firstMessageCap, err := decayLimit(scoreDecay(firstDecay*oneEpochDuration()), float64(rate))
 	if err != nil {
-		log.Warnf("skipping initializing topic scoring: %v", err)
+		log.WithError(err).Warn("skipping initializing topic scoring")
 		return nil
 	}
 	firstMessageWeight := maxFirstDeliveryScore / firstMessageCap
 	// Determine expected mesh deliveries based on message rate applied with a dampening factor.
 	meshThreshold, err := decayThreshold(scoreDecay(meshDecay*oneEpochDuration()), float64(numPerSlot)/dampeningFactor)
 	if err != nil {
-		log.Warnf("skipping initializing topic scoring: %v", err)
+		log.WithError(err).Warn("skipping initializing topic scoring")
 		return nil
 	}
 	meshWeight := -scoreByWeight(topicWeight, meshThreshold)

beacon-chain/p2p/log.go

@@ -31,7 +31,7 @@ func logExternalIPAddr(id peer.ID, addr string, port uint) {
 	if addr != "" {
 		multiAddr, err := multiAddressBuilder(addr, port)
 		if err != nil {
-			log.Errorf("Could not create multiaddress: %v", err)
+			log.WithError(err).Error("Could not create multiaddress")
 			return
 		}
 		log.WithField(

beacon-chain/p2p/options.go

@@ -20,24 +20,24 @@ func (s *Service) buildOptions(ip net.IP, priKey *ecdsa.PrivateKey) []libp2p.Opt
 	cfg := s.cfg
 	listen, err := multiAddressBuilder(ip.String(), cfg.TCPPort)
 	if err != nil {
-		log.Fatalf("Failed to p2p listen: %v", err)
+		log.WithError(err).Fatal("Failed to p2p listen")
 	}
 	if cfg.LocalIP != "" {
 		if net.ParseIP(cfg.LocalIP) == nil {
 			log.Fatalf("Invalid local ip provided: %s", cfg.LocalIP)
 		}
 		listen, err = multiAddressBuilder(cfg.LocalIP, cfg.TCPPort)
 		if err != nil {
-			log.Fatalf("Failed to p2p listen: %v", err)
+			log.WithError(err).Fatal("Failed to p2p listen")
 		}
 	}
 	ifaceKey, err := ecdsaprysm.ConvertToInterfacePrivkey(priKey)
 	if err != nil {
-		log.Fatalf("Failed to retrieve private key: %v", err)
+		log.WithError(err).Fatal("Failed to retrieve private key")
 	}
 	id, err := peer.IDFromPublicKey(ifaceKey.GetPublic())
 	if err != nil {
-		log.Fatalf("Failed to retrieve peer id: %v", err)
+		log.WithError(err).Fatal("Failed to retrieve peer id")
 	}
 	log.Infof("Running node with peer id of %s ", id.String())
 

beacon-chain/p2p/service.go

@@ -226,7 +226,7 @@ func (s *Service) Start() {
 	if len(s.cfg.StaticPeers) > 0 {
 		addrs, err := peersFromStringAddrs(s.cfg.StaticPeers)
 		if err != nil {
-			log.Errorf("Could not connect to static peer: %v", err)
+			log.WithError(err).Error("Could not connect to static peer")
 		}
 		s.connectWithAllPeers(addrs)
 	}
@@ -437,7 +437,7 @@ func (s *Service) awaitStateInitialized() {
 func (s *Service) connectWithAllPeers(multiAddrs []multiaddr.Multiaddr) {
 	addrInfos, err := peer.AddrInfosFromP2pAddrs(multiAddrs...)
 	if err != nil {
-		log.Errorf("Could not convert to peer address info's from multiaddresses: %v", err)
+		log.WithError(err).Error("Could not convert to peer address info's from multiaddresses")
 		return
 	}
 	for _, info := range addrInfos {

beacon-chain/p2p/utils.go

@@ -133,7 +133,7 @@ func metaDataFromConfig(cfg *Config) (metadata.Metadata, error) {
 func ipAddr() net.IP {
 	ip, err := network.ExternalIP()
 	if err != nil {
-		log.Fatalf("Could not get IPv4 address: %v", err)
+		log.WithError(err).Fatal("Could not get IPv4 address")
 	}
 	return net.ParseIP(ip)
 }

beacon-chain/p2p/watch_peers.go

@@ -19,7 +19,7 @@ func ensurePeerConnections(ctx context.Context, h host.Host, peers ...string) {
 		}
 		peerInfo, err := MakePeer(p)
 		if err != nil {
-			log.Errorf("Could not make peer: %v", err)
+			log.WithError(err).Error("Could not make peer")
 			continue
 		}