logging: remove reamining instances of SetLogger interface (#7572)

rpc/jsonrpc/client/integration_test.go

@@ -8,6 +8,7 @@ package client
 
 import (
 	"bytes"
+	"context"
 	"errors"
 	"net"
 	"regexp"
@@ -15,34 +16,33 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/libs/log"
 )
 
 func TestWSClientReconnectWithJitter(t *testing.T) {
 	n := 8
-	maxReconnectAttempts := 3
+	var maxReconnectAttempts uint = 3
 	// Max wait time is ceil(1+0.999) + ceil(2+0.999) + ceil(4+0.999) + ceil(...) = 2 + 3 + 5 = 10s + ...
 	maxSleepTime := time.Second * time.Duration(((1<<uint(maxReconnectAttempts))-1)+maxReconnectAttempts)
 
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
 	var errNotConnected = errors.New("not connected")
 	clientMap := make(map[int]*WSClient)
 	buf := new(bytes.Buffer)
-	logger := log.NewTMLogger(buf)
 	for i := 0; i < n; i++ {
 		c, err := NewWS("tcp://foo", "/websocket")
 		require.NoError(t, err)
 		c.Dialer = func(string, string) (net.Conn, error) {
 			return nil, errNotConnected
 		}
-		c.SetLogger(logger)
 		c.maxReconnectAttempts = maxReconnectAttempts
 		// Not invoking defer c.Stop() because
 		// after all the reconnect attempts have been
 		// exhausted, c.Stop is implicitly invoked.
 		clientMap[i] = c
 		// Trigger the reconnect routine that performs exponential backoff.
-		go c.reconnect()
+		go c.reconnect(ctx)
 	}
 
 	stopCount := 0

rpc/jsonrpc/jsonrpc_test.go

@@ -107,8 +107,7 @@ func setup(ctx context.Context) error {
 	tcpLogger := logger.With("socket", "tcp")
 	mux := http.NewServeMux()
 	server.RegisterRPCFuncs(mux, Routes, tcpLogger)
-	wm := server.NewWebsocketManager(Routes, server.ReadWait(5*time.Second), server.PingPeriod(1*time.Second))
-	wm.SetLogger(tcpLogger)
+	wm := server.NewWebsocketManager(tcpLogger, Routes, server.ReadWait(5*time.Second), server.PingPeriod(1*time.Second))
 	mux.HandleFunc(websocketEndpoint, wm.WebsocketHandler)
 	config := server.DefaultConfig()
 	listener1, err := server.Listen(tcpAddr, config.MaxOpenConnections)
@@ -124,8 +123,7 @@ func setup(ctx context.Context) error {
 	unixLogger := logger.With("socket", "unix")
 	mux2 := http.NewServeMux()
 	server.RegisterRPCFuncs(mux2, Routes, unixLogger)
-	wm = server.NewWebsocketManager(Routes)
-	wm.SetLogger(unixLogger)
+	wm = server.NewWebsocketManager(unixLogger, Routes)
 	mux2.HandleFunc(websocketEndpoint, wm.WebsocketHandler)
 	listener2, err := server.Listen(unixAddr, config.MaxOpenConnections)
 	if err != nil {

rpc/jsonrpc/server/ws_handler.go

@@ -41,6 +41,7 @@ type WebsocketManager struct {
 // NewWebsocketManager returns a new WebsocketManager that passes a map of
 // functions, connection options and logger to new WS connections.
 func NewWebsocketManager(
+	logger log.Logger,
 	funcMap map[string]*RPCFunc,
 	wsConnOptions ...func(*wsConnection),
 ) *WebsocketManager {
@@ -60,16 +61,11 @@ func NewWebsocketManager(
 				return true
 			},
 		},
-		logger:        log.NewNopLogger(),
+		logger:        logger,
 		wsConnOptions: wsConnOptions,
 	}
 }
 
-// SetLogger sets the logger.
-func (wm *WebsocketManager) SetLogger(l log.Logger) {
-	wm.logger = l
-}
-
 // WebsocketHandler upgrades the request/response (via http.Hijack) and starts
 // the wsConnection.
 func (wm *WebsocketManager) WebsocketHandler(w http.ResponseWriter, r *http.Request) {

rpc/jsonrpc/server/ws_handler_test.go

@@ -49,9 +49,7 @@ func newWSServer(t *testing.T, logger log.Logger) *httptest.Server {
 	funcMap := map[string]*RPCFunc{
 		"c": NewWSRPCFunc(func(ctx context.Context, s string, i int) (string, error) { return "foo", nil }, "s,i"),
 	}
-	wm := NewWebsocketManager(funcMap)
-
-	wm.SetLogger(logger)
+	wm := NewWebsocketManager(logger, funcMap)
 
 	mux := http.NewServeMux()
 	mux.HandleFunc("/websocket", wm.WebsocketHandler)