Expose metrics of data cluster (#7177)

Signed-off-by: dragondriver <jiquan.long@zilliz.com>

internal/datacoord/errors.go

@@ -0,0 +1,25 @@
+// Copyright (C) 2019-2020 Zilliz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+// or implied. See the License for the specific language governing permissions and limitations under the License.
+
+package datacoord
+
+import (
+	"errors"
+	"fmt"
+)
+
+func msgDataCoordIsUnhealthy(coordID UniqueID) string {
+	return fmt.Sprintf("data coord %d is not ready", coordID)
+}
+
+func errDataCoordIsUnhealthy(coordID UniqueID) error {
+	return errors.New(msgDataCoordIsUnhealthy(coordID))
+}

internal/datacoord/errors_test.go

@@ -0,0 +1,35 @@
+// Copyright (C) 2019-2020 Zilliz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+// or implied. See the License for the specific language governing permissions and limitations under the License.
+
+package datacoord
+
+import (
+	"testing"
+
+	"github.com/milvus-io/milvus/internal/util/typeutil"
+
+	"github.com/milvus-io/milvus/internal/log"
+	"go.uber.org/zap"
+)
+
+func TestMsgDataCoordIsUnhealthy(t *testing.T) {
+	nodeIDList := []typeutil.UniqueID{1, 2, 3}
+	for _, nodeID := range nodeIDList {
+		log.Info("TestMsgDataCoordIsUnhealthy", zap.String("msg", msgDataCoordIsUnhealthy(nodeID)))
+	}
+}
+
+func TestErrDataCoordIsUnhealthy(t *testing.T) {
+	nodeIDList := []typeutil.UniqueID{1, 2, 3}
+	for _, nodeID := range nodeIDList {
+		log.Info("TestErrDataCoordIsUnhealthy", zap.Error(errDataCoordIsUnhealthy(nodeID)))
+	}
+}

internal/datacoord/grpc_services.go

@@ -11,6 +11,7 @@ import (
 	"github.com/milvus-io/milvus/internal/proto/datapb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
 	"github.com/milvus-io/milvus/internal/proto/milvuspb"
+	"github.com/milvus-io/milvus/internal/util/metricsinfo"
 	"go.uber.org/zap"
 )
 
@@ -430,3 +431,69 @@ func (s *Server) GetFlushedSegments(ctx context.Context, req *datapb.GetFlushedS
 		Segments: ret,
 	}, nil
 }
+
+func (s *Server) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	log.Debug("DataCoord.GetMetrics",
+		zap.Int64("node_id", Params.NodeID),
+		zap.String("req", req.Request))
+
+	if s.isClosed() {
+		log.Warn("DataCoord.GetMetrics failed",
+			zap.Int64("node_id", Params.NodeID),
+			zap.String("req", req.Request),
+			zap.Error(errDataCoordIsUnhealthy(Params.NodeID)))
+
+		return &milvuspb.GetMetricsResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    msgDataCoordIsUnhealthy(Params.NodeID),
+			},
+			Response: "",
+		}, nil
+	}
+
+	metricType, err := metricsinfo.ParseMetricType(req.Request)
+	if err != nil {
+		log.Warn("DataCoord.GetMetrics failed to parse metric type",
+			zap.Int64("node_id", Params.NodeID),
+			zap.String("req", req.Request),
+			zap.Error(err))
+
+		return &milvuspb.GetMetricsResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    err.Error(),
+			},
+			Response: "",
+		}, nil
+	}
+
+	log.Debug("DataCoord.GetMetrics",
+		zap.String("metric_type", metricType))
+
+	if metricType == metricsinfo.SystemInfoMetrics {
+		metrics, err := s.getSystemInfoMetrics(ctx, req)
+
+		log.Debug("DataCoord.GetMetrics",
+			zap.Int64("node_id", Params.NodeID),
+			zap.String("req", req.Request),
+			zap.String("metric_type", metricType),
+			zap.Any("metrics", metrics), // TODO(dragondriver): necessary? may be very large
+			zap.Error(err))
+
+		return metrics, err
+	}
+
+	log.Debug("DataCoord.GetMetrics failed, request metric type is not implemented yet",
+		zap.Int64("node_id", Params.NodeID),
+		zap.String("req", req.Request),
+		zap.String("metric_type", metricType))
+
+	return &milvuspb.GetMetricsResponse{
+		Status: &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UnexpectedError,
+			Reason:    metricsinfo.MsgUnimplementedMetric,
+		},
+		Response: "",
+	}, nil
+}

internal/datacoord/metrics_info.go

@@ -0,0 +1,119 @@
+// Copyright (C) 2019-2020 Zilliz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+// or implied. See the License for the specific language governing permissions and limitations under the License.
+
+package datacoord
+
+import (
+	"context"
+
+	"github.com/milvus-io/milvus/internal/util/typeutil"
+
+	"go.uber.org/zap"
+
+	"github.com/milvus-io/milvus/internal/log"
+
+	"github.com/milvus-io/milvus/internal/proto/commonpb"
+	"github.com/milvus-io/milvus/internal/proto/milvuspb"
+	"github.com/milvus-io/milvus/internal/util/metricsinfo"
+)
+
+// TODO(dragondriver): add more detail metrics
+func (s *Server) getSystemInfoMetrics(
+	ctx context.Context,
+	req *milvuspb.GetMetricsRequest,
+) (*milvuspb.GetMetricsResponse, error) {
+
+	clusterTopology := metricsinfo.DataClusterTopology{
+		Self: metricsinfo.DataCoordInfos{
+			BaseComponentInfos: metricsinfo.BaseComponentInfos{
+				Name: metricsinfo.ConstructComponentName(typeutil.DataCoordRole, Params.NodeID),
+			},
+		},
+		ConnectedNodes: make([]metricsinfo.DataNodeInfos, 0),
+	}
+
+	nodes := s.cluster.GetNodes()
+	for _, node := range nodes {
+		metrics, err := node.GetClient().GetMetrics(ctx, req)
+		if err != nil {
+			log.Warn("invalid metrics of query node was found",
+				zap.Error(err))
+			clusterTopology.ConnectedNodes = append(clusterTopology.ConnectedNodes, metricsinfo.DataNodeInfos{
+				BaseComponentInfos: metricsinfo.BaseComponentInfos{
+					HasError:    true,
+					ErrorReason: err.Error(),
+					// Name doesn't matter here cause we can't get it when error occurs, using address as the Name?
+					Name: "",
+				},
+			})
+			continue
+		}
+
+		if metrics.Status.ErrorCode != commonpb.ErrorCode_Success {
+			log.Warn("invalid metrics of query node was found",
+				zap.Any("error_code", metrics.Status.ErrorCode),
+				zap.Any("error_reason", metrics.Status.Reason))
+			clusterTopology.ConnectedNodes = append(clusterTopology.ConnectedNodes, metricsinfo.DataNodeInfos{
+				BaseComponentInfos: metricsinfo.BaseComponentInfos{
+					HasError:    true,
+					ErrorReason: metrics.Status.Reason,
+					Name:        metrics.ComponentName,
+				},
+			})
+			continue
+		}
+
+		infos := metricsinfo.DataNodeInfos{}
+		err = metricsinfo.UnmarshalComponentInfos(metrics.Response, &infos)
+		if err != nil {
+			log.Warn("invalid metrics of query node was found",
+				zap.Error(err))
+			clusterTopology.ConnectedNodes = append(clusterTopology.ConnectedNodes, metricsinfo.DataNodeInfos{
+				BaseComponentInfos: metricsinfo.BaseComponentInfos{
+					HasError:    true,
+					ErrorReason: err.Error(),
+					Name:        metrics.ComponentName,
+				},
+			})
+			continue
+		}
+		clusterTopology.ConnectedNodes = append(clusterTopology.ConnectedNodes, infos)
+	}
+
+	coordTopology := metricsinfo.DataCoordTopology{
+		Cluster: clusterTopology,
+		Connections: metricsinfo.ConnTopology{
+			Name: metricsinfo.ConstructComponentName(typeutil.DataCoordRole, Params.NodeID),
+			// TODO(dragondriver): connection info
+		},
+	}
+
+	resp, err := metricsinfo.MarshalTopology(coordTopology)
+	if err != nil {
+		return &milvuspb.GetMetricsResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    err.Error(),
+			},
+			Response:      "",
+			ComponentName: metricsinfo.ConstructComponentName(typeutil.DataCoordRole, Params.NodeID),
+		}, nil
+	}
+
+	return &milvuspb.GetMetricsResponse{
+		Status: &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_Success,
+			Reason:    "",
+		},
+		Response:      resp,
+		ComponentName: metricsinfo.ConstructComponentName(typeutil.DataCoordRole, Params.NodeID),
+	}, nil
+}

internal/datacoord/mock_test.go

@@ -15,6 +15,9 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/milvus-io/milvus/internal/util/metricsinfo"
+	"github.com/milvus-io/milvus/internal/util/typeutil"
+
 	memkv "github.com/milvus-io/milvus/internal/kv/mem"
 	"github.com/milvus-io/milvus/internal/util/tsoutil"
 
@@ -311,3 +314,34 @@ func (m *mockRootCoordService) SegmentFlushCompleted(ctx context.Context, in *da
 func (m *mockRootCoordService) AddNewSegment(ctx context.Context, in *datapb.SegmentMsg) (*commonpb.Status, error) {
 	panic("not implemented") // TODO: Implement
 }
+
+func (c *mockDataNodeClient) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	// TODO(dragondriver): change the id, though it's not important in ut
+	nodeID := UniqueID(20210819)
+
+	nodeInfos := metricsinfo.DataNodeInfos{
+		BaseComponentInfos: metricsinfo.BaseComponentInfos{
+			Name: metricsinfo.ConstructComponentName(typeutil.DataNodeRole, nodeID),
+		},
+	}
+	resp, err := metricsinfo.MarshalComponentInfos(nodeInfos)
+	if err != nil {
+		return &milvuspb.GetMetricsResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    err.Error(),
+			},
+			Response:      "",
+			ComponentName: metricsinfo.ConstructComponentName(typeutil.DataNodeRole, nodeID),
+		}, nil
+	}
+
+	return &milvuspb.GetMetricsResponse{
+		Status: &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_Success,
+			Reason:    "",
+		},
+		Response:      resp,
+		ComponentName: metricsinfo.ConstructComponentName(typeutil.DataNodeRole, nodeID),
+	}, nil
+}

internal/datacoord/server_test.go

