*: add infoschema client errors

errno/infoschema.go

@@ -0,0 +1,157 @@
+// Copyright 2021 PingCAP, Inc.
+//
+// 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,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package errno
+
+import (
+	"sync"
+	"time"
+)
+
+// The error summary is protected by a mutex for simplicity.
+// It is not expected to be hot unless there are concurrent workloads
+// that are generating high error/warning counts, in which case
+// the system probably has other issues already.
+
+// ErrorSummary summarizes errors and warnings
+type ErrorSummary struct {
+	ErrorCount   int
+	WarningCount int
+	FirstSeen    time.Time
+	LastSeen     time.Time
+}
+
+// instanceStatistics provide statistics for a tidb-server instance.
+type instanceStatistics struct {
+	sync.Mutex
+	global map[uint16]*ErrorSummary
+	users  map[string]map[uint16]*ErrorSummary
+	hosts  map[string]map[uint16]*ErrorSummary
+}
+
+var stats instanceStatistics
+
+func init() {
+	FlushStats()
+}
+
+// FlushStats resets errors and warnings across global/users/hosts
+func FlushStats() {
+	stats.Lock()
+	defer stats.Unlock()
+	stats.global = make(map[uint16]*ErrorSummary)
+	stats.users = make(map[string]map[uint16]*ErrorSummary)
+	stats.hosts = make(map[string]map[uint16]*ErrorSummary)
+}
+
+func copyMap(oldMap map[uint16]*ErrorSummary) map[uint16]*ErrorSummary {
+	newMap := make(map[uint16]*ErrorSummary, len(oldMap))
+	for k, v := range oldMap {
+		newMap[k] = &ErrorSummary{
+			ErrorCount:   v.ErrorCount,
+			WarningCount: v.WarningCount,
+			FirstSeen:    v.FirstSeen,
+			LastSeen:     v.LastSeen,
+		}
+	}
+	return newMap
+}
+
+// GlobalStats summarizes errors and warnings across all users/hosts
+func GlobalStats() map[uint16]*ErrorSummary {
+	stats.Lock()
+	defer stats.Unlock()
+	return copyMap(stats.global)
+}
+
+// UserStats summarizes per-user
+func UserStats() map[string]map[uint16]*ErrorSummary {
+	stats.Lock()
+	defer stats.Unlock()
+	newMap := make(map[string]map[uint16]*ErrorSummary, len(stats.users))
+	for k, v := range stats.users {
+		newMap[k] = copyMap(v)
+	}
+	return newMap
+}
+
+// HostStats summarizes per remote-host
+func HostStats() map[string]map[uint16]*ErrorSummary {
+	stats.Lock()
+	defer stats.Unlock()
+	newMap := make(map[string]map[uint16]*ErrorSummary, len(stats.hosts))
+	for k, v := range stats.hosts {
+		newMap[k] = copyMap(v)
+	}
+	return newMap
+}
+
+func initCounters(errCode uint16, user, host string) {
+	seen := time.Now()
+	stats.Lock()
+	defer stats.Unlock()
+
+	if _, ok := stats.global[errCode]; !ok {
+		stats.global[errCode] = &ErrorSummary{FirstSeen: seen}
+	}
+	if _, ok := stats.users[user]; !ok {
+		stats.users[user] = make(map[uint16]*ErrorSummary)
+	}
+	if _, ok := stats.users[user][errCode]; !ok {
+		stats.users[user][errCode] = &ErrorSummary{FirstSeen: seen}
+	}
+	if _, ok := stats.hosts[host]; !ok {
+		stats.hosts[host] = make(map[uint16]*ErrorSummary)
+	}
+	if _, ok := stats.hosts[host][errCode]; !ok {
+		stats.hosts[host][errCode] = &ErrorSummary{FirstSeen: seen}
+	}
+}
+
+// IncrementError increments the global/user/host statistics for an errCode
+func IncrementError(errCode uint16, user, host string) {
+	seen := time.Now()
+	initCounters(errCode, user, host)
+
+	stats.Lock()
+	defer stats.Unlock()
+
+	// Increment counter + update last seen
+	stats.global[errCode].ErrorCount++
+	stats.global[errCode].LastSeen = seen
+	// Increment counter + update last seen
+	stats.users[user][errCode].ErrorCount++
+	stats.users[user][errCode].LastSeen = seen
+	// Increment counter + update last seen
+	stats.hosts[host][errCode].ErrorCount++
+	stats.hosts[host][errCode].LastSeen = seen
+}
+
+// IncrementWarning increments the global/user/host statistics for an errCode
+func IncrementWarning(errCode uint16, user, host string) {
+	seen := time.Now()
+	initCounters(errCode, user, host)
+
+	stats.Lock()
+	defer stats.Unlock()
+
+	// Increment counter + update last seen
+	stats.global[errCode].WarningCount++
+	stats.global[errCode].LastSeen = seen
+	// Increment counter + update last seen
+	stats.users[user][errCode].WarningCount++
+	stats.users[user][errCode].LastSeen = seen
+	// Increment counter + update last seen
+	stats.hosts[host][errCode].WarningCount++
+	stats.hosts[host][errCode].LastSeen = seen
+}

