feat: implement MetricsGet to support V1 and V2 data engines in ProxyOps

longhorn 10472

Signed-off-by: jinhong.kim0 <[email protected]>

Author: hookak

pkg/client/proxy_metrics.go

@@ -1,21 +1,27 @@
 package client
 
 import (
-	"github.com/pkg/errors"
-
+	"fmt"
 	rpc "github.com/longhorn/types/pkg/generated/imrpc"
+	"github.com/pkg/errors"
 )
 
-func (c *ProxyClient) MetricsGet(engineName, volumeName, serviceAddress string) (metrics *Metrics, err error) {
+func (c *ProxyClient) MetricsGet(dataEngine, engineName, volumeName, serviceAddress string) (metrics *Metrics, err error) {
 	input := map[string]string{
 		"engineName":     engineName,
 		"volumeName":     volumeName,
 		"serviceAddress": serviceAddress,
+		"dataEngine":     dataEngine,
 	}
 	if err := validateProxyMethodParameters(input); err != nil {
 		return nil, errors.Wrap(err, "failed to get metrics for volume")
 	}
 
+	driver, ok := rpc.DataEngine_value[getDataEngine(dataEngine)]
+	if !ok {
+		return nil, fmt.Errorf("failed to get metrics for volume: invalid data engine %v", dataEngine)
+	}
+
 	defer func() {
 		err = errors.Wrapf(err, "%v failed to get metrics for volume", c.getProxyErrorPrefix(serviceAddress))
 	}()
@@ -24,6 +30,7 @@ func (c *ProxyClient) MetricsGet(engineName, volumeName, serviceAddress string)
 		Address:    serviceAddress,
 		EngineName: engineName,
 		VolumeName: volumeName,
+		DataEngine: rpc.DataEngine(driver),
 	}
 	resp, err := c.service.MetricsGet(getContextWithGRPCTimeout(c.ctx), req)
 	if err != nil {

pkg/proxy/metrics.go

@@ -3,16 +3,31 @@ package proxy
 import (
 	"github.com/sirupsen/logrus"
 	"golang.org/x/net/context"
+	grpccodes "google.golang.org/grpc/codes"
+	grpcstatus "google.golang.org/grpc/status"
 
 	eclient "github.com/longhorn/longhorn-engine/pkg/controller/client"
 	"github.com/longhorn/types/pkg/generated/enginerpc"
 	rpc "github.com/longhorn/types/pkg/generated/imrpc"
 )
 
 func (p *Proxy) MetricsGet(ctx context.Context, req *rpc.ProxyEngineRequest) (resp *rpc.EngineMetricsGetProxyResponse, err error) {
-	log := logrus.WithFields(logrus.Fields{"serviceURL": req.Address})
+	log := logrus.WithFields(logrus.Fields{
+		"serviceURL": req.Address,
+		"volume":     req.VolumeName,
+		"instance":   req.EngineName,
+		"dataEngine": req.DataEngine,
+	})
 	log.Trace("Getting metrics")
 
+	ops, ok := p.ops[req.DataEngine]
+	if !ok {
+		return nil, grpcstatus.Errorf(grpccodes.Unimplemented, "unsupported data engine %v", req.DataEngine)
+	}
+	return ops.MetricsGet(ctx, req)
+}
+
+func (ops V1DataEngineProxyOps) MetricsGet(ctx context.Context, req *rpc.ProxyEngineRequest) (resp *rpc.EngineMetricsGetProxyResponse, err error) {
 	c, err := eclient.NewControllerClient(req.Address, req.VolumeName, req.EngineName)
 	if err != nil {
 		return nil, err
@@ -35,3 +50,27 @@ func (p *Proxy) MetricsGet(ctx context.Context, req *rpc.ProxyEngineRequest) (re
 		},
 	}, nil
 }
+
+func (ops V2DataEngineProxyOps) MetricsGet(ctx context.Context, req *rpc.ProxyEngineRequest) (resp *rpc.EngineMetricsGetProxyResponse, err error) {
+	c, err := getSPDKClientFromAddress(req.Address)
+	if err != nil {
+		return nil, grpcstatus.Errorf(grpccodes.Internal, "failed to get SPDK client from engine address %v: %v", req.Address, err)
+	}
+	defer c.Close()
+
+	metrics, err := c.MetricsGet(req.EngineName)
+	if err != nil {
+		return nil, grpcstatus.Errorf(grpccodes.Internal, "failed to get engine %v: %v", req.EngineName, err)
+	}
+
+	return &rpc.EngineMetricsGetProxyResponse{
+		Metrics: &enginerpc.Metrics{
+			ReadThroughput:  metrics.ReadThroughput,
+			WriteThroughput: metrics.WriteThroughput,
+			ReadLatency:     metrics.ReadLatency,
+			WriteLatency:    metrics.WriteLatency,
+			ReadIOPS:        metrics.ReadIOPS,
+			WriteIOPS:       metrics.WriteIOPS,
+		},
+	}, nil
+}

pkg/proxy/proxy.go

@@ -52,6 +52,8 @@ type ProxyOps interface {
 	SnapshotBackupStatus(context.Context, *rpc.EngineSnapshotBackupStatusRequest) (*rpc.EngineSnapshotBackupStatusProxyResponse, error)
 	BackupRestore(context.Context, *rpc.EngineBackupRestoreRequest, map[string]string) error
 	BackupRestoreStatus(context.Context, *rpc.ProxyEngineRequest) (*rpc.EngineBackupRestoreStatusProxyResponse, error)
+
+	MetricsGet(context.Context, *rpc.ProxyEngineRequest) (*rpc.EngineMetricsGetProxyResponse, error)
 }
 
 type V1DataEngineProxyOps struct{}