*: add infoschema client errors

errno/infoschema.go

@@ -0,0 +1,156 @@
+// 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.
+
+type errorSummary struct {
+	sync.Mutex
+	ErrorCount   int
+	WarningCount int
+	FirstSeen    time.Time
+	LastSeen     time.Time
+}
+
+type globalStats struct {
+	sync.Mutex
+	errors map[uint16]*errorSummary
+}
+
+type userStats struct {
+	sync.Mutex
+	errors map[string]map[uint16]*errorSummary
+}
+
+type hostStats struct {
+	sync.Mutex
+	errors map[string]map[uint16]*errorSummary
+}
+
+var global globalStats
+var users userStats
+var hosts hostStats
+
+func init() {
+	global.errors = make(map[uint16]*errorSummary)
+	users.errors = make(map[string]map[uint16]*errorSummary)
+	hosts.errors = make(map[string]map[uint16]*errorSummary)
+}
+
+// FlushStats resets errors and warnings across global/users/hosts
+func FlushStats() {
+	global.Lock()
+	defer global.Unlock()
+	users.Lock()
+	defer users.Unlock()
+	hosts.Lock()
+	defer hosts.Unlock()
+
+	global.errors = make(map[uint16]*errorSummary)
+	users.errors = make(map[string]map[uint16]*errorSummary)
+	hosts.errors = make(map[string]map[uint16]*errorSummary)
+}
+
+// GlobalStats summarizes errors and warnings across all users/hosts
+func GlobalStats() map[uint16]*errorSummary {
+	global.Lock()
+	defer global.Unlock()
+	return global.errors
+}
+
+// UserStats summarizes per-user
+func UserStats() map[string]map[uint16]*errorSummary {
+	users.Lock()
+	defer users.Unlock()
+	return users.errors
+}
+
+// HostStats summarizes per remote-host
+func HostStats() map[string]map[uint16]*errorSummary {
+	hosts.Lock()
+	defer hosts.Unlock()
+	return hosts.errors
+}
+
+func initCounters(errCode uint16, user, host string) {
+	global.Lock()
+	if _, ok := global.errors[errCode]; !ok {
+		global.errors[errCode] = &errorSummary{FirstSeen: time.Now()}
+	}
+	global.Unlock()
+	users.Lock()
+	if _, ok := users.errors[user]; !ok {
+		users.errors[user] = make(map[uint16]*errorSummary)
+	}
+	if _, ok := users.errors[user][errCode]; !ok {
+		users.errors[user][errCode] = &errorSummary{FirstSeen: time.Now()}
+	}
+	users.Unlock()
+	hosts.Lock()
+	if _, ok := hosts.errors[host]; !ok {
+		hosts.errors[host] = make(map[uint16]*errorSummary)
+	}
+	if _, ok := hosts.errors[host][errCode]; !ok {
+		hosts.errors[host][errCode] = &errorSummary{FirstSeen: time.Now()}
+	}
+	hosts.Unlock()
+}
+
+// IncrementError increments the global/user/host statistics for an errCode
+func IncrementError(errCode uint16, user, host string) {
+	initCounters(errCode, user, host)
+	// Increment counter + update last seen
+	global.errors[errCode].Lock()
+	global.errors[errCode].ErrorCount++
+	global.errors[errCode].LastSeen = time.Now()
+	global.errors[errCode].Unlock()
+	// Increment counter + update last seen
+	users.errors[user][errCode].Lock()
+	users.errors[user][errCode].ErrorCount++
+	users.errors[user][errCode].LastSeen = time.Now()
+	users.errors[user][errCode].Unlock()
+	// Increment counter + update last seen
+	hosts.errors[host][errCode].Lock()
+	hosts.errors[host][errCode].ErrorCount++
+	hosts.errors[host][errCode].LastSeen = time.Now()
+	hosts.errors[host][errCode].Unlock()
+}
+
+// IncrementWarning increments the global/user/host statistics for an errCode
+func IncrementWarning(errCode uint16, user, host string) {
+	initCounters(errCode, user, host)
+	// Increment counter + update last seen
+	global.errors[errCode].Lock()
+	global.errors[errCode].WarningCount++
+	global.errors[errCode].LastSeen = time.Now()
+	global.errors[errCode].Unlock()
+	// Increment counter + update last seen
+	users.errors[user][errCode].Lock()
+	users.errors[user][errCode].WarningCount++
+	users.errors[user][errCode].LastSeen = time.Now()
+	users.errors[user][errCode].Unlock()
+	// Increment counter + update last seen
+	hosts.errors[host][errCode].Lock()
+	hosts.errors[host][errCode].WarningCount++
+	hosts.errors[host][errCode].LastSeen = time.Now()
+	hosts.errors[host][errCode].Unlock()
+}

