statistics: show stores of peers in pd-ctl output

server/handler.go

@@ -1032,23 +1032,14 @@ func (h *Handler) packHotRegions(hotPeersStat statistics.StoreHotPeersStat, hotR
 			if err != nil {
 				return nil, err
 			}
-			var peerID uint64
-			var isLearner bool
-			for _, peer := range meta.Peers {
-				if peer.StoreId == hotPeerStat.StoreID {
-					peerID = peer.Id
-					isLearner = core.IsLearner(peer)
-					break
-				}
-			}
 			stat := storage.HistoryHotRegion{
 				// store in ms.
 				UpdateTime:     hotPeerStat.LastUpdateTime.UnixNano() / int64(time.Millisecond),
 				RegionID:       hotPeerStat.RegionID,
 				StoreID:        hotPeerStat.StoreID,
-				PeerID:         peerID,
-				IsLeader:       peerID == region.GetLeader().Id,
-				IsLearner:      isLearner,
+				PeerID:         region.GetStorePeer(hotPeerStat.StoreID).GetId(),
+				IsLeader:       hotPeerStat.IsLeader,
+				IsLearner:      hotPeerStat.IsLearner,
 				HotDegree:      int64(hotPeerStat.HotDegree),
 				FlowBytes:      hotPeerStat.ByteRate,
 				KeyRate:        hotPeerStat.KeyRate,

server/statistics/hot_peer.go

@@ -100,6 +100,7 @@ type HotPeerStat struct {
 
 	actionType             ActionType
 	isLeader               bool
+	isLearner              bool
 	interval               uint64
 	thresholds             []float64
 	peers                  []*metapb.Peer
@@ -131,6 +132,7 @@ func (stat *HotPeerStat) Log(str string, level func(msg string, fields ...zap.Fi
 		zap.Uint64("region-id", stat.RegionID),
 		zap.Uint64("store", stat.StoreID),
 		zap.Bool("is-leader", stat.isLeader),
+		zap.Bool("is-learner", stat.isLearner),
 		zap.String("type", stat.Kind.String()),
 		zap.Float64s("loads", stat.GetLoads()),
 		zap.Float64s("loads-instant", stat.Loads),
@@ -219,3 +221,17 @@ func (stat *HotPeerStat) getIntervalSum() time.Duration {
 	}
 	return stat.rollingLoads[0].lastAverage.GetIntervalSum()
 }
+
+// GetStores returns stores of the item.
+func (stat *HotPeerStat) GetStores() []uint64 {
+	stores := []uint64{}
+	for _, peer := range stat.peers {
+		stores = append(stores, peer.StoreId)
+	}
+	return stores
+}
+
+// IsLearner indicates whether the item is learner.
+func (stat *HotPeerStat) IsLearner() bool {
+	return stat.isLearner
+}

server/statistics/hot_peer_cache.go

@@ -181,6 +181,7 @@ func (f *hotPeerCache) checkPeerFlow(peer *core.PeerInfo, region *core.RegionInf
 		Loads:          loads,
 		LastUpdateTime: time.Now(),
 		isLeader:       region.GetLeader().GetStoreId() == storeID,
+		isLearner:      core.IsLearner(region.GetPeer(storeID)),
 		interval:       interval,
 		peers:          region.GetPeers(),
 		actionType:     Update,
@@ -230,6 +231,7 @@ func (f *hotPeerCache) checkColdPeer(storeID uint64, reportRegions map[uint64]*c
 				Loads:          oldItem.thresholds,
 				LastUpdateTime: time.Now(),
 				isLeader:       oldItem.isLeader,
+				isLearner:      oldItem.isLearner,
 				interval:       interval,
 				peers:          oldItem.peers,
 				actionType:     Update,

server/statistics/hot_regions_stat.go

@@ -34,6 +34,9 @@ type HotPeersStat struct {
 // HotPeerStatShow records the hot region statistics for output
 type HotPeerStatShow struct {
 	StoreID        uint64    `json:"store_id"`
+	Stores         []uint64  `json:"stores"`
+	IsLeader       bool      `json:"is_leader"`
+	IsLearner      bool      `json:"is_learner"`
 	RegionID       uint64    `json:"region_id"`
 	HotDegree      int       `json:"hot_degree"`
 	ByteRate       float64   `json:"flow_bytes"`

server/statistics/store_load.go

@@ -85,6 +85,9 @@ func toHotPeerStatShow(p *HotPeerStat, kind RWType) HotPeerStatShow {
 	queryRate := p.Loads[q]
 	return HotPeerStatShow{
 		StoreID:        p.StoreID,
+		Stores:         p.GetStores(),
+		IsLeader:       p.IsLeader(),
+		IsLearner:      p.IsLearner(),
 		RegionID:       p.RegionID,
 		HotDegree:      p.HotDegree,
 		ByteRate:       byteRate,