proxy: stats will record error response (including rewritten internel…

… errors)

cmd/fe/assets/dashboard-fe.js

@@ -246,7 +246,11 @@ function processProxyStats(codis_stats) {
         } else {
             if (s.stats.online) {
                 p.sessions = "total=" + s.stats.sessions.total + ",alive=" + s.stats.sessions.alive;
-                p.commands = "total=" + s.stats.ops.total + ",fails=" + s.stats.ops.fails + ",qps=" + s.stats.ops.qps;
+                p.commands = "total=" + s.stats.ops.total + ",fails=" + s.stats.ops.fails;
+                if (s.stats.ops.redis != undefined) {
+                    p.commands += ",errors=" + s.stats.ops.redis.errors;
+                }
+                p.commands += ",qps=" + s.stats.ops.qps;
                 p.status = "HEALTHY";
             } else {
                 p.status = "PENDING";

pkg/proxy/metrics.go

@@ -91,6 +91,7 @@ func (p *Proxy) startMetricsInfluxdb() {
 		fields := map[string]interface{}{
 			"ops_total":                stats.Ops.Total,
 			"ops_fails":                stats.Ops.Fails,
+			"ops_redis_errors":         stats.Ops.Redis.Errors,
 			"ops_qps":                  stats.Ops.QPS,
 			"sessions_total":           stats.Sessions.Total,
 			"sessions_alive":           stats.Sessions.Alive,

pkg/proxy/proxy.go

@@ -461,10 +461,13 @@ type Stats struct {
 	} `json:"sentinels"`
 
 	Ops struct {
-		Total int64      `json:"total"`
-		Fails int64      `json:"fails"`
-		QPS   int64      `json:"qps"`
-		Cmd   []*OpStats `json:"cmd,omitempty"`
+		Total int64 `json:"total"`
+		Fails int64 `json:"fails"`
+		Redis struct {
+			Errors int64 `json:"errors"`
+		} `json:"redis"`
+		QPS int64      `json:"qps"`
+		Cmd []*OpStats `json:"cmd,omitempty"`
 	} `json:"ops"`
 
 	Sessions struct {
@@ -553,6 +556,7 @@ func (s *Proxy) Stats(flags StatsFlags) *Stats {
 
 	stats.Ops.Total = OpTotal()
 	stats.Ops.Fails = OpFails()
+	stats.Ops.Redis.Errors = OpRedisErrors()
 	stats.Ops.QPS = OpQPS()
 
 	if flags.HasBit(StatsCmds) {

pkg/proxy/session.go

@@ -179,8 +179,8 @@ func (s *Session) loopReader(tasks chan<- *Request, d *Router) (err error) {
 func (s *Session) loopWriter(tasks <-chan *Request) (err error) {
 	defer func() {
 		s.CloseWithError(err)
-		for _ = range tasks {
-			s.incrOpFails(nil)
+		for r := range tasks {
+			s.incrOpFails(r, nil)
 		}
 		s.flushOpStats(true)
 	}()
@@ -197,16 +197,16 @@ func (s *Session) loopWriter(tasks <-chan *Request) (err error) {
 			resp = redis.NewErrorf("ERR handle response, %s", err)
 			if sensitive {
 				s.Conn.Encode(resp, true)
-				return s.incrOpFails(err)
+				return s.incrOpFails(r, err)
 			}
 		}
 		if err := p.Encode(resp); err != nil {
-			return s.incrOpFails(err)
+			return s.incrOpFails(r, err)
 		}
 		if err := p.Flush(len(tasks) == 0); err != nil {
-			return s.incrOpFails(err)
+			return s.incrOpFails(r, err)
 		} else {
-			s.incrOpStats(r)
+			s.incrOpStats(r, resp.Type)
 		}
 		if len(tasks) == 0 {
 			s.flushOpStats(false)
@@ -570,19 +570,29 @@ func (s *Session) incrOpTotal() {
 	s.stats.total.Incr()
 }
 
-func (s *Session) incrOpFails(err error) error {
-	incrOpFails()
-	return err
-}
-
-func (s *Session) incrOpStats(r *Request) {
-	e := s.stats.opmap[r.OpStr]
+func (s *Session) getOpStats(opstr string) *opStats {
+	e := s.stats.opmap[opstr]
 	if e == nil {
-		e = &opStats{opstr: r.OpStr}
-		s.stats.opmap[r.OpStr] = e
+		e = &opStats{opstr: opstr}
+		s.stats.opmap[opstr] = e
 	}
+	return e
+}
+
+func (s *Session) incrOpStats(r *Request, t redis.RespType) {
+	e := s.getOpStats(r.OpStr)
 	e.calls.Incr()
 	e.nsecs.Add(time.Now().UnixNano() - r.Start)
+	switch t {
+	case redis.TypeError:
+		e.redis.errors.Incr()
+	}
+}
+
+func (s *Session) incrOpFails(r *Request, err error) error {
+	e := s.getOpStats(r.OpStr)
+	e.fails.Incr()
+	return err
 }
 
 func (s *Session) flushOpStats(force bool) {
@@ -597,8 +607,8 @@ func (s *Session) flushOpStats(force bool) {
 
 	incrOpTotal(s.stats.total.Swap(0))
 	for _, e := range s.stats.opmap {
-		if n := e.calls.Swap(0); n != 0 {
-			incrOpStats(e.opstr, n, e.nsecs.Swap(0))
+		if e.calls.Get() != 0 || e.fails.Get() != 0 {
+			incrOpStats(e)
 		}
 	}
 	s.stats.flush.n++

pkg/proxy/stats.go

@@ -17,17 +17,23 @@ type opStats struct {
 	opstr string
 	calls atomic2.Int64
 	nsecs atomic2.Int64
+	fails atomic2.Int64
+	redis struct {
+		errors atomic2.Int64
+	}
 }
 
 func (s *opStats) OpStats() *OpStats {
 	o := &OpStats{
 		OpStr: s.opstr,
 		Calls: s.calls.Get(),
 		Usecs: s.nsecs.Get() / 1e3,
+		Fails: s.fails.Get(),
 	}
 	if o.Calls != 0 {
 		o.UsecsPercall = o.Usecs / o.Calls
 	}
+	o.RedisErrType = s.redis.errors.Get()
 	return o
 }
 
@@ -36,14 +42,19 @@ type OpStats struct {
 	Calls        int64  `json:"calls"`
 	Usecs        int64  `json:"usecs"`
 	UsecsPercall int64  `json:"usecs_percall"`
+	Fails        int64  `json:"fails"`
+	RedisErrType int64  `json:"redis_errtype"`
 }
 
 var cmdstats struct {
 	sync.RWMutex
 
+	opmap map[string]*opStats
 	total atomic2.Int64
 	fails atomic2.Int64
-	opmap map[string]*opStats
+	redis struct {
+		errors atomic2.Int64
+	}
 
 	qps atomic2.Int64
 }
@@ -70,6 +81,10 @@ func OpFails() int64 {
 	return cmdstats.fails.Get()
 }
 
+func OpRedisErrors() int64 {
+	return cmdstats.redis.errors.Get()
+}
+
 func OpQPS() int64 {
 	return cmdstats.qps.Get()
 }
@@ -125,21 +140,26 @@ func ResetStats() {
 
 	cmdstats.total.Set(0)
 	cmdstats.fails.Set(0)
+	cmdstats.redis.errors.Set(0)
 	sessions.total.Set(sessions.alive.Get())
 }
 
 func incrOpTotal(n int64) {
 	cmdstats.total.Add(n)
 }
 
-func incrOpFails() {
-	cmdstats.fails.Incr()
-}
-
-func incrOpStats(opstr string, calls int64, nsecs int64) {
-	s := getOpStats(opstr, true)
-	s.calls.Add(calls)
-	s.nsecs.Add(nsecs)
+func incrOpStats(e *opStats) {
+	s := getOpStats(e.opstr, true)
+	s.calls.Add(e.calls.Swap(0))
+	s.nsecs.Add(e.nsecs.Swap(0))
+	if n := e.fails.Swap(0); n != 0 {
+		s.fails.Add(n)
+		cmdstats.fails.Add(n)
+	}
+	if n := e.redis.errors.Swap(0); n != 0 {
+		s.redis.errors.Add(n)
+		cmdstats.redis.errors.Add(n)
+	}
 }
 
 var sessions struct {