Merge pull request #699 from cameron-p-m/fix/allow-setting-logger

lance6716 · web-flow · commit 62e840761f43 · 2022-06-11T21:50:29.000+08:00
Allow logger override
diff --git a/canal/canal.go b/canal/canal.go
@@ -19,7 +19,6 @@ import (
 	"github.com/go-mysql-org/go-mysql/schema"
 	"github.com/pingcap/errors"
 	"github.com/pingcap/parser"
-	"github.com/siddontang/go-log/log"
 )
 
 // Canal can sync your MySQL data into everywhere, like Elasticsearch, Redis, etc...
@@ -72,7 +71,7 @@ func NewCanal(cfg *Config) (*Canal, error) {
 	if c.cfg.DiscardNoMetaRowEvent {
 		c.errorTablesGetTime = make(map[string]time.Time)
 	}
-	c.master = &masterInfo{}
+	c.master = &masterInfo{logger: c.cfg.Logger}
 
 	c.delay = new(uint32)
 
@@ -222,14 +221,14 @@ func (c *Canal) run() error {
 		close(c.dumpDoneCh)
 
 		if err != nil {
-			log.Errorf("canal dump mysql err: %v", err)
+			c.cfg.Logger.Errorf("canal dump mysql err: %v", err)
 			return errors.Trace(err)
 		}
 	}
 
 	if err := c.runSyncBinlog(); err != nil {
 		if errors.Cause(err) != context.Canceled {
-			log.Errorf("canal start sync binlog err: %v", err)
+			c.cfg.Logger.Errorf("canal start sync binlog err: %v", err)
 			return errors.Trace(err)
 		}
 	}
@@ -238,7 +237,7 @@ func (c *Canal) run() error {
 }
 
 func (c *Canal) Close() {
-	log.Infof("closing canal")
+	c.cfg.Logger.Infof("closing canal")
 	c.m.Lock()
 	defer c.m.Unlock()
 
@@ -353,7 +352,7 @@ func (c *Canal) GetTable(db string, table string) (*schema.Table, error) {
 			c.errorTablesGetTime[key] = time.Now()
 			c.tableLock.Unlock()
 			// log error and return ErrMissingTableMeta
-			log.Errorf("canal get table meta err: %v", errors.Trace(err))
+			c.cfg.Logger.Errorf("canal get table meta err: %v", errors.Trace(err))
 			return nil, schema.ErrMissingTableMeta
 		}
 		return nil, err
@@ -427,6 +426,7 @@ func (c *Canal) prepareSyncer() error {
 		DisableRetrySync:        c.cfg.DisableRetrySync,
 		TimestampStringLocation: c.cfg.TimestampStringLocation,
 		TLSConfig:               c.cfg.TLSConfig,
+		Logger:                  c.cfg.Logger,
 	}
 
 	if strings.Contains(c.cfg.Addr, "/") {
diff --git a/canal/config.go b/canal/config.go
@@ -4,11 +4,13 @@ import (
 	"crypto/tls"
 	"io/ioutil"
 	"math/rand"
+	"os"
 	"time"
 
 	"github.com/BurntSushi/toml"
 	"github.com/go-mysql-org/go-mysql/mysql"
 	"github.com/pingcap/errors"
+	"github.com/siddontang/go-log/log"
 )
 
 type DumpConfig struct {
@@ -86,6 +88,9 @@ type Config struct {
 
 	// Set TLS config
 	TLSConfig *tls.Config
+
+	//Set Logger
+	Logger *log.Logger
 }
 
 func NewConfigWithFile(name string) (*Config, error) {
@@ -124,5 +129,8 @@ func NewDefaultConfig() *Config {
 	c.Dump.DiscardErr = true
 	c.Dump.SkipMasterData = false
 
+	streamHandler, _ := log.NewStreamHandler(os.Stdout)
+	c.Logger = log.NewDefault(streamHandler)
+
 	return c
 }
diff --git a/canal/dump.go b/canal/dump.go
@@ -11,7 +11,6 @@ import (
 	"github.com/go-mysql-org/go-mysql/schema"
 	"github.com/pingcap/errors"
 	"github.com/shopspring/decimal"
-	"github.com/siddontang/go-log/log"
 )
 
 type dumpParseHandler struct {
@@ -49,7 +48,7 @@ func (h *dumpParseHandler) Data(db string, table string, values []string) error
 			e == schema.ErrMissingTableMeta {
 			return nil
 		}
-		log.Errorf("get %s.%s information err: %v", db, table, err)
+		h.c.cfg.Logger.Errorf("get %s.%s information err: %v", db, table, err)
 		return errors.Trace(err)
 	}
 
@@ -163,13 +162,13 @@ func (c *Canal) dump() error {
 		if err != nil {
 			return errors.Trace(err)
 		}
-		log.Infof("skip master data, get current binlog position %v", pos)
+		c.cfg.Logger.Infof("skip master data, get current binlog position %v", pos)
 		h.name = pos.Name
 		h.pos = uint64(pos.Pos)
 	}
 
 	start := time.Now()
-	log.Info("try dump MySQL and parse")
+	c.cfg.Logger.Info("try dump MySQL and parse")
 	if err := c.dumper.DumpAndParse(h); err != nil {
 		return errors.Trace(err)
 	}
@@ -185,7 +184,7 @@ func (c *Canal) dump() error {
 		c.master.UpdateGTIDSet(h.gset)
 		startPos = h.gset
 	}
-	log.Infof("dump MySQL and parse OK, use %0.2f seconds, start binlog replication at %s",
+	c.cfg.Logger.Infof("dump MySQL and parse OK, use %0.2f seconds, start binlog replication at %s",
 		time.Since(start).Seconds(), startPos)
 	return nil
 }
@@ -196,12 +195,12 @@ func (c *Canal) tryDump() error {
 	if (len(pos.Name) > 0 && pos.Pos > 0) ||
 		(gset != nil && gset.String() != "") {
 		// we will sync with binlog name and position
-		log.Infof("skip dump, use last binlog replication pos %s or GTID set %v", pos, gset)
+		c.cfg.Logger.Infof("skip dump, use last binlog replication pos %s or GTID set %v", pos, gset)
 		return nil
 	}
 
 	if c.dumper == nil {
-		log.Info("skip dump, no mysqldump")
+		c.cfg.Logger.Info("skip dump, no mysqldump")
 		return nil
 	}
 
diff --git a/canal/master.go b/canal/master.go
@@ -15,26 +15,28 @@ type masterInfo struct {
 	gset mysql.GTIDSet
 
 	timestamp uint32
+
+	logger *log.Logger
 }
 
 func (m *masterInfo) Update(pos mysql.Position) {
-	log.Debugf("update master position %s", pos)
+	m.logger.Debugf("update master position %s", pos)
 
 	m.Lock()
 	m.pos = pos
 	m.Unlock()
 }
 
 func (m *masterInfo) UpdateTimestamp(ts uint32) {
-	log.Debugf("update master timestamp %d", ts)
+	m.logger.Debugf("update master timestamp %d", ts)
 
 	m.Lock()
 	m.timestamp = ts
 	m.Unlock()
 }
 
 func (m *masterInfo) UpdateGTIDSet(gset mysql.GTIDSet) {
-	log.Debugf("update master gtid set %s", gset)
+	m.logger.Debugf("update master gtid set %s", gset)
 
 	m.Lock()
 	m.gset = gset
diff --git a/canal/sync.go b/canal/sync.go
@@ -11,7 +11,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/pingcap/errors"
 	"github.com/pingcap/parser/ast"
-	"github.com/siddontang/go-log/log"
 )
 
 func (c *Canal) startSyncer() (*replication.BinlogStreamer, error) {
@@ -22,15 +21,15 @@ func (c *Canal) startSyncer() (*replication.BinlogStreamer, error) {
 		if err != nil {
 			return nil, errors.Errorf("start sync replication at binlog %v error %v", pos, err)
 		}
-		log.Infof("start sync binlog at binlog file %v", pos)
+		c.cfg.Logger.Infof("start sync binlog at binlog file %v", pos)
 		return s, nil
 	} else {
 		gsetClone := gset.Clone()
 		s, err := c.syncer.StartSyncGTID(gset)
 		if err != nil {
 			return nil, errors.Errorf("start sync replication at GTID set %v error %v", gset, err)
 		}
-		log.Infof("start sync binlog at GTID set %v", gsetClone)
+		c.cfg.Logger.Infof("start sync binlog at GTID set %v", gsetClone)
 		return s, nil
 	}
 }
@@ -65,7 +64,7 @@ func (c *Canal) runSyncBinlog() error {
 			switch e := ev.Event.(type) {
 			case *replication.RotateEvent:
 				fakeRotateLogName = string(e.NextLogName)
-				log.Infof("received fake rotate event, next log name is %s", e.NextLogName)
+				c.cfg.Logger.Infof("received fake rotate event, next log name is %s", e.NextLogName)
 			}
 
 			continue
@@ -76,6 +75,7 @@ func (c *Canal) runSyncBinlog() error {
 		pos := c.master.Position()
 
 		curPos := pos.Pos
+
 		// next binlog pos
 		pos.Pos = ev.Header.LogPos
 
@@ -92,7 +92,7 @@ func (c *Canal) runSyncBinlog() error {
 		case *replication.RotateEvent:
 			pos.Name = string(e.NextLogName)
 			pos.Pos = uint32(e.Position)
-			log.Infof("rotate binlog to %s", pos)
+			c.cfg.Logger.Infof("rotate binlog to %s", pos)
 			savePos = true
 			force = true
 			if err = c.eventHandler.OnRotate(e); err != nil {
@@ -107,7 +107,7 @@ func (c *Canal) runSyncBinlog() error {
 				if e != ErrExcludedTable &&
 					e != schema.ErrTableNotExist &&
 					e != schema.ErrMissingTableMeta {
-					log.Errorf("handle rows event at (%s, %d) error %v", pos.Name, curPos, err)
+					c.cfg.Logger.Errorf("handle rows event at (%s, %d) error %v", pos.Name, curPos, err)
 					return errors.Trace(err)
 				}
 			}
@@ -142,7 +142,7 @@ func (c *Canal) runSyncBinlog() error {
 		case *replication.QueryEvent:
 			stmts, _, err := c.parser.Parse(string(e.Query), "", "")
 			if err != nil {
-				log.Errorf("parse query(%s) err %v, will skip this event", e.Query, err)
+				c.cfg.Logger.Errorf("parse query(%s) err %v, will skip this event", e.Query, err)
 				continue
 			}
 			for _, stmt := range stmts {
@@ -230,7 +230,7 @@ func parseStmt(stmt ast.StmtNode) (ns []*node) {
 
 func (c *Canal) updateTable(db, table string) (err error) {
 	c.ClearTableCache([]byte(db), []byte(table))
-	log.Infof("table structure changed, clear table cache: %s.%s\n", db, table)
+	c.cfg.Logger.Infof("table structure changed, clear table cache: %s.%s\n", db, table)
 	if err = c.eventHandler.OnTableChanged(db, table); err != nil && errors.Cause(err) != schema.ErrTableNotExist {
 		return errors.Trace(err)
 	}
@@ -291,7 +291,7 @@ func (c *Canal) WaitUntilPos(pos mysql.Position, timeout time.Duration) error {
 			if curPos.Compare(pos) >= 0 {
 				return nil
 			} else {
-				log.Debugf("master pos is %v, wait catching %v", curPos, pos)
+				c.cfg.Logger.Debugf("master pos is %v, wait catching %v", curPos, pos)
 				time.Sleep(100 * time.Millisecond)
 			}
 		}
diff --git a/replication/binlogsyncer.go b/replication/binlogsyncer.go

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,6 @@ import (`
`19`	`19`	`"github.com/go-mysql-org/go-mysql/schema"`
`20`	`20`	`"github.com/pingcap/errors"`
`21`	`21`	`"github.com/pingcap/parser"`
`22`		`- "github.com/siddontang/go-log/log"`
`23`	`22`	`)`
`24`	`23`
`25`	`24`	`// Canal can sync your MySQL data into everywhere, like Elasticsearch, Redis, etc...`
`@@ -72,7 +71,7 @@ func NewCanal(cfg Config) (Canal, error) {`
`72`	`71`	`if c.cfg.DiscardNoMetaRowEvent {`
`73`	`72`	`c.errorTablesGetTime = make(map[string]time.Time)`
`74`	`73`	`}`
`75`		`- c.master = &masterInfo{}`
	`74`	`+ c.master = &masterInfo{logger: c.cfg.Logger}`
`76`	`75`
`77`	`76`	`c.delay = new(uint32)`
`78`	`77`
`@@ -222,14 +221,14 @@ func (c *Canal) run() error {`
`222`	`221`	`close(c.dumpDoneCh)`
`223`	`222`
`224`	`223`	`if err != nil {`
`225`		`- log.Errorf("canal dump mysql err: %v", err)`
	`224`	`+ c.cfg.Logger.Errorf("canal dump mysql err: %v", err)`
`226`	`225`	`return errors.Trace(err)`
`227`	`226`	`}`
`228`	`227`	`}`
`229`	`228`
`230`	`229`	`if err := c.runSyncBinlog(); err != nil {`
`231`	`230`	`if errors.Cause(err) != context.Canceled {`
`232`		`- log.Errorf("canal start sync binlog err: %v", err)`
	`231`	`+ c.cfg.Logger.Errorf("canal start sync binlog err: %v", err)`
`233`	`232`	`return errors.Trace(err)`
`234`	`233`	`}`
`235`	`234`	`}`
`@@ -238,7 +237,7 @@ func (c *Canal) run() error {`
`238`	`237`	`}`
`239`	`238`
`240`	`239`	`func (c *Canal) Close() {`
`241`		`- log.Infof("closing canal")`
	`240`	`+ c.cfg.Logger.Infof("closing canal")`
`242`	`241`	`c.m.Lock()`
`243`	`242`	`defer c.m.Unlock()`
`244`	`243`
`@@ -353,7 +352,7 @@ func (c Canal) GetTable(db string, table string) (schema.Table, error) {`
`353`	`352`	`c.errorTablesGetTime[key] = time.Now()`
`354`	`353`	`c.tableLock.Unlock()`
`355`	`354`	`// log error and return ErrMissingTableMeta`
`356`		`- log.Errorf("canal get table meta err: %v", errors.Trace(err))`
	`355`	`+ c.cfg.Logger.Errorf("canal get table meta err: %v", errors.Trace(err))`
`357`	`356`	`return nil, schema.ErrMissingTableMeta`
`358`	`357`	`}`
`359`	`358`	`return nil, err`
`@@ -427,6 +426,7 @@ func (c *Canal) prepareSyncer() error {`
`427`	`426`	`DisableRetrySync: c.cfg.DisableRetrySync,`
`428`	`427`	`TimestampStringLocation: c.cfg.TimestampStringLocation,`
`429`	`428`	`TLSConfig: c.cfg.TLSConfig,`
	`429`	`+ Logger: c.cfg.Logger,`
`430`	`430`	`}`
`431`	`431`
`432`	`432`	`if strings.Contains(c.cfg.Addr, "/") {`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,6 @@ import (`
`11`	`11`	`"github.com/go-mysql-org/go-mysql/schema"`
`12`	`12`	`"github.com/pingcap/errors"`
`13`	`13`	`"github.com/shopspring/decimal"`
`14`		`- "github.com/siddontang/go-log/log"`
`15`	`14`	`)`
`16`	`15`
`17`	`16`	`type dumpParseHandler struct {`
`@@ -49,7 +48,7 @@ func (h *dumpParseHandler) Data(db string, table string, values []string) error`
`49`	`48`	`e == schema.ErrMissingTableMeta {`
`50`	`49`	`return nil`
`51`	`50`	`}`
`52`		`- log.Errorf("get %s.%s information err: %v", db, table, err)`
	`51`	`+ h.c.cfg.Logger.Errorf("get %s.%s information err: %v", db, table, err)`
`53`	`52`	`return errors.Trace(err)`
`54`	`53`	`}`
`55`	`54`
`@@ -163,13 +162,13 @@ func (c *Canal) dump() error {`
`163`	`162`	`if err != nil {`
`164`	`163`	`return errors.Trace(err)`
`165`	`164`	`}`
`166`		`- log.Infof("skip master data, get current binlog position %v", pos)`
	`165`	`+ c.cfg.Logger.Infof("skip master data, get current binlog position %v", pos)`
`167`	`166`	`h.name = pos.Name`
`168`	`167`	`h.pos = uint64(pos.Pos)`
`169`	`168`	`}`
`170`	`169`
`171`	`170`	`start := time.Now()`
`172`		`- log.Info("try dump MySQL and parse")`
	`171`	`+ c.cfg.Logger.Info("try dump MySQL and parse")`
`173`	`172`	`if err := c.dumper.DumpAndParse(h); err != nil {`
`174`	`173`	`return errors.Trace(err)`
`175`	`174`	`}`
`@@ -185,7 +184,7 @@ func (c *Canal) dump() error {`
`185`	`184`	`c.master.UpdateGTIDSet(h.gset)`
`186`	`185`	`startPos = h.gset`
`187`	`186`	`}`
`188`		`- log.Infof("dump MySQL and parse OK, use %0.2f seconds, start binlog replication at %s",`
	`187`	`+ c.cfg.Logger.Infof("dump MySQL and parse OK, use %0.2f seconds, start binlog replication at %s",`
`189`	`188`	`time.Since(start).Seconds(), startPos)`
`190`	`189`	`return nil`
`191`	`190`	`}`
`@@ -196,12 +195,12 @@ func (c *Canal) tryDump() error {`
`196`	`195`	`if (len(pos.Name) > 0 && pos.Pos > 0) \|\|`
`197`	`196`	`(gset != nil && gset.String() != "") {`
`198`	`197`	`// we will sync with binlog name and position`
`199`		`- log.Infof("skip dump, use last binlog replication pos %s or GTID set %v", pos, gset)`
	`198`	`+ c.cfg.Logger.Infof("skip dump, use last binlog replication pos %s or GTID set %v", pos, gset)`
`200`	`199`	`return nil`
`201`	`200`	`}`
`202`	`201`
`203`	`202`	`if c.dumper == nil {`
`204`		`- log.Info("skip dump, no mysqldump")`
	`203`	`+ c.cfg.Logger.Info("skip dump, no mysqldump")`
`205`	`204`	`return nil`
`206`	`205`	`}`
`207`	`206`