Remove logging

Signed-off-by: Marek Siarkowicz <[email protected]>

Author: serathius

server/etcdserver/api/rafthttp/transport.go

@@ -174,15 +174,12 @@ func (t *Transport) Get(id types.ID) Peer {
 
 func (t *Transport) Send(msgs []raftpb.Message) {
 	for _, m := range msgs {
-		t.Logger.Info("Got message to send", zap.Any("to", m.To))
 		if m.To == 0 {
-			t.Logger.Info("Drop")
 			// ignore intentionally dropped message
 			continue
 		}
 		to := types.ID(m.To)
 		if to == t.ID {
-			t.Logger.Info("Sending message to self", zap.Any("to", m.To))
 			t.Raft.Process(context.Background(), m)
 			continue
 		}
@@ -193,7 +190,6 @@ func (t *Transport) Send(msgs []raftpb.Message) {
 		t.mu.RUnlock()
 
 		if pok {
-			t.Logger.Info("Send to peer", zap.Any("peer", p))
 			if isMsgApp(m) {
 				t.ServerStats.SendAppendReq(m.Size())
 			}
@@ -202,13 +198,12 @@ func (t *Transport) Send(msgs []raftpb.Message) {
 		}
 
 		if rok {
-			t.Logger.Info("Send to remote", zap.Any("remote", g))
 			g.send(m)
 			continue
 		}
 
 		if t.Logger != nil {
-			t.Logger.Info(
+			t.Logger.Debug(
 				"ignored message send request; unknown remote peer target",
 				zap.String("type", m.Type.String()),
 				zap.String("unknown-target-peer-id", to.String()),

server/etcdserver/raft.go

@@ -208,7 +208,6 @@ func (r *raftNode) start(rh *raftReadyHandler) {
 				// Must save the snapshot file and WAL snapshot entry before saving any other entries or hardstate to
 				// ensure that recovery after a snapshot restore is possible.
 				if m.Snapshot != nil {
-					r.lg.Info("Save snap", zap.Any("snap", m.Snapshot))
 					// gofail: var raftBeforeSaveSnap struct{}
 					if err := r.storage.SaveSnap(*m.Snapshot); err != nil {
 						r.lg.Fatal("failed to save Raft snapshot", zap.Error(err))
@@ -217,17 +216,15 @@ func (r *raftNode) start(rh *raftReadyHandler) {
 				}
 
 				// gofail: var raftBeforeSave struct{}
-				r.lg.Info("Save entries", zap.Any("entries", m.Entries))
 				if err := r.storage.Save(messageHardState.hardState, m.Entries); err != nil {
 					r.lg.Fatal("failed to save Raft hard state and entries", zap.Error(err))
 				}
-				//if !raft.IsEmptyHardState(hardState) {
-				//	proposalsCommitted.Set(float64(hardState.Commit))
-				//}
+				if !raft.IsEmptyHardState(messageHardState.hardState) {
+					proposalsCommitted.Set(float64(messageHardState.hardState.Commit))
+				}
 				// gofail: var raftAfterSave struct{}
 
 				if m.Snapshot != nil {
-					r.lg.Info("Sync wal")
 					// Force WAL to fsync its hard state before Release() releases
 					// old data from the WAL. Otherwise could get an error like:
 					// panic: tocommit(107) is out of range [lastIndex(84)]. Was the raft log corrupted, truncated, or lost?
@@ -239,17 +236,14 @@ func (r *raftNode) start(rh *raftReadyHandler) {
 					// etcdserver now claim the snapshot has been persisted onto the disk
 					// gofail: var raftBeforeApplySnap struct{}
 					r.raftStorage.ApplySnapshot(*m.Snapshot)
-					r.lg.Info("applied incoming Raft snapshot", zap.Uint64("snapshot-index", m.Snapshot.Metadata.Index))
 					// gofail: var raftAfterApplySnap struct{}
 
 					if err := r.storage.Release(*m.Snapshot); err != nil {
 						r.lg.Fatal("failed to release Raft wal", zap.Error(err))
 					}
 					// gofail: var raftAfterWALRelease struct{}
 				}
-				r.lg.Info("Append entries", zap.Any("entries", m.Entries))
 				r.raftStorage.Append(m.Entries)
-				r.lg.Info("Append sent responses", zap.Any("entries", m.Responses))
 				r.transport.Send(m.Responses)
 			case <-r.stopped:
 				return
@@ -292,33 +286,24 @@ func (r *raftNode) start(rh *raftReadyHandler) {
 			case <-r.ticker.C:
 				r.tick()
 			case rd := <-r.Ready():
-				r.lg.Info("Ready")
 				if rd.SoftState != nil {
-					r.lg.Info("SoftState", zap.Any("soft-state", rd.SoftState))
 					r.handleSoftState(rh, rd.SoftState, rd.RaftState)
 				}
 				if len(rd.ReadStates) != 0 {
-					r.lg.Info("ReadyStates", zap.Any("ready-state", rd.ReadStates))
 					if r.handleReadyStates(rd.ReadStates) {
 						return
 					}
 				}
-				if !raft.IsEmptyHardState(rd.HardState) {
-					r.lg.Info("HardState", zap.Any("hard-state", rd.HardState))
-				}
 				for _, m := range rd.Messages {
 					switch m.To {
 					case raft.LocalApplyThread:
-						r.lg.Info("Message apply", zap.Any("message", m))
 						toApply <- m
 					case raft.LocalAppendThread:
-						r.lg.Info("Message append", zap.Any("message", m))
 						toAppend <- hardStateMessage{
 							hardState: rd.HardState,
 							message:   m,
 						}
 					default:
-						r.lg.Info("Message sent", zap.Any("message", m))
 						r.transport.Send([]raftpb.Message{m})
 					}
 				}