@@ -15,9 +15,17 @@ import (
 	"os"
 	"path"
 	"strconv"
+	"sync/atomic"
 	"testing"
 	"time"
 
+	"github.com/milvus-io/milvus/internal/proto/milvuspb"
+
+	"github.com/milvus-io/milvus/internal/log"
+	"go.uber.org/zap"
+
+	"github.com/milvus-io/milvus/internal/util/metricsinfo"
+
 	"github.com/milvus-io/milvus/internal/msgstream"
 	"github.com/milvus-io/milvus/internal/proto/commonpb"
 	"github.com/milvus-io/milvus/internal/proto/datapb"
@@ -279,6 +287,71 @@ func TestGetSegmentInfo(t *testing.T) {
 	assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
 }
 
+func TestServer_GetMetrics(t *testing.T) {
+	svr := newTestServer(t, nil)
+	defer closeTestServer(t, svr)
+
+	var err error
+
+	// server is closed
+	stateSave := atomic.LoadInt64(&svr.isServing)
+	atomic.StoreInt64(&svr.isServing, ServerStateInitializing)
+	resp, err := svr.GetMetrics(svr.ctx, &milvuspb.GetMetricsRequest{})
+	assert.Nil(t, err)
+	assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+	atomic.StoreInt64(&svr.isServing, stateSave)
+
+	// failed to parse metric type
+	invalidRequest := "invalid request"
+	resp, err = svr.GetMetrics(svr.ctx, &milvuspb.GetMetricsRequest{
+		Request: invalidRequest,
+	})
+	assert.Nil(t, err)
+	assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+
+	// unsupported metric type
+	unsupportedMetricType := "unsupported"
+	req, err := metricsinfo.ConstructRequestByMetricType(unsupportedMetricType)
+	assert.Nil(t, err)
+	resp, err = svr.GetMetrics(svr.ctx, req)
+	assert.Nil(t, err)
+	assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+
+	// normal case
+	req, err = metricsinfo.ConstructRequestByMetricType(metricsinfo.SystemInfoMetrics)
+	assert.Nil(t, err)
+	resp, err = svr.GetMetrics(svr.ctx, req)
+	assert.Nil(t, err)
+	assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+	log.Info("TestServer_GetMetrics",
+		zap.String("name", resp.ComponentName),
+		zap.String("response", resp.Response))
+}
+
+func TestServer_getSystemInfoMetrics(t *testing.T) {
+	svr := newTestServer(t, nil)
+	defer closeTestServer(t, svr)
+
+	req, err := metricsinfo.ConstructRequestByMetricType(metricsinfo.SystemInfoMetrics)
+	assert.Nil(t, err)
+	resp, err := svr.getSystemInfoMetrics(svr.ctx, req)
+	assert.Nil(t, err)
+	log.Info("TestServer_getSystemInfoMetrics",
+		zap.String("name", resp.ComponentName),
+		zap.String("response", resp.Response))
+
+	var coordTopology metricsinfo.DataCoordTopology
+	err = metricsinfo.UnmarshalTopology(resp.Response, &coordTopology)
+	assert.Nil(t, err)
+	assert.Equal(t, len(svr.cluster.GetNodes()), len(coordTopology.Cluster.ConnectedNodes))
+	for _, nodeMetrics := range coordTopology.Cluster.ConnectedNodes {
+		assert.Equal(t, false, nodeMetrics.HasError)
+		assert.Equal(t, 0, len(nodeMetrics.ErrorReason))
+		_, err = metricsinfo.MarshalComponentInfos(nodeMetrics)
+		assert.Nil(t, err)
+	}
+}
+
 func TestChannel(t *testing.T) {
 	svr := newTestServer(t, nil)
 	defer closeTestServer(t, svr)

internal/datanode/data_node.go

@@ -36,6 +36,7 @@ import (
 	"github.com/milvus-io/milvus/internal/metrics"
 	"github.com/milvus-io/milvus/internal/msgstream"
 	"github.com/milvus-io/milvus/internal/types"
+	"github.com/milvus-io/milvus/internal/util/metricsinfo"
 	"github.com/milvus-io/milvus/internal/util/retry"
 	"github.com/milvus-io/milvus/internal/util/sessionutil"
 	"github.com/milvus-io/milvus/internal/util/typeutil"
@@ -348,6 +349,11 @@ func (node *DataNode) UpdateStateCode(code internalpb.StateCode) {
 	node.State.Store(code)
 }
 
+func (node *DataNode) isHealthy() bool {
+	code := node.State.Load().(internalpb.StateCode)
+	return code == internalpb.StateCode_Healthy
+}
+
 // WatchDmChannels create a new dataSyncService for every unique dmlVchannel name, ignore if dmlVchannel existed.
 func (node *DataNode) WatchDmChannels(ctx context.Context, in *datapb.WatchDmChannelsRequest) (*commonpb.Status, error) {
 	metrics.DataNodeWatchDmChannelsCounter.WithLabelValues(MetricRequestsTotal).Inc()
@@ -569,3 +575,70 @@ func (node *DataNode) GetStatisticsChannel(ctx context.Context) (*milvuspb.Strin
 		Value: "",
 	}, nil
 }
+
+// TODO(dragondriver): cache the Metrics and set a retention to the cache
+func (node *DataNode) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	log.Debug("DataNode.GetMetrics",
+		zap.Int64("node_id", Params.NodeID),
+		zap.String("req", req.Request))
+
+	if !node.isHealthy() {
+		log.Warn("DataNode.GetMetrics failed",
+			zap.Int64("node_id", Params.NodeID),
+			zap.String("req", req.Request),
+			zap.Error(errDataNodeIsUnhealthy(Params.NodeID)))
+
+		return &milvuspb.GetMetricsResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    msgDataNodeIsUnhealthy(Params.NodeID),
+			},
+			Response: "",
+		}, nil
+	}
+
+	metricType, err := metricsinfo.ParseMetricType(req.Request)
+	if err != nil {
+		log.Warn("DataNode.GetMetrics failed to parse metric type",
+			zap.Int64("node_id", Params.NodeID),
+			zap.String("req", req.Request),
+			zap.Error(err))
+
+		return &milvuspb.GetMetricsResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    err.Error(),
+			},
+			Response: "",
+		}, nil
+	}
+
+	log.Debug("DataNode.GetMetrics",
+		zap.String("metric_type", metricType))
+
+	if metricType == metricsinfo.SystemInfoMetrics {
+		systemInfoMetrics, err := node.getSystemInfoMetrics(ctx, req)
+
+		log.Debug("DataNode.GetMetrics",
+			zap.Int64("node_id", Params.NodeID),
+			zap.String("req", req.Request),
+			zap.String("metric_type", metricType),
+			zap.Any("systemInfoMetrics", systemInfoMetrics), // TODO(dragondriver): necessary? may be very large
+			zap.Error(err))
+
+		return systemInfoMetrics, err
+	}
+
+	log.Debug("DataNode.GetMetrics failed, request metric type is not implemented yet",
+		zap.Int64("node_id", Params.NodeID),
+		zap.String("req", req.Request),
+		zap.String("metric_type", metricType))
+
+	return &milvuspb.GetMetricsResponse{
+		Status: &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UnexpectedError,
+			Reason:    metricsinfo.MsgUnimplementedMetric,
+		},
+		Response: "",
+	}, nil
+}

internal/datanode/data_node_test.go

@@ -21,6 +21,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/milvus-io/milvus/internal/proto/milvuspb"
+
+	"github.com/milvus-io/milvus/internal/util/metricsinfo"
+
 	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -209,6 +213,52 @@ func TestDataNode(t *testing.T) {
 		assert.NoError(t, err)
 	})
 
+	t.Run("Test getSystemInfoMetrics", func(t *testing.T) {
+		req, err := metricsinfo.ConstructRequestByMetricType(metricsinfo.SystemInfoMetrics)
+		assert.NoError(t, err)
+		resp, err := node.getSystemInfoMetrics(node.ctx, req)
+		assert.NoError(t, err)
+		log.Info("Test DataNode.getSystemInfoMetrics",
+			zap.String("name", resp.ComponentName),
+			zap.String("response", resp.Response))
+	})
+
+	t.Run("Test GetMetrics", func(t *testing.T) {
+		// server is closed
+		stateSave := node.State.Load().(internalpb.StateCode)
+		node.State.Store(internalpb.StateCode_Abnormal)
+		resp, err := node.GetMetrics(ctx, &milvuspb.GetMetricsRequest{})
+		assert.NoError(t, err)
+		assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+		node.State.Store(stateSave)
+
+		// failed to parse metric type
+		invalidRequest := "invalid request"
+		resp, err = node.GetMetrics(ctx, &milvuspb.GetMetricsRequest{
+			Request: invalidRequest,
+		})
+		assert.NoError(t, err)
+		assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+
+		// unsupported metric type
+		unsupportedMetricType := "unsupported"
+		req, err := metricsinfo.ConstructRequestByMetricType(unsupportedMetricType)
+		assert.NoError(t, err)
+		resp, err = node.GetMetrics(ctx, req)
+		assert.NoError(t, err)
+		assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+
+		// normal case
+		req, err = metricsinfo.ConstructRequestByMetricType(metricsinfo.SystemInfoMetrics)
+		assert.NoError(t, err)
+		resp, err = node.GetMetrics(node.ctx, req)
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
+		log.Info("Test DataNode.GetMetrics",
+			zap.String("name", resp.ComponentName),
+			zap.String("response", resp.Response))
+	})
+
 	t.Run("Test BackGroundGC", func(te *testing.T) {
 		te.Skipf("issue #6574")
 		ctx, cancel := context.WithCancel(context.Background())

internal/datanode/errors.go

@@ -0,0 +1,25 @@
+// Copyright (C) 2019-2020 Zilliz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+// or implied. See the License for the specific language governing permissions and limitations under the License.
+
+package datanode
+
+import (
+	"errors"
+	"fmt"
+)
+
+func msgDataNodeIsUnhealthy(nodeID UniqueID) string {
+	return fmt.Sprintf("data node %d is not ready", nodeID)
+}
+
+func errDataNodeIsUnhealthy(nodeID UniqueID) error {
+	return errors.New(msgDataNodeIsUnhealthy(nodeID))
+}

internal/datanode/errors_test.go

@@ -0,0 +1,35 @@
+// Copyright (C) 2019-2020 Zilliz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+// or implied. See the License for the specific language governing permissions and limitations under the License.
+
+package datanode
+
+import (
+	"testing"
+
+	"github.com/milvus-io/milvus/internal/util/typeutil"
+
+	"github.com/milvus-io/milvus/internal/log"
+	"go.uber.org/zap"
+)
+
+func TestMsgDataNodeIsUnhealthy(t *testing.T) {
+	nodeIDList := []typeutil.UniqueID{1, 2, 3}
+	for _, nodeID := range nodeIDList {
+		log.Info("TestMsgDataNodeIsUnhealthy", zap.String("msg", msgDataNodeIsUnhealthy(nodeID)))
+	}
+}
+
+func TestErrDataNodeIsUnhealthy(t *testing.T) {
+	nodeIDList := []typeutil.UniqueID{1, 2, 3}
+	for _, nodeID := range nodeIDList {
+		log.Info("TestErrDataNodeIsUnhealthy", zap.Error(errDataNodeIsUnhealthy(nodeID)))
+	}
+}

internal/datanode/metrics_info.go

@@ -0,0 +1,50 @@
+// Copyright (C) 2019-2020 Zilliz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+// or implied. See the License for the specific language governing permissions and limitations under the License.
+
+package datanode
+
+import (
+	"context"
+
+	"github.com/milvus-io/milvus/internal/proto/commonpb"
+	"github.com/milvus-io/milvus/internal/proto/milvuspb"
+	"github.com/milvus-io/milvus/internal/util/metricsinfo"
+	"github.com/milvus-io/milvus/internal/util/typeutil"
+)
+
+func (node *DataNode) getSystemInfoMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	// TODO(dragondriver): add more metrics
+	nodeInfos := metricsinfo.DataNodeInfos{
+		BaseComponentInfos: metricsinfo.BaseComponentInfos{
+			Name: metricsinfo.ConstructComponentName(typeutil.DataNodeRole, Params.NodeID),
+		},
+	}
+	resp, err := metricsinfo.MarshalComponentInfos(nodeInfos)
+	if err != nil {
+		return &milvuspb.GetMetricsResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_UnexpectedError,
+				Reason:    err.Error(),
+			},
+			Response:      "",
+			ComponentName: metricsinfo.ConstructComponentName(typeutil.DataNodeRole, Params.NodeID),
+		}, nil
+	}
+
+	return &milvuspb.GetMetricsResponse{
+		Status: &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_Success,
+			Reason:    "",
+		},
+		Response:      resp,
+		ComponentName: metricsinfo.ConstructComponentName(typeutil.DataNodeRole, Params.NodeID),
+	}, nil
+}

internal/distributed/datacoord/client/client.go