errno/infoschema_test.go

@@ -0,0 +1,89 @@
+// Copyright 2021 PingCAP, Inc.
+//
+// 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,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package errno
+
+import (
+	"testing"
+
+	. "github.com/pingcap/check"
+)
+
+func TestT(t *testing.T) {
+	TestingT(t)
+}
+
+var _ = Suite(&testErrno{})
+
+type testErrno struct{}
+
+func (s *testErrno) TestCopySafety(c *C) {
+
+	IncrementError(123, "user", "host")
+	IncrementError(321, "user2", "host2")
+	IncrementWarning(123, "user", "host")
+	IncrementWarning(999, "user", "host")
+	IncrementWarning(222, "u", "h")
+
+	globalCopy := GlobalStats()
+	userCopy := UserStats()
+	hostCopy := HostStats()
+
+	IncrementError(123, "user", "host")
+	IncrementError(999, "user2", "host2")
+	IncrementError(123, "user3", "host")
+	IncrementWarning(123, "user", "host")
+	IncrementWarning(222, "u", "h")
+	IncrementWarning(222, "a", "b")
+	IncrementWarning(333, "c", "d")
+
+	// global stats
+	c.Assert(stats.global[123].ErrorCount, Equals, 3)
+	c.Assert(globalCopy[123].ErrorCount, Equals, 1)
+
+	// user stats
+	c.Assert(len(stats.users), Equals, 6)
+	c.Assert(len(userCopy), Equals, 3)
+	c.Assert(stats.users["user"][123].ErrorCount, Equals, 2)
+	c.Assert(stats.users["user"][123].WarningCount, Equals, 2)
+	c.Assert(userCopy["user"][123].ErrorCount, Equals, 1)
+	c.Assert(userCopy["user"][123].WarningCount, Equals, 1)
+
+	// ensure there is no user3 in userCopy
+	_, ok := userCopy["user3"]
+	c.Assert(ok, IsFalse)
+	_, ok = stats.users["user3"]
+	c.Assert(ok, IsTrue)
+	_, ok = userCopy["a"]
+	c.Assert(ok, IsFalse)
+	_, ok = stats.users["a"]
+	c.Assert(ok, IsTrue)
+
+	// host stats
+	c.Assert(len(stats.hosts), Equals, 5)
+	c.Assert(len(hostCopy), Equals, 3)
+	IncrementError(123, "user3", "newhost")
+	c.Assert(len(stats.hosts), Equals, 6)
+	c.Assert(len(hostCopy), Equals, 3)
+
+	// ensure there is no newhost in hostCopy
+	_, ok = hostCopy["newhost"]
+	c.Assert(ok, IsFalse)
+	_, ok = stats.hosts["newhost"]
+	c.Assert(ok, IsTrue)
+	_, ok = hostCopy["b"]
+	c.Assert(ok, IsFalse)
+	_, ok = stats.hosts["b"]
+	c.Assert(ok, IsTrue)
+
+}

executor/builder.go

@@ -1536,7 +1536,10 @@ func (b *executorBuilder) buildMemTable(v *plannercore.PhysicalMemTable) Executo
 			strings.ToLower(infoschema.TableStatementsSummaryHistory),
 			strings.ToLower(infoschema.ClusterTableStatementsSummary),
 			strings.ToLower(infoschema.ClusterTableStatementsSummaryHistory),
-			strings.ToLower(infoschema.TablePlacementPolicy):
+			strings.ToLower(infoschema.TablePlacementPolicy),
+			strings.ToLower(infoschema.TableClientErrorsSummaryGlobal),
+			strings.ToLower(infoschema.TableClientErrorsSummaryByUser),
+			strings.ToLower(infoschema.TableClientErrorsSummaryByHost):
 			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ID()),
 				table:        v.Table,

executor/infoschema_reader.go

