libs/service: pass logger explicitly (#7288)

This is a very small change, but removes a method from the
`service.Service` interface (a win!) and forces callers to explicitly
pass loggers in to objects during construction rather than (later)
injecting them. There's not a real need for this kind of lazy
construction of loggers, and I think a decent potential for confusion
for mutable loggers.

The main concern I have is that this changes the constructor API for
ABCI clients. I think this is fine, and I suspect that as we plumb
contexts through, and make changes to the RPC services there'll be a
number of similar sorts of changes to various (quasi) public
interfaces, which I think we should welcome.

internal/blocksync/pool.go

@@ -91,7 +91,13 @@ type BlockPool struct {
 
 // NewBlockPool returns a new BlockPool with the height equal to start. Block
 // requests and errors will be sent to requestsCh and errorsCh accordingly.
-func NewBlockPool(start int64, requestsCh chan<- BlockRequest, errorsCh chan<- peerError) *BlockPool {
+func NewBlockPool(
+	logger log.Logger,
+	start int64,
+	requestsCh chan<- BlockRequest,
+	errorsCh chan<- peerError,
+) *BlockPool {
+
 	bp := &BlockPool{
 		peers: make(map[types.NodeID]*bpPeer),
 
@@ -104,7 +110,7 @@ func NewBlockPool(start int64, requestsCh chan<- BlockRequest, errorsCh chan<- p
 		errorsCh:     errorsCh,
 		lastSyncRate: 0,
 	}
-	bp.BaseService = *service.NewBaseService(nil, "BlockPool", bp)
+	bp.BaseService = *service.NewBaseService(logger, "BlockPool", bp)
 	return bp
 }
 

internal/blocksync/pool_test.go

@@ -82,8 +82,7 @@ func TestBlockPoolBasic(t *testing.T) {
 	peers := makePeers(10, start+1, 1000)
 	errorsCh := make(chan peerError, 1000)
 	requestsCh := make(chan BlockRequest, 1000)
-	pool := NewBlockPool(start, requestsCh, errorsCh)
-	pool.SetLogger(log.TestingLogger())
+	pool := NewBlockPool(log.TestingLogger(), start, requestsCh, errorsCh)
 
 	err := pool.Start()
 	if err != nil {
@@ -142,8 +141,7 @@ func TestBlockPoolTimeout(t *testing.T) {
 	peers := makePeers(10, start+1, 1000)
 	errorsCh := make(chan peerError, 1000)
 	requestsCh := make(chan BlockRequest, 1000)
-	pool := NewBlockPool(start, requestsCh, errorsCh)
-	pool.SetLogger(log.TestingLogger())
+	pool := NewBlockPool(log.TestingLogger(), start, requestsCh, errorsCh)
 	err := pool.Start()
 	if err != nil {
 		t.Error(err)
@@ -210,8 +208,7 @@ func TestBlockPoolRemovePeer(t *testing.T) {
 	requestsCh := make(chan BlockRequest)
 	errorsCh := make(chan peerError)
 
-	pool := NewBlockPool(1, requestsCh, errorsCh)
-	pool.SetLogger(log.TestingLogger())
+	pool := NewBlockPool(log.TestingLogger(), 1, requestsCh, errorsCh)
 	err := pool.Start()
 	require.NoError(t, err)
 	t.Cleanup(func() {

internal/blocksync/reactor.go

@@ -127,7 +127,7 @@ func NewReactor(
 		initialState:         state,
 		blockExec:            blockExec,
 		store:                store,
-		pool:                 NewBlockPool(startHeight, requestsCh, errorsCh),
+		pool:                 NewBlockPool(logger, startHeight, requestsCh, errorsCh),
 		consReactor:          consReactor,
 		blockSync:            tmsync.NewBool(blockSync),
 		requestsCh:           requestsCh,

internal/blocksync/reactor_test.go

@@ -97,8 +97,10 @@ func (rts *reactorTestSuite) addNode(t *testing.T,
 ) {
 	t.Helper()
 
+	logger := log.TestingLogger()
+
 	rts.nodes = append(rts.nodes, nodeID)
-	rts.app[nodeID] = proxy.NewAppConns(abciclient.NewLocalCreator(&abci.BaseApplication{}), proxy.NopMetrics())
+	rts.app[nodeID] = proxy.NewAppConns(abciclient.NewLocalCreator(&abci.BaseApplication{}), logger, proxy.NopMetrics())
 	require.NoError(t, rts.app[nodeID].Start())
 
 	blockDB := dbm.NewMemDB()