Merge branch 'master' into load-balance-search-commands-to-shards

Author: ofekshenawa

command.go

@@ -4508,7 +4508,6 @@ func parseCommandPolicies(commandInfoTips map[string]string) *routing.CommandPol
 	req := routing.ReqDefault
 	resp := routing.RespAllSucceeded
 
-
 	tips := make(map[string]string, len(commandInfoTips))
 	for k, v := range commandInfoTips {
 		if k == requestPolicy {
@@ -4666,6 +4665,95 @@ func (cmd *SlowLogCmd) Clone() Cmder {
 
 //-----------------------------------------------------------------------
 
+type Latency struct {
+	Name   string
+	Time   time.Time
+	Latest time.Duration
+	Max    time.Duration
+}
+
+type LatencyCmd struct {
+	baseCmd
+	val []Latency
+}
+
+var _ Cmder = (*LatencyCmd)(nil)
+
+func NewLatencyCmd(ctx context.Context, args ...interface{}) *LatencyCmd {
+	return &LatencyCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *LatencyCmd) SetVal(val []Latency) {
+	cmd.val = val
+}
+
+func (cmd *LatencyCmd) Val() []Latency {
+	return cmd.val
+}
+
+func (cmd *LatencyCmd) Result() ([]Latency, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *LatencyCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *LatencyCmd) readReply(rd *proto.Reader) error {
+	n, err := rd.ReadArrayLen()
+	if err != nil {
+		return err
+	}
+	cmd.val = make([]Latency, n)
+	for i := 0; i < len(cmd.val); i++ {
+		nn, err := rd.ReadArrayLen()
+		if err != nil {
+			return err
+		}
+		if nn < 3 {
+			return fmt.Errorf("redis: got %d elements in latency get, expected at least 3", nn)
+		}
+		if cmd.val[i].Name, err = rd.ReadString(); err != nil {
+			return err
+		}
+		createdAt, err := rd.ReadInt()
+		if err != nil {
+			return err
+		}
+		cmd.val[i].Time = time.Unix(createdAt, 0)
+		latest, err := rd.ReadInt()
+		if err != nil {
+			return err
+		}
+		cmd.val[i].Latest = time.Duration(latest) * time.Millisecond
+		maximum, err := rd.ReadInt()
+		if err != nil {
+			return err
+		}
+		cmd.val[i].Max = time.Duration(maximum) * time.Millisecond
+	}
+	return nil
+}
+
+func (cmd *LatencyCmd) Clone() Cmder {
+	var val []Latency
+	if cmd.val != nil {
+		val = make([]Latency, len(cmd.val))
+		copy(val, cmd.val)
+	}
+	return &LatencyCmd{
+		baseCmd: cmd.cloneBaseCmd(),
+		val:     val,
+	}
+}
+
+//-----------------------------------------------------------------------
+
 type MapStringInterfaceCmd struct {
 	baseCmd
 

commands.go

@@ -211,9 +211,13 @@ type Cmdable interface {
 	ShutdownNoSave(ctx context.Context) *StatusCmd
 	SlaveOf(ctx context.Context, host, port string) *StatusCmd
 	SlowLogGet(ctx context.Context, num int64) *SlowLogCmd
+	SlowLogLen(ctx context.Context) *IntCmd
+	SlowLogReset(ctx context.Context) *StatusCmd
 	Time(ctx context.Context) *TimeCmd
 	DebugObject(ctx context.Context, key string) *StringCmd
 	MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd
+	Latency(ctx context.Context) *LatencyCmd
+	LatencyReset(ctx context.Context, events ...interface{}) *StatusCmd
 
 	ModuleLoadex(ctx context.Context, conf *ModuleLoadexConfig) *StringCmd
 
@@ -673,6 +677,34 @@ func (c cmdable) SlowLogGet(ctx context.Context, num int64) *SlowLogCmd {
 	return cmd
 }
 
+func (c cmdable) SlowLogLen(ctx context.Context) *IntCmd {
+	cmd := NewIntCmd(ctx, "slowlog", "len")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SlowLogReset(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "slowlog", "reset")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Latency(ctx context.Context) *LatencyCmd {
+	cmd := NewLatencyCmd(ctx, "latency", "latest")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LatencyReset(ctx context.Context, events ...interface{}) *StatusCmd {
+	args := make([]interface{}, 2+len(events))
+	args[0] = "latency"
+	args[1] = "reset"
+	copy(args[2:], events)
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
 func (c cmdable) Sync(_ context.Context) {
 	panic("not implemented")
 }