service: remove exported logger from base implemenation (#7381)

internal/blocksync/pool.go

@@ -69,6 +69,8 @@ type BlockRequest struct {
 // BlockPool keeps track of the block sync peers, block requests and block responses.
 type BlockPool struct {
 	service.BaseService
+	logger log.Logger
+
 	lastAdvance time.Time
 
 	mtx tmsync.RWMutex
@@ -101,8 +103,8 @@ func NewBlockPool(
 ) *BlockPool {
 
 	bp := &BlockPool{
-		peers: make(map[types.NodeID]*bpPeer),
-
+		logger:       logger,
+		peers:        make(map[types.NodeID]*bpPeer),
 		requesters:   make(map[int64]*bpRequester),
 		height:       start,
 		startHeight:  start,
@@ -171,7 +173,7 @@ func (pool *BlockPool) removeTimedoutPeers() {
 			if curRate != 0 && curRate < minRecvRate {
 				err := errors.New("peer is not sending us data fast enough")
 				pool.sendError(err, peer.id)
-				pool.Logger.Error("SendTimeout", "peer", peer.id,
+				pool.logger.Error("SendTimeout", "peer", peer.id,
 					"reason", err,
 					"curRate", fmt.Sprintf("%d KB/s", curRate/1024),
 					"minRate", fmt.Sprintf("%d KB/s", minRecvRate/1024))
@@ -234,7 +236,7 @@ func (pool *BlockPool) PopRequest() {
 
 	if r := pool.requesters[pool.height]; r != nil {
 		if err := r.Stop(); err != nil {
-			pool.Logger.Error("Error stopping requester", "err", err)
+			pool.logger.Error("Error stopping requester", "err", err)
 		}
 		delete(pool.requesters, pool.height)
 		pool.height++
@@ -281,7 +283,7 @@ func (pool *BlockPool) AddBlock(peerID types.NodeID, block *types.Block, blockSi
 
 	requester := pool.requesters[block.Height]
 	if requester == nil {
-		pool.Logger.Error("peer sent us a block we didn't expect",
+		pool.logger.Error("peer sent us a block we didn't expect",
 			"peer", peerID, "curHeight", pool.height, "blockHeight", block.Height)
 		diff := pool.height - block.Height
 		if diff < 0 {
@@ -301,7 +303,7 @@ func (pool *BlockPool) AddBlock(peerID types.NodeID, block *types.Block, blockSi
 		}
 	} else {
 		err := errors.New("requester is different or block already exists")
-		pool.Logger.Error(err.Error(), "peer", peerID, "requester", requester.getPeerID(), "blockHeight", block.Height)
+		pool.logger.Error(err.Error(), "peer", peerID, "requester", requester.getPeerID(), "blockHeight", block.Height)
 		pool.sendError(err, peerID)
 	}
 }
@@ -332,7 +334,7 @@ func (pool *BlockPool) SetPeerRange(peerID types.NodeID, base int64, height int6
 		peer.height = height
 	} else {
 		peer = newBPPeer(pool, peerID, base, height)
-		peer.setLogger(pool.Logger.With("peer", peerID))
+		peer.logger = pool.logger.With("peer", peerID)
 		pool.peers[peerID] = peer
 	}
 
@@ -423,7 +425,7 @@ func (pool *BlockPool) makeNextRequester(ctx context.Context) {
 
 	err := request.Start(ctx)
 	if err != nil {
-		request.Logger.Error("Error starting request", "err", err)
+		request.logger.Error("Error starting request", "err", err)
 	}
 }
 
@@ -506,10 +508,6 @@ func newBPPeer(pool *BlockPool, peerID types.NodeID, base int64, height int64) *
 	return peer
 }
 
-func (peer *bpPeer) setLogger(l log.Logger) {
-	peer.logger = l
-}
-
 func (peer *bpPeer) resetMonitor() {
 	peer.recvMonitor = flowrate.New(time.Second, time.Second*40)
 	initialValue := float64(minRecvRate) * math.E
@@ -556,6 +554,7 @@ func (peer *bpPeer) onTimeout() {
 
 type bpRequester struct {
 	service.BaseService
+	logger     log.Logger
 	pool       *BlockPool
 	height     int64
 	gotBlockCh chan struct{}
@@ -568,6 +567,7 @@ type bpRequester struct {
 
 func newBPRequester(pool *BlockPool, height int64) *bpRequester {
 	bpr := &bpRequester{
+		logger:     pool.logger,
 		pool:       pool,
 		height:     height,
 		gotBlockCh: make(chan struct{}, 1),
@@ -677,7 +677,7 @@ OUTER_LOOP:
 				return
 			case <-bpr.pool.exitedCh:
 				if err := bpr.Stop(); err != nil {
-					bpr.Logger.Error("Error stopped requester", "err", err)
+					bpr.logger.Error("Error stopped requester", "err", err)
 				}
 				return
 			case peerID := <-bpr.redoCh:

internal/blocksync/reactor.go

@@ -65,6 +65,7 @@ func (e peerError) Error() string {
 // Reactor handles long-term catchup syncing.
 type Reactor struct {
 	service.BaseService
+	logger log.Logger
 
 	// immutable
 	initialState sm.State
@@ -125,6 +126,7 @@ func NewReactor(
 	errorsCh := make(chan peerError, maxPeerErrBuffer) // NOTE: The capacity should be larger than the peer count.
 
 	r := &Reactor{
+		logger:               logger,
 		initialState:         state,
 		blockExec:            blockExec,
 		store:                store,
@@ -175,7 +177,7 @@ func (r *Reactor) OnStart(ctx context.Context) error {
 func (r *Reactor) OnStop() {
 	if r.blockSync.IsSet() {
 		if err := r.pool.Stop(); err != nil {
-			r.Logger.Error("failed to stop pool", "err", err)
+			r.logger.Error("failed to stop pool", "err", err)
 		}
 	}
 
@@ -196,7 +198,7 @@ func (r *Reactor) respondToPeer(msg *bcproto.BlockRequest, peerID types.NodeID)
 	if block != nil {
 		blockProto, err := block.ToProto()
 		if err != nil {
-			r.Logger.Error("failed to convert msg to protobuf", "err", err)
+			r.logger.Error("failed to convert msg to protobuf", "err", err)
 			return
 		}
 
@@ -208,7 +210,7 @@ func (r *Reactor) respondToPeer(msg *bcproto.BlockRequest, peerID types.NodeID)
 		return
 	}
 
-	r.Logger.Info("peer requesting a block we do not have", "peer", peerID, "height", msg.Height)
+	r.logger.Info("peer requesting a block we do not have", "peer", peerID, "height", msg.Height)
 	r.blockSyncCh.Out <- p2p.Envelope{
 		To:      peerID,
 		Message: &bcproto.NoBlockResponse{Height: msg.Height},
@@ -219,7 +221,7 @@ func (r *Reactor) respondToPeer(msg *bcproto.BlockRequest, peerID types.NodeID)
 // BlockSyncChannel. It returns an error only if the Envelope.Message is unknown
 // for this channel. This should never be called outside of handleMessage.
 func (r *Reactor) handleBlockSyncMessage(envelope p2p.Envelope) error {
-	logger := r.Logger.With("peer", envelope.From)
+	logger := r.logger.With("peer", envelope.From)
 
 	switch msg := envelope.Message.(type) {
 	case *bcproto.BlockRequest:
@@ -263,7 +265,7 @@ func (r *Reactor) handleMessage(chID p2p.ChannelID, envelope p2p.Envelope) (err
 	defer func() {
 		if e := recover(); e != nil {
 			err = fmt.Errorf("panic in processing message: %v", e)
-			r.Logger.Error(
+			r.logger.Error(
 				"recovering from processing message panic",
 				"err", err,
 				"stack", string(debug.Stack()),
@@ -271,7 +273,7 @@ func (r *Reactor) handleMessage(chID p2p.ChannelID, envelope p2p.Envelope) (err
 		}
 	}()
 
-	r.Logger.Debug("received message", "message", envelope.Message, "peer", envelope.From)
+	r.logger.Debug("received message", "message", envelope.Message, "peer", envelope.From)
 
 	switch chID {
 	case BlockSyncChannel:
@@ -296,7 +298,7 @@ func (r *Reactor) processBlockSyncCh(ctx context.Context) {
 			return
 		case envelope := <-r.blockSyncCh.In:
 			if err := r.handleMessage(r.blockSyncCh.ID, envelope); err != nil {
-				r.Logger.Error("failed to process message", "ch_id", r.blockSyncCh.ID, "envelope", envelope, "err", err)
+				r.logger.Error("failed to process message", "ch_id", r.blockSyncCh.ID, "envelope", envelope, "err", err)
 				r.blockSyncCh.Error <- p2p.PeerError{
 					NodeID: envelope.From,
 					Err:    err,
@@ -307,7 +309,7 @@ func (r *Reactor) processBlockSyncCh(ctx context.Context) {
 			r.blockSyncCh.Out <- envelope
 
 		case <-r.closeCh:
-			r.Logger.Debug("stopped listening on block sync channel; closing...")
+			r.logger.Debug("stopped listening on block sync channel; closing...")
 			return
 
 		}
@@ -316,7 +318,7 @@ func (r *Reactor) processBlockSyncCh(ctx context.Context) {
 
 // processPeerUpdate processes a PeerUpdate.
 func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) {
-	r.Logger.Debug("received peer update", "peer", peerUpdate.NodeID, "status", peerUpdate.Status)
+	r.logger.Debug("received peer update", "peer", peerUpdate.NodeID, "status", peerUpdate.Status)
 
 	// XXX: Pool#RedoRequest can sometimes give us an empty peer.
 	if len(peerUpdate.NodeID) == 0 {
@@ -353,7 +355,7 @@ func (r *Reactor) processPeerUpdates(ctx context.Context) {
 			r.processPeerUpdate(peerUpdate)
 
 		case <-r.closeCh:
-			r.Logger.Debug("stopped listening on peer updates channel; closing...")
+			r.logger.Debug("stopped listening on peer updates channel; closing...")
 			return
 		}
 	}
@@ -459,7 +461,7 @@ FOR_LOOP:
 				lastAdvance                       = r.pool.LastAdvance()
 			)
 
-			r.Logger.Debug(
+			r.logger.Debug(
 				"consensus ticker",
 				"num_pending", numPending,
 				"total", lenRequesters,
@@ -468,13 +470,13 @@ FOR_LOOP:
 
 			switch {
 			case r.pool.IsCaughtUp():
-				r.Logger.Info("switching to consensus reactor", "height", height)
+				r.logger.Info("switching to consensus reactor", "height", height)
 
 			case time.Since(lastAdvance) > syncTimeout:
-				r.Logger.Error("no progress since last advance", "last_advance", lastAdvance)
+				r.logger.Error("no progress since last advance", "last_advance", lastAdvance)
 
 			default:
-				r.Logger.Info(
+				r.logger.Info(
 					"not caught up yet",
 					"height", height,
 					"max_peer_height", r.pool.MaxPeerHeight(),
@@ -484,7 +486,7 @@ FOR_LOOP:
 			}
 
 			if err := r.pool.Stop(); err != nil {
-				r.Logger.Error("failed to stop pool", "err", err)
+				r.logger.Error("failed to stop pool", "err", err)
 			}
 
 			r.blockSync.UnSet()
@@ -535,7 +537,7 @@ FOR_LOOP:
 			err := state.Validators.VerifyCommitLight(chainID, firstID, first.Height, second.LastCommit)
 			if err != nil {
 				err = fmt.Errorf("invalid last commit: %w", err)
-				r.Logger.Error(
+				r.logger.Error(
 					err.Error(),
 					"last_commit", second.LastCommit,
 					"block_id", firstID,
@@ -581,7 +583,7 @@ FOR_LOOP:
 
 				if blocksSynced%100 == 0 {
 					lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds())
-					r.Logger.Info(
+					r.logger.Info(
 						"block sync rate",
 						"height", r.pool.height,
 						"max_peer_height", r.pool.MaxPeerHeight(),