@@ -255,3 +255,10 @@ func (c *Client) GetFlushedSegments(ctx context.Context, req *datapb.GetFlushedS
 	})
 	return ret.(*datapb.GetFlushedSegmentsResponse), err
 }
+
+func (c *Client) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	ret, err := c.recall(func() (interface{}, error) {
+		return c.grpcClient.GetMetrics(ctx, req)
+	})
+	return ret.(*milvuspb.GetMetricsResponse), err
+}

internal/distributed/datacoord/service.go

@@ -233,3 +233,7 @@ func (s *Server) GetRecoveryInfo(ctx context.Context, req *datapb.GetRecoveryInf
 func (s *Server) GetFlushedSegments(ctx context.Context, req *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error) {
 	return s.dataCoord.GetFlushedSegments(ctx, req)
 }
+
+func (s *Server) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	return s.dataCoord.GetMetrics(ctx, req)
+}

internal/distributed/datanode/client/client.go

@@ -169,3 +169,10 @@ func (c *Client) FlushSegments(ctx context.Context, req *datapb.FlushSegmentsReq
 	})
 	return ret.(*commonpb.Status), err
 }
+
+func (c *Client) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	ret, err := c.recall(func() (interface{}, error) {
+		return c.grpc.GetMetrics(ctx, req)
+	})
+	return ret.(*milvuspb.GetMetricsResponse), err
+}

internal/distributed/datanode/service.go

@@ -272,3 +272,7 @@ func (s *Server) FlushSegments(ctx context.Context, req *datapb.FlushSegmentsReq
 	}
 	return s.datanode.FlushSegments(ctx, req)
 }
+
+func (s *Server) GetMetrics(ctx context.Context, request *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	return s.datanode.GetMetrics(ctx, request)
+}

internal/proto/data_coord.proto

