Merge pull request #535 from tendermint/bugfix/fix-invalid-logger-keys

Fix invalid logger keys

blockchain/reactor.go

@@ -128,7 +128,7 @@ func (bcR *BlockchainReactor) RemovePeer(peer *p2p.Peer, reason interface{}) {
 func (bcR *BlockchainReactor) Receive(chID byte, src *p2p.Peer, msgBytes []byte) {
 	_, msg, err := DecodeMessage(msgBytes)
 	if err != nil {
-		bcR.Logger.Error("Error decoding message", "error", err)
+		bcR.Logger.Error("Error decoding message", "err", err)
 		return
 	}
 
@@ -231,7 +231,7 @@ FOR_LOOP:
 				err := bcR.state.Validators.VerifyCommit(
 					bcR.state.ChainID, types.BlockID{first.Hash(), firstPartsHeader}, first.Height, second.LastCommit)
 				if err != nil {
-					bcR.Logger.Info("error in validation", "error", err)
+					bcR.Logger.Info("error in validation", "err", err)
 					bcR.pool.RedoRequest(first.Height)
 					break SYNC_LOOP
 				} else {

consensus/reactor.go

@@ -154,7 +154,7 @@ func (conR *ConsensusReactor) Receive(chID byte, src *p2p.Peer, msgBytes []byte)
 
 	_, msg, err := DecodeMessage(msgBytes)
 	if err != nil {
-		conR.Logger.Error("Error decoding message", "src", src, "chId", chID, "msg", msg, "error", err, "bytes", msgBytes)
+		conR.Logger.Error("Error decoding message", "src", src, "chId", chID, "msg", msg, "err", err, "bytes", msgBytes)
 		// TODO punish peer?
 		return
 	}
@@ -282,7 +282,7 @@ func (conR *ConsensusReactor) Receive(chID byte, src *p2p.Peer, msgBytes []byte)
 	}
 
 	if err != nil {
-		conR.Logger.Error("Error in Receive()", "error", err)
+		conR.Logger.Error("Error in Receive()", "err", err)
 	}
 }
 
@@ -412,7 +412,7 @@ OUTER_LOOP:
 				// Ensure that the peer's PartSetHeader is correct
 				blockMeta := conR.conS.blockStore.LoadBlockMeta(prs.Height)
 				if blockMeta == nil {
-					logger.Error("Failed to load block meta", "peer height", prs.Height, "our height", rs.Height, "blockstore height", conR.conS.blockStore.Height(), "pv", conR.conS.privValidator)
+					logger.Error("Failed to load block meta", "peer height", prs.Height, "ourHeight", rs.Height, "blockstoreHeight", conR.conS.blockStore.Height(), "pv", conR.conS.privValidator)
 					time.Sleep(peerGossipSleepDuration)
 					continue OUTER_LOOP
 				} else if !blockMeta.BlockID.PartsHeader.Equals(prs.ProposalBlockPartsHeader) {

consensus/state.go

@@ -311,7 +311,7 @@ func (cs *ConsensusState) OnStart() error {
 
 	walFile := cs.config.WalFile()
 	if err := cs.OpenWAL(walFile); err != nil {
-		cs.Logger.Error("Error loading ConsensusState wal", "error", err.Error())
+		cs.Logger.Error("Error loading ConsensusState wal", "err", err.Error())
 		return err
 	}
 
@@ -325,7 +325,7 @@ func (cs *ConsensusState) OnStart() error {
 	// we may have lost some votes if the process crashed
 	// reload from consensus log to catchup
 	if err := cs.catchupReplay(cs.Height); err != nil {
-		cs.Logger.Error("Error on catchup replay. Proceeding to start ConsensusState anyway", "error", err.Error())
+		cs.Logger.Error("Error on catchup replay. Proceeding to start ConsensusState anyway", "err", err.Error())
 		// NOTE: if we ever do return an error here,
 		// make sure to stop the timeoutTicker
 	}
@@ -368,7 +368,7 @@ func (cs *ConsensusState) Wait() {
 func (cs *ConsensusState) OpenWAL(walFile string) (err error) {
 	err = cmn.EnsureDir(path.Dir(walFile), 0700)
 	if err != nil {
-		cs.Logger.Error("Error ensuring ConsensusState wal dir", "error", err.Error())
+		cs.Logger.Error("Error ensuring ConsensusState wal dir", "err", err.Error())
 		return err
 	}
 
@@ -663,7 +663,7 @@ func (cs *ConsensusState) handleMsg(mi msgInfo, rs RoundState) {
 		cs.Logger.Error("Unknown msg type", reflect.TypeOf(msg))
 	}
 	if err != nil {
-		cs.Logger.Error("Error with msg", "type", reflect.TypeOf(msg), "peer", peerKey, "error", err, "msg", msg)
+		cs.Logger.Error("Error with msg", "type", reflect.TypeOf(msg), "peer", peerKey, "err", err, "msg", msg)
 	}
 }
 
@@ -831,7 +831,7 @@ func (cs *ConsensusState) defaultDecideProposal(height, round int) {
 		cs.Logger.Debug(cmn.Fmt("Signed proposal block: %v", block))
 	} else {
 		if !cs.replayMode {
-			cs.Logger.Error("enterPropose: Error signing proposal", "height", height, "round", round, "error", err)
+			cs.Logger.Error("enterPropose: Error signing proposal", "height", height, "round", round, "err", err)
 		}
 	}
 }
@@ -930,7 +930,7 @@ func (cs *ConsensusState) defaultDoPrevote(height int, round int) {
 	err := cs.state.ValidateBlock(cs.ProposalBlock)
 	if err != nil {
 		// ProposalBlock is invalid, prevote nil.
-		cs.Logger.Error("enterPrevote: ProposalBlock is invalid", "error", err)
+		cs.Logger.Error("enterPrevote: ProposalBlock is invalid", "err", err)
 		cs.signAddVote(types.VoteTypePrevote, nil, types.PartSetHeader{})
 		return
 	}
@@ -1218,7 +1218,7 @@ func (cs *ConsensusState) finalizeCommit(height int) {
 	// NOTE: the block.AppHash wont reflect these txs until the next block
 	err := stateCopy.ApplyBlock(eventCache, cs.proxyAppConn, block, blockParts.Header(), cs.mempool)
 	if err != nil {
-		cs.Logger.Error("Error on ApplyBlock. Did the application crash? Please restart tendermint", "error", err)
+		cs.Logger.Error("Error on ApplyBlock. Did the application crash? Please restart tendermint", "err", err)
 		return
 	}
 
@@ -1350,7 +1350,7 @@ func (cs *ConsensusState) tryAddVote(vote *types.Vote, peerKey string) error {
 			return err
 		} else {
 			// Probably an invalid signature. Bad peer.
-			cs.Logger.Error("Error attempting to add vote", "error", err)
+			cs.Logger.Error("Error attempting to add vote", "err", err)
 			return ErrAddingVote
 		}
 	}
@@ -1491,11 +1491,11 @@ func (cs *ConsensusState) signAddVote(type_ byte, hash []byte, header types.Part
 	vote, err := cs.signVote(type_, hash, header)
 	if err == nil {
 		cs.sendInternalMessage(msgInfo{&VoteMessage{vote}, ""})
-		cs.Logger.Info("Signed and pushed vote", "height", cs.Height, "round", cs.Round, "vote", vote, "error", err)
+		cs.Logger.Info("Signed and pushed vote", "height", cs.Height, "round", cs.Round, "vote", vote, "err", err)
 		return vote
 	} else {
 		//if !cs.replayMode {
-		cs.Logger.Error("Error signing vote", "height", cs.Height, "round", cs.Round, "vote", vote, "error", err)
+		cs.Logger.Error("Error signing vote", "height", cs.Height, "round", cs.Round, "vote", vote, "err", err)
 		//}
 		return nil
 	}

mempool/reactor.go

@@ -63,7 +63,7 @@ func (memR *MempoolReactor) RemovePeer(peer *p2p.Peer, reason interface{}) {
 func (memR *MempoolReactor) Receive(chID byte, src *p2p.Peer, msgBytes []byte) {
 	_, msg, err := DecodeMessage(msgBytes)
 	if err != nil {
-		memR.Logger.Error("Error decoding message", "error", err)
+		memR.Logger.Error("Error decoding message", "err", err)
 		return
 	}
 	memR.Logger.Debug("Receive", "src", src, "chId", chID, "msg", msg)

node/node.go

@@ -205,7 +205,7 @@ func NewNode(config *cfg.Config, privValidator *types.PrivValidator, clientCreat
 	if profileHost != "" {
 
 		go func() {
-			logger.Error("Profile server", "error", http.ListenAndServe(profileHost, nil))
+			logger.Error("Profile server", "err", http.ListenAndServe(profileHost, nil))
 		}()
 	}
 
@@ -276,7 +276,7 @@ func (n *Node) OnStop() {
 	for _, l := range n.rpcListeners {
 		n.Logger.Info("Closing rpc listener", "listener", l)
 		if err := l.Close(); err != nil {
-			n.Logger.Error("Error closing listener", "listener", l, "error", err)
+			n.Logger.Error("Error closing listener", "listener", l, "err", err)
 		}
 	}
 }

p2p/addrbook.go

@@ -340,7 +340,7 @@ func (a *AddrBook) saveToFile(filePath string) {
 	}
 	err = cmn.WriteFileAtomic(filePath, jsonBytes, 0644)
 	if err != nil {
-		a.Logger.Error("Failed to save AddrBook to file", "file", filePath, "error", err)
+		a.Logger.Error("Failed to save AddrBook to file", "file", filePath, "err", err)
 	}
 }
 

p2p/connection.go

@@ -180,7 +180,7 @@ func (c *MConnection) flush() {
 	c.Logger.Debug("Flush", "conn", c)
 	err := c.bufWriter.Flush()
 	if err != nil {
-		c.Logger.Error("MConnection flush failed", "error", err)
+		c.Logger.Error("MConnection flush failed", "err", err)
 	}
 }
 
@@ -318,7 +318,7 @@ FOR_LOOP:
 			break FOR_LOOP
 		}
 		if err != nil {
-			c.Logger.Error("Connection failed @ sendRoutine", "conn", c, "error", err)
+			c.Logger.Error("Connection failed @ sendRoutine", "conn", c, "err", err)
 			c.stopForError(err)
 			break FOR_LOOP
 		}
@@ -373,7 +373,7 @@ func (c *MConnection) sendMsgPacket() bool {
 	// Make & send a msgPacket from this channel
 	n, err := leastChannel.writeMsgPacketTo(c.bufWriter)
 	if err != nil {
-		c.Logger.Error("Failed to write msgPacket", "error", err)
+		c.Logger.Error("Failed to write msgPacket", "err", err)
 		c.stopForError(err)
 		return true
 	}
@@ -401,7 +401,7 @@ FOR_LOOP:
 					if err == nil {
 						return bytes
 					} else {
-						log.Warn("Error peeking connection buffer", "error", err)
+						log.Warn("Error peeking connection buffer", "err", err)
 						return nil
 					}
 				}})
@@ -415,7 +415,7 @@ FOR_LOOP:
 		c.recvMonitor.Update(int(n))
 		if err != nil {
 			if c.IsRunning() {
-				c.Logger.Error("Connection failed @ recvRoutine (reading byte)", "conn", c, "error", err)
+				c.Logger.Error("Connection failed @ recvRoutine (reading byte)", "conn", c, "err", err)
 				c.stopForError(err)
 			}
 			break FOR_LOOP
@@ -436,7 +436,7 @@ FOR_LOOP:
 			c.recvMonitor.Update(int(n))
 			if err != nil {
 				if c.IsRunning() {
-					c.Logger.Error("Connection failed @ recvRoutine", "conn", c, "error", err)
+					c.Logger.Error("Connection failed @ recvRoutine", "conn", c, "err", err)
 					c.stopForError(err)
 				}
 				break FOR_LOOP
@@ -448,7 +448,7 @@ FOR_LOOP:
 			msgBytes, err := channel.recvMsgPacket(pkt)
 			if err != nil {
 				if c.IsRunning() {
-					c.Logger.Error("Connection failed @ recvRoutine", "conn", c, "error", err)
+					c.Logger.Error("Connection failed @ recvRoutine", "conn", c, "err", err)
 					c.stopForError(err)
 				}
 				break FOR_LOOP

p2p/listener.go

@@ -171,13 +171,13 @@ func getUPNPExternalAddress(externalPort, internalPort int, logger log.Logger) *
 	logger.Info("Getting UPNP external address")
 	nat, err := upnp.Discover()
 	if err != nil {
-		logger.Info("Could not perform UPNP discover", "error", err)
+		logger.Info("Could not perform UPNP discover", "err", err)
 		return nil
 	}
 
 	ext, err := nat.GetExternalAddress()
 	if err != nil {
-		logger.Info("Could not get UPNP external address", "error", err)
+		logger.Info("Could not get UPNP external address", "err", err)
 		return nil
 	}
 
@@ -188,7 +188,7 @@ func getUPNPExternalAddress(externalPort, internalPort int, logger log.Logger) *
 
 	externalPort, err = nat.AddPortMapping("tcp", externalPort, internalPort, "tendermint", 0)
 	if err != nil {
-		logger.Info("Could not add UPNP port mapping", "error", err)
+		logger.Info("Could not add UPNP port mapping", "err", err)
 		return nil
 	}
 

p2p/pex_reactor.go

@@ -105,7 +105,7 @@ func (r *PEXReactor) AddPeer(p *Peer) {
 		addr, err := NewNetAddressString(p.ListenAddr)
 		if err != nil {
 			// this should never happen
-			r.Logger.Error("Error in AddPeer: invalid peer address", "addr", p.ListenAddr, "error", err)
+			r.Logger.Error("Error in AddPeer: invalid peer address", "addr", p.ListenAddr, "err", err)
 			return
 		}
 		r.book.AddAddress(addr, addr)
@@ -132,7 +132,7 @@ func (r *PEXReactor) Receive(chID byte, src *Peer, msgBytes []byte) {
 
 	_, msg, err := DecodeMessage(msgBytes)
 	if err != nil {
-		r.Logger.Error("Error decoding message", "error", err)
+		r.Logger.Error("Error decoding message", "err", err)
 		return
 	}
 	r.Logger.Info("Received message", "msg", msg)

p2p/switch.go

@@ -309,7 +309,7 @@ func (sw *Switch) DialSeeds(addrBook *AddrBook, seeds []string) error {
 func (sw *Switch) dialSeed(addr *NetAddress) {
 	peer, err := sw.DialPeerWithAddress(addr, true)
 	if err != nil {
-		sw.Logger.Error("Error dialing seed", "error", err)
+		sw.Logger.Error("Error dialing seed", "err", err)
 	} else {
 		sw.Logger.Info("Connected to seed", "peer", peer)
 	}
@@ -322,7 +322,7 @@ func (sw *Switch) DialPeerWithAddress(addr *NetAddress, persistent bool) (*Peer,
 	sw.Logger.Info("Dialing peer", "address", addr)
 	peer, err := newOutboundPeerWithConfig(addr, sw.reactorsByCh, sw.chDescs, sw.StopPeerForError, sw.nodePrivKey, sw.peerConfig)
 	if err != nil {
-		sw.Logger.Error("Failed to dial peer", "address", addr, "error", err)
+		sw.Logger.Error("Failed to dial peer", "address", addr, "err", err)
 		return nil, err
 	}
 	peer.SetLogger(sw.Logger.With("peer", addr))
@@ -331,7 +331,7 @@ func (sw *Switch) DialPeerWithAddress(addr *NetAddress, persistent bool) (*Peer,
 	}
 	err = sw.AddPeer(peer)
 	if err != nil {
-		sw.Logger.Error("Failed to add peer", "address", addr, "error", err)
+		sw.Logger.Error("Failed to add peer", "address", addr, "err", err)
 		peer.CloseConn()
 		return nil, err
 	}
@@ -381,7 +381,7 @@ func (sw *Switch) Peers() IPeerSet {
 // TODO: make record depending on reason.
 func (sw *Switch) StopPeerForError(peer *Peer, reason interface{}) {
 	addr := NewNetAddress(peer.Addr())
-	sw.Logger.Info("Stopping peer for error", "peer", peer, "error", reason)
+	sw.Logger.Info("Stopping peer for error", "peer", peer, "err", reason)
 	sw.stopAndRemovePeer(peer, reason)
 
 	if peer.IsPersistent() {
@@ -395,10 +395,10 @@ func (sw *Switch) StopPeerForError(peer *Peer, reason interface{}) {
 				peer, err := sw.DialPeerWithAddress(addr, true)
 				if err != nil {
 					if i == reconnectAttempts {
-						sw.Logger.Info("Error reconnecting to peer. Giving up", "tries", i, "error", err)
+						sw.Logger.Info("Error reconnecting to peer. Giving up", "tries", i, "err", err)
 						return
 					}
-					sw.Logger.Info("Error reconnecting to peer. Trying again", "tries", i, "error", err)
+					sw.Logger.Info("Error reconnecting to peer. Trying again", "tries", i, "err", err)
 					time.Sleep(reconnectInterval)
 					continue
 				}
@@ -442,7 +442,7 @@ func (sw *Switch) listenerRoutine(l Listener) {
 		// New inbound connection!
 		err := sw.addPeerWithConnectionAndConfig(inConn, sw.peerConfig)
 		if err != nil {
-			sw.Logger.Info("Ignoring inbound connection: error while adding peer", "address", inConn.RemoteAddr().String(), "error", err)
+			sw.Logger.Info("Ignoring inbound connection: error while adding peer", "address", inConn.RemoteAddr().String(), "err", err)
 			continue
 		}
 

rpc/lib/client/ws_client.go

@@ -100,14 +100,14 @@ func (wsc *WSClient) receiveEventsRoutine() {
 	for {
 		_, data, err := wsc.ReadMessage()
 		if err != nil {
-			wsc.Logger.Info("WSClient failed to read message", "error", err, "data", string(data))
+			wsc.Logger.Info("WSClient failed to read message", "err", err, "data", string(data))
 			wsc.Stop()
 			break
 		} else {
 			var response types.RPCResponse
 			err := json.Unmarshal(data, &response)
 			if err != nil {
-				wsc.Logger.Info("WSClient failed to parse message", "error", err, "data", string(data))
+				wsc.Logger.Info("WSClient failed to parse message", "err", err, "data", string(data))
 				wsc.ErrorsCh <- err
 				continue
 			}

rpc/lib/server/handlers.go

@@ -534,18 +534,18 @@ func (wsc *wsConnection) writeRoutine() {
 		case <-wsc.pingTicker.C:
 			err := wsc.baseConn.WriteMessage(websocket.PingMessage, []byte{})
 			if err != nil {
-				wsc.Logger.Error("Failed to write ping message on websocket", "error", err)
+				wsc.Logger.Error("Failed to write ping message on websocket", "err", err)
 				wsc.Stop()
 				return
 			}
 		case msg := <-wsc.writeChan:
 			jsonBytes, err := json.MarshalIndent(msg, "", "  ")
 			if err != nil {
-				wsc.Logger.Error("Failed to marshal RPCResponse to JSON", "error", err)
+				wsc.Logger.Error("Failed to marshal RPCResponse to JSON", "err", err)
 			} else {
 				wsc.baseConn.SetWriteDeadline(time.Now().Add(time.Second * wsWriteTimeoutSeconds))
 				if err = wsc.baseConn.WriteMessage(websocket.TextMessage, jsonBytes); err != nil {
-					wsc.Logger.Error("Failed to write response on websocket", "error", err)
+					wsc.Logger.Error("Failed to write response on websocket", "err", err)
 					wsc.Stop()
 					return
 				}
@@ -591,7 +591,7 @@ func (wm *WebsocketManager) WebsocketHandler(w http.ResponseWriter, r *http.Requ
 	wsConn, err := wm.Upgrade(w, r, nil)
 	if err != nil {
 		// TODO - return http error
-		wm.logger.Error("Failed to upgrade to websocket connection", "error", err)
+		wm.logger.Error("Failed to upgrade to websocket connection", "err", err)
 		return
 	}
 

rpc/lib/server/http_server.go

@@ -97,7 +97,7 @@ func RecoverAndLogHandler(handler http.Handler, logger log.Logger) http.Handler
 					WriteRPCResponseHTTP(rww, res)
 				} else {
 					// For the rest,
-					logger.Error("Panic in RPC HTTP handler", "error", e, "stack", string(debug.Stack()))
+					logger.Error("Panic in RPC HTTP handler", "err", e, "stack", string(debug.Stack()))
 					rww.WriteHeader(http.StatusInternalServerError)
 					WriteRPCResponseHTTP(rww, types.NewRPCResponse("", nil, fmt.Sprintf("Internal Server Error: %v", e)))
 				}

state/execution.go

@@ -85,7 +85,7 @@ func execBlockOnProxyApp(eventCache types.Fireable, proxyAppConn proxy.AppConnCo
 	// Begin block
 	err := proxyAppConn.BeginBlockSync(block.Hash(), types.TM2PB.Header(block.Header))
 	if err != nil {
-		logger.Error("Error in proxyAppConn.BeginBlock", "error", err)
+		logger.Error("Error in proxyAppConn.BeginBlock", "err", err)
 		return nil, err
 	}
 
@@ -100,7 +100,7 @@ func execBlockOnProxyApp(eventCache types.Fireable, proxyAppConn proxy.AppConnCo
 	// End block
 	abciResponses.EndBlock, err = proxyAppConn.EndBlockSync(uint64(block.Height))
 	if err != nil {
-		logger.Error("Error in proxyAppConn.EndBlock", "error", err)
+		logger.Error("Error in proxyAppConn.EndBlock", "err", err)
 		return nil, err
 	}
 
@@ -252,7 +252,7 @@ func (s *State) CommitStateUpdateMempool(proxyAppConn proxy.AppConnConsensus, bl
 	// Commit block, get hash back
 	res := proxyAppConn.CommitSync()
 	if res.IsErr() {
-		s.logger.Error("Error in proxyAppConn.CommitSync", "error", res)
+		s.logger.Error("Error in proxyAppConn.CommitSync", "err", res)
 		return res
 	}
 	if res.Log != "" {
@@ -298,7 +298,7 @@ func ExecCommitBlock(appConnConsensus proxy.AppConnConsensus, block *types.Block
 	// Commit block, get hash back
 	res := appConnConsensus.CommitSync()
 	if res.IsErr() {
-		logger.Error("Error in proxyAppConn.CommitSync", "error", res)
+		logger.Error("Error in proxyAppConn.CommitSync", "err", res)
 		return nil, res
 	}
 	if res.Log != "" {

state/state.go

@@ -148,7 +148,7 @@ func (s *State) SetBlockAndValidators(header *types.Header, blockPartsHeader typ
 	// update the validator set with the latest abciResponses
 	err := updateValidators(nextValSet, abciResponses.EndBlock.Diffs)
 	if err != nil {
-		s.logger.Error("Error changing validator set", "error", err)
+		s.logger.Error("Error changing validator set", "err", err)
 		// TODO: err or carry on?
 	}