executor/builder.go

@@ -1533,7 +1533,11 @@ 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.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/meta/autoid"
 	plannercore "github.com/pingcap/tidb/planner/core"
@@ -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
@@ -1869,6 +1874,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

@@ -29,6 +29,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"
@@ -1255,6 +1256,8 @@ func (e *SimpleExec) executeFlush(s *ast.FlushStmt) error {
 				return err
 			}
 		}
+	case ast.FlushClientErrorsSummary:
+		errno.FlushStats()
 	}
 	return nil
 }

infoschema/tables.go

@@ -155,6 +155,12 @@ const (
 	TableTiFlashSegments = "TIFLASH_SEGMENTS"
 	// TablePlacementPolicy is the string constant of placement policy table.
 	TablePlacementPolicy = "PLACEMENT_POLICY"
+	// TableClientErrorsSummaryGlobal is the string constant of client errors table.
+	TableClientErrorsSummaryGlobal = "CLIENT_ERRORS_SUMMARY_GLOBAL"
+	// TableClientErrorsSummaryByUser is the string constant of client errors table.
+	TableClientErrorsSummaryByUser = "CLIENT_ERRORS_SUMMARY_BY_USER"
+	// TableClientErrorsSummaryByHost is the string constant of client errors table.
+	TableClientErrorsSummaryByHost = "CLIENT_ERRORS_SUMMARY_BY_HOST"
 )
 
 var tableIDMap = map[string]int64{
@@ -224,6 +230,9 @@ var tableIDMap = map[string]int64{
 	TableTiFlashTables:                      autoid.InformationSchemaDBID + 64,
 	TableTiFlashSegments:                    autoid.InformationSchemaDBID + 65,
 	TablePlacementPolicy:                    autoid.InformationSchemaDBID + 66,
+	TableClientErrorsSummaryGlobal:          autoid.InformationSchemaDBID + 67,
+	TableClientErrorsSummaryByUser:          autoid.InformationSchemaDBID + 68,
+	TableClientErrorsSummaryByHost:          autoid.InformationSchemaDBID + 69,
 }
 
 type columnInfo struct {
@@ -1290,6 +1299,35 @@ var tablePlacementPolicyCols = []columnInfo{
 	{name: "CONSTRAINTS", tp: mysql.TypeVarchar, size: 1024},
 }
 
+var tableClientErrorsSummaryGlobalCols = []columnInfo{
+	{name: "ERROR_NUMBER", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "ERROR_MESSAGE", tp: mysql.TypeVarchar, size: 1024, flag: mysql.NotNullFlag},
+	{name: "ERROR_COUNT", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "WARNING_COUNT", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "FIRST_SEEN", tp: mysql.TypeTimestamp, size: 26},
+	{name: "LAST_SEEN", tp: mysql.TypeTimestamp, size: 26},
+}
+
+var tableClientErrorsSummaryByUserCols = []columnInfo{
+	{name: "USER", tp: mysql.TypeVarchar, size: 64, flag: mysql.NotNullFlag},
+	{name: "ERROR_NUMBER", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "ERROR_MESSAGE", tp: mysql.TypeVarchar, size: 1024, flag: mysql.NotNullFlag},
+	{name: "ERROR_COUNT", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "WARNING_COUNT", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "FIRST_SEEN", tp: mysql.TypeTimestamp, size: 26},
+	{name: "LAST_SEEN", tp: mysql.TypeTimestamp, size: 26},
+}
+
+var tableClientErrorsSummaryByHostCols = []columnInfo{
+	{name: "HOST", tp: mysql.TypeVarchar, size: 255, flag: mysql.NotNullFlag},
+	{name: "ERROR_NUMBER", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "ERROR_MESSAGE", tp: mysql.TypeVarchar, size: 1024, flag: mysql.NotNullFlag},
+	{name: "ERROR_COUNT", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "WARNING_COUNT", tp: mysql.TypeLonglong, size: 64, flag: mysql.NotNullFlag},
+	{name: "FIRST_SEEN", tp: mysql.TypeTimestamp, size: 26},
+	{name: "LAST_SEEN", tp: mysql.TypeTimestamp, size: 26},
+}
+
 // GetShardingInfo returns a nil or description string for the sharding information of given TableInfo.
 // The returned description string may be:
 //  - "NOT_SHARDED": for tables that SHARD_ROW_ID_BITS is not specified.
@@ -1656,6 +1694,9 @@ var tableNameToColumns = map[string][]columnInfo{
 	TableTiFlashTables:                      tableTableTiFlashTablesCols,
 	TableTiFlashSegments:                    tableTableTiFlashSegmentsCols,
 	TablePlacementPolicy:                    tablePlacementPolicyCols,
+	TableClientErrorsSummaryGlobal:          tableClientErrorsSummaryGlobalCols,
+	TableClientErrorsSummaryByUser:          tableClientErrorsSummaryByUserCols,
+	TableClientErrorsSummaryByHost:          tableClientErrorsSummaryByHostCols,
 }
 
 func createInfoSchemaTable(_ autoid.Allocators, meta *model.TableInfo) (table.Table, error) {

infoschema/tables_test.go

@@ -35,6 +35,7 @@ import (
 	"github.com/pingcap/tidb/config"
 	"github.com/pingcap/tidb/ddl/placement"
 	"github.com/pingcap/tidb/domain"
+	"github.com/pingcap/tidb/errno"
 	"github.com/pingcap/tidb/infoschema"
 	"github.com/pingcap/tidb/kv"
 	"github.com/pingcap/tidb/meta/autoid"
@@ -1460,3 +1461,27 @@ func (s *testTableSuite) TestPlacementPolicy(c *C) {
 	tk.MustQuery("select rule_id, schema_name, table_name, partition_name from information_schema.placement_policy order by partition_name, rule_id").Check(testkit.Rows(
 		"0 test test_placement p0", "1 test test_placement p0", "0 test test_placement p1", "1 test test_placement p1"))
 }
+
+func (s *testTableSuite) TestInfoschemaClientErrors(c *C) {
+	tk := s.newTestKitWithRoot(c)
+
+	tk.MustExec("FLUSH CLIENT_ERRORS_SUMMARY")
+
+	errno.IncrementError(1365, "root", "localhost")
+	errno.IncrementError(1365, "infoschematest", "localhost")
+	errno.IncrementError(1365, "root", "localhost")
+
+	tk.MustExec("CREATE USER 'infoschematest'@'localhost'")
+	c.Assert(tk.Se.Auth(&auth.UserIdentity{Username: "infoschematest", Hostname: "localhost"}, nil, nil), IsTrue)
+
+	err := tk.QueryToErr("SELECT * FROM information_schema.client_errors_summary_global")
+	c.Assert(err.Error(), Equals, "[planner:1227]Access denied; you need (at least one of) the PROCESS privilege(s) for this operation")
+
+	err = tk.QueryToErr("SELECT * FROM information_schema.client_errors_summary_by_host")
+	c.Assert(err.Error(), Equals, "[planner:1227]Access denied; you need (at least one of) the PROCESS privilege(s) for this operation")
+
+	tk.MustQuery("SELECT error_number, error_count, warning_count FROM information_schema.client_errors_summary_by_user ORDER BY error_number").Check(testkit.Rows("1365 1 0"))
+
+	err = tk.ExecToErr("FLUSH CLIENT_ERRORS_SUMMARY")
+	c.Assert(err.Error(), Equals, "[planner:1227]Access denied; you need (at least one of) the RELOAD privilege(s) for this operation")
+}