@@ -35,6 +35,7 @@ import (
 	"github.com/pingcap/tidb/ddl/placement"
 	"github.com/pingcap/tidb/domain"
 	"github.com/pingcap/tidb/domain/infosync"
+	"github.com/pingcap/tidb/errno"
 	"github.com/pingcap/tidb/infoschema"
 	"github.com/pingcap/tidb/kv"
 	"github.com/pingcap/tidb/meta/autoid"
@@ -142,6 +143,10 @@ func (e *memtableRetriever) retrieve(ctx context.Context, sctx sessionctx.Contex
 			err = e.setDataForStatementsSummary(sctx, e.table.Name.O)
 		case infoschema.TablePlacementPolicy:
 			err = e.setDataForPlacementPolicy(sctx)
+		case infoschema.TableClientErrorsSummaryGlobal,
+			infoschema.TableClientErrorsSummaryByUser,
+			infoschema.TableClientErrorsSummaryByHost:
+			err = e.setDataForClientErrorsSummary(sctx, e.table.Name.O)
 		}
 		if err != nil {
 			return nil, err
@@ -1879,6 +1884,82 @@ func (e *memtableRetriever) setDataForPlacementPolicy(ctx sessionctx.Context) er
 	return nil
 }
 
+func (e *memtableRetriever) setDataForClientErrorsSummary(ctx sessionctx.Context, tableName string) error {
+	// Seeing client errors should require the PROCESS privilege, with the exception of errors for your own user.
+	// This is similar to information_schema.processlist, which is the closest comparison.
+	var hasProcessPriv bool
+	loginUser := ctx.GetSessionVars().User
+	if pm := privilege.GetPrivilegeManager(ctx); pm != nil {
+		if pm.RequestVerification(ctx.GetSessionVars().ActiveRoles, "", "", "", mysql.ProcessPriv) {
+			hasProcessPriv = true
+		}
+	}
+
+	var rows [][]types.Datum
+	switch tableName {
+	case infoschema.TableClientErrorsSummaryGlobal:
+		if !hasProcessPriv {
+			return plannercore.ErrSpecificAccessDenied.GenWithStackByArgs("PROCESS")
+		}
+		for code, summary := range errno.GlobalStats() {
+			firstSeen := types.NewTime(types.FromGoTime(summary.FirstSeen), mysql.TypeTimestamp, types.DefaultFsp)
+			lastSeen := types.NewTime(types.FromGoTime(summary.LastSeen), mysql.TypeTimestamp, types.DefaultFsp)
+			row := types.MakeDatums(
+				int(code),                    // ERROR_NUMBER
+				errno.MySQLErrName[code].Raw, // ERROR_MESSAGE
+				summary.ErrorCount,           // ERROR_COUNT
+				summary.WarningCount,         // WARNING_COUNT
+				firstSeen,                    // FIRST_SEEN
+				lastSeen,                     // LAST_SEEN
+			)
+			rows = append(rows, row)
+		}
+	case infoschema.TableClientErrorsSummaryByUser:
+		for user, agg := range errno.UserStats() {
+			for code, summary := range agg {
+				// Allow anyone to see their own errors.
+				if !hasProcessPriv && loginUser != nil && loginUser.Username != user {
+					continue
+				}
+				firstSeen := types.NewTime(types.FromGoTime(summary.FirstSeen), mysql.TypeTimestamp, types.DefaultFsp)
+				lastSeen := types.NewTime(types.FromGoTime(summary.LastSeen), mysql.TypeTimestamp, types.DefaultFsp)
+				row := types.MakeDatums(
+					user,                         // USER
+					int(code),                    // ERROR_NUMBER
+					errno.MySQLErrName[code].Raw, // ERROR_MESSAGE
+					summary.ErrorCount,           // ERROR_COUNT
+					summary.WarningCount,         // WARNING_COUNT
+					firstSeen,                    // FIRST_SEEN
+					lastSeen,                     // LAST_SEEN
+				)
+				rows = append(rows, row)
+			}
+		}
+	case infoschema.TableClientErrorsSummaryByHost:
+		if !hasProcessPriv {
+			return plannercore.ErrSpecificAccessDenied.GenWithStackByArgs("PROCESS")
+		}
+		for host, agg := range errno.HostStats() {
+			for code, summary := range agg {
+				firstSeen := types.NewTime(types.FromGoTime(summary.FirstSeen), mysql.TypeTimestamp, types.DefaultFsp)
+				lastSeen := types.NewTime(types.FromGoTime(summary.LastSeen), mysql.TypeTimestamp, types.DefaultFsp)
+				row := types.MakeDatums(
+					host,                         // HOST
+					int(code),                    // ERROR_NUMBER
+					errno.MySQLErrName[code].Raw, // ERROR_MESSAGE
+					summary.ErrorCount,           // ERROR_COUNT
+					summary.WarningCount,         // WARNING_COUNT
+					firstSeen,                    // FIRST_SEEN
+					lastSeen,                     // LAST_SEEN
+				)
+				rows = append(rows, row)
+			}
+		}
+	}
+	e.rows = rows
+	return nil
+}
+
 type hugeMemTableRetriever struct {
 	dummyCloser
 	table       *model.TableInfo

executor/simple.go

@@ -30,6 +30,7 @@ import (
 	"github.com/pingcap/tidb/config"
 	"github.com/pingcap/tidb/distsql"
 	"github.com/pingcap/tidb/domain"
+	"github.com/pingcap/tidb/errno"
 	"github.com/pingcap/tidb/infoschema"
 	"github.com/pingcap/tidb/kv"
 	"github.com/pingcap/tidb/metrics"
@@ -1327,6 +1328,8 @@ func (e *SimpleExec) executeFlush(s *ast.FlushStmt) error {
 				return err
 			}
 		}
+	case ast.FlushClientErrorsSummary:
+		errno.FlushStats()
 	}
 	return nil
 }