@@ -30,6 +30,9 @@ service DataCoord {
   rpc SaveBinlogPaths(SaveBinlogPathsRequest) returns (common.Status){}
   rpc GetRecoveryInfo(GetRecoveryInfoRequest) returns (GetRecoveryInfoResponse){}
   rpc GetFlushedSegments(GetFlushedSegmentsRequest) returns(GetFlushedSegmentsResponse){}
+
+  // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
+  rpc GetMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {}
 }
 
 service DataNode {
@@ -38,6 +41,9 @@ service DataNode {
 
   rpc WatchDmChannels(WatchDmChannelsRequest) returns (common.Status) {}
   rpc FlushSegments(FlushSegmentsRequest) returns(common.Status) {}
+
+  // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
+  rpc GetMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {}
 }
 
 message FlushRequest {

internal/proto/datapb/data_coord.pb.go

@@ -2333,131 +2333,132 @@ func init() {
 func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
 
 var fileDescriptor_82cd95f524594f49 = []byte{
-	// 1969 bytes of a gzipped FileDescriptorProto
+	// 1992 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdb, 0x6f, 0x23, 0x57,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdb, 0x6f, 0x1b, 0x59,
-	0x19, 0xdf, 0xf1, 0xe4, 0x62, 0x7f, 0x76, 0x9c, 0xe4, 0xb0, 0xa4, 0x66, 0x76, 0x9b, 0xcd, 0x0e,
+	0x19, 0xef, 0x78, 0x72, 0xb1, 0x3f, 0x3b, 0x4e, 0x72, 0x28, 0x59, 0xe3, 0x76, 0xd3, 0x74, 0x60,
-	0xb4, 0x75, 0x17, 0x9a, 0x74, 0xbd, 0x20, 0x2a, 0x96, 0x82, 0xba, 0x71, 0x37, 0xb2, 0xc8, 0x2e,
+	0xdb, 0x6c, 0x61, 0x93, 0xad, 0x0b, 0x62, 0x45, 0x59, 0xd0, 0x36, 0xde, 0x46, 0x11, 0x49, 0x09,
-	0xe1, 0x64, 0xdb, 0x4a, 0xf4, 0xc1, 0x1a, 0xdb, 0x27, 0xce, 0x10, 0xcf, 0x8c, 0x3b, 0x67, 0x9c,
+	0x93, 0xee, 0xae, 0xc4, 0x3e, 0x58, 0x13, 0xfb, 0xc4, 0x19, 0xea, 0x99, 0xf1, 0xce, 0x39, 0x4e,
-	0xcd, 0x3e, 0x6d, 0x55, 0x24, 0x10, 0x08, 0x71, 0x11, 0xe2, 0x0d, 0x89, 0x8b, 0x84, 0x84, 0xc4,
+	0xd3, 0xa7, 0xae, 0x8a, 0xb4, 0x08, 0x84, 0xb8, 0x08, 0xf1, 0x86, 0x04, 0xe2, 0x09, 0x89, 0x17,
-	0x0b, 0x7f, 0x06, 0xff, 0x12, 0x6f, 0xe8, 0x5c, 0xe6, 0xcc, 0xd5, 0xf6, 0xc4, 0x61, 0x9b, 0x37,
+	0xfe, 0x0c, 0xfe, 0x25, 0xde, 0xd0, 0xb9, 0xce, 0xd5, 0xf6, 0xc4, 0xd9, 0x36, 0x6f, 0x3e, 0x67,
-	0x9f, 0x33, 0xdf, 0xed, 0x7c, 0xe7, 0xbb, 0xfc, 0xce, 0x97, 0xc0, 0xc6, 0xc0, 0x0a, 0xac, 0x6e,
+	0xbe, 0xdb, 0xf9, 0xce, 0x77, 0xf9, 0x9d, 0x2f, 0x81, 0x95, 0x9e, 0x43, 0x9d, 0x4e, 0x37, 0x08,
-	0xdf, 0xf3, 0xfc, 0xc1, 0xee, 0xd8, 0xf7, 0x02, 0x0f, 0x6d, 0x3a, 0xf6, 0xe8, 0x7c, 0x42, 0xc5,
+	0xc2, 0xde, 0xd6, 0x30, 0x0c, 0x68, 0x80, 0x56, 0x3d, 0x77, 0x70, 0x36, 0x22, 0x62, 0xb5, 0xc5,
-	0x6a, 0x97, 0x7d, 0x36, 0x6a, 0x7d, 0xcf, 0x71, 0x3c, 0x57, 0x6c, 0x19, 0x75, 0xdb, 0x0d, 0x88,
+	0x3e, 0x37, 0x6b, 0xdd, 0xc0, 0xf3, 0x02, 0x5f, 0x6c, 0x35, 0xeb, 0xae, 0x4f, 0x71, 0xe8, 0x3b,
-	0xef, 0x5a, 0x23, 0xb9, 0xae, 0xc5, 0x19, 0x8c, 0x1a, 0xed, 0x9f, 0x12, 0xc7, 0x12, 0x2b, 0xf3,
+	0x03, 0xb9, 0xae, 0xc5, 0x19, 0x9a, 0x35, 0xd2, 0x3d, 0xc5, 0x9e, 0x23, 0x56, 0xd6, 0x39, 0xd4,
-	0x02, 0x6a, 0x8f, 0x47, 0x13, 0x7a, 0x8a, 0xc9, 0x67, 0x13, 0x42, 0x03, 0xf4, 0x2e, 0x2c, 0xf5,
+	0x1e, 0x0f, 0x46, 0xe4, 0xd4, 0xc6, 0x5f, 0x8c, 0x30, 0xa1, 0xe8, 0x7d, 0x98, 0x3b, 0x76, 0x08,
-	0x2c, 0x4a, 0x1a, 0xda, 0x8e, 0xd6, 0xac, 0xb6, 0x6e, 0xef, 0x26, 0x74, 0x49, 0x2d, 0x4f, 0xe8,
+	0x6e, 0x18, 0x1b, 0xc6, 0x66, 0xb5, 0x75, 0x73, 0x2b, 0xa1, 0x4b, 0x6a, 0x39, 0x20, 0xfd, 0x47,
-	0xf0, 0x91, 0x45, 0x09, 0xe6, 0x94, 0x08, 0xc1, 0xd2, 0xa0, 0xd7, 0x69, 0x37, 0x4a, 0x3b, 0x5a,
+	0x0e, 0xc1, 0x36, 0xa7, 0x44, 0x08, 0xe6, 0x7a, 0xc7, 0x7b, 0xed, 0x46, 0x69, 0xc3, 0xd8, 0x34,
-	0x53, 0xc7, 0xfc, 0x37, 0x32, 0xa1, 0xd6, 0xf7, 0x46, 0x23, 0xd2, 0x0f, 0x6c, 0xcf, 0xed, 0xb4,
+	0x6d, 0xfe, 0x1b, 0x59, 0x50, 0xeb, 0x06, 0x83, 0x01, 0xee, 0x52, 0x37, 0xf0, 0xf7, 0xda, 0x8d,
-	0x1b, 0x4b, 0xfc, 0x5b, 0x62, 0xcf, 0xfc, 0xb3, 0x06, 0x6b, 0x52, 0x35, 0x1d, 0x7b, 0x2e, 0x25,
+	0x39, 0xfe, 0x2d, 0xb1, 0x67, 0xfd, 0xcd, 0x80, 0x25, 0xa9, 0x9a, 0x0c, 0x03, 0x9f, 0x60, 0xf4,
-	0xe8, 0x01, 0xac, 0xd0, 0xc0, 0x0a, 0x26, 0x54, 0x6a, 0xbf, 0x95, 0xab, 0xfd, 0x98, 0x93, 0x60,
+	0x00, 0x16, 0x08, 0x75, 0xe8, 0x88, 0x48, 0xed, 0x37, 0x72, 0xb5, 0x1f, 0x71, 0x12, 0x5b, 0x92,
-	0x49, 0x5a, 0x48, 0xbd, 0x9e, 0x55, 0x8f, 0xb6, 0x01, 0x28, 0x19, 0x3a, 0xc4, 0x0d, 0x3a, 0x6d,
+	0x16, 0x52, 0x6f, 0x66, 0xd5, 0xa3, 0x75, 0x00, 0x82, 0xfb, 0x1e, 0xf6, 0xe9, 0x5e, 0x9b, 0x34,
-	0xda, 0x58, 0xda, 0xd1, 0x9b, 0x3a, 0x8e, 0xed, 0x98, 0x7f, 0xd0, 0x60, 0xe3, 0x38, 0x5c, 0x86,
+	0xe6, 0x36, 0xcc, 0x4d, 0xd3, 0x8e, 0xed, 0x58, 0x7f, 0x36, 0x60, 0xe5, 0x48, 0x2d, 0x95, 0x77,
-	0xde, 0xb9, 0x09, 0xcb, 0x7d, 0x6f, 0xe2, 0x06, 0xdc, 0xc0, 0x35, 0x2c, 0x16, 0xe8, 0x2e, 0xd4,
+	0xae, 0xc3, 0x7c, 0x37, 0x18, 0xf9, 0x94, 0x1b, 0xb8, 0x64, 0x8b, 0x05, 0xba, 0x0d, 0xb5, 0xee,
-	0xfa, 0xa7, 0x96, 0xeb, 0x92, 0x51, 0xd7, 0xb5, 0x1c, 0xc2, 0x4d, 0xa9, 0xe0, 0xaa, 0xdc, 0x7b,
+	0xa9, 0xe3, 0xfb, 0x78, 0xd0, 0xf1, 0x1d, 0x0f, 0x73, 0x53, 0x2a, 0x76, 0x55, 0xee, 0x3d, 0x71,
-	0x6a, 0x39, 0xa4, 0x90, 0x45, 0x3b, 0x50, 0x1d, 0x5b, 0x7e, 0x60, 0x27, 0x7c, 0x16, 0xdf, 0x32,
+	0x3c, 0x5c, 0xc8, 0xa2, 0x0d, 0xa8, 0x0e, 0x9d, 0x90, 0xba, 0x09, 0x9f, 0xc5, 0xb7, 0xac, 0x7f,
-	0xff, 0xaa, 0xc1, 0xd6, 0x07, 0x94, 0xda, 0x43, 0x37, 0x63, 0xd9, 0x16, 0xac, 0xb8, 0xde, 0x80,
+	0x18, 0xb0, 0xf6, 0x11, 0x21, 0x6e, 0xdf, 0xcf, 0x58, 0xb6, 0x06, 0x0b, 0x7e, 0xd0, 0xc3, 0x7b,
-	0x74, 0xda, 0xdc, 0x34, 0x1d, 0xcb, 0x15, 0xba, 0x05, 0x95, 0x31, 0x21, 0x7e, 0xd7, 0xf7, 0x46,
+	0x6d, 0x6e, 0x9a, 0x69, 0xcb, 0x15, 0xba, 0x01, 0x95, 0x21, 0xc6, 0x61, 0x27, 0x0c, 0x06, 0xca,
-	0xa1, 0x61, 0x65, 0xb6, 0x81, 0xbd, 0x11, 0x41, 0x3f, 0x81, 0x4d, 0x9a, 0x12, 0x44, 0x1b, 0xfa,
+	0xb0, 0x32, 0xdb, 0xb0, 0x83, 0x01, 0x46, 0xbf, 0x80, 0x55, 0x92, 0x12, 0x44, 0x1a, 0xe6, 0x86,
-	0x8e, 0xde, 0xac, 0xb6, 0xbe, 0xbe, 0x9b, 0x89, 0xb2, 0xdd, 0xb4, 0x52, 0x9c, 0xe5, 0x36, 0x3f,
+	0xb9, 0x59, 0x6d, 0x7d, 0x7b, 0x2b, 0x13, 0x65, 0x5b, 0x69, 0xa5, 0x76, 0x96, 0xdb, 0xfa, 0xb2,
-	0x2f, 0xc1, 0x57, 0x14, 0x9d, 0xb0, 0x95, 0xfd, 0x66, 0x9e, 0xa3, 0x64, 0xa8, 0xcc, 0x13, 0x8b,
+	0x04, 0xdf, 0xd0, 0x74, 0xc2, 0x56, 0xf6, 0x9b, 0x79, 0x8e, 0xe0, 0xbe, 0x36, 0x4f, 0x2c, 0x8a,
-	0x22, 0x9e, 0x53, 0x2e, 0xd7, 0xe3, 0x2e, 0x2f, 0x10, 0x60, 0x69, 0x7f, 0x2e, 0x67, 0xfc, 0x89,
+	0x78, 0x4e, 0xbb, 0xdc, 0x8c, 0xbb, 0xbc, 0x40, 0x80, 0xa5, 0xfd, 0x39, 0x9f, 0xf1, 0x27, 0xba,
-	0xee, 0x40, 0x95, 0x5c, 0x8c, 0x6d, 0x9f, 0x74, 0x03, 0xdb, 0x21, 0x8d, 0x95, 0x1d, 0xad, 0xb9,
+	0x05, 0x55, 0x7c, 0x3e, 0x74, 0x43, 0xdc, 0xa1, 0xae, 0x87, 0x1b, 0x0b, 0x1b, 0xc6, 0xe6, 0x9c,
-	0x84, 0x41, 0x6c, 0x3d, 0xb3, 0x9d, 0x78, 0x44, 0xae, 0x16, 0x8e, 0x48, 0xf3, 0xef, 0x1a, 0xbc,
+	0x0d, 0x62, 0xeb, 0xa9, 0xeb, 0xc5, 0x23, 0x72, 0xb1, 0x70, 0x44, 0x5a, 0xff, 0x34, 0xe0, 0xad,
-	0x96, 0xb9, 0x25, 0x19, 0xe2, 0x18, 0x36, 0xf8, 0xc9, 0x23, 0xcf, 0xb0, 0x60, 0x67, 0x0e, 0x7f,
+	0xcc, 0x2d, 0xc9, 0x10, 0xb7, 0x61, 0x85, 0x9f, 0x3c, 0xf2, 0x0c, 0x0b, 0x76, 0xe6, 0xf0, 0x3b,
-	0x73, 0x96, 0xc3, 0x23, 0x72, 0x9c, 0xe1, 0x8f, 0x19, 0x59, 0x2a, 0x6e, 0xe4, 0x19, 0xbc, 0x76,
+	0x93, 0x1c, 0x1e, 0x91, 0xdb, 0x19, 0xfe, 0x98, 0x91, 0xa5, 0xe2, 0x46, 0x3e, 0x83, 0xb7, 0x76,
-	0x40, 0x02, 0xa9, 0x80, 0x7d, 0x23, 0x74, 0xf1, 0x12, 0x90, 0xcc, 0xa5, 0x52, 0x26, 0x97, 0xfe,
+	0x31, 0x95, 0x0a, 0xd8, 0x37, 0x4c, 0x66, 0x2f, 0x01, 0xc9, 0x5c, 0x2a, 0x65, 0x72, 0xe9, 0x3f,
-	0x5d, 0x52, 0xb9, 0xc4, 0x55, 0x75, 0xdc, 0x13, 0x0f, 0xdd, 0x86, 0x8a, 0x22, 0x91, 0x51, 0x11,
+	0x25, 0x9d, 0x4b, 0x5c, 0xd5, 0x9e, 0x7f, 0x12, 0xa0, 0x9b, 0x50, 0xd1, 0x24, 0x32, 0x2a, 0xa2,
-	0x6d, 0xa0, 0xef, 0xc2, 0x32, 0xb3, 0x54, 0x84, 0x44, 0xbd, 0x75, 0x37, 0xff, 0x4c, 0x31, 0x99,
+	0x0d, 0xf4, 0x43, 0x98, 0x67, 0x96, 0x8a, 0x90, 0xa8, 0xb7, 0x6e, 0xe7, 0x9f, 0x29, 0x26, 0xd3,
-	0x58, 0xd0, 0xa3, 0x0e, 0xd4, 0x69, 0x60, 0xf9, 0x41, 0x77, 0xec, 0x51, 0x7e, 0xcf, 0x3c, 0x70,
+	0x16, 0xf4, 0x68, 0x0f, 0xea, 0x84, 0x3a, 0x21, 0xed, 0x0c, 0x03, 0xc2, 0xef, 0x99, 0x07, 0x4e,
-	0xaa, 0x2d, 0x33, 0x29, 0x41, 0x95, 0xc8, 0x27, 0x74, 0x78, 0x24, 0x29, 0xf1, 0x1a, 0xe7, 0x0c,
+	0xb5, 0x65, 0x25, 0x25, 0xe8, 0x12, 0x79, 0x40, 0xfa, 0x87, 0x92, 0xd2, 0x5e, 0xe2, 0x9c, 0x6a,
-	0x97, 0xe8, 0x43, 0xa8, 0x11, 0x77, 0x10, 0x09, 0x5a, 0x2a, 0x2c, 0xa8, 0x4a, 0xdc, 0x81, 0x12,
+	0x89, 0x3e, 0x86, 0x1a, 0xf6, 0x7b, 0x91, 0xa0, 0xb9, 0xc2, 0x82, 0xaa, 0xd8, 0xef, 0x69, 0x31,
-	0x13, 0xdd, 0xcf, 0x72, 0xf1, 0xfb, 0xf9, 0x8d, 0x06, 0x8d, 0xec, 0x05, 0x5d, 0xa5, 0x50, 0x3e,
+	0xd1, 0xfd, 0xcc, 0x17, 0xbf, 0x9f, 0xdf, 0x1b, 0xd0, 0xc8, 0x5e, 0xd0, 0x65, 0x0a, 0xe5, 0x43,
-	0x14, 0x4c, 0x44, 0x5c, 0xd0, 0xcc, 0x0c, 0x57, 0x97, 0x84, 0x25, 0x8b, 0x69, 0xc3, 0x57, 0x23,
+	0xc1, 0x84, 0xc5, 0x05, 0x4d, 0xcc, 0x70, 0x7d, 0x49, 0xb6, 0x64, 0xb1, 0x5c, 0xf8, 0x66, 0x64,
-	0x6b, 0xf8, 0x97, 0x57, 0x16, 0x2c, 0x3f, 0xd7, 0x60, 0x2b, 0xad, 0xeb, 0x2a, 0xe7, 0xfe, 0x36,
+	0x0d, 0xff, 0xf2, 0xda, 0x82, 0xe5, 0xd7, 0x06, 0xac, 0xa5, 0x75, 0x5d, 0xe6, 0xdc, 0xdf, 0x87,
-	0x2c, 0xdb, 0xee, 0x89, 0x17, 0x1e, 0x7b, 0x7b, 0x46, 0x9e, 0x31, 0x5d, 0x82, 0xd8, 0x74, 0xe0,
+	0x79, 0xd7, 0x3f, 0x09, 0xd4, 0xb1, 0xd7, 0x27, 0xe4, 0x19, 0xd3, 0x25, 0x88, 0x2d, 0x0f, 0x6e,
-	0xd6, 0x01, 0x09, 0x3a, 0x2e, 0x25, 0x7e, 0xf0, 0xc8, 0x76, 0x47, 0xde, 0xf0, 0xc8, 0x0a, 0x4e,
+	0xec, 0x62, 0xba, 0xe7, 0x13, 0x1c, 0xd2, 0x47, 0xae, 0x3f, 0x08, 0xfa, 0x87, 0x0e, 0x3d, 0xbd,
-	0xaf, 0x90, 0x23, 0x89, 0x70, 0x2f, 0xa5, 0xc2, 0xdd, 0xfc, 0xa7, 0x06, 0xb7, 0xf3, 0xf5, 0xc9,
+	0x44, 0x8e, 0x24, 0xc2, 0xbd, 0x94, 0x0a, 0x77, 0xeb, 0x5f, 0x06, 0xdc, 0xcc, 0xd7, 0x27, 0x8f,
-	0xa3, 0x1b, 0x50, 0x3e, 0xb1, 0xc9, 0x68, 0xc0, 0x7c, 0xa6, 0x71, 0x9f, 0xa9, 0x35, 0xcb, 0x95,
+	0xde, 0x84, 0xf2, 0x89, 0x8b, 0x07, 0x3d, 0xe6, 0x33, 0x83, 0xfb, 0x4c, 0xaf, 0x59, 0xae, 0x0c,
-	0x31, 0x23, 0x96, 0x27, 0xbc, 0x3b, 0x25, 0x40, 0x8f, 0x03, 0xdf, 0x76, 0x87, 0x87, 0x36, 0x0d,
+	0x19, 0xb1, 0x3c, 0xe1, 0xed, 0x31, 0x01, 0x7a, 0x44, 0x43, 0xd7, 0xef, 0xef, 0xbb, 0x84, 0xda,
-	0xb0, 0xa0, 0x8f, 0xf9, 0x53, 0x2f, 0x1e, 0x99, 0xbf, 0xd6, 0x60, 0xfb, 0x80, 0x04, 0xfb, 0xaa,
+	0x82, 0x3e, 0xe6, 0x4f, 0xb3, 0x78, 0x64, 0xfe, 0xce, 0x80, 0xf5, 0x5d, 0x4c, 0x77, 0x74, 0xa9,
-	0xd4, 0xb2, 0xef, 0x36, 0x0d, 0xec, 0x3e, 0x7d, 0xb5, 0x20, 0x22, 0xa7, 0x67, 0x9a, 0xbf, 0xd3,
+	0x65, 0xdf, 0x5d, 0x42, 0xdd, 0x2e, 0x79, 0xbd, 0x20, 0x22, 0xa7, 0x67, 0x5a, 0x7f, 0x34, 0xe0,
-	0xe0, 0xce, 0x54, 0x63, 0xa4, 0xeb, 0x64, 0x29, 0x09, 0x0b, 0x6d, 0x7e, 0x29, 0xf9, 0x11, 0x79,
+	0xd6, 0x58, 0x63, 0xa4, 0xeb, 0x64, 0x29, 0x51, 0x85, 0x36, 0xbf, 0x94, 0xfc, 0x0c, 0xbf, 0xf8,
-	0xf1, 0xb1, 0x35, 0x9a, 0x90, 0x23, 0xcb, 0xf6, 0x45, 0x29, 0x59, 0xb0, 0xb0, 0xfe, 0x4b, 0x83,
+	0xd4, 0x19, 0x8c, 0xf0, 0xa1, 0xe3, 0x86, 0xa2, 0x94, 0xcc, 0x58, 0x58, 0xff, 0x6d, 0xc0, 0xdb,
-	0xd7, 0x0f, 0x48, 0x70, 0x14, 0xb6, 0x99, 0x6b, 0xf4, 0x4e, 0x01, 0x44, 0xf1, 0x5b, 0x71, 0x99,
+	0xbb, 0x98, 0x1e, 0xaa, 0x36, 0x73, 0x85, 0xde, 0x29, 0x80, 0x28, 0xfe, 0x20, 0x2e, 0x33, 0xd7,
-	0xb9, 0xd6, 0x5e, 0x8b, 0xfb, 0xb6, 0x79, 0x1e, 0xc4, 0x12, 0x72, 0x5f, 0x60, 0x01, 0xe9, 0x3c,
+	0xda, 0x2b, 0x71, 0xdf, 0x3a, 0xcf, 0x83, 0x58, 0x42, 0xee, 0x08, 0x2c, 0x20, 0x9d, 0x67, 0xfd,
-	0xf3, 0x4f, 0x25, 0xa8, 0x7d, 0x2c, 0xf1, 0x01, 0x6f, 0x23, 0x69, 0x3f, 0x68, 0xf9, 0x7e, 0x88,
+	0xb5, 0x04, 0xb5, 0x4f, 0x25, 0x3e, 0xe0, 0x6d, 0x24, 0xed, 0x07, 0x23, 0xdf, 0x0f, 0x31, 0x48,
-	0x41, 0x8a, 0x3c, 0x94, 0x71, 0x00, 0x6b, 0x94, 0x90, 0xb3, 0x45, 0x9a, 0x46, 0x8d, 0x31, 0xaa,
+	0x91, 0x87, 0x32, 0x76, 0x61, 0x89, 0x60, 0xfc, 0x6c, 0x96, 0xa6, 0x51, 0x63, 0x8c, 0xba, 0xd8,
-	0x62, 0x7f, 0x08, 0x9b, 0x13, 0xf7, 0x84, 0xc1, 0x5a, 0x32, 0x90, 0xa7, 0x10, 0xe8, 0x72, 0x7e,
+	0xef, 0xc3, 0xea, 0xc8, 0x3f, 0x61, 0xb0, 0x16, 0xf7, 0xe4, 0x29, 0x04, 0xba, 0x9c, 0x5e, 0x79,
-	0xe5, 0xc9, 0x32, 0xa2, 0x26, 0xac, 0xa7, 0x65, 0x2d, 0xf3, 0xe4, 0x4f, 0x6f, 0x9b, 0xbf, 0xd2,
+	0xb2, 0x8c, 0x68, 0x13, 0x96, 0xd3, 0xb2, 0xe6, 0x79, 0xf2, 0xa7, 0xb7, 0xad, 0xdf, 0x1a, 0xb0,
-	0x60, 0xeb, 0x13, 0x2b, 0xe8, 0x9f, 0xb6, 0x1d, 0xe9, 0xb1, 0x2b, 0xc4, 0xdb, 0xfb, 0x50, 0x39,
+	0xf6, 0x99, 0x43, 0xbb, 0xa7, 0x6d, 0x4f, 0x7a, 0xec, 0x12, 0xf1, 0xf6, 0x21, 0x54, 0xce, 0xa4,
-	0x97, 0xde, 0x09, 0x8b, 0xca, 0x9d, 0x1c, 0xe3, 0xe3, 0xf7, 0x80, 0x23, 0x0e, 0x06, 0x53, 0x6f,
+	0x77, 0x54, 0x51, 0xb9, 0x95, 0x63, 0x7c, 0xfc, 0x1e, 0xec, 0x88, 0x83, 0xc1, 0xd4, 0xeb, 0x1c,
-	0x72, 0x64, 0x1f, 0x5a, 0xf7, 0xe5, 0x47, 0xfe, 0x3c, 0x74, 0x7f, 0x01, 0x20, 0x8d, 0x7b, 0x42,
+	0xd9, 0x2b, 0xeb, 0xde, 0x7c, 0xe4, 0x4f, 0x43, 0xf7, 0xe7, 0x00, 0xd2, 0xb8, 0x03, 0xd2, 0x9f,
-	0x87, 0x0b, 0xd8, 0xf5, 0x1e, 0xac, 0x4a, 0x69, 0x32, 0xb8, 0xe7, 0x5d, 0x6e, 0x48, 0x6e, 0x7e,
+	0xc1, 0xae, 0x0f, 0x60, 0x51, 0x4a, 0x93, 0xc1, 0x3d, 0xed, 0x72, 0x15, 0xb9, 0xf5, 0x09, 0xd4,
-	0x04, 0xb5, 0x76, 0xfb, 0x90, 0xbb, 0xe7, 0x09, 0x09, 0xac, 0x42, 0xf1, 0x7b, 0x17, 0x6a, 0x3d,
+	0xda, 0xed, 0x7d, 0xee, 0x9e, 0x03, 0x4c, 0x9d, 0x42, 0xf1, 0x7b, 0x1b, 0x6a, 0xc7, 0xbc, 0x27,
-	0xde, 0x13, 0xba, 0x51, 0x9d, 0xaf, 0xe0, 0x6a, 0x2f, 0xea, 0x13, 0xe6, 0x4b, 0xa8, 0x47, 0x45,
+	0x74, 0xa2, 0x3a, 0x5f, 0xb1, 0xab, 0xc7, 0x51, 0x9f, 0xb0, 0x5e, 0x42, 0x3d, 0x2a, 0x82, 0x3c,
-	0x90, 0x27, 0x46, 0x1d, 0x4a, 0x4a, 0x5c, 0xa9, 0xd3, 0x46, 0xef, 0xc3, 0x8a, 0x78, 0xf9, 0x49,
+	0x31, 0xea, 0x50, 0xd2, 0xe2, 0x4a, 0x7b, 0x6d, 0xf4, 0x21, 0x2c, 0x88, 0x97, 0x9f, 0xb4, 0xf8,
-	0x8b, 0xdf, 0x48, 0x5a, 0x2c, 0x5f, 0x85, 0xb1, 0x4a, 0xca, 0x37, 0xb0, 0x64, 0x62, 0x1e, 0x55,
+	0x9d, 0xa4, 0xc5, 0xf2, 0x55, 0x18, 0xab, 0xa4, 0x7c, 0xc3, 0x96, 0x4c, 0xcc, 0xa3, 0xba, 0x70,
-	0x85, 0x43, 0x3c, 0x12, 0x74, 0x1c, 0xdb, 0x31, 0xff, 0xab, 0x43, 0x35, 0x76, 0xe0, 0x8c, 0xfa,
+	0x88, 0x47, 0x82, 0x69, 0xc7, 0x76, 0xac, 0xff, 0x99, 0x50, 0x8d, 0x1d, 0x38, 0xa3, 0x3e, 0x7d,
-	0xf4, 0x39, 0x4b, 0xf3, 0xeb, 0x95, 0x9e, 0x45, 0xec, 0x6f, 0x40, 0xdd, 0xe6, 0x3d, 0xb2, 0x2b,
+	0xce, 0xd2, 0xf4, 0x7a, 0x65, 0x66, 0x11, 0xfb, 0x3b, 0x50, 0x77, 0x79, 0x8f, 0xec, 0xc8, 0x68,
-	0xa3, 0x8d, 0x17, 0xb5, 0x0a, 0x5e, 0x13, 0xbb, 0x32, 0xf4, 0xd1, 0x36, 0x54, 0xdd, 0x89, 0xd3,
+	0xe3, 0x45, 0xad, 0x62, 0x2f, 0x89, 0x5d, 0x19, 0xfa, 0x68, 0x1d, 0xaa, 0xfe, 0xc8, 0xeb, 0x04,
-	0xf5, 0x4e, 0xba, 0xbe, 0xf7, 0x9c, 0x4a, 0xe8, 0x5f, 0x71, 0x27, 0xce, 0x8f, 0x4f, 0xb0, 0xf7,
+	0x27, 0x9d, 0x30, 0x78, 0x4e, 0x24, 0xf4, 0xaf, 0xf8, 0x23, 0xef, 0xe7, 0x27, 0x76, 0xf0, 0x9c,
-	0x9c, 0x46, 0xe8, 0x72, 0xe5, 0x92, 0xe8, 0x72, 0x1b, 0xaa, 0x8e, 0x75, 0xc1, 0xa4, 0x76, 0xdd,
+	0x44, 0xe8, 0x72, 0xe1, 0x82, 0xe8, 0x72, 0x1d, 0xaa, 0x9e, 0x73, 0xce, 0xa4, 0x76, 0xfc, 0x91,
-	0x89, 0xc3, 0x5f, 0x05, 0x3a, 0xae, 0x38, 0xd6, 0x05, 0xf6, 0x9e, 0x3f, 0x9d, 0x38, 0xa8, 0x09,
+	0xc7, 0x5f, 0x05, 0xa6, 0x5d, 0xf1, 0x9c, 0x73, 0x3b, 0x78, 0xfe, 0x64, 0xe4, 0xa1, 0x4d, 0x58,
-	0x1b, 0x23, 0x8b, 0x06, 0xdd, 0xf8, 0xb3, 0xa2, 0xcc, 0x9f, 0x15, 0x75, 0xb6, 0xff, 0x61, 0xf4,
+	0x19, 0x38, 0x84, 0x76, 0xe2, 0xcf, 0x8a, 0x32, 0x7f, 0x56, 0xd4, 0xd9, 0xfe, 0xc7, 0xd1, 0xd3,
-	0xb4, 0xc8, 0xe2, 0xd4, 0xca, 0x15, 0x70, 0xea, 0xc0, 0x19, 0x45, 0x82, 0xa0, 0x38, 0x4e, 0x1d,
+	0x22, 0x8b, 0x53, 0x2b, 0x97, 0xc0, 0xa9, 0x3d, 0x6f, 0x10, 0x09, 0x82, 0xe2, 0x38, 0xb5, 0xe7,
-	0x38, 0x23, 0x25, 0xe6, 0x3d, 0x58, 0x15, 0x11, 0x45, 0x1b, 0xd5, 0xa9, 0x05, 0xeb, 0x31, 0x03,
+	0x0d, 0xb4, 0x98, 0x0f, 0x60, 0x51, 0x44, 0x14, 0x69, 0x54, 0xc7, 0x16, 0xac, 0xc7, 0x0c, 0x74,
-	0x1d, 0x02, 0xa0, 0xe0, 0x90, 0xdc, 0x7c, 0x09, 0x37, 0x23, 0x67, 0xc5, 0x0c, 0xcb, 0x9e, 0x51,
+	0x08, 0x80, 0x62, 0x2b, 0x72, 0xeb, 0x25, 0x5c, 0x8f, 0x9c, 0x15, 0x33, 0x2c, 0x7b, 0x46, 0x63,
-	0x5b, 0xf4, 0x8c, 0xb3, 0xe1, 0xd3, 0x2f, 0x75, 0xd8, 0x3a, 0xb6, 0xce, 0xc9, 0xab, 0x47, 0x6a,
+	0xd6, 0x33, 0x4e, 0x86, 0x4f, 0xbf, 0x31, 0x61, 0xed, 0xc8, 0x39, 0xc3, 0xaf, 0x1f, 0xa9, 0x15,
-	0x85, 0xaa, 0xcf, 0x21, 0x6c, 0x72, 0x70, 0xd6, 0x8a, 0xd9, 0x33, 0xa3, 0x09, 0xc4, 0x7d, 0x9a,
+	0xaa, 0x3e, 0xfb, 0xb0, 0xca, 0xc1, 0x59, 0x2b, 0x66, 0xcf, 0x84, 0x26, 0x10, 0xf7, 0x69, 0x96,
-	0x65, 0x44, 0x3f, 0x64, 0xdd, 0x8b, 0xf4, 0xcf, 0x8e, 0x3c, 0x3b, 0x6c, 0x00, 0xd5, 0xd6, 0xeb,
+	0x11, 0xfd, 0x94, 0x75, 0x2f, 0xdc, 0x7d, 0x76, 0x18, 0xb8, 0xaa, 0x01, 0x54, 0x5b, 0x6f, 0xe7,
-	0x39, 0x72, 0xf6, 0x15, 0x15, 0x8e, 0x73, 0xa0, 0x23, 0x58, 0x4f, 0x5e, 0x03, 0x6d, 0xac, 0x70,
+	0xc8, 0xd9, 0xd1, 0x54, 0x76, 0x9c, 0x03, 0x1d, 0xc2, 0x72, 0xf2, 0x1a, 0x48, 0x63, 0x81, 0x0b,
-	0x21, 0x6f, 0xcd, 0x7c, 0x02, 0x44, 0xde, 0xc7, 0xf5, 0xc4, 0x65, 0x50, 0xd4, 0x80, 0x55, 0xd9,
+	0xb9, 0x3b, 0xf1, 0x09, 0x10, 0x79, 0xdf, 0xae, 0x27, 0x2e, 0x83, 0xa0, 0x06, 0x2c, 0xca, 0x06,
-	0x80, 0x78, 0x0a, 0x94, 0x71, 0xb8, 0x64, 0xe8, 0x10, 0x22, 0x3b, 0xe6, 0x3c, 0xf2, 0x7e, 0x00,
+	0xc4, 0x53, 0xa0, 0x6c, 0xab, 0x25, 0x43, 0x87, 0x10, 0xd9, 0x31, 0xe5, 0x91, 0xf7, 0x13, 0x28,
-	0x65, 0x15, 0x19, 0xa5, 0xc2, 0x91, 0xa1, 0x78, 0xd2, 0x69, 0xae, 0xa7, 0xd2, 0xdc, 0xfc, 0x42,
+	0xeb, 0xc8, 0x28, 0x15, 0x8e, 0x0c, 0xcd, 0x93, 0x4e, 0x73, 0x33, 0x95, 0xe6, 0xd6, 0x2b, 0x03,
-	0x83, 0xb5, 0xb6, 0x15, 0x58, 0x4f, 0xbd, 0x01, 0x79, 0xb6, 0x60, 0xa5, 0x2f, 0x30, 0xa2, 0xb8,
+	0x96, 0xda, 0x0e, 0x75, 0x9e, 0x04, 0x3d, 0xfc, 0x74, 0xc6, 0x4a, 0x5f, 0x60, 0x44, 0x71, 0x13,
-	0x0d, 0x15, 0x96, 0xe8, 0x34, 0xb0, 0x9c, 0x31, 0x37, 0x62, 0x09, 0x47, 0x1b, 0xec, 0x3d, 0xb3,
+	0x2a, 0x2c, 0xd1, 0x09, 0x75, 0xbc, 0x21, 0x37, 0x62, 0xce, 0x8e, 0x36, 0xd8, 0x7b, 0x66, 0x49,
-	0x26, 0xeb, 0xd2, 0xb1, 0x1a, 0x59, 0x71, 0x51, 0x1a, 0x17, 0xc5, 0x7f, 0xa3, 0xef, 0x25, 0xdf,
+	0xd6, 0xa5, 0x23, 0x3d, 0xb2, 0xe2, 0xa2, 0x0c, 0x2e, 0x8a, 0xff, 0x46, 0x3f, 0x4a, 0xbe, 0x77,
-	0xbb, 0xdf, 0xc8, 0xbd, 0x5e, 0x2e, 0x84, 0x77, 0xf9, 0x44, 0x51, 0x2a, 0x02, 0x94, 0x3f, 0xd7,
+	0xbf, 0x93, 0x7b, 0xbd, 0x5c, 0x08, 0xef, 0xf2, 0x89, 0xa2, 0x54, 0x04, 0x28, 0x7f, 0x69, 0x40,
-	0xa0, 0x16, 0xba, 0x82, 0xd7, 0xe7, 0x06, 0xac, 0x5a, 0x83, 0x81, 0x4f, 0x28, 0x95, 0x76, 0x84,
+	0x4d, 0xb9, 0x82, 0xd7, 0xe7, 0x06, 0x2c, 0x3a, 0xbd, 0x5e, 0x88, 0x09, 0x91, 0x76, 0xa8, 0x25,
-	0x4b, 0xf6, 0xe5, 0x9c, 0xf8, 0x34, 0xbc, 0x14, 0x1d, 0x87, 0x4b, 0xf4, 0x7d, 0x28, 0x2b, 0x58,
+	0xfb, 0x72, 0x86, 0x43, 0xa2, 0x2e, 0xc5, 0xb4, 0xd5, 0x12, 0xfd, 0x18, 0xca, 0x1a, 0x16, 0x88,
-	0x20, 0xc6, 0x44, 0x3b, 0xd3, 0xed, 0x94, 0xc0, 0x4e, 0x71, 0x98, 0x3e, 0xd4, 0x65, 0x70, 0x89,
+	0x31, 0xd1, 0xc6, 0x78, 0x3b, 0x25, 0xb0, 0xd3, 0x1c, 0x56, 0x08, 0x75, 0x19, 0x5c, 0x22, 0xba,
-	0xe8, 0xa6, 0x73, 0xa2, 0xe3, 0x11, 0xd4, 0x4e, 0xa2, 0xcc, 0x98, 0xf5, 0x7e, 0x8b, 0x27, 0x50,
+	0xc9, 0x94, 0xe8, 0x78, 0x04, 0xb5, 0x93, 0x28, 0x33, 0x26, 0xbd, 0xdf, 0xe2, 0x09, 0x94, 0xe0,
-	0x82, 0xc7, 0xfc, 0x00, 0xaa, 0xb1, 0x8f, 0x3c, 0x6e, 0xc5, 0xab, 0x49, 0xaa, 0x0b, 0x97, 0xec,
+	0xb1, 0x3e, 0x82, 0x6a, 0xec, 0x23, 0x8f, 0x5b, 0xf1, 0x6a, 0x92, 0xea, 0xd4, 0x92, 0x7d, 0x39,
-	0x4b, 0x2f, 0xa6, 0xa7, 0x12, 0x15, 0xb7, 0xff, 0x68, 0x7c, 0x54, 0x82, 0x49, 0xdf, 0x3b, 0x27,
+	0x8e, 0xe9, 0xa9, 0x44, 0xc5, 0xed, 0xbf, 0x06, 0x1f, 0x95, 0xd8, 0xb8, 0x1b, 0x9c, 0xe1, 0xf0,
-	0xfe, 0x8b, 0xab, 0x3f, 0x48, 0x1f, 0xc6, 0xbc, 0x58, 0x10, 0x5c, 0x29, 0x06, 0xf4, 0x30, 0xb2,
+	0xc5, 0xe5, 0x1f, 0xa4, 0x0f, 0x63, 0x5e, 0x2c, 0x08, 0xae, 0x34, 0x03, 0x7a, 0x18, 0xd9, 0x69,
-	0x53, 0xcf, 0xc3, 0xe3, 0xf1, 0x1c, 0x96, 0x4e, 0x88, 0x8e, 0xf2, 0x7b, 0xf1, 0xb4, 0x4e, 0x1e,
+	0xe6, 0xe1, 0xf1, 0x78, 0x0e, 0x4b, 0x27, 0x44, 0x47, 0xf9, 0x93, 0x78, 0x5a, 0x27, 0x8f, 0x32,
-	0x65, 0xd1, 0x32, 0xf9, 0x7f, 0x69, 0xe8, 0xe6, 0x1f, 0x35, 0xf8, 0xda, 0x01, 0x09, 0x1e, 0x27,
+	0x6b, 0x99, 0xfc, 0x5a, 0x1a, 0xba, 0xf5, 0x17, 0x03, 0xbe, 0xb5, 0x8b, 0xe9, 0xe3, 0x24, 0x9c,
-	0xe1, 0xec, 0x75, 0x5b, 0xe5, 0x80, 0x91, 0x67, 0xd4, 0x55, 0x6e, 0xdd, 0x80, 0x32, 0x0d, 0x31,
+	0xbd, 0x6a, 0xab, 0x3c, 0x68, 0xe6, 0x19, 0x75, 0x99, 0x5b, 0x6f, 0x42, 0x99, 0x28, 0x0c, 0x2f,
-	0xbc, 0x18, 0x7a, 0xa8, 0xb5, 0xf9, 0x0b, 0x0d, 0x1a, 0x52, 0x0b, 0xd7, 0xb9, 0xef, 0x39, 0xe3,
+	0x86, 0x1e, 0x7a, 0x6d, 0x7d, 0x65, 0x40, 0x43, 0x6a, 0xe1, 0x3a, 0x77, 0x02, 0x6f, 0x38, 0xc0,
-	0x11, 0x09, 0xc8, 0xe0, 0xcb, 0x06, 0xa7, 0x7f, 0xd1, 0x60, 0x23, 0x5e, 0x66, 0x78, 0xa5, 0xf8,
+	0x14, 0xf7, 0xde, 0x34, 0x38, 0xfd, 0xbb, 0x01, 0x2b, 0xf1, 0x32, 0xc3, 0x2b, 0xc5, 0x0f, 0x60,
-	0x0e, 0x2c, 0x73, 0x6c, 0x2f, 0x2d, 0x98, 0x1b, 0xac, 0x82, 0x9a, 0x65, 0x14, 0xef, 0x1a, 0xcf,
+	0x9e, 0x63, 0x7b, 0x69, 0xc1, 0xd4, 0x60, 0x15, 0xd4, 0x2c, 0xa3, 0x78, 0xd7, 0x78, 0x4a, 0x54,
-	0x68, 0x58, 0x46, 0xe4, 0x32, 0xaa, 0x75, 0xfa, 0xa5, 0x6b, 0x9d, 0x79, 0x0c, 0x5b, 0xa1, 0xa7,
+	0x19, 0x91, 0xcb, 0xa8, 0xd6, 0x99, 0x17, 0xae, 0x75, 0xd6, 0x11, 0xac, 0x29, 0x4f, 0x45, 0x79,
-	0xa2, 0xbc, 0xe6, 0x40, 0x7a, 0x7a, 0x6e, 0xdf, 0x81, 0x6a, 0x0c, 0x3e, 0xcb, 0x0a, 0x0e, 0x11,
+	0xcd, 0x81, 0xf4, 0xf8, 0xdc, 0xbe, 0x05, 0xd5, 0x18, 0x7c, 0x96, 0x15, 0x1c, 0x22, 0xf4, 0x7c,
-	0x7a, 0xbe, 0x77, 0x1f, 0x36, 0x33, 0x0a, 0x51, 0x1d, 0xe0, 0x23, 0xb7, 0x2f, 0x6f, 0x62, 0xe3,
+	0xef, 0x3e, 0xac, 0x66, 0x14, 0xa2, 0x3a, 0xc0, 0x27, 0x7e, 0x57, 0xde, 0xc4, 0xca, 0x35, 0x54,
-	0x06, 0xaa, 0x41, 0x39, 0xbc, 0x97, 0x0d, 0xad, 0xf5, 0xb7, 0x1a, 0x54, 0x58, 0x3d, 0xdd, 0xf7,
+	0x83, 0xb2, 0xba, 0x97, 0x15, 0xa3, 0xf5, 0x6a, 0x09, 0x2a, 0xac, 0x9e, 0xee, 0x04, 0x41, 0xd8,
-	0x3c, 0x7f, 0x80, 0xc6, 0x80, 0xf8, 0x14, 0xc2, 0x19, 0x7b, 0xae, 0x1a, 0xd7, 0xa1, 0x77, 0xa7,
+	0x43, 0x43, 0x40, 0x7c, 0x0a, 0xe1, 0x0d, 0x03, 0x5f, 0x8f, 0xeb, 0xd0, 0xfb, 0x63, 0x9a, 0x59,
-	0x34, 0xb3, 0x2c, 0xa9, 0x8c, 0x77, 0xe3, 0xcd, 0x29, 0x1c, 0x29, 0x72, 0xf3, 0x06, 0x72, 0xb8,
+	0x96, 0x54, 0xc6, 0x7b, 0xf3, 0xce, 0x18, 0x8e, 0x14, 0xb9, 0x75, 0x0d, 0x79, 0x5c, 0x23, 0x43,
-	0x46, 0x86, 0x24, 0x9f, 0xd9, 0xfd, 0xb3, 0x10, 0xf7, 0xce, 0xd0, 0x98, 0x22, 0x0d, 0x35, 0xa6,
+	0x92, 0x4f, 0xdd, 0xee, 0x33, 0x85, 0x7b, 0x27, 0x68, 0x4c, 0x91, 0x2a, 0x8d, 0xa9, 0x29, 0xa0,
-	0xa6, 0x80, 0x72, 0x21, 0x46, 0x45, 0x61, 0xc0, 0x9b, 0x37, 0xd0, 0x67, 0x70, 0x93, 0x3d, 0xcb,
+	0x5c, 0x88, 0x51, 0x91, 0x0a, 0x78, 0xeb, 0x1a, 0xfa, 0x02, 0xae, 0xb3, 0x67, 0xb9, 0x9e, 0x0e,
-	0xd5, 0x74, 0x20, 0x54, 0xd8, 0x9a, 0xae, 0x30, 0x43, 0x7c, 0x49, 0x95, 0x87, 0xb0, 0xcc, 0x93,
+	0x28, 0x85, 0xad, 0xf1, 0x0a, 0x33, 0xc4, 0x17, 0x54, 0xb9, 0x0f, 0xf3, 0x3c, 0x19, 0x50, 0x5e,
-	0x01, 0xe5, 0x05, 0x5c, 0xfc, 0x6f, 0x56, 0xc6, 0xce, 0x74, 0x02, 0x25, 0xed, 0x67, 0xb0, 0x9e,
+	0xc0, 0xc5, 0xff, 0x66, 0xd5, 0xdc, 0x18, 0x4f, 0xa0, 0xa5, 0xfd, 0x0a, 0x96, 0x53, 0x33, 0x79,
-	0x9a, 0xc9, 0xa3, 0xb7, 0x73, 0xd8, 0xf2, 0xff, 0xba, 0x62, 0xdc, 0x2b, 0x42, 0xaa, 0x74, 0x0d,
+	0xf4, 0x6e, 0x0e, 0x5b, 0xfe, 0x5f, 0x57, 0x9a, 0xf7, 0x8a, 0x90, 0x6a, 0x5d, 0x7d, 0xa8, 0x27,
-	0xa1, 0x9e, 0x9c, 0x61, 0xa0, 0x66, 0x0e, 0x7f, 0xee, 0x3c, 0xd5, 0x78, 0xbb, 0x00, 0xa5, 0x52,
+	0x67, 0x18, 0x68, 0x33, 0x87, 0x3f, 0x77, 0x9e, 0xda, 0x7c, 0xb7, 0x00, 0xa5, 0x56, 0xe4, 0xc1,
-	0xe4, 0xc0, 0x46, 0x7a, 0x46, 0x8c, 0xee, 0xcd, 0x14, 0x90, 0x0c, 0xb7, 0x6f, 0x16, 0xa2, 0x55,
+	0x4a, 0x7a, 0x46, 0x8c, 0xee, 0x4d, 0x14, 0x90, 0x0c, 0xb7, 0xef, 0x16, 0xa2, 0xd5, 0xea, 0x5e,
-	0xea, 0x5e, 0xf0, 0x20, 0xc8, 0xcc, 0x28, 0xd1, 0x6e, 0xbe, 0x98, 0x69, 0xc3, 0x53, 0x63, 0xaf,
+	0xf0, 0x20, 0xc8, 0xcc, 0x28, 0xd1, 0x56, 0xbe, 0x98, 0x71, 0xc3, 0xd3, 0xe6, 0x76, 0x61, 0x7a,
-	0x30, 0xbd, 0x52, 0xfd, 0x85, 0x68, 0xc2, 0x79, 0x73, 0x3e, 0x74, 0x3f, 0x5f, 0xdc, 0x8c, 0x01,
+	0xad, 0xfa, 0x95, 0x68, 0xc2, 0x79, 0x73, 0x3e, 0x74, 0x3f, 0x5f, 0xdc, 0x84, 0x01, 0x65, 0xb3,
-	0xa5, 0xd1, 0xba, 0x0c, 0x8b, 0x32, 0xe2, 0x25, 0xef, 0x9e, 0x39, 0xb3, 0xb2, 0x74, 0xde, 0x85,
+	0x75, 0x11, 0x16, 0x6d, 0xc4, 0x4b, 0xde, 0x3d, 0x73, 0x66, 0x65, 0xe9, 0xbc, 0x53, 0xf2, 0xc6,
-	0xf2, 0xa6, 0x0f, 0x01, 0x8d, 0xfb, 0x97, 0xe0, 0x50, 0x06, 0x78, 0xe9, 0x29, 0x7c, 0x98, 0x86,
+	0x0f, 0x01, 0x9b, 0xf7, 0x2f, 0xc0, 0xa1, 0x0d, 0x08, 0xd2, 0x53, 0x78, 0x95, 0x86, 0xdb, 0x53,
-	0x7b, 0x73, 0xa3, 0x66, 0xb1, 0x1c, 0xfc, 0x14, 0xd6, 0x53, 0xcf, 0xaa, 0xdc, 0xac, 0xc9, 0x7f,
+	0xa3, 0x66, 0xb6, 0x1c, 0xfc, 0x1c, 0x96, 0x53, 0xcf, 0xaa, 0xdc, 0xac, 0xc9, 0x7f, 0x7a, 0x35,
-	0x7a, 0x19, 0xb3, 0xfa, 0xa2, 0x48, 0xc9, 0x14, 0x18, 0x41, 0x53, 0xa2, 0x3f, 0x07, 0xb0, 0x18,
+	0x27, 0xf5, 0x45, 0x91, 0x92, 0x29, 0x30, 0x82, 0xc6, 0x44, 0x7f, 0x0e, 0x60, 0x69, 0xde, 0x2b,
-	0xf7, 0x8a, 0x90, 0xaa, 0x83, 0x50, 0x5e, 0x2e, 0x53, 0x0d, 0x1d, 0x7d, 0x2b, 0x5f, 0x46, 0x3e,
+	0x42, 0xaa, 0x0f, 0x42, 0x78, 0xb9, 0x4c, 0x35, 0x74, 0xf4, 0xbd, 0x7c, 0x19, 0xf9, 0x60, 0xa4,
-	0x18, 0x31, 0xde, 0x29, 0x48, 0x1d, 0x2a, 0x6d, 0xfd, 0x43, 0x87, 0x72, 0x88, 0xb9, 0xaf, 0xa1,
+	0xf9, 0x5e, 0x41, 0x6a, 0xad, 0xb4, 0x03, 0xb0, 0x8b, 0xe9, 0x01, 0xa6, 0x21, 0x8b, 0x91, 0x3b,
-	0x45, 0x5c, 0x43, 0xcd, 0xfe, 0x14, 0xd6, 0x53, 0x43, 0xc8, 0xdc, 0x2b, 0xcd, 0x1f, 0x54, 0xce,
+	0xb9, 0x2e, 0x8f, 0x08, 0x94, 0x9a, 0xbb, 0x53, 0xe9, 0x94, 0x82, 0xd6, 0x57, 0x73, 0x50, 0x56,
-	0x8b, 0x97, 0x4f, 0xe4, 0xff, 0x0b, 0xa8, 0xeb, 0x7b, 0x6b, 0x5a, 0xdd, 0x4f, 0xdf, 0xdc, 0x6c,
+	0xa0, 0xfe, 0x0a, 0x7a, 0xd0, 0x15, 0x34, 0x85, 0xcf, 0x61, 0x39, 0x35, 0xe5, 0xcc, 0x8d, 0x99,
-	0xc1, 0x8f, 0x1e, 0xfc, 0xf4, 0xfe, 0xd0, 0x0e, 0x4e, 0x27, 0x3d, 0xf6, 0x65, 0x4f, 0x90, 0xbe,
+	0xfc, 0x49, 0xe8, 0xb4, 0x80, 0xfc, 0x4c, 0xfe, 0x43, 0x82, 0x8e, 0x8f, 0xbb, 0xe3, 0x1a, 0x4b,
-	0x63, 0x7b, 0xf2, 0xd7, 0x5e, 0xe8, 0xa0, 0x3d, 0xce, 0xbd, 0xc7, 0xd4, 0x8c, 0x7b, 0xbd, 0x15,
+	0x3a, 0x34, 0xa6, 0x08, 0x7e, 0xdd, 0x81, 0xf0, 0xe8, 0xc1, 0x2f, 0xef, 0xf7, 0x5d, 0x7a, 0x3a,
-	0xbe, 0x7a, 0xf0, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x44, 0x51, 0x2e, 0xe7, 0xa0, 0x21, 0x00,
+	0x3a, 0x66, 0xaa, 0xb7, 0x05, 0xe5, 0x7b, 0x6e, 0x20, 0x7f, 0x6d, 0xab, 0x1b, 0xd8, 0xe6, 0x92,
-	0x00,
+	0xb6, 0xd9, 0x39, 0x86, 0xc7, 0xc7, 0x0b, 0x7c, 0xf5, 0xe0, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0xd5, 0xbb, 0xa2, 0xe1, 0x62, 0x22, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2486,6 +2487,8 @@ type DataCoordClient interface {
 	SaveBinlogPaths(ctx context.Context, in *SaveBinlogPathsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	GetRecoveryInfo(ctx context.Context, in *GetRecoveryInfoRequest, opts ...grpc.CallOption) (*GetRecoveryInfoResponse, error)
 	GetFlushedSegments(ctx context.Context, in *GetFlushedSegmentsRequest, opts ...grpc.CallOption) (*GetFlushedSegmentsResponse, error)
+	// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
+	GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error)
 }
 
 type dataCoordClient struct {
@@ -2622,6 +2625,15 @@ func (c *dataCoordClient) GetFlushedSegments(ctx context.Context, in *GetFlushed
 	return out, nil
 }
 
+func (c *dataCoordClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error) {
+	out := new(milvuspb.GetMetricsResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/GetMetrics", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // DataCoordServer is the server API for DataCoord service.
 type DataCoordServer interface {
 	GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
@@ -2638,6 +2650,8 @@ type DataCoordServer interface {
 	SaveBinlogPaths(context.Context, *SaveBinlogPathsRequest) (*commonpb.Status, error)
 	GetRecoveryInfo(context.Context, *GetRecoveryInfoRequest) (*GetRecoveryInfoResponse, error)
 	GetFlushedSegments(context.Context, *GetFlushedSegmentsRequest) (*GetFlushedSegmentsResponse, error)
+	// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
+	GetMetrics(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)
 }
 
 // UnimplementedDataCoordServer can be embedded to have forward compatible implementations.
@@ -2686,6 +2700,9 @@ func (*UnimplementedDataCoordServer) GetRecoveryInfo(ctx context.Context, req *G
 func (*UnimplementedDataCoordServer) GetFlushedSegments(ctx context.Context, req *GetFlushedSegmentsRequest) (*GetFlushedSegmentsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetFlushedSegments not implemented")
 }
+func (*UnimplementedDataCoordServer) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetMetrics not implemented")
+}
 
 func RegisterDataCoordServer(s *grpc.Server, srv DataCoordServer) {
 	s.RegisterService(&_DataCoord_serviceDesc, srv)
@@ -2943,6 +2960,24 @@ func _DataCoord_GetFlushedSegments_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _DataCoord_GetMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.GetMetricsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DataCoordServer).GetMetrics(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.data.DataCoord/GetMetrics",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DataCoordServer).GetMetrics(ctx, req.(*milvuspb.GetMetricsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _DataCoord_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.data.DataCoord",
 	HandlerType: (*DataCoordServer)(nil),
@@ -3003,6 +3038,10 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetFlushedSegments",
 			Handler:    _DataCoord_GetFlushedSegments_Handler,
 		},
+		{
+			MethodName: "GetMetrics",
+			Handler:    _DataCoord_GetMetrics_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "data_coord.proto",
@@ -3016,6 +3055,8 @@ type DataNodeClient interface {
 	GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
 	WatchDmChannels(ctx context.Context, in *WatchDmChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	FlushSegments(ctx context.Context, in *FlushSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
+	GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error)
 }
 
 type dataNodeClient struct {
@@ -3062,12 +3103,23 @@ func (c *dataNodeClient) FlushSegments(ctx context.Context, in *FlushSegmentsReq
 	return out, nil
 }
 
+func (c *dataNodeClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error) {
+	out := new(milvuspb.GetMetricsResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/GetMetrics", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // DataNodeServer is the server API for DataNode service.
 type DataNodeServer interface {
 	GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
 	GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
 	WatchDmChannels(context.Context, *WatchDmChannelsRequest) (*commonpb.Status, error)
 	FlushSegments(context.Context, *FlushSegmentsRequest) (*commonpb.Status, error)
+	// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
+	GetMetrics(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)
 }
 
 // UnimplementedDataNodeServer can be embedded to have forward compatible implementations.
@@ -3086,6 +3138,9 @@ func (*UnimplementedDataNodeServer) WatchDmChannels(ctx context.Context, req *Wa
 func (*UnimplementedDataNodeServer) FlushSegments(ctx context.Context, req *FlushSegmentsRequest) (*commonpb.Status, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method FlushSegments not implemented")
 }
+func (*UnimplementedDataNodeServer) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetMetrics not implemented")
+}
 
 func RegisterDataNodeServer(s *grpc.Server, srv DataNodeServer) {
 	s.RegisterService(&_DataNode_serviceDesc, srv)
@@ -3163,6 +3218,24 @@ func _DataNode_FlushSegments_Handler(srv interface{}, ctx context.Context, dec f
 	return interceptor(ctx, in, info, handler)
 }
 
+func _DataNode_GetMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.GetMetricsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DataNodeServer).GetMetrics(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.data.DataNode/GetMetrics",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DataNodeServer).GetMetrics(ctx, req.(*milvuspb.GetMetricsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _DataNode_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.data.DataNode",
 	HandlerType: (*DataNodeServer)(nil),
@@ -3183,6 +3256,10 @@ var _DataNode_serviceDesc = grpc.ServiceDesc{
 			MethodName: "FlushSegments",
 			Handler:    _DataNode_FlushSegments_Handler,
 		},
+		{
+			MethodName: "GetMetrics",
+			Handler:    _DataNode_GetMetrics_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "data_coord.proto",

internal/types/types.go

@@ -43,6 +43,8 @@ type DataNode interface {
 
 	WatchDmChannels(ctx context.Context, req *datapb.WatchDmChannelsRequest) (*commonpb.Status, error)
 	FlushSegments(ctx context.Context, req *datapb.FlushSegmentsRequest) (*commonpb.Status, error)
+
+	GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)
 }
 
 type DataCoord interface {

internal/util/metricsinfo/metrics_info.go

@@ -68,6 +68,18 @@ type IndexCoordInfos struct {
 	// TODO(dragondriver): add more detail metrics
 }
 
+// DataNodeInfos implements ComponentInfos
+type DataNodeInfos struct {
+	BaseComponentInfos
+	// TODO(dragondriver): add more detail metrics
+}
+
+// DataCoordInfos implements ComponentInfos
+type DataCoordInfos struct {
+	BaseComponentInfos
+	// TODO(dragondriver): add more detail metrics
+}
+
 // RootCoordInfos implements ComponentInfos
 type RootCoordInfos struct {
 	BaseComponentInfos

internal/util/metricsinfo/metrics_info_test.go

@@ -100,6 +100,38 @@ func TestIndexCoordInfos_Codec(t *testing.T) {
 	assert.Equal(t, infos1.Name, infos2.Name)
 }
 
+func TestDataNodeInfos_Codec(t *testing.T) {
+	infos1 := DataNodeInfos{
+		BaseComponentInfos: BaseComponentInfos{
+			Name: ConstructComponentName(typeutil.DataNodeRole, 1),
+		},
+	}
+	s, err := MarshalComponentInfos(infos1)
+	assert.Equal(t, nil, err)
+	log.Info("TestDataNodeInfos_Codec",
+		zap.String("marshaled_result", s))
+	var infos2 DataNodeInfos
+	err = UnmarshalComponentInfos(s, &infos2)
+	assert.Equal(t, nil, err)
+	assert.Equal(t, infos1.Name, infos2.Name)
+}
+
+func TestDataCoordInfos_Codec(t *testing.T) {
+	infos1 := DataCoordInfos{
+		BaseComponentInfos: BaseComponentInfos{
+			Name: ConstructComponentName(typeutil.DataCoordRole, 1),
+		},
+	}
+	s, err := MarshalComponentInfos(infos1)
+	assert.Equal(t, nil, err)
+	log.Info("TestDataCoordInfos_Codec",
+		zap.String("marshaled_result", s))
+	var infos2 DataCoordInfos
+	err = UnmarshalComponentInfos(s, &infos2)
+	assert.Equal(t, nil, err)
+	assert.Equal(t, infos1.Name, infos2.Name)
+}
+
 func TestRootCoordInfos_Codec(t *testing.T) {
 	infos1 := RootCoordInfos{
 		BaseComponentInfos: BaseComponentInfos{

internal/util/metricsinfo/topology.go

@@ -75,6 +75,18 @@ type IndexCoordTopology struct {
 	Connections ConnTopology         `json:"connections"`
 }
 
+// DataClusterTopology shows the topology between DataCoord and DataNodes
+type DataClusterTopology struct {
+	Self           DataCoordInfos  `json:"self"`
+	ConnectedNodes []DataNodeInfos `json:"connected_nodes"`
+}
+
+// DataCoordTopology shows the whole metrics of index cluster
+type DataCoordTopology struct {
+	Cluster     DataClusterTopology `json:"cluster"`
+	Connections ConnTopology        `json:"connections"`
+}
+
 // RootCoordTopology shows the whole metrics of root coordinator
 type RootCoordTopology struct {
 	Self        RootCoordInfos `json:"self"`

internal/util/metricsinfo/topology_test.go

@@ -200,6 +200,87 @@ func TestIndexCoordTopology_Codec(t *testing.T) {
 	}
 }
 
+func TestDataClusterTopology_Codec(t *testing.T) {
+	topology1 := DataClusterTopology{
+		Self: DataCoordInfos{
+			BaseComponentInfos: BaseComponentInfos{
+				Name: ConstructComponentName(typeutil.DataCoordRole, 1),
+			},
+		},
+		ConnectedNodes: []DataNodeInfos{
+			{
+				BaseComponentInfos: BaseComponentInfos{
+					Name: ConstructComponentName(typeutil.DataNodeRole, 1),
+				},
+			},
+			{
+				BaseComponentInfos: BaseComponentInfos{
+					Name: ConstructComponentName(typeutil.DataNodeRole, 2),
+				},
+			},
+		},
+	}
+	s, err := MarshalTopology(topology1)
+	assert.Equal(t, nil, err)
+	log.Info("TestDataClusterTopology_Codec",
+		zap.String("marshaled_result", s))
+	var topology2 DataClusterTopology
+	err = UnmarshalTopology(s, &topology2)
+	assert.Equal(t, nil, err)
+	assert.Equal(t, topology1.Self, topology2.Self)
+	assert.Equal(t, len(topology1.ConnectedNodes), len(topology2.ConnectedNodes))
+	for i := range topology1.ConnectedNodes {
+		assert.Equal(t, topology1.ConnectedNodes[i], topology2.ConnectedNodes[i])
+	}
+}
+
+func TestDataCoordTopology_Codec(t *testing.T) {
+	topology1 := DataCoordTopology{
+		Cluster: DataClusterTopology{
+			Self: DataCoordInfos{
+				BaseComponentInfos: BaseComponentInfos{
+					Name: ConstructComponentName(typeutil.DataCoordRole, 1),
+				},
+			},
+			ConnectedNodes: []DataNodeInfos{
+				{
+					BaseComponentInfos: BaseComponentInfos{
+						Name: ConstructComponentName(typeutil.DataNodeRole, 1),
+					},
+				},
+				{
+					BaseComponentInfos: BaseComponentInfos{
+						Name: ConstructComponentName(typeutil.DataNodeRole, 2),
+					},
+				},
+			},
+		},
+		Connections: ConnTopology{
+			Name: ConstructComponentName(typeutil.DataCoordRole, 1),
+			ConnectedComponents: []string{
+				ConstructComponentName(typeutil.RootCoordRole, 1),
+			},
+		},
+	}
+	s, err := MarshalTopology(topology1)
+	assert.Equal(t, nil, err)
+	log.Info("TestDataCoordTopology_Codec",
+		zap.String("marshaled_result", s))
+	var topology2 DataCoordTopology
+	err = UnmarshalTopology(s, &topology2)
+	assert.Equal(t, nil, err)
+	assert.Equal(t, topology1.Cluster.Self, topology2.Cluster.Self)
+	assert.Equal(t, len(topology1.Cluster.ConnectedNodes), len(topology2.Cluster.ConnectedNodes))
+	for i := range topology1.Cluster.ConnectedNodes {
+		assert.Equal(t, topology1.Cluster.ConnectedNodes[i], topology2.Cluster.ConnectedNodes[i])
+	}
+	assert.Equal(t, topology1.Connections.Name, topology2.Connections.Name)
+	assert.Equal(t, len(topology1.Connections.ConnectedComponents), len(topology1.Connections.ConnectedComponents))
+	for i := range topology1.Connections.ConnectedComponents {
+		assert.Equal(t, topology1.Connections.ConnectedComponents[i], topology2.Connections.ConnectedComponents[i])
+	}
+}
+
 func TestRootCoordTopology_Codec(t *testing.T) {
 	topology1 := RootCoordTopology{
 		Self: RootCoordInfos{