refactor: improve logging

blame/manager.go

@@ -6,7 +6,8 @@ import (
 	btss "github.com/bnb-chain/tss-lib/tss"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
+
+	"github.com/zeta-chain/go-tss/logs"
 )
 
 type Manager struct {
@@ -24,10 +25,11 @@ type Manager struct {
 	localPartyID      string
 }
 
-func NewBlameManager() *Manager {
+func NewBlameManager(logger zerolog.Logger) *Manager {
 	blame := NewBlame("", nil)
+
 	return &Manager{
-		logger:            log.With().Str("module", "blame_manager").Logger(),
+		logger:            logger.With().Str(logs.Component, "blame_manager").Logger(),
 		partyInfo:         nil,
 		PartyIDtoP2PID:    make(map[string]peer.ID),
 		lastUnicastPeer:   make(map[string][]peer.ID),

blame/policy_test.go

@@ -9,6 +9,7 @@ import (
 	btss "github.com/bnb-chain/tss-lib/tss"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/rs/zerolog"
 	. "gopkg.in/check.v1"
 
 	"github.com/zeta-chain/go-tss/conversion"
@@ -40,7 +41,7 @@ type policyTestSuite struct {
 var _ = Suite(&policyTestSuite{})
 
 func (p *policyTestSuite) SetUpTest(c *C) {
-	p.blameMgr = NewBlameManager()
+	p.blameMgr = NewBlameManager(zerolog.Nop())
 	conversion.SetupBech32Prefix()
 	p1, err := peer.Decode(testPeers[0])
 	c.Assert(err, IsNil)

cmd/tss/main.go

@@ -13,6 +13,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/input"
 	golog "github.com/ipfs/go-log"
 	"github.com/libp2p/go-libp2p/core/peer"
+	zlog "github.com/rs/zerolog/log"
 
 	"github.com/zeta-chain/go-tss/common"
 	"github.com/zeta-chain/go-tss/conversion"
@@ -44,6 +45,7 @@ func main() {
 	conversion.SetupBech32Prefix()
 	// Read stdin for the private key
 	inBuf := bufio.NewReader(os.Stdin)
+
 	priKeyBytes, err := input.GetPassword("input node secret key:", inBuf)
 	if err != nil {
 		fmt.Printf("error in get the secret key: %s\n", err.Error())
@@ -53,17 +55,23 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
+
+	networkConfig := tss.NetworkConfig{
+		TssConfig:        tssConf,
+		BootstrapPeers:   p2pConf.BootstrapPeers,
+		ExternalIP:       p2pConf.ExternalIP,
+		Port:             p2pConf.Port,
+		WhitelistedPeers: []peer.ID{},
+	}
+
 	// init tss module
 	tss, err := tss.New(
-		p2pConf.BootstrapPeers,
-		p2pConf.Port,
-		priKey,
+		networkConfig,
 		baseFolder,
-		tssConf,
-		nil,
-		p2pConf.ExternalIP,
+		priKey,
 		os.Getenv("PASSWORD"),
-		[]peer.ID{},
+		nil,
+		zlog.Logger,
 	)
 	if nil != err {
 		log.Fatal(err)

cmd/tss/tss_http.go

@@ -129,36 +129,36 @@ func (t *HTTPServer) keySignHandler(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusMethodNotAllowed)
 		return
 	}
+
 	defer func() {
 		if err := r.Body.Close(); nil != err {
 			t.logger.Error().Err(err).Msg("fail to close request body")
 		}
 	}()
-	t.logger.Info().Msg("receive key sign request")
 
 	var keySignReq keysign.Request
-	decoder := json.NewDecoder(r.Body)
-	if err := decoder.Decode(&keySignReq); nil != err {
+
+	if err := json.NewDecoder(r.Body).Decode(&keySignReq); nil != err {
 		t.logger.Error().Err(err).Msg("fail to decode key sign request")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
-	t.logger.Info().Msgf("request:%+v", keySignReq)
+
 	signResp, err := t.tssServer.KeySign(keySignReq)
 	if err != nil {
 		t.logger.Error().Err(err).Msg("fail to key sign")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	jsonResult, err := json.MarshalIndent(signResp, "", "	")
+	jsonResult, err := json.MarshalIndent(signResp, "", "  ")
 	if err != nil {
 		t.logger.Error().Err(err).Msg("fail to marshal response to json message")
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-	_, err = w.Write(jsonResult)
-	if err != nil {
+
+	if _, err = w.Write(jsonResult); err != nil {
 		t.logger.Error().Err(err).Msg("fail to write response")
 	}
 }

common/tss.go

@@ -13,7 +13,6 @@ import (
 	"github.com/cometbft/cometbft/crypto/secp256k1"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 
 	"github.com/zeta-chain/go-tss/blame"
 	"github.com/zeta-chain/go-tss/conversion"
@@ -60,10 +59,11 @@ func NewTssCommon(
 	msgID string,
 	privKey tcrypto.PrivKey,
 	msgNum int,
+	logger zerolog.Logger,
 ) *TssCommon {
 	return &TssCommon{
 		conf:                        conf,
-		logger:                      log.With().Str("module", "tsscommon").Logger(),
+		logger:                      logger,
 		partyLock:                   &sync.Mutex{},
 		partyInfo:                   nil,
 		PartyIDtoP2PID:              make(map[string]peer.ID),
@@ -77,7 +77,7 @@ func NewTssCommon(
 		localPeerID:                 peerID,
 		privateKey:                  privKey,
 		taskDone:                    make(chan struct{}),
-		blameMgr:                    blame.NewBlameManager(),
+		blameMgr:                    blame.NewBlameManager(logger),
 		finishedPeers:               make(map[string]bool),
 		culpritsLock:                &sync.RWMutex{},
 		cachedWireBroadcastMsgLists: &sync.Map{},
@@ -139,7 +139,7 @@ func (t *TssCommon) doTssJob(tssJobChan chan *tssJob, jobWg *sync.WaitGroup) {
 		_, errUp := party.UpdateFromBytes(wireBytes, partyID, isBroadcast)
 		if errUp != nil {
 			err := t.processInvalidMsgBlame(round.RoundMsg, round, errUp)
-			t.logger.Error().Err(err).Msgf("fail to apply the share to tss")
+			t.logger.Error().Err(err).Msg("fail to apply the share to tss")
 			continue
 		}
 		// we need to retrieve the partylist again as others may update it once we process apply tss share
@@ -204,7 +204,7 @@ func (t *TssCommon) processInvalidMsgBlame(roundInfo string, round blame.RoundIn
 	}
 	pubkeys, errBlame := conversion.AccPubKeysFromPartyIDs(culpritsID, t.partyInfo.PartyIDMap)
 	if errBlame != nil {
-		t.logger.Error().Err(err.Cause()).Msgf("error in get the blame nodes")
+		t.logger.Error().Err(err.Cause()).Msg("error in get the blame nodes")
 		t.blameMgr.GetBlame().SetBlame(blame.TssBrokenMsg, nil, unicast, roundInfo)
 		return fmt.Errorf("error in getting the blame nodes")
 	}
@@ -603,7 +603,7 @@ func (t *TssCommon) applyShare(
 
 		blamePk, err := t.blameMgr.TssWrongShareBlame(localCacheItem.Msg)
 		if err != nil {
-			t.logger.Error().Err(err).Msgf("error in get the blame nodes")
+			t.logger.Error().Err(err).Msg("error in get the blame nodes")
 			t.blameMgr.GetBlame().SetBlame(blame.HashCheckFail, nil, unicast, t.RoundInfo)
 			return fmt.Errorf("error in getting the blame nodes %w", blame.ErrHashCheck)
 		}

common/tss_helper_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/cometbft/cometbft/crypto/secp256k1"
 	sdk "github.com/cosmos/cosmos-sdk/types/bech32/legacybech32"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/rs/zerolog"
 	. "gopkg.in/check.v1"
 
 	"github.com/zeta-chain/go-tss/blame"
@@ -70,7 +71,7 @@ func (t *tssHelpSuite) TestTssCommon_NotifyTaskDone(c *C) {
 	peerID, err := conversion.GetPeerIDFromSecp256PubKey(pk.Bytes())
 	c.Assert(err, IsNil)
 	sk := secp256k1.GenPrivKey()
-	tssCommon := NewTssCommon(peerID.String(), nil, TssConfig{}, "message-id", sk, 1)
+	tssCommon := NewTssCommon(peerID.String(), nil, TssConfig{}, "message-id", sk, 1, zerolog.Nop())
 	err = tssCommon.NotifyTaskDone()
 	c.Assert(err, IsNil)
 }
@@ -86,7 +87,7 @@ func (t *tssHelpSuite) TestTssCommon_processRequestMsgFromPeer(c *C) {
 	sk := secp256k1.GenPrivKey()
 	testPeer, err := peer.Decode("16Uiu2HAm2FzqoUdS6Y9Esg2EaGcAG5rVe1r6BFNnmmQr2H3bqafa")
 	c.Assert(err, IsNil)
-	tssCommon := NewTssCommon(peerID.String(), nil, TssConfig{}, "message-id", sk, 1)
+	tssCommon := NewTssCommon(peerID.String(), nil, TssConfig{}, "message-id", sk, 1, zerolog.Nop())
 	err = tssCommon.processRequestMsgFromPeer([]peer.ID{testPeer}, nil, true)
 	c.Assert(err, IsNil)
 	err = tssCommon.processRequestMsgFromPeer([]peer.ID{testPeer}, nil, false)

common/tss_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/cometbft/cometbft/crypto/secp256k1"
 	coskey "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	sdk "github.com/cosmos/cosmos-sdk/types/bech32/legacybech32"
+	"github.com/rs/zerolog/log"
 	. "gopkg.in/check.v1"
 
 	"github.com/btcsuite/btcd/btcec/v2"
@@ -136,7 +137,7 @@ func (t *TssTestSuite) TestTssProcessOutCh(c *C) {
 	}
 	msg := btss.NewMessageWrapper(messageRouting, testContent)
 	tssMsg := btss.NewMessage(messageRouting, testContent, msg)
-	tssCommonStruct := NewTssCommon("", nil, conf, "test", t.privKey, 1)
+	tssCommonStruct := NewTssCommon("", nil, conf, "test", t.privKey, 1, log.Logger)
 	err = tssCommonStruct.ProcessOutCh(tssMsg, messages.TSSKeyGenMsg)
 	c.Assert(err, IsNil)
 }
@@ -230,7 +231,7 @@ func setupProcessVerMsgEnv(
 	partyNum int,
 ) (*TssCommon, []*btss.PartyID, []*btss.PartyID) {
 	conf := TssConfig{}
-	tssCommonStruct := NewTssCommon("", nil, conf, "test", privKey, 1)
+	tssCommonStruct := NewTssCommon("", nil, conf, "test", privKey, 1, log.Logger)
 	localTestPubKeys := make([]string, partyNum)
 	copy(localTestPubKeys, keyPool[:partyNum])
 	// for the test, we choose the first pubic key as the test instance public key
@@ -479,7 +480,7 @@ func (t *TssTestSuite) TestTssCommon(c *C) {
 	c.Assert(err, IsNil)
 	broadcastChannel := make(chan *messages.BroadcastMsgChan)
 	sk := secp256k1.GenPrivKey()
-	tssCommon := NewTssCommon(peerID.String(), broadcastChannel, TssConfig{}, "message-id", sk, 1)
+	tssCommon := NewTssCommon(peerID.String(), broadcastChannel, TssConfig{}, "message-id", sk, 1, log.Logger)
 	c.Assert(tssCommon, NotNil)
 	stopchan := make(chan struct{})
 	wg := sync.WaitGroup{}

keygen/ecdsa/keygen_test.go

@@ -124,13 +124,13 @@ func (s *TssECDSAKeygenTestSuite) SetUpTest(c *C) {
 		buf, err := base64.StdEncoding.DecodeString(testPriKeyArr[i])
 		c.Assert(err, IsNil)
 		if i == 0 {
-			comm, err := p2p.NewCommunication(nil, ports[i], "", whitelistedPeers)
+			comm, err := p2p.NewCommunication(nil, ports[i], "", whitelistedPeers, zlog.Logger)
 			c.Assert(err, IsNil)
 			c.Assert(comm.Start(buf[:]), IsNil)
 			s.comms[i] = comm
 			continue
 		}
-		comm, err := p2p.NewCommunication(bootstrapPeers, ports[i], "", whitelistedPeers)
+		comm, err := p2p.NewCommunication(bootstrapPeers, ports[i], "", whitelistedPeers, zlog.Logger)
 		c.Assert(err, IsNil)
 		c.Assert(comm.Start(buf[:]), IsNil)
 		s.comms[i] = comm
@@ -199,7 +199,11 @@ func (s *TssECDSAKeygenTestSuite) TestGenerateNewKey(c *C) {
 				stopChan,
 				s.preParams[idx],
 				messageID,
-				s.stateMgrs[idx], s.nodePrivKeys[idx], s.comms[idx])
+				s.stateMgrs[idx],
+				s.nodePrivKeys[idx],
+				s.comms[idx],
+				zlog.Logger,
+			)
 			c.Assert(keygenInstance, NotNil)
 			keygenMsgChannel := keygenInstance.GetTssKeyGenChannels()
 			comm.SetSubscribe(messages.TSSKeyGenMsg, messageID, keygenMsgChannel)
@@ -254,7 +258,10 @@ func (s *TssECDSAKeygenTestSuite) TestGenerateNewKeyWithStop(c *C) {
 				s.preParams[idx],
 				messageID,
 				s.stateMgrs[idx],
-				s.nodePrivKeys[idx], s.comms[idx])
+				s.nodePrivKeys[idx],
+				s.comms[idx],
+				zlog.Logger,
+			)
 			c.Assert(keygenInstance, NotNil)
 			keygenMsgChannel := keygenInstance.GetTssKeyGenChannels()
 			comm.SetSubscribe(messages.TSSKeyGenMsg, messageID, keygenMsgChannel)
@@ -290,7 +297,19 @@ func (s *TssECDSAKeygenTestSuite) TestKeyGenWithError(c *C) {
 	}
 	conf := common.TssConfig{}
 	stateManager := &storage.MockLocalStateManager{}
-	keyGenInstance := NewTssKeyGen("", conf, "", nil, nil, nil, "test", stateManager, s.nodePrivKeys[0], nil)
+	keyGenInstance := NewTssKeyGen(
+		"",
+		conf,
+		"",
+		nil,
+		nil,
+		nil,
+		"test",
+		stateManager,
+		s.nodePrivKeys[0],
+		nil,
+		zlog.Logger,
+	)
 	generatedKey, err := keyGenInstance.GenerateNewKey(req)
 	c.Assert(err, NotNil)
 	c.Assert(generatedKey, IsNil)
@@ -299,7 +318,19 @@ func (s *TssECDSAKeygenTestSuite) TestKeyGenWithError(c *C) {
 func (s *TssECDSAKeygenTestSuite) TestCloseKeyGenNotifyChannel(c *C) {
 	conf := common.TssConfig{}
 	stateManager := &storage.MockLocalStateManager{}
-	keyGenInstance := NewTssKeyGen("", conf, "", nil, nil, nil, "test", stateManager, s.nodePrivKeys[0], s.comms[0])
+	keyGenInstance := NewTssKeyGen(
+		"",
+		conf,
+		"",
+		nil,
+		nil,
+		nil,
+		"test",
+		stateManager,
+		s.nodePrivKeys[0],
+		s.comms[0],
+		zlog.Logger,
+	)
 
 	taskDone := messages.TssTaskNotifier{TaskDone: true}
 	taskDoneBytes, err := json.Marshal(taskDone)

keygen/ecdsa/tss_keygen.go

@@ -13,12 +13,12 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	tcrypto "github.com/cometbft/cometbft/crypto"
 	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 
 	"github.com/zeta-chain/go-tss/blame"
 	"github.com/zeta-chain/go-tss/common"
 	"github.com/zeta-chain/go-tss/conversion"
 	"github.com/zeta-chain/go-tss/keygen"
+	"github.com/zeta-chain/go-tss/logs"
 	"github.com/zeta-chain/go-tss/messages"
 	"github.com/zeta-chain/go-tss/p2p"
 	"github.com/zeta-chain/go-tss/storage"
@@ -36,7 +36,8 @@ type TssKeyGen struct {
 	p2pComm         *p2p.Communication
 }
 
-func NewTssKeyGen(localP2PID string,
+func NewTssKeyGen(
+	localP2PID string,
 	conf common.TssConfig,
 	localNodePubKey string,
 	broadcastChan chan *messages.BroadcastMsgChan,
@@ -45,14 +46,19 @@ func NewTssKeyGen(localP2PID string,
 	msgID string,
 	stateManager storage.LocalStateManager,
 	privateKey tcrypto.PrivKey,
-	p2pComm *p2p.Communication) *TssKeyGen {
+	p2pComm *p2p.Communication,
+	logger zerolog.Logger,
+) *TssKeyGen {
+	logger = logger.With().
+		Str(logs.Component, "keygen").
+		Str(logs.MsgID, msgID).
+		Logger()
+
 	return &TssKeyGen{
-		logger: log.With().
-			Str("module", "keygen").
-			Str("msgID", msgID).Logger(),
+		logger:          logger,
 		localNodePubKey: localNodePubKey,
 		preParams:       preParam,
-		tssCommonStruct: common.NewTssCommon(localP2PID, broadcastChan, conf, msgID, privateKey, 1),
+		tssCommonStruct: common.NewTssCommon(localP2PID, broadcastChan, conf, msgID, privateKey, 1, logger),
 		stopChan:        stopChan,
 		localParty:      nil,
 		stateManager:    stateManager,