alibaba
diff --git a/‎api/tracer.go
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎api/tracer.go
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎core/base/slot_chain.go
Copy file name to clipboard
+1-3Lines changed: 1 addition & 3 deletions b/‎core/base/slot_chain.go
Copy file name to clipboard
+1-3Lines changed: 1 addition & 3 deletions
diff --git a/‎core/circuitbreaker/circuit_breaker.go
Copy file name to clipboard
+13-12Lines changed: 13 additions & 12 deletions b/‎core/circuitbreaker/circuit_breaker.go
Copy file name to clipboard
+13-12Lines changed: 13 additions & 12 deletions
diff --git a/‎core/circuitbreaker/rule.go
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion b/‎core/circuitbreaker/rule.go
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion
diff --git a/‎core/circuitbreaker/rule_manager.go
Copy file name to clipboard
+8-9Lines changed: 8 additions & 9 deletions b/‎core/circuitbreaker/rule_manager.go
Copy file name to clipboard
+8-9Lines changed: 8 additions & 9 deletions
diff --git a/‎core/config/config.go
Copy file name to clipboard
+20-9Lines changed: 20 additions & 9 deletions b/‎core/config/config.go
Copy file name to clipboard
+20-9Lines changed: 20 additions & 9 deletions
diff --git a/‎core/config/entity.go
Copy file name to clipboard
+8Lines changed: 8 additions & 0 deletions b/‎core/config/entity.go
Copy file name to clipboard
+8Lines changed: 8 additions & 0 deletions
diff --git a/‎core/flow/rule_manager.go
Copy file name to clipboard
+6-11Lines changed: 6 additions & 11 deletions b/‎core/flow/rule_manager.go
Copy file name to clipboard
+6-11Lines changed: 6 additions & 11 deletions
diff --git a/‎core/flow/slot.go
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion b/‎core/flow/slot.go
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion
@@ -9,7 +9,7 @@ import (
 func TraceError(entry *base.SentinelEntry, err error) {
 	defer func() {
 		if e := recover(); e != nil {
-			logging.GetDefaultLogger().Panicf("Failed to TraceError, panic error: %+v", e)
+			logging.Panicf("Failed to TraceError, panic error: %+v", e)
 			return
 		}
 	}()
 
@@ -8,8 +8,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-var logger = logging.GetDefaultLogger()
-
 // StatPrepareSlot is responsible for some preparation before statistic
 // For example: init structure and so on
 type StatPrepareSlot interface {
@@ -131,7 +129,7 @@ func (sc *SlotChain) Entry(ctx *EntryContext) *TokenResult {
 	// If happened, need to add TokenResult in EntryContext
 	defer func() {
 		if err := recover(); err != nil {
-			logger.Panicf("Sentinel internal panic in SlotChain, err: %+v", err)
+			logging.Panicf("Sentinel internal panic in SlotChain, err: %+v", err)
 			ctx.SetError(errors.Errorf("%+v", err))
 			return
 		}
 
@@ -6,6 +6,7 @@ import (
 
 	"github.com/alibaba/sentinel-golang/core/base"
 	sbase "github.com/alibaba/sentinel-golang/core/stat/base"
+	"github.com/alibaba/sentinel-golang/logging"
 	"github.com/alibaba/sentinel-golang/util"
 )
 
@@ -318,21 +319,21 @@ func (s *slowRequestLeapArray) ResetBucketTo(bw *sbase.BucketWrap, startTime uin
 func (s *slowRequestLeapArray) currentCounter() *slowRequestCounter {
 	curBucket, err := s.data.CurrentBucket(s)
 	if err != nil {
-		logger.Errorf("Failed to get current bucket, current ts=%d, err: %+v.", util.CurrentTimeMillis(), err)
+		logging.Errorf("Failed to get current bucket, current ts=%d, err: %+v.", util.CurrentTimeMillis(), err)
 		return nil
 	}
 	if curBucket == nil {
-		logger.Error("Current bucket is nil")
+		logging.Error("Current bucket is nil")
 		return nil
 	}
 	mb := curBucket.Value.Load()
 	if mb == nil {
-		logger.Error("Current bucket atomic Value is nil")
+		logging.Error("Current bucket atomic Value is nil")
 		return nil
 	}
 	counter, ok := mb.(*slowRequestCounter)
 	if !ok {
-		logger.Error("Bucket data type error")
+		logging.Error("Bucket data type error")
 		return nil
 	}
 	return counter
@@ -344,12 +345,12 @@ func (s *slowRequestLeapArray) allCounter() []*slowRequestCounter {
 	for _, b := range buckets {
 		mb := b.Value.Load()
 		if mb == nil {
-			logger.Error("Current bucket atomic Value is nil")
+			logging.Error("Current bucket atomic Value is nil")
 			continue
 		}
 		counter, ok := mb.(*slowRequestCounter)
 		if !ok {
-			logger.Error("Bucket data type error")
+			logging.Error("Bucket data type error")
 			continue
 		}
 		ret = append(ret, counter)
@@ -498,21 +499,21 @@ func (s *errorCounterLeapArray) ResetBucketTo(bw *sbase.BucketWrap, startTime ui
 func (s *errorCounterLeapArray) currentCounter() *errorCounter {
 	curBucket, err := s.data.CurrentBucket(s)
 	if err != nil {
-		logger.Errorf("Failed to get current bucket, current ts=%d, err: %+v.", util.CurrentTimeMillis(), err)
+		logging.Errorf("Failed to get current bucket, current ts=%d, err: %+v.", util.CurrentTimeMillis(), err)
 		return nil
 	}
 	if curBucket == nil {
-		logger.Error("Current bucket is nil")
+		logging.Error("Current bucket is nil")
 		return nil
 	}
 	mb := curBucket.Value.Load()
 	if mb == nil {
-		logger.Error("Current bucket atomic Value is nil")
+		logging.Error("Current bucket atomic Value is nil")
 		return nil
 	}
 	counter, ok := mb.(*errorCounter)
 	if !ok {
-		logger.Error("Bucket data type error")
+		logging.Error("Bucket data type error")
 		return nil
 	}
 	return counter
@@ -524,12 +525,12 @@ func (s *errorCounterLeapArray) allCounter() []*errorCounter {
 	for _, b := range buckets {
 		mb := b.Value.Load()
 		if mb == nil {
-			logger.Error("Current bucket atomic Value is nil")
+			logging.Error("Current bucket atomic Value is nil")
 			continue
 		}
 		counter, ok := mb.(*errorCounter)
 		if !ok {
-			logger.Error("Bucket data type error")
+			logging.Error("Bucket data type error")
 			continue
 		}
 		ret = append(ret, counter)
 
@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/alibaba/sentinel-golang/core/base"
+	"github.com/alibaba/sentinel-golang/logging"
 	"github.com/alibaba/sentinel-golang/util"
 	"github.com/pkg/errors"
 )
@@ -247,7 +248,7 @@ func NewRule(resource string, strategy Strategy, opts ...RuleOption) Rule {
 			Threshold: ruleOpts.errorCountThreshold,
 		}
 	default:
-		logger.Errorf("unsupported circuit breaker rule, strategy: %d", strategy)
+		logging.Errorf("unsupported circuit breaker rule, strategy: %d", strategy)
 		return nil
 	}
 }
 
@@ -13,7 +13,6 @@ import (
 type CircuitBreakerGenFunc func(r Rule, reuseStat interface{}) (CircuitBreaker, error)
 
 var (
-	logger       = logging.GetDefaultLogger()
 	cbGenFuncMap = make(map[Strategy]CircuitBreakerGenFunc)
 
 	breakerRules = make(map[string][]Rule)
@@ -34,7 +33,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*slowRequestLeapArray)
 		if !ok || stat == nil {
-			logger.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray, in fact: %+v", stat)
+			logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray, in fact: %+v", stat)
 			return newSlowRtCircuitBreaker(rtRule)
 		}
 		return newSlowRtCircuitBreakerWithStat(rtRule, stat), nil
@@ -50,7 +49,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*errorCounterLeapArray)
 		if !ok || stat == nil {
-			logger.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)
+			logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)
 			return newErrorRatioCircuitBreaker(errRatioRule)
 		}
 		return newErrorRatioCircuitBreakerWithStat(errRatioRule, stat), nil
@@ -66,7 +65,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*errorCounterLeapArray)
 		if !ok || stat == nil {
-			logger.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)
+			logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)
 			return newErrorCountCircuitBreaker(errCountRule)
 		}
 		return newErrorCountCircuitBreakerWithStat(errCountRule, stat), nil
@@ -167,7 +166,7 @@ func onRuleUpdate(rules []Rule) (err error) {
 			continue
 		}
 		if err := rule.IsApplicable(); err != nil {
-			logger.Warnf("Ignoring invalid circuit breaking rule when loading new rules, rule: %+v, reason: %s", rule, err.Error())
+			logging.Warnf("Ignoring invalid circuit breaking rule when loading new rules, rule: %+v, reason: %s", rule, err.Error())
 			continue
 		}
 
@@ -193,7 +192,7 @@ func onRuleUpdate(rules []Rule) (err error) {
 		if r := recover(); r != nil {
 			return
 		}
-		logger.Debugf("Updating circuit breaker rule spends %d ns.", util.CurrentTimeNano()-start)
+		logging.Debugf("Updating circuit breaker rule spends %d ns.", util.CurrentTimeNano()-start)
 		logRuleUpdate(newBreakerRules)
 	}()
 
@@ -218,7 +217,7 @@ func onRuleUpdate(rules []Rule) (err error) {
 
 			generator := cbGenFuncMap[r.BreakerStrategy()]
 			if generator == nil {
-				logger.Warnf("Ignoring the rule due to unsupported circuit breaking strategy: %v", r)
+				logging.Warnf("Ignoring the rule due to unsupported circuit breaking strategy: %v", r)
 				continue
 			}
 
@@ -230,7 +229,7 @@ func onRuleUpdate(rules []Rule) (err error) {
 				cb, e = generator(r, nil)
 			}
 			if cb == nil || e != nil {
-				logger.Warnf("Ignoring the rule due to bad generated circuit breaker, r: %s, err: %+v", r.String(), e)
+				logging.Warnf("Ignoring the rule due to bad generated circuit breaker, r: %s, err: %+v", r.String(), e)
 				continue
 			}
 
@@ -272,7 +271,7 @@ func logRuleUpdate(rules map[string][]Rule) {
 		sb.WriteString(r.String() + ",")
 	}
 	sb.WriteString("]")
-	logger.Info(sb.String())
+	logging.Info(sb.String())
 }
 
 func RegisterStateChangeListeners(listeners ...StateChangeListener) {
 
@@ -50,11 +50,20 @@ func OverrideConfigFromEnvAndInitLog() error {
 	if err != nil {
 		return err
 	}
+
+	// Configured Logger is the highest priority
+	if configLogger := Logger(); configLogger != nil {
+		err = logging.ResetGlobalLogger(configLogger)
+		if err != nil {
+			return err
+		}
+		return nil
+	}
 	err = initializeLogConfig(LogBaseDir(), LogUsePid())
 	if err != nil {
 		return err
 	}
-	logging.GetDefaultLogger().Infof("App name resolved: %s", AppName())
+	logging.Infof("App name resolved: %s", AppName())
 	return nil
 }
 
@@ -77,7 +86,7 @@ func loadFromYamlFile(filePath string) error {
 	if err != nil {
 		return err
 	}
-	logging.GetDefaultLogger().Infof("Resolving Sentinel config from file: %s", filePath)
+	logging.Infof("Resolving Sentinel config from file: %s", filePath)
 	return checkConfValid(&(globalCfg.Sentinel))
 }
 
@@ -131,17 +140,15 @@ func reconfigureRecordLogger(logBaseDir string, withPid bool) error {
 		filePath = filePath + ".pid" + strconv.Itoa(os.Getpid())
 	}
 
-	defaultLogger := logging.GetDefaultLogger()
-	if defaultLogger == nil {
-		return errors.New("Unexpected state: defaultLogger == nil")
-	}
-	logFile, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0777)
+	fileLogger, err := logging.NewSimpleFileLogger(filePath, "", log.LstdFlags|log.Lshortfile)
 	if err != nil {
 		return err
 	}
-
 	// Note: not thread-safe!
-	logging.ResetDefaultLogger(log.New(logFile, "", log.LstdFlags|log.Lshortfile), logging.DefaultNamespace)
+	if err := logging.ResetGlobalLogger(fileLogger); err != nil {
+		return err
+	}
+
 	fmt.Println("INFO: log base directory is: " + logDir)
 
 	return nil
@@ -163,6 +170,10 @@ func AppType() int32 {
 	return globalCfg.AppType()
 }
 
+func Logger() logging.Logger {
+	return globalCfg.Logger()
+}
+
 func LogBaseDir() string {
 	return globalCfg.LogBaseDir()
 }
 
@@ -1,6 +1,7 @@
 package config
 
 import (
+	"github.com/alibaba/sentinel-golang/logging"
 	"github.com/pkg/errors"
 )
 
@@ -29,6 +30,8 @@ type SentinelConfig struct {
 
 // LogConfig represent the configuration of logging in Sentinel.
 type LogConfig struct {
+	// logger indicates that using logger to replace default logging.
+	Logger logging.Logger
 	// Dir represents the log directory path.
 	Dir string
 	// UsePid indicates whether the filename ends with the process ID (PID).
@@ -68,6 +71,7 @@ func NewDefaultConfig() *Entity {
 				Type: DefaultAppType,
 			},
 			Log: LogConfig{
+				Logger: nil,
 				Dir:    GetDefaultLogDir(),
 				UsePid: false,
 				Metric: MetricLogConfig{
@@ -128,6 +132,10 @@ func (entity *Entity) LogBaseDir() string {
 	return entity.Sentinel.Log.Dir
 }
 
+func (entity *Entity) Logger() logging.Logger {
+	return entity.Sentinel.Log.Logger
+}
+
 // LogUsePid returns whether the log file name contains the PID suffix.
 func (entity *Entity) LogUsePid() bool {
 	return entity.Sentinel.Log.UsePid
 
@@ -10,11 +10,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-// const
-var (
-	logger = logging.GetDefaultLogger()
-)
-
 // TrafficControllerGenFunc represents the TrafficShapingController generator function of a specific control behavior.
 type TrafficControllerGenFunc func(*FlowRule) *TrafficShapingController
 
@@ -40,9 +35,9 @@ func init() {
 func logRuleUpdate(m TrafficControllerMap) {
 	bs, err := json.Marshal(rulesFrom(m))
 	if err != nil {
-		logger.Info("[FlowRuleManager] Flow rules loaded")
+		logging.Info("[FlowRuleManager] Flow rules loaded")
 	} else {
-		logger.Infof("[FlowRuleManager] Flow rules loaded: %s", bs)
+		logging.Infof("[FlowRuleManager] Flow rules loaded: %s", bs)
 	}
 }
 
@@ -66,7 +61,7 @@ func onRuleUpdate(rules []*FlowRule) (err error) {
 		if r := recover(); r != nil {
 			return
 		}
-		logger.Debugf("Updating flow rule spends %d ns.", util.CurrentTimeNano()-start)
+		logging.Debugf("Updating flow rule spends %d ns.", util.CurrentTimeNano()-start)
 		logRuleUpdate(m)
 	}()
 
@@ -154,20 +149,20 @@ func buildFlowMap(rules []*FlowRule) TrafficControllerMap {
 
 	for _, rule := range rules {
 		if err := IsValidFlowRule(rule); err != nil {
-			logger.Warnf("Ignoring invalid flow rule: %v, reason: %s", rule, err.Error())
+			logging.Warnf("Ignoring invalid flow rule: %v, reason: %s", rule, err.Error())
 			continue
 		}
 		if rule.LimitOrigin == "" {
 			rule.LimitOrigin = LimitOriginDefault
 		}
 		generator, supported := tcGenFuncMap[rule.ControlBehavior]
 		if !supported {
-			logger.Warnf("Ignoring the rule due to unsupported control behavior: %v", rule)
+			logging.Warnf("Ignoring the rule due to unsupported control behavior: %v", rule)
 			continue
 		}
 		tsc := generator(rule)
 		if tsc == nil {
-			logger.Warnf("Ignoring the rule due to bad generated traffic controller: %v", rule)
+			logging.Warnf("Ignoring the rule due to bad generated traffic controller: %v", rule)
 			continue
 		}
 
 
@@ -5,6 +5,7 @@ import (
 
 	"github.com/alibaba/sentinel-golang/core/base"
 	"github.com/alibaba/sentinel-golang/core/stat"
+	"github.com/alibaba/sentinel-golang/logging"
 )
 
 // FlowSlot
@@ -22,7 +23,7 @@ func (s *FlowSlot) Check(ctx *base.EntryContext) *base.TokenResult {
 	// Check rules in order
 	for _, tc := range tcs {
 		if tc == nil {
-			logger.Warnf("nil traffic controller found, res: %s", res)
+			logging.Warnf("nil traffic controller found, res: %s", res)
 			continue
 		}
 		r := canPassCheck(tc, ctx.StatNode, ctx.Input.AcquireCount)
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ import (`
`9`	`9`	`func TraceError(entry *base.SentinelEntry, err error) {`
`10`	`10`	`defer func() {`
`11`	`11`	`if e := recover(); e != nil {`
`12`		`- logging.GetDefaultLogger().Panicf("Failed to TraceError, panic error: %+v", e)`
	`12`	`+ logging.Panicf("Failed to TraceError, panic error: %+v", e)`
`13`	`13`	`return`
`14`	`14`	`}`
`15`	`15`	`}()`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ import (`
`4`	`4`	`"fmt"`
`5`	`5`
`6`	`6`	`"github.com/alibaba/sentinel-golang/core/base"`
	`7`	`+ "github.com/alibaba/sentinel-golang/logging"`
`7`	`8`	`"github.com/alibaba/sentinel-golang/util"`
`8`	`9`	`"github.com/pkg/errors"`
`9`	`10`	`)`
`@@ -247,7 +248,7 @@ func NewRule(resource string, strategy Strategy, opts ...RuleOption) Rule {`
`247`	`248`	`Threshold: ruleOpts.errorCountThreshold,`
`248`	`249`	`}`
`249`	`250`	`default:`
`250`		`- logger.Errorf("unsupported circuit breaker rule, strategy: %d", strategy)`
	`251`	`+ logging.Errorf("unsupported circuit breaker rule, strategy: %d", strategy)`
`251`	`252`	`return nil`
`252`	`253`	`}`
`253`	`254`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,6 @@ import (`
`13`	`13`	`type CircuitBreakerGenFunc func(r Rule, reuseStat interface{}) (CircuitBreaker, error)`
`14`	`14`
`15`	`15`	`var (`
`16`		`- logger = logging.GetDefaultLogger()`
`17`	`16`	`cbGenFuncMap = make(map[Strategy]CircuitBreakerGenFunc)`
`18`	`17`
`19`	`18`	`breakerRules = make(map[string][]Rule)`
`@@ -34,7 +33,7 @@ func init() {`
`34`	`33`	`}`
`35`	`34`	`stat, ok := reuseStat.(*slowRequestLeapArray)`
`36`	`35`	`if !ok \|\| stat == nil {`
`37`		`- logger.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray, in fact: %+v", stat)`
	`36`	`+ logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray, in fact: %+v", stat)`
`38`	`37`	`return newSlowRtCircuitBreaker(rtRule)`
`39`	`38`	`}`
`40`	`39`	`return newSlowRtCircuitBreakerWithStat(rtRule, stat), nil`
`@@ -50,7 +49,7 @@ func init() {`
`50`	`49`	`}`
`51`	`50`	`stat, ok := reuseStat.(*errorCounterLeapArray)`
`52`	`51`	`if !ok \|\| stat == nil {`
`53`		`- logger.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)`
	`52`	`+ logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)`
`54`	`53`	`return newErrorRatioCircuitBreaker(errRatioRule)`
`55`	`54`	`}`
`56`	`55`	`return newErrorRatioCircuitBreakerWithStat(errRatioRule, stat), nil`
`@@ -66,7 +65,7 @@ func init() {`
`66`	`65`	`}`
`67`	`66`	`stat, ok := reuseStat.(*errorCounterLeapArray)`
`68`	`67`	`if !ok \|\| stat == nil {`
`69`		`- logger.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)`
	`68`	`+ logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)`
`70`	`69`	`return newErrorCountCircuitBreaker(errCountRule)`
`71`	`70`	`}`
`72`	`71`	`return newErrorCountCircuitBreakerWithStat(errCountRule, stat), nil`
`@@ -167,7 +166,7 @@ func onRuleUpdate(rules []Rule) (err error) {`
`167`	`166`	`continue`
`168`	`167`	`}`
`169`	`168`	`if err := rule.IsApplicable(); err != nil {`
`170`		`- logger.Warnf("Ignoring invalid circuit breaking rule when loading new rules, rule: %+v, reason: %s", rule, err.Error())`
	`169`	`+ logging.Warnf("Ignoring invalid circuit breaking rule when loading new rules, rule: %+v, reason: %s", rule, err.Error())`
`171`	`170`	`continue`
`172`	`171`	`}`
`173`	`172`
`@@ -193,7 +192,7 @@ func onRuleUpdate(rules []Rule) (err error) {`
`193`	`192`	`if r := recover(); r != nil {`
`194`	`193`	`return`
`195`	`194`	`}`
`196`		`- logger.Debugf("Updating circuit breaker rule spends %d ns.", util.CurrentTimeNano()-start)`
	`195`	`+ logging.Debugf("Updating circuit breaker rule spends %d ns.", util.CurrentTimeNano()-start)`
`197`	`196`	`logRuleUpdate(newBreakerRules)`
`198`	`197`	`}()`
`199`	`198`
`@@ -218,7 +217,7 @@ func onRuleUpdate(rules []Rule) (err error) {`
`218`	`217`
`219`	`218`	`generator := cbGenFuncMap[r.BreakerStrategy()]`
`220`	`219`	`if generator == nil {`
`221`		`- logger.Warnf("Ignoring the rule due to unsupported circuit breaking strategy: %v", r)`
	`220`	`+ logging.Warnf("Ignoring the rule due to unsupported circuit breaking strategy: %v", r)`
`222`	`221`	`continue`
`223`	`222`	`}`
`224`	`223`
`@@ -230,7 +229,7 @@ func onRuleUpdate(rules []Rule) (err error) {`
`230`	`229`	`cb, e = generator(r, nil)`
`231`	`230`	`}`
`232`	`231`	`if cb == nil \|\| e != nil {`
`233`		`- logger.Warnf("Ignoring the rule due to bad generated circuit breaker, r: %s, err: %+v", r.String(), e)`
	`232`	`+ logging.Warnf("Ignoring the rule due to bad generated circuit breaker, r: %s, err: %+v", r.String(), e)`
`234`	`233`	`continue`
`235`	`234`	`}`
`236`	`235`
`@@ -272,7 +271,7 @@ func logRuleUpdate(rules map[string][]Rule) {`
`272`	`271`	`sb.WriteString(r.String() + ",")`
`273`	`272`	`}`
`274`	`273`	`sb.WriteString("]")`
`275`		`- logger.Info(sb.String())`
	`274`	`+ logging.Info(sb.String())`
`276`	`275`	`}`
`277`	`276`
`278`	`277`	`func RegisterStateChangeListeners(listeners ...StateChangeListener) {`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@ import (`
`5`	`5`
`6`	`6`	`"github.com/alibaba/sentinel-golang/core/base"`
`7`	`7`	`"github.com/alibaba/sentinel-golang/core/stat"`
	`8`	`+ "github.com/alibaba/sentinel-golang/logging"`
`8`	`9`	`)`
`9`	`10`
`10`	`11`	`// FlowSlot`
`@@ -22,7 +23,7 @@ func (s FlowSlot) Check(ctx base.EntryContext) *base.TokenResult {`
`22`	`23`	`// Check rules in order`
`23`	`24`	`for _, tc := range tcs {`
`24`	`25`	`if tc == nil {`
`25`		`- logger.Warnf("nil traffic controller found, res: %s", res)`
	`26`	`+ logging.Warnf("nil traffic controller found, res: %s", res)`
`26`	`27`	`continue`
`27`	`28`	`}`
`28`	`29`	`r := canPassCheck(tc, ctx.StatNode, ctx.Input.AcquireCount)`