replace log to logutil

domain/domain.go

@@ -27,7 +27,6 @@ import (
 	"github.com/ngaut/pools"
 	"github.com/ngaut/sync2"
 	"github.com/pingcap/errors"
-	"github.com/pingcap/log"
 	"github.com/pingcap/parser"
 	"github.com/pingcap/parser/ast"
 	"github.com/pingcap/parser/model"
@@ -98,12 +97,12 @@ func (do *Domain) loadInfoSchema(handle *infoschema.Handle, usedSchemaVersion in
 	// Update self schema version to etcd.
 	defer func() {
 		if err != nil {
-			log.Info("cannot update self schema version to etcd.")
+			logutil.Logger(context.Background()).Info("cannot update self schema version to etcd.")
 			return
 		}
 		err = do.ddl.SchemaSyncer().UpdateSelfVersion(context.Background(), latestSchemaVersion)
 		if err != nil {
-			log.Info("update self version failed.", zap.Int64("usedSchemaVersion", usedSchemaVersion),
+			logutil.Logger(context.Background()).Info("update self version failed.", zap.Int64("usedSchemaVersion", usedSchemaVersion),
 				zap.Int64("latestSchemaVersion", latestSchemaVersion), zap.Error(err))
 		}
 	}()
@@ -112,10 +111,11 @@ func (do *Domain) loadInfoSchema(handle *infoschema.Handle, usedSchemaVersion in
 	ok, tblIDs, err := do.tryLoadSchemaDiffs(m, usedSchemaVersion, latestSchemaVersion)
 	if err != nil {
 		// We can fall back to full load, don't need to return the error.
-		log.Error("failed to load schema diff", zap.Error(err))
+
+		logutil.Logger(context.Background()).Error("failed to load schema diff", zap.Error(err))
 	}
 	if ok {
-		log.Info("diff load InfoSchema from version failed.", zap.Int64("usedSchemaVersion", usedSchemaVersion),
+		logutil.Logger(context.Background()).Info("diff load InfoSchema from version failed.", zap.Int64("usedSchemaVersion", usedSchemaVersion),
 			zap.Int64("latestSchemaVersion", latestSchemaVersion), zap.Duration("time", time.Since(startTime)), zap.Int64s("tblIDs", tblIDs))
 		return latestSchemaVersion, tblIDs, fullLoad, nil
 	}
@@ -130,7 +130,7 @@ func (do *Domain) loadInfoSchema(handle *infoschema.Handle, usedSchemaVersion in
 	if err != nil {
 		return 0, nil, fullLoad, errors.Trace(err)
 	}
-	log.Info("full load InfoSchema failed", zap.Int64("usedSchemaVersion", usedSchemaVersion),
+	logutil.Logger(context.Background()).Info("full load InfoSchema failed", zap.Int64("usedSchemaVersion", usedSchemaVersion),
 		zap.Int64("latestSchemaVersion", latestSchemaVersion), zap.Duration("time", time.Since(startTime)))
 	newISBuilder.Build()
 	return latestSchemaVersion, nil, fullLoad, nil
@@ -336,7 +336,7 @@ func (do *Domain) Reload() error {
 	metrics.LoadSchemaCounter.WithLabelValues("succ").Inc()
 
 	if fullLoad {
-		log.Info("full load and reset schema validator.")
+		logutil.Logger(context.Background()).Info("full load and reset schema validator.")
 		do.SchemaValidator.Reset()
 	}
 	do.SchemaValidator.Update(ver.Ver, schemaVersion, latestSchemaVersion, changedTableIDs)
@@ -346,7 +346,7 @@ func (do *Domain) Reload() error {
 	// Reload interval is lease / 2, if load schema time elapses more than this interval,
 	// some query maybe responded by ErrInfoSchemaExpired error.
 	if sub > (lease/2) && lease > 0 {
-		log.Warn("loading schema takes a long time.", zap.Duration("time", sub))
+		logutil.Logger(context.Background()).Warn("loading schema takes a long time.", zap.Duration("time", sub))
 	}
 
 	return nil
@@ -412,11 +412,11 @@ func (do *Domain) infoSyncerKeeper() {
 	for {
 		select {
 		case <-do.info.Done():
-			log.Info("server info syncer need to restart")
+			logutil.Logger(context.Background()).Info("server info syncer need to restart")
 			if err := do.info.Restart(context.Background()); err != nil {
-				log.Error("server restart failed", zap.Error(err))
+				logutil.Logger(context.Background()).Error("server restart failed", zap.Error(err))
 			}
-			log.Info("server info syncer restarted.")
+			logutil.Logger(context.Background()).Info("server info syncer restarted.")
 		case <-do.exit:
 			return
 		}
@@ -437,21 +437,21 @@ func (do *Domain) loadSchemaInLoop(lease time.Duration) {
 		case <-ticker.C:
 			err := do.Reload()
 			if err != nil {
-				log.Error("reload schema in loop.", zap.Error(err))
+				logutil.Logger(context.Background()).Error("reload schema in loop.", zap.Error(err))
 			}
 		case _, ok := <-syncer.GlobalVersionCh():
 			err := do.Reload()
 			if err != nil {
-				log.Error("reload schema in loop.", zap.Error(err))
+				logutil.Logger(context.Background()).Error("reload schema in loop.", zap.Error(err))
 			}
 			if !ok {
-				log.Warn("Reload schema in loop, schema syncer need rewatch")
+				logutil.Logger(context.Background()).Warn("Reload schema in loop, schema syncer need rewatch")
 				// Make sure the rewatch doesn't affect load schema, so we watch the global schema version asynchronously.
 				syncer.WatchGlobalSchemaVer(context.Background())
 			}
 		case <-syncer.Done():
 			// The schema syncer stops, we need stop the schema validator to synchronize the schema version.
-			log.Info("reload schema in loop, schema syncer need restart")
+			logutil.Logger(context.Background()).Info("reload schema in loop, schema syncer need restart")
 			// The etcd is responsible for schema synchronization, we should ensure there is at most two different schema version
 			// in the TiDB cluster, to make the data/schema be consistent. If we lost connection/session to etcd, the cluster
 			// will treats this TiDB as a down instance, and etcd will remove the key of `/tidb/ddl/all_schema_versions/tidb-id`.
@@ -461,18 +461,18 @@ func (do *Domain) loadSchemaInLoop(lease time.Duration) {
 			do.SchemaValidator.Stop()
 			err := do.mustRestartSyncer()
 			if err != nil {
-				log.Error("reload schema in loop, schema syncer restart err.", zap.Error(err))
+				logutil.Logger(context.Background()).Error("reload schema in loop, schema syncer restart err.", zap.Error(err))
 				break
 			}
 			// The schema maybe changed, must reload schema then the schema validator can restart.
 			exitLoop := do.mustReload()
 			if exitLoop {
 				// domain is closed.
-				log.Error("domain is closed, exit loadSchemaInLoop")
+				logutil.Logger(context.Background()).Error("domain is closed, exit loadSchemaInLoop")
 				return
 			}
 			do.SchemaValidator.Restart()
-			log.Info("schema syncer restarted.")
+			logutil.Logger(context.Background()).Info("schema syncer restarted.")
 		case <-do.exit:
 			return
 		}
@@ -497,7 +497,7 @@ func (do *Domain) mustRestartSyncer() error {
 		default:
 		}
 		time.Sleep(time.Second)
-		log.Info("restart the schema syncer failed.", zap.Error(err))
+		logutil.Logger(context.Background()).Info("restart the schema syncer failed.", zap.Error(err))
 	}
 }
 
@@ -507,15 +507,15 @@ func (do *Domain) mustReload() (exitLoop bool) {
 	for {
 		err := do.Reload()
 		if err == nil {
-			log.Info("mustReload succeed.")
+			logutil.Logger(context.Background()).Info("mustReload succeed.")
 			return false
 		}
 
-		log.Info("reload the schema failed.", zap.Error(err))
+		logutil.Logger(context.Background()).Info("reload the schema failed.", zap.Error(err))
 		// If the domain is closed, we returns immediately.
 		select {
 		case <-do.exit:
-			log.Info("domain is closed.")
+			logutil.Logger(context.Background()).Info("domain is closed.")
 			return true
 		default:
 		}
@@ -539,7 +539,7 @@ func (do *Domain) Close() {
 	do.sysSessionPool.Close()
 	do.slowQuery.Close()
 	do.wg.Wait()
-	log.Info("closed")
+	logutil.Logger(context.Background()).Info("closed")
 }
 
 type ddlCallback struct {
@@ -551,11 +551,11 @@ func (c *ddlCallback) OnChanged(err error) error {
 	if err != nil {
 		return err
 	}
-	log.Info("doing  DDL change, must reload")
+	logutil.Logger(context.Background()).Info("doing  DDL change, must reload")
 
 	err = c.do.Reload()
 	if err != nil {
-		log.Error("doing DDL change failed", zap.Error(err))
+		logutil.Logger(context.Background()).Error("doing DDL change failed", zap.Error(err))
 	}
 
 	return nil
@@ -773,7 +773,7 @@ func (do *Domain) LoadPrivilegeLoop(ctx sessionctx.Context) error {
 			case <-time.After(duration):
 			}
 			if !ok {
-				log.Error("load privilege loop watch channel closed.")
+				logutil.Logger(context.Background()).Error("load privilege loop watch channel closed.")
 				watchCh = do.etcdClient.Watch(context.Background(), privilegeKey)
 				count++
 				if count > 10 {
@@ -786,9 +786,9 @@ func (do *Domain) LoadPrivilegeLoop(ctx sessionctx.Context) error {
 			err := do.privHandle.Update(ctx)
 			metrics.LoadPrivilegeCounter.WithLabelValues(metrics.RetLabel(err)).Inc()
 			if err != nil {
-				log.Error("load privilege failed.", zap.Error(err))
+				logutil.Logger(context.Background()).Error("load privilege failed.", zap.Error(err))
 			} else {
-				log.Debug("reload privilege success.")
+				logutil.Logger(context.Background()).Debug("reload privilege success.")
 			}
 		}
 	}()
@@ -896,7 +896,7 @@ func (do *Domain) newStatsOwner() owner.Manager {
 	// TODO: Need to do something when err is not nil.
 	err := statsOwner.CampaignOwner(cancelCtx)
 	if err != nil {
-		log.Warn("campaign owner failed.", zap.Error(err))
+		logutil.Logger(context.Background()).Warn("campaign owner failed.", zap.Error(err))
 	}
 	return statsOwner
 }
@@ -921,9 +921,9 @@ func (do *Domain) updateStatsWorker(ctx sessionctx.Context, owner owner.Manager)
 	t := time.Now()
 	err := statsHandle.InitStats(do.InfoSchema())
 	if err != nil {
-		log.Debug("init stats info failed.", zap.Error(err))
+		logutil.Logger(context.Background()).Debug("init stats info failed.", zap.Error(err))
 	} else {
-		log.Info("init stats info time.", zap.Duration("time", time.Since(t)))
+		logutil.Logger(context.Background()).Info("init stats info time.", zap.Duration("time", time.Since(t)))
 	}
 	defer func() {
 		do.SetStatsUpdating(false)
@@ -934,7 +934,7 @@ func (do *Domain) updateStatsWorker(ctx sessionctx.Context, owner owner.Manager)
 		case <-loadTicker.C:
 			err = statsHandle.Update(do.InfoSchema())
 			if err != nil {
-				log.Debug("update stats info failed.", zap.Error(err))
+				logutil.Logger(context.Background()).Debug("update stats info failed.", zap.Error(err))
 			}
 		case <-do.exit:
 			statsHandle.FlushStats()
@@ -943,18 +943,18 @@ func (do *Domain) updateStatsWorker(ctx sessionctx.Context, owner owner.Manager)
 		case t := <-statsHandle.DDLEventCh():
 			err = statsHandle.HandleDDLEvent(t)
 			if err != nil {
-				log.Debug("handle ddl event failed.", zap.Error(err))
+				logutil.Logger(context.Background()).Debug("handle ddl event failed.", zap.Error(err))
 			}
 		case <-deltaUpdateTicker.C:
 			err = statsHandle.DumpStatsDeltaToKV(statistics.DumpDelta)
 			if err != nil {
-				log.Debug("dump stats delta failed.", zap.Error(err))
+				logutil.Logger(context.Background()).Debug("dump stats delta failed.", zap.Error(err))
 			}
 			statsHandle.UpdateErrorRate(do.InfoSchema())
 		case <-loadHistogramTicker.C:
 			err = statsHandle.LoadNeededHistograms()
 			if err != nil {
-				log.Debug("load histograms failed.", zap.Error(err))
+				logutil.Logger(context.Background()).Debug("load histograms failed.", zap.Error(err))
 			}
 		case <-loadFeedbackTicker.C:
 			statsHandle.UpdateStatsByLocalFeedback(do.InfoSchema())
@@ -963,20 +963,20 @@ func (do *Domain) updateStatsWorker(ctx sessionctx.Context, owner owner.Manager)
 			}
 			err = statsHandle.HandleUpdateStats(do.InfoSchema())
 			if err != nil {
-				log.Debug("update stats using feedback failed.", zap.Error(err))
+				logutil.Logger(context.Background()).Debug("update stats using feedback failed.", zap.Error(err))
 			}
 		case <-dumpFeedbackTicker.C:
 			err = statsHandle.DumpStatsFeedbackToKV()
 			if err != nil {
-				log.Debug("dump stats feedback failed.", zap.Error(err))
+				logutil.Logger(context.Background()).Debug("dump stats feedback failed.", zap.Error(err))
 			}
 		case <-gcStatsTicker.C:
 			if !owner.IsOwner() {
 				continue
 			}
 			err = statsHandle.GCStats(do.InfoSchema(), do.DDL().GetLease())
 			if err != nil {
-				log.Debug("GC stats failed.", zap.Error(err))
+				logutil.Logger(context.Background()).Debug("GC stats failed.", zap.Error(err))
 			}
 		}
 	}
@@ -1011,13 +1011,13 @@ func (do *Domain) NotifyUpdatePrivilege(ctx sessionctx.Context) {
 		row := do.etcdClient.KV
 		_, err := row.Put(context.Background(), privilegeKey, "")
 		if err != nil {
-			log.Warn("notify update privilege failed", zap.Error(err))
+			logutil.Logger(context.Background()).Warn("notify update privilege failed", zap.Error(err))
 		}
 	}
 	// update locally
 	_, _, err := ctx.(sqlexec.RestrictedSQLExecutor).ExecRestrictedSQL(ctx, `FLUSH PRIVILEGES`)
 	if err != nil {
-		log.Error("unable to update privileges.", zap.Error(err))
+		logutil.Logger(context.Background()).Error("unable to update privileges.", zap.Error(err))
 	}
 }
 
@@ -1027,7 +1027,7 @@ func recoverInDomain(funcName string, quit bool) {
 		return
 	}
 	buf := util.GetStack()
-	log.Error("recover in domain failed.", zap.String("function name", funcName),
+	logutil.Logger(context.Background()).Error("recover in domain failed.", zap.String("function name", funcName),
 		zap.Any("error", r), zap.String("buffer", string(buf)))
 	metrics.PanicCounter.WithLabelValues(metrics.LabelDomain).Inc()
 	if quit {

domain/info.go

@@ -22,12 +22,12 @@ import (
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/clientv3/concurrency"
 	"github.com/pingcap/errors"
-	"github.com/pingcap/log"
 	"github.com/pingcap/parser/mysql"
 	"github.com/pingcap/tidb/config"
 	"github.com/pingcap/tidb/ddl"
 	"github.com/pingcap/tidb/owner"
 	"github.com/pingcap/tidb/util/hack"
+	"github.com/pingcap/tidb/util/logutil"
 	"github.com/pingcap/tidb/util/printer"
 	"go.uber.org/zap"
 )
@@ -140,7 +140,7 @@ func (is *InfoSyncer) RemoveServerInfo() {
 	}
 	err := ddl.DeleteKeyFromEtcd(is.serverInfoPath, is.etcdCli, keyOpDefaultRetryCnt, keyOpDefaultTimeout)
 	if err != nil {
-		log.Error("remove server info failed.", zap.Error(err))
+		logutil.Logger(context.Background()).Error("remove server info failed.", zap.Error(err))
 	}
 }
 
@@ -189,15 +189,15 @@ func getInfo(ctx context.Context, etcdCli *clientv3.Client, key string, retryCnt
 		resp, err = etcdCli.Get(childCtx, key, opts...)
 		cancel()
 		if err != nil {
-			log.Info("get key failed.", zap.String("key", key), zap.Error(err))
+			logutil.Logger(context.Background()).Info("get key failed.", zap.String("key", key), zap.Error(err))
 			time.Sleep(200 * time.Millisecond)
 			continue
 		}
 		for _, kv := range resp.Kvs {
 			info := &ServerInfo{}
 			err = json.Unmarshal(kv.Value, info)
 			if err != nil {
-				log.Info("get key failed.", zap.String("key", string(kv.Key)), zap.ByteString("value", kv.Value),
+				logutil.Logger(context.Background()).Info("get key failed.", zap.String("key", string(kv.Key)), zap.ByteString("value", kv.Value),
 					zap.Error(err))
 				return nil, errors.Trace(err)
 			}