alibaba
diff --git a/‎api/tracer.go
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion b/‎api/tracer.go
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion
diff --git a/‎core/base/entry.go
Copy file name to clipboard
+3-2Lines changed: 3 additions & 2 deletions b/‎core/base/entry.go
Copy file name to clipboard
+3-2Lines changed: 3 additions & 2 deletions
diff --git a/‎core/base/slot_chain.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎core/base/slot_chain.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎core/circuitbreaker/circuit_breaker.go
Copy file name to clipboard
+14-13Lines changed: 14 additions & 13 deletions b/‎core/circuitbreaker/circuit_breaker.go
Copy file name to clipboard
+14-13Lines changed: 14 additions & 13 deletions
diff --git a/‎core/circuitbreaker/rule_manager.go
Copy file name to clipboard
+8-7Lines changed: 8 additions & 7 deletions b/‎core/circuitbreaker/rule_manager.go
Copy file name to clipboard
+8-7Lines changed: 8 additions & 7 deletions
diff --git a/‎core/config/config.go
Copy file name to clipboard
+5-7Lines changed: 5 additions & 7 deletions b/‎core/config/config.go
Copy file name to clipboard
+5-7Lines changed: 5 additions & 7 deletions
diff --git a/‎core/flow/rule_manager.go
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions b/‎core/flow/rule_manager.go
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions
diff --git a/‎core/flow/slot.go
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎core/flow/slot.go
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎core/flow/tc_warm_up.go
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎core/flow/tc_warm_up.go
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎core/hotspot/cache/lru.go
Copy file name to clipboard
-3Lines changed: 0 additions & 3 deletions b/‎core/hotspot/cache/lru.go
Copy file name to clipboard
-3Lines changed: 0 additions & 3 deletions
@@ -3,13 +3,14 @@ package api
 import (
 	"github.com/alibaba/sentinel-golang/core/base"
 	"github.com/alibaba/sentinel-golang/logging"
+	"github.com/pkg/errors"
 )
 
 // TraceError records the provided error to the given SentinelEntry.
 func TraceError(entry *base.SentinelEntry, err error) {
 	defer func() {
 		if e := recover(); e != nil {
-			logging.Panicf("Failed to TraceError, panic error: %+v", e)
+			logging.Error(errors.Errorf("%+v", e), "failed to TraceError")
 			return
 		}
 	}()
 
@@ -4,6 +4,7 @@ import (
 	"sync"
 
 	"github.com/alibaba/sentinel-golang/logging"
+	"github.com/pkg/errors"
 )
 
 type ExitHandler func(entry *SentinelEntry, ctx *EntryContext) error
@@ -76,15 +77,15 @@ func (e *SentinelEntry) Exit(exitOps ...ExitOption) {
 	e.exitCtl.Do(func() {
 		defer func() {
 			if err := recover(); err != nil {
-				logging.Panicf("Sentinel internal panic in entry exit func, err: %+v", err)
+				logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in entry exit func")
 			}
 			if e.sc != nil {
 				e.sc.RefurbishContext(ctx)
 			}
 		}()
 		for _, handler := range e.exitHandlers {
 			if err := handler(e, ctx); err != nil {
-				logging.Errorf("Fail to execute exitHandler for resource: %s, err: %+v", e.Resource().Name(), err)
+				logging.Error(err, "Fail to execute exitHandler", "resource", e.Resource().Name())
 			}
 		}
 		if e.sc != nil {
 
@@ -130,7 +130,7 @@ func (sc *SlotChain) Entry(ctx *EntryContext) *TokenResult {
 	// If happened, need to add TokenResult in EntryContext
 	defer func() {
 		if err := recover(); err != nil {
-			logging.Panicf("Sentinel internal panic in SlotChain, err: %+v", err)
+			logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in SlotChain")
 			ctx.SetError(errors.Errorf("%+v", err))
 			return
 		}
@@ -186,7 +186,7 @@ func (sc *SlotChain) Entry(ctx *EntryContext) *TokenResult {
 
 func (sc *SlotChain) exit(ctx *EntryContext) {
 	if ctx == nil || ctx.Entry() == nil {
-		logging.Errorf("nil ctx or nil associated entry")
+		logging.Error(errors.New("nil EntryContext or SentinelEntry"), "")
 		return
 	}
 	// The OnCompleted is called only when entry passed
 
@@ -8,6 +8,7 @@ import (
 	sbase "github.com/alibaba/sentinel-golang/core/stat/base"
 	"github.com/alibaba/sentinel-golang/logging"
 	"github.com/alibaba/sentinel-golang/util"
+	"github.com/pkg/errors"
 )
 
 //
@@ -151,7 +152,7 @@ func (b *circuitBreakerBase) fromOpenToHalfOpen(ctx *base.EntryContext) bool {
 
 		entry := ctx.Entry()
 		if entry == nil {
-			logging.Errorf("nil entry when probing, rule: %+v", b.rule)
+			logging.Error(errors.New("nil entry"), "nil entry when probing", "rule", b.rule)
 		} else {
 			// add hook for entry exit
 			// if the current circuit breaker performs the probe through this entry, but the entry was blocked,
@@ -342,21 +343,21 @@ func (s *slowRequestLeapArray) ResetBucketTo(bw *sbase.BucketWrap, startTime uin
 func (s *slowRequestLeapArray) currentCounter() *slowRequestCounter {
 	curBucket, err := s.data.CurrentBucket(s)
 	if err != nil {
-		logging.Errorf("Failed to get current bucket, current ts=%d, err: %+v.", util.CurrentTimeMillis(), err)
+		logging.Error(err, "failed to get current bucket")
 		return nil
 	}
 	if curBucket == nil {
-		logging.Error("Current bucket is nil")
+		logging.Error(errors.New("nil current BucketWrap"), "Current bucket is nil")
 		return nil
 	}
 	mb := curBucket.Value.Load()
 	if mb == nil {
-		logging.Error("Current bucket atomic Value is nil")
+		logging.Error(errors.New("Current bucket atomic Value is nil"), "")
 		return nil
 	}
 	counter, ok := mb.(*slowRequestCounter)
 	if !ok {
-		logging.Error("Bucket data type error")
+		logging.Error(errors.New("Bucket data type error"), "")
 		return nil
 	}
 	return counter
@@ -368,12 +369,12 @@ func (s *slowRequestLeapArray) allCounter() []*slowRequestCounter {
 	for _, b := range buckets {
 		mb := b.Value.Load()
 		if mb == nil {
-			logging.Error("Current bucket atomic Value is nil")
+			logging.Error(errors.New("Current bucket atomic Value is nil"), "")
 			continue
 		}
 		counter, ok := mb.(*slowRequestCounter)
 		if !ok {
-			logging.Error("Bucket data type error")
+			logging.Error(errors.New("Bucket data type error"), "")
 			continue
 		}
 		ret = append(ret, counter)
@@ -522,21 +523,21 @@ func (s *errorCounterLeapArray) ResetBucketTo(bw *sbase.BucketWrap, startTime ui
 func (s *errorCounterLeapArray) currentCounter() *errorCounter {
 	curBucket, err := s.data.CurrentBucket(s)
 	if err != nil {
-		logging.Errorf("Failed to get current bucket, current ts=%d, err: %+v.", util.CurrentTimeMillis(), err)
+		logging.Error(err, "Failed to get current bucket")
 		return nil
 	}
 	if curBucket == nil {
-		logging.Error("Current bucket is nil")
+		logging.Error(errors.New("Current bucket is nil"), "")
 		return nil
 	}
 	mb := curBucket.Value.Load()
 	if mb == nil {
-		logging.Error("Current bucket atomic Value is nil")
+		logging.Error(errors.New("Current bucket atomic Value is nil"), "")
 		return nil
 	}
 	counter, ok := mb.(*errorCounter)
 	if !ok {
-		logging.Error("Bucket data type error")
+		logging.Error(errors.New("Bucket data type error"), "")
 		return nil
 	}
 	return counter
@@ -548,12 +549,12 @@ func (s *errorCounterLeapArray) allCounter() []*errorCounter {
 	for _, b := range buckets {
 		mb := b.Value.Load()
 		if mb == nil {
-			logging.Error("Current bucket atomic Value is nil")
+			logging.Error(errors.New("Current bucket atomic Value is nil"), "")
 			continue
 		}
 		counter, ok := mb.(*errorCounter)
 		if !ok {
-			logging.Error("Bucket data type error")
+			logging.Error(errors.New("Bucket data type error"), "")
 			continue
 		}
 		ret = append(ret, counter)
 
@@ -2,6 +2,7 @@ package circuitbreaker
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
 	"sync"
 
@@ -32,7 +33,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*slowRequestLeapArray)
 		if !ok || stat == nil {
-			logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray, in fact: %+v", stat)
+			logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray", "statType", reflect.TypeOf(stat).Name())
 			return newSlowRtCircuitBreaker(r)
 		}
 		return newSlowRtCircuitBreakerWithStat(r, stat), nil
@@ -47,7 +48,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*errorCounterLeapArray)
 		if !ok || stat == nil {
-			logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)
+			logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray", "statType", reflect.TypeOf(stat).Name())
 			return newErrorRatioCircuitBreaker(r)
 		}
 		return newErrorRatioCircuitBreakerWithStat(r, stat), nil
@@ -62,7 +63,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*errorCounterLeapArray)
 		if !ok || stat == nil {
-			logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)
+			logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray", "statType", reflect.TypeOf(stat).Name())
 			return newErrorCountCircuitBreaker(r)
 		}
 		return newErrorCountCircuitBreakerWithStat(r, stat), nil
@@ -186,7 +187,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 			continue
 		}
 		if err := IsValid(rule); err != nil {
-			logging.Warnf("Ignoring invalid circuit breaking rule when loading new rules, rule: %+v, reason: %s", rule, err.Error())
+			logging.Warn("Ignoring invalid circuit breaking rule when loading new rules", "rule", rule, "err", err)
 			continue
 		}
 
@@ -212,7 +213,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 		if r := recover(); r != nil {
 			return
 		}
-		logging.Debugf("Updating circuit breaker rule spends %d ns.", util.CurrentTimeNano()-start)
+		logging.Debug("Time statistics(ns) for updating circuit breaker rule", "timeCost", util.CurrentTimeNano()-start)
 		logRuleUpdate(newBreakerRules)
 	}()
 
@@ -237,7 +238,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 
 			generator := cbGenFuncMap[r.Strategy]
 			if generator == nil {
-				logging.Warnf("Ignoring the rule due to unsupported circuit breaking strategy: %v", r)
+				logging.Warn("Ignoring the rule due to unsupported circuit breaking strategy", "rule", r)
 				continue
 			}
 
@@ -249,7 +250,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 				cb, e = generator(r, nil)
 			}
 			if cb == nil || e != nil {
-				logging.Warnf("Ignoring the rule due to bad generated circuit breaker, r: %s, err: %+v", r.String(), e)
+				logging.Warn("Ignoring the rule due to bad generated circuit breaker", "rule", r, "err", e)
 				continue
 			}
 
 
@@ -1,9 +1,7 @@
 package config
 
 import (
-	"fmt"
 	"io/ioutil"
-	"log"
 	"os"
 	"strconv"
 	"sync"
@@ -51,7 +49,7 @@ func OverrideConfigFromEnvAndInitLog() error {
 		return err
 	}
 
-	defer logging.Infof("effective global config: %+v", *globalCfg)
+	defer logging.Info("print effective global config", "globalConfig", *globalCfg)
 	// Configured Logger is the highest priority
 	if configLogger := Logger(); configLogger != nil {
 		err = logging.ResetGlobalLogger(configLogger)
@@ -68,7 +66,7 @@ func OverrideConfigFromEnvAndInitLog() error {
 	if err := initializeLogConfig(logDir, LogUsePid()); err != nil {
 		return err
 	}
-	logging.Infof("App name resolved: %s", AppName())
+	logging.Info("App name resolved", "appName", AppName())
 	return nil
 }
 
@@ -91,7 +89,7 @@ func loadFromYamlFile(filePath string) error {
 	if err != nil {
 		return err
 	}
-	logging.Infof("Resolving Sentinel config from file: %s", filePath)
+	logging.Info("Resolving Sentinel config from file", "file", filePath)
 	return checkConfValid(&(globalCfg.Sentinel))
 }
 
@@ -145,7 +143,7 @@ func reconfigureRecordLogger(logBaseDir string, withPid bool) error {
 		filePath = filePath + ".pid" + strconv.Itoa(os.Getpid())
 	}
 
-	fileLogger, err := logging.NewSimpleFileLogger(filePath, "", log.LstdFlags|log.Lshortfile)
+	fileLogger, err := logging.NewSimpleFileLogger(filePath)
 	if err != nil {
 		return err
 	}
@@ -154,7 +152,7 @@ func reconfigureRecordLogger(logBaseDir string, withPid bool) error {
 		return err
 	}
 
-	fmt.Println("INFO: log base directory is: " + logDir)
+	logging.Info("INFO: log base directory is: " + logDir)
 
 	return nil
 }
 
@@ -67,7 +67,7 @@ func logRuleUpdate(m TrafficControllerMap) {
 		if len(m) == 0 {
 			logging.Info("[FlowRuleManager] Flow rules were cleared")
 		} else {
-			logging.Infof("[FlowRuleManager] Flow rules were loaded: %s", bs)
+			logging.Info("[FlowRuleManager] Flow rules were loaded", "rules", string(bs))
 		}
 	}
 }
@@ -92,7 +92,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 		if r := recover(); r != nil {
 			return
 		}
-		logging.Debugf("Updating flow rule spends %d ns.", util.CurrentTimeNano()-start)
+		logging.Debug("time statistic(ns) for updating flow rule", "timeCost", util.CurrentTimeNano()-start)
 		logRuleUpdate(m)
 	}()
 
@@ -235,20 +235,20 @@ func buildFlowMap(rules []*Rule) TrafficControllerMap {
 
 	for _, rule := range rules {
 		if err := IsValidRule(rule); err != nil {
-			logging.Warnf("Ignoring invalid flow rule: %v, reason: %s", rule, err.Error())
+			logging.Warn("Ignoring invalid flow rule", "rule", rule, "err", err)
 			continue
 		}
 		generator, supported := tcGenFuncMap[trafficControllerGenKey{
 			tokenCalculateStrategy: rule.TokenCalculateStrategy,
 			controlBehavior:        rule.ControlBehavior,
 		}]
 		if !supported {
-			logging.Warnf("Ignoring the rule due to unsupported control behavior: %v", rule)
+			logging.Warn("Ignoring the rule due to unsupported control behavior", "rule", rule)
 			continue
 		}
 		tsc := generator(rule)
 		if tsc == nil {
-			logging.Warnf("Ignoring the rule due to bad generated traffic controller: %v", rule)
+			logging.Warn("Ignoring the rule due to bad generated traffic controller.", "rule", rule)
 			continue
 		}
 
 
@@ -22,7 +22,7 @@ func (s *Slot) Check(ctx *base.EntryContext) *base.TokenResult {
 	// Check rules in order
 	for _, tc := range tcs {
 		if tc == nil {
-			logging.Warnf("nil traffic controller found, res: %s", res)
+			logging.Warn("nil traffic controller found", "resourceName", res)
 			continue
 		}
 		r := canPassCheck(tc, ctx.StatNode, ctx.Input.AcquireCount)
 
@@ -25,7 +25,7 @@ type WarmUpTrafficShapingCalculator struct {
 func NewWarmUpTrafficShapingCalculator(rule *Rule) *WarmUpTrafficShapingCalculator {
 	if rule.WarmUpColdFactor <= 1 {
 		rule.WarmUpColdFactor = config.DefaultWarmUpColdFactor
-		logging.Warnf("[NewWarmUpTrafficShapingCalculator] invalid WarmUpColdFactor,use default values: %d", config.DefaultWarmUpColdFactor)
+		logging.Warn("[NewWarmUpTrafficShapingCalculator] No set WarmUpColdFactor,use default warm up cold factor value", "defaultWarmUpColdFactor", config.DefaultWarmUpColdFactor)
 	}
 
 	warningToken := uint64((float64(rule.WarmUpPeriodSec) * rule.Count) / float64(rule.WarmUpColdFactor-1))
 
@@ -3,7 +3,6 @@ package cache
 import (
 	"container/list"
 
-	"github.com/alibaba/sentinel-golang/logging"
 	"github.com/pkg/errors"
 )
 
@@ -193,12 +192,10 @@ func (c *LRU) removeOldest() {
 func (c *LRU) removeElement(e *list.Element) {
 	c.evictList.Remove(e)
 	if e.Value == nil {
-		logging.Errorf("The Value of evictList's Element is nil.")
 		return
 	}
 	kv, ok := e.Value.(*entry)
 	if !ok {
-		logging.Errorf("Fail to assert the Value of evictList's Element as *entry.")
 		return
 	}
 	delete(c.items, kv.key)
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ import (`
`4`	`4`	`"sync"`
`5`	`5`
`6`	`6`	`"github.com/alibaba/sentinel-golang/logging"`
	`7`	`+ "github.com/pkg/errors"`
`7`	`8`	`)`
`8`	`9`
`9`	`10`	`type ExitHandler func(entry SentinelEntry, ctx EntryContext) error`
`@@ -76,15 +77,15 @@ func (e *SentinelEntry) Exit(exitOps ...ExitOption) {`
`76`	`77`	`e.exitCtl.Do(func() {`
`77`	`78`	`defer func() {`
`78`	`79`	`if err := recover(); err != nil {`
`79`		`- logging.Panicf("Sentinel internal panic in entry exit func, err: %+v", err)`
	`80`	`+ logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in entry exit func")`
`80`	`81`	`}`
`81`	`82`	`if e.sc != nil {`
`82`	`83`	`e.sc.RefurbishContext(ctx)`
`83`	`84`	`}`
`84`	`85`	`}()`
`85`	`86`	`for _, handler := range e.exitHandlers {`
`86`	`87`	`if err := handler(e, ctx); err != nil {`
`87`		`- logging.Errorf("Fail to execute exitHandler for resource: %s, err: %+v", e.Resource().Name(), err)`
	`88`	`+ logging.Error(err, "Fail to execute exitHandler", "resource", e.Resource().Name())`
`88`	`89`	`}`
`89`	`90`	`}`
`90`	`91`	`if e.sc != nil {`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ package circuitbreaker`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"fmt"`
	`5`	`+ "reflect"`
`5`	`6`	`"strings"`
`6`	`7`	`"sync"`
`7`	`8`
`@@ -32,7 +33,7 @@ func init() {`
`32`	`33`	`}`
`33`	`34`	`stat, ok := reuseStat.(*slowRequestLeapArray)`
`34`	`35`	`if !ok \|\| stat == nil {`
`35`		`- logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray, in fact: %+v", stat)`
	`36`	`+ logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray", "statType", reflect.TypeOf(stat).Name())`
`36`	`37`	`return newSlowRtCircuitBreaker(r)`
`37`	`38`	`}`
`38`	`39`	`return newSlowRtCircuitBreakerWithStat(r, stat), nil`
`@@ -47,7 +48,7 @@ func init() {`
`47`	`48`	`}`
`48`	`49`	`stat, ok := reuseStat.(*errorCounterLeapArray)`
`49`	`50`	`if !ok \|\| stat == nil {`
`50`		`- logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)`
	`51`	`+ logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray", "statType", reflect.TypeOf(stat).Name())`
`51`	`52`	`return newErrorRatioCircuitBreaker(r)`
`52`	`53`	`}`
`53`	`54`	`return newErrorRatioCircuitBreakerWithStat(r, stat), nil`
`@@ -62,7 +63,7 @@ func init() {`
`62`	`63`	`}`
`63`	`64`	`stat, ok := reuseStat.(*errorCounterLeapArray)`
`64`	`65`	`if !ok \|\| stat == nil {`
`65`		`- logging.Warnf("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray, in fact: %+v", stat)`
	`66`	`+ logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray", "statType", reflect.TypeOf(stat).Name())`
`66`	`67`	`return newErrorCountCircuitBreaker(r)`
`67`	`68`	`}`
`68`	`69`	`return newErrorCountCircuitBreakerWithStat(r, stat), nil`
`@@ -186,7 +187,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`186`	`187`	`continue`
`187`	`188`	`}`
`188`	`189`	`if err := IsValid(rule); err != nil {`
`189`		`- logging.Warnf("Ignoring invalid circuit breaking rule when loading new rules, rule: %+v, reason: %s", rule, err.Error())`
	`190`	`+ logging.Warn("Ignoring invalid circuit breaking rule when loading new rules", "rule", rule, "err", err)`
`190`	`191`	`continue`
`191`	`192`	`}`
`192`	`193`
`@@ -212,7 +213,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`212`	`213`	`if r := recover(); r != nil {`
`213`	`214`	`return`
`214`	`215`	`}`
`215`		`- logging.Debugf("Updating circuit breaker rule spends %d ns.", util.CurrentTimeNano()-start)`
	`216`	`+ logging.Debug("Time statistics(ns) for updating circuit breaker rule", "timeCost", util.CurrentTimeNano()-start)`
`216`	`217`	`logRuleUpdate(newBreakerRules)`
`217`	`218`	`}()`
`218`	`219`
`@@ -237,7 +238,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`237`	`238`
`238`	`239`	`generator := cbGenFuncMap[r.Strategy]`
`239`	`240`	`if generator == nil {`
`240`		`- logging.Warnf("Ignoring the rule due to unsupported circuit breaking strategy: %v", r)`
	`241`	`+ logging.Warn("Ignoring the rule due to unsupported circuit breaking strategy", "rule", r)`
`241`	`242`	`continue`
`242`	`243`	`}`
`243`	`244`
`@@ -249,7 +250,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`249`	`250`	`cb, e = generator(r, nil)`
`250`	`251`	`}`
`251`	`252`	`if cb == nil \|\| e != nil {`
`252`		`- logging.Warnf("Ignoring the rule due to bad generated circuit breaker, r: %s, err: %+v", r.String(), e)`
	`253`	`+ logging.Warn("Ignoring the rule due to bad generated circuit breaker", "rule", r, "err", e)`
`253`	`254`	`continue`
`254`	`255`	`}`
`255`	`256`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,7 @@`
`1`	`1`	`package config`
`2`	`2`
`3`	`3`	`import (`
`4`		`- "fmt"`
`5`	`4`	`"io/ioutil"`
`6`		`- "log"`
`7`	`5`	`"os"`
`8`	`6`	`"strconv"`
`9`	`7`	`"sync"`
`@@ -51,7 +49,7 @@ func OverrideConfigFromEnvAndInitLog() error {`
`51`	`49`	`return err`
`52`	`50`	`}`
`53`	`51`
`54`		`- defer logging.Infof("effective global config: %+v", *globalCfg)`
	`52`	`+ defer logging.Info("print effective global config", "globalConfig", *globalCfg)`
`55`	`53`	`// Configured Logger is the highest priority`
`56`	`54`	`if configLogger := Logger(); configLogger != nil {`
`57`	`55`	`err = logging.ResetGlobalLogger(configLogger)`
`@@ -68,7 +66,7 @@ func OverrideConfigFromEnvAndInitLog() error {`
`68`	`66`	`if err := initializeLogConfig(logDir, LogUsePid()); err != nil {`
`69`	`67`	`return err`
`70`	`68`	`}`
`71`		`- logging.Infof("App name resolved: %s", AppName())`
	`69`	`+ logging.Info("App name resolved", "appName", AppName())`
`72`	`70`	`return nil`
`73`	`71`	`}`
`74`	`72`
`@@ -91,7 +89,7 @@ func loadFromYamlFile(filePath string) error {`
`91`	`89`	`if err != nil {`
`92`	`90`	`return err`
`93`	`91`	`}`
`94`		`- logging.Infof("Resolving Sentinel config from file: %s", filePath)`
	`92`	`+ logging.Info("Resolving Sentinel config from file", "file", filePath)`
`95`	`93`	`return checkConfValid(&(globalCfg.Sentinel))`
`96`	`94`	`}`
`97`	`95`
`@@ -145,7 +143,7 @@ func reconfigureRecordLogger(logBaseDir string, withPid bool) error {`
`145`	`143`	`filePath = filePath + ".pid" + strconv.Itoa(os.Getpid())`
`146`	`144`	`}`
`147`	`145`
`148`		`- fileLogger, err := logging.NewSimpleFileLogger(filePath, "", log.LstdFlags\|log.Lshortfile)`
	`146`	`+ fileLogger, err := logging.NewSimpleFileLogger(filePath)`
`149`	`147`	`if err != nil {`
`150`	`148`	`return err`
`151`	`149`	`}`
`@@ -154,7 +152,7 @@ func reconfigureRecordLogger(logBaseDir string, withPid bool) error {`
`154`	`152`	`return err`
`155`	`153`	`}`
`156`	`154`
`157`		`- fmt.Println("INFO: log base directory is: " + logDir)`
	`155`	`+ logging.Info("INFO: log base directory is: " + logDir)`
`158`	`156`
`159`	`157`	`return nil`
`160`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ func logRuleUpdate(m TrafficControllerMap) {`
`67`	`67`	`if len(m) == 0 {`
`68`	`68`	`logging.Info("[FlowRuleManager] Flow rules were cleared")`
`69`	`69`	`} else {`
`70`		`- logging.Infof("[FlowRuleManager] Flow rules were loaded: %s", bs)`
	`70`	`+ logging.Info("[FlowRuleManager] Flow rules were loaded", "rules", string(bs))`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`	`}`
`@@ -92,7 +92,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`92`	`92`	`if r := recover(); r != nil {`
`93`	`93`	`return`
`94`	`94`	`}`
`95`		`- logging.Debugf("Updating flow rule spends %d ns.", util.CurrentTimeNano()-start)`
	`95`	`+ logging.Debug("time statistic(ns) for updating flow rule", "timeCost", util.CurrentTimeNano()-start)`
`96`	`96`	`logRuleUpdate(m)`
`97`	`97`	`}()`
`98`	`98`
`@@ -235,20 +235,20 @@ func buildFlowMap(rules []*Rule) TrafficControllerMap {`
`235`	`235`
`236`	`236`	`for _, rule := range rules {`
`237`	`237`	`if err := IsValidRule(rule); err != nil {`
`238`		`- logging.Warnf("Ignoring invalid flow rule: %v, reason: %s", rule, err.Error())`
	`238`	`+ logging.Warn("Ignoring invalid flow rule", "rule", rule, "err", err)`
`239`	`239`	`continue`
`240`	`240`	`}`
`241`	`241`	`generator, supported := tcGenFuncMap[trafficControllerGenKey{`
`242`	`242`	`tokenCalculateStrategy: rule.TokenCalculateStrategy,`
`243`	`243`	`controlBehavior: rule.ControlBehavior,`
`244`	`244`	`}]`
`245`	`245`	`if !supported {`
`246`		`- logging.Warnf("Ignoring the rule due to unsupported control behavior: %v", rule)`
	`246`	`+ logging.Warn("Ignoring the rule due to unsupported control behavior", "rule", rule)`
`247`	`247`	`continue`
`248`	`248`	`}`
`249`	`249`	`tsc := generator(rule)`
`250`	`250`	`if tsc == nil {`
`251`		`- logging.Warnf("Ignoring the rule due to bad generated traffic controller: %v", rule)`
	`251`	`+ logging.Warn("Ignoring the rule due to bad generated traffic controller.", "rule", rule)`
`252`	`252`	`continue`
`253`	`253`	`}`
`254`	`254`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func (s Slot) Check(ctx base.EntryContext) *base.TokenResult {`
`22`	`22`	`// Check rules in order`
`23`	`23`	`for _, tc := range tcs {`
`24`	`24`	`if tc == nil {`
`25`		`- logging.Warnf("nil traffic controller found, res: %s", res)`
	`25`	`+ logging.Warn("nil traffic controller found", "resourceName", res)`
`26`	`26`	`continue`
`27`	`27`	`}`
`28`	`28`	`r := canPassCheck(tc, ctx.StatNode, ctx.Input.AcquireCount)`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ type WarmUpTrafficShapingCalculator struct {`
`25`	`25`	`func NewWarmUpTrafficShapingCalculator(rule Rule) WarmUpTrafficShapingCalculator {`
`26`	`26`	`if rule.WarmUpColdFactor <= 1 {`
`27`	`27`	`rule.WarmUpColdFactor = config.DefaultWarmUpColdFactor`
`28`		`- logging.Warnf("[NewWarmUpTrafficShapingCalculator] invalid WarmUpColdFactor,use default values: %d", config.DefaultWarmUpColdFactor)`
	`28`	`+ logging.Warn("[NewWarmUpTrafficShapingCalculator] No set WarmUpColdFactor,use default warm up cold factor value", "defaultWarmUpColdFactor", config.DefaultWarmUpColdFactor)`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`warningToken := uint64((float64(rule.WarmUpPeriodSec) * rule.Count) / float64(rule.WarmUpColdFactor-1))`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@ package cache`
`3`	`3`	`import (`
`4`	`4`	`"container/list"`
`5`	`5`
`6`		`- "github.com/alibaba/sentinel-golang/logging"`
`7`	`6`	`"github.com/pkg/errors"`
`8`	`7`	`)`
`9`	`8`
`@@ -193,12 +192,10 @@ func (c *LRU) removeOldest() {`
`193`	`192`	`func (c LRU) removeElement(e list.Element) {`
`194`	`193`	`c.evictList.Remove(e)`
`195`	`194`	`if e.Value == nil {`
`196`		`- logging.Errorf("The Value of evictList's Element is nil.")`
`197`	`195`	`return`
`198`	`196`	`}`
`199`	`197`	`kv, ok := e.Value.(*entry)`
`200`	`198`	`if !ok {`
`201`		`- logging.Errorf("Fail to assert the Value of evictList's Element as *entry.")`
`202`	`199`	`return`
`203`	`200`	`}`
`204`	`201`	`delete(c.items, kv.key)`