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/entry.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎core/base/entry.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎core/base/slot_chain.go
Copy file name to clipboard
+3-2Lines changed: 3 additions & 2 deletions b/‎core/base/slot_chain.go
Copy file name to clipboard
+3-2Lines changed: 3 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
+7-7Lines changed: 7 additions & 7 deletions b/‎core/circuitbreaker/rule_manager.go
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
diff --git a/‎core/config/config.go
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions b/‎core/config/config.go
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions
diff --git a/‎core/flow/rule_manager.go
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions b/‎core/flow/rule_manager.go
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions
diff --git a/‎core/flow/slot.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎core/flow/slot.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎core/flow/standalone_stat_slot.go
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎core/flow/standalone_stat_slot.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
+1-1Lines changed: 1 addition & 1 deletion b/‎core/hotspot/cache/lru.go
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
@@ -10,7 +10,7 @@ import (
 func TraceError(entry *base.SentinelEntry, err error) {
 	defer func() {
 		if e := recover(); e != nil {
-			logging.Error(errors.Errorf("%+v", e), "failed to TraceError")
+			logging.Error(errors.Errorf("%+v", e), "Failed to api.TraceError()")
 			return
 		}
 	}()
 
@@ -77,15 +77,15 @@ func (e *SentinelEntry) Exit(exitOps ...ExitOption) {
 	e.exitCtl.Do(func() {
 		defer func() {
 			if err := recover(); err != nil {
-				logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in entry exit func")
+				logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in SentinelEntry.Exit()")
 			}
 			if e.sc != nil {
 				e.sc.RefurbishContext(ctx)
 			}
 		}()
 		for _, handler := range e.exitHandlers {
 			if err := handler(e, ctx); err != nil {
-				logging.Error(err, "Fail to execute exitHandler", "resource", e.Resource().Name())
+				logging.Error(err, "Fail to execute exitHandler in SentinelEntry.Exit()", "resource", e.Resource().Name())
 			}
 		}
 		if e.sc != nil {
 
@@ -205,7 +205,7 @@ func (sc *SlotChain) Entry(ctx *EntryContext) *TokenResult {
 	// If happened, need to add TokenResult in EntryContext
 	defer func() {
 		if err := recover(); err != nil {
-			logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in SlotChain")
+			logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in SlotChain.Entry()")
 			ctx.SetError(errors.Errorf("%+v", err))
 			return
 		}
@@ -261,7 +261,8 @@ func (sc *SlotChain) Entry(ctx *EntryContext) *TokenResult {
 
 func (sc *SlotChain) exit(ctx *EntryContext) {
 	if ctx == nil || ctx.Entry() == nil {
-		logging.Error(errors.New("nil EntryContext or SentinelEntry"), "")
+		logging.Error(errors.New("entryContext or SentinelEntry is nil"),
+			"EntryContext or SentinelEntry is nil in SlotChain.exit()", "ctx", ctx)
 		return
 	}
 	// The OnCompleted is called only when entry passed
 
@@ -1,6 +1,7 @@
 package circuitbreaker
 
 import (
+	"reflect"
 	"sync/atomic"
 
 	"github.com/alibaba/sentinel-golang/core/base"
@@ -152,7 +153,7 @@ func (b *circuitBreakerBase) fromOpenToHalfOpen(ctx *base.EntryContext) bool {
 
 		entry := ctx.Entry()
 		if entry == nil {
-			logging.Error(errors.New("nil entry"), "nil entry when probing", "rule", b.rule)
+			logging.Error(errors.New("nil entry"), "Nil entry in circuitBreakerBase.fromOpenToHalfOpen()", "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,
@@ -341,21 +342,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.Error(err, "failed to get current bucket")
+		logging.Error(err, "Failed to get current bucket in slowRequestLeapArray.currentCounter()")
 		return nil
 	}
 	if curBucket == nil {
-		logging.Error(errors.New("nil current BucketWrap"), "Current bucket is nil")
+		logging.Error(errors.New("nil current BucketWrap"), "Current bucket is nil in slowRequestLeapArray.currentCounter()")
 		return nil
 	}
 	mb := curBucket.Value.Load()
 	if mb == nil {
-		logging.Error(errors.New("Current bucket atomic Value is nil"), "")
+		logging.Error(errors.New("current bucket atomic Value is nil"), "Current bucket atomic Value is nil in slowRequestLeapArray.currentCounter()")
 		return nil
 	}
 	counter, ok := mb.(*slowRequestCounter)
 	if !ok {
-		logging.Error(errors.New("Bucket data type error"), "")
+		logging.Error(errors.New("bucket data type error"), "Bucket data type error in slowRequestLeapArray.currentCounter()", "expect type", "*slowRequestCounter", "actual type", reflect.TypeOf(mb).Name())
 		return nil
 	}
 	return counter
@@ -367,12 +368,12 @@ func (s *slowRequestLeapArray) allCounter() []*slowRequestCounter {
 	for _, b := range buckets {
 		mb := b.Value.Load()
 		if mb == nil {
-			logging.Error(errors.New("Current bucket atomic Value is nil"), "")
+			logging.Error(errors.New("current bucket atomic Value is nil"), "Current bucket atomic Value is nil in slowRequestLeapArray.allCounter()")
 			continue
 		}
 		counter, ok := mb.(*slowRequestCounter)
 		if !ok {
-			logging.Error(errors.New("Bucket data type error"), "")
+			logging.Error(errors.New("bucket data type error"), "Bucket data type error in slowRequestLeapArray.allCounter()", "expect type", "*slowRequestCounter", "actual type", reflect.TypeOf(mb).Name())
 			continue
 		}
 		ret = append(ret, counter)
@@ -518,21 +519,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.Error(err, "Failed to get current bucket")
+		logging.Error(err, "Failed to get current bucket in errorCounterLeapArray.currentCounter()")
 		return nil
 	}
 	if curBucket == nil {
-		logging.Error(errors.New("Current bucket is nil"), "")
+		logging.Error(errors.New("current bucket is nil"), "Current bucket is nil in errorCounterLeapArray.currentCounter()")
 		return nil
 	}
 	mb := curBucket.Value.Load()
 	if mb == nil {
-		logging.Error(errors.New("Current bucket atomic Value is nil"), "")
+		logging.Error(errors.New("current bucket atomic Value is nil"), "Current bucket atomic Value is nil in errorCounterLeapArray.currentCounter()")
 		return nil
 	}
 	counter, ok := mb.(*errorCounter)
 	if !ok {
-		logging.Error(errors.New("Bucket data type error"), "")
+		logging.Error(errors.New("bucket data type error"), "Bucket data type error in errorCounterLeapArray.currentCounter()", "expect type", "*errorCounter", "actual type", reflect.TypeOf(mb).Name())
 		return nil
 	}
 	return counter
@@ -544,12 +545,12 @@ func (s *errorCounterLeapArray) allCounter() []*errorCounter {
 	for _, b := range buckets {
 		mb := b.Value.Load()
 		if mb == nil {
-			logging.Error(errors.New("Current bucket atomic Value is nil"), "")
+			logging.Error(errors.New("current bucket atomic Value is nil"), "Current bucket atomic Value is nil in errorCounterLeapArray.allCounter()")
 			continue
 		}
 		counter, ok := mb.(*errorCounter)
 		if !ok {
-			logging.Error(errors.New("Bucket data type error"), "")
+			logging.Error(errors.New("bucket data type error"), "Bucket data type error in errorCounterLeapArray.allCounter()", "expect type", "*errorCounter", "actual type", reflect.TypeOf(mb).Name())
 			continue
 		}
 		ret = append(ret, counter)
 
@@ -33,7 +33,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*slowRequestLeapArray)
 		if !ok || stat == nil {
-			logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray", "statType", reflect.TypeOf(stat).Name())
+			logging.Warn("[CircuitBreaker RuleManager] 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
@@ -48,7 +48,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*errorCounterLeapArray)
 		if !ok || stat == nil {
-			logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray", "statType", reflect.TypeOf(stat).Name())
+			logging.Warn("[CircuitBreaker RuleManager] 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
@@ -63,7 +63,7 @@ func init() {
 		}
 		stat, ok := reuseStat.(*errorCounterLeapArray)
 		if !ok || stat == nil {
-			logging.Warn("Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray", "statType", reflect.TypeOf(stat).Name())
+			logging.Warn("[CircuitBreaker RuleManager] 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
@@ -187,7 +187,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 			continue
 		}
 		if err := IsValid(rule); err != nil {
-			logging.Warn("Ignoring invalid circuit breaking rule when loading new rules", "rule", rule, "err", err)
+			logging.Warn("[CircuitBreaker onRuleUpdate] Ignoring invalid circuit breaking rule when loading new rules", "rule", rule, "err", err)
 			continue
 		}
 
@@ -213,7 +213,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 		if r := recover(); r != nil {
 			return
 		}
-		logging.Debug("Time statistics(ns) for updating circuit breaker rule", "timeCost", util.CurrentTimeNano()-start)
+		logging.Debug("[CircuitBreaker onRuleUpdate] Time statistics(ns) for updating circuit breaker rule", "timeCost", util.CurrentTimeNano()-start)
 		logRuleUpdate(newBreakerRules)
 	}()
 
@@ -238,7 +238,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 
 			generator := cbGenFuncMap[r.Strategy]
 			if generator == nil {
-				logging.Warn("Ignoring the rule due to unsupported circuit breaking strategy", "rule", r)
+				logging.Warn("[CircuitBreaker onRuleUpdate] Ignoring the rule due to unsupported circuit breaking strategy", "rule", r)
 				continue
 			}
 
@@ -250,7 +250,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 				cb, e = generator(r, nil)
 			}
 			if cb == nil || e != nil {
-				logging.Warn("Ignoring the rule due to bad generated circuit breaker", "rule", r, "err", e)
+				logging.Warn("[CircuitBreaker onRuleUpdate] Ignoring the rule due to bad generated circuit breaker", "rule", r, "err", e)
 				continue
 			}
 
 
@@ -53,7 +53,7 @@ func OverrideConfigFromEnvAndInitLog() error {
 		return err
 	}
 
-	defer logging.Info("print effective global config", "globalConfig", *globalCfg)
+	defer logging.Info("[Config] Print effective global config", "globalConfig", *globalCfg)
 	// Configured Logger is the highest priority
 	if configLogger := Logger(); configLogger != nil {
 		err = logging.ResetGlobalLogger(configLogger)
@@ -70,7 +70,7 @@ func OverrideConfigFromEnvAndInitLog() error {
 	if err := initializeLogConfig(logDir, LogUsePid()); err != nil {
 		return err
 	}
-	logging.Info("App name resolved", "appName", AppName())
+	logging.Info("[Config] App name resolved", "appName", AppName())
 	return nil
 }
 
@@ -93,7 +93,7 @@ func loadGlobalConfigFromYamlFile(filePath string) error {
 	if err != nil {
 		return err
 	}
-	logging.Info("Resolving Sentinel config from file", "file", filePath)
+	logging.Info("[Config] Resolving Sentinel config from file", "file", filePath)
 	return checkConfValid(&(globalCfg.Sentinel))
 }
 
@@ -128,7 +128,7 @@ func overrideItemsFromSystemEnv() error {
 
 func initializeLogConfig(logDir string, usePid bool) (err error) {
 	if logDir == "" {
-		return errors.New("Invalid empty log path")
+		return errors.New("invalid empty log path")
 	}
 
 	initLogOnce.Do(func() {
@@ -155,7 +155,7 @@ func reconfigureRecordLogger(logBaseDir string, withPid bool) error {
 		return err
 	}
 
-	logging.Info("INFO: log base directory is: " + logBaseDir)
+	logging.Info("[Config] Log base directory", "baseDir", logBaseDir)
 
 	return nil
 }
 
@@ -133,7 +133,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 	resRulesMap := make(map[string][]*Rule)
 	for _, rule := range rules {
 		if err := IsValidRule(rule); err != nil {
-			logging.Warn("ignoring invalid flow rule", "rule", rule, "reason", err)
+			logging.Warn("[Flow onRuleUpdate] Ignoring invalid flow rule", "rule", rule, "reason", err)
 			continue
 		}
 		resRules, exist := resRulesMap[rule.Resource]
@@ -150,7 +150,7 @@ func onRuleUpdate(rules []*Rule) (err error) {
 		if r := recover(); r != nil {
 			return
 		}
-		logging.Debug("time statistic(ns) for updating flow rule", "timeCost", util.CurrentTimeNano()-start)
+		logging.Debug("[Flow onRuleUpdate] Time statistic(ns) for updating flow rule", "timeCost", util.CurrentTimeNano()-start)
 		logRuleUpdate(m)
 	}()
 	for res, rulesOfRes := range resRulesMap {
@@ -297,7 +297,7 @@ func generateStatFor(rule *Rule) (*standaloneStatistic, error) {
 		retStat.writeOnlyMetric = nil
 		return &retStat, nil
 	} else if err == base.GlobalStatisticNonReusableError {
-		logging.Info("flow rule couldn't reuse global statistic and will generate independent statistic", "rule", rule)
+		logging.Info("[FlowRuleManager] Flow rule couldn't reuse global statistic and will generate independent statistic", "rule", rule)
 		retStat.reuseResourceStat = false
 		realLeapArray := sbase.NewBucketLeapArray(sampleCount, intervalInMs)
 		metricStat, e := sbase.NewSlidingWindowMetric(sampleCount, intervalInMs, realLeapArray)
@@ -390,7 +390,7 @@ func buildRulesOfRes(res string, rulesOfRes []*Rule) []*TrafficShapingController
 	emptyTcs := make([]*TrafficShapingController, 0, 0)
 	for _, rule := range rulesOfRes {
 		if res != rule.Resource {
-			logging.Error(errors.Errorf("unmatched resource name, expect: %s, actual: %s", res, rule.Resource), "FlowManager: unmatched resource name ", "rule", rule)
+			logging.Error(errors.Errorf("unmatched resource name expect: %s, actual: %s", res, rule.Resource), "Unmatched resource name in flow.buildRulesOfRes()", "rule", rule)
 			continue
 		}
 		oldResTcs, exist := tcMap[res]
@@ -415,7 +415,7 @@ func buildRulesOfRes(res string, rulesOfRes []*Rule) []*TrafficShapingController
 			controlBehavior:        rule.ControlBehavior,
 		}]
 		if !supported || generator == nil {
-			logging.Error(errors.New("unsupported flow control strategy"), "ignoring the rule due to unsupported control behavior", "rule", rule)
+			logging.Error(errors.New("unsupported flow control strategy"), "Ignoring the rule due to unsupported control behavior in flow.buildRulesOfRes()", "rule", rule)
 			continue
 		}
 		var tc *TrafficShapingController
@@ -427,7 +427,7 @@ func buildRulesOfRes(res string, rulesOfRes []*Rule) []*TrafficShapingController
 		}
 
 		if tc == nil || e != nil {
-			logging.Error(errors.New("bad generated traffic controller"), "ignoring the rule due to bad generated traffic controller.", "rule", rule)
+			logging.Error(errors.New("bad generated traffic controller"), "Ignoring the rule due to bad generated traffic controller in flow.buildRulesOfRes()", "rule", rule)
 			continue
 		}
 		if reuseStatIdx >= 0 {
 
@@ -32,7 +32,7 @@ func (s *Slot) Check(ctx *base.EntryContext) *base.TokenResult {
 	// Check rules in order
 	for _, tc := range tcs {
 		if tc == nil {
-			logging.Warn("nil traffic controller found", "resourceName", res)
+			logging.Warn("[FlowSlot Check]Nil traffic controller found", "resourceName", res)
 			continue
 		}
 		r := canPassCheck(tc, ctx.StatNode, ctx.Input.BatchCount)
@@ -73,7 +73,7 @@ func checkInLocal(tc *TrafficShapingController, resStat base.StatNode, batchCoun
 	actual := selectNodeByRelStrategy(tc.rule, resStat)
 	if actual == nil {
 		logging.FrequentErrorOnce.Do(func() {
-			logging.Error(errors.Errorf("nil resource node"), "no resource node for flow rule", "rule", tc.rule)
+			logging.Error(errors.Errorf("nil resource node"), "No resource node for flow rule in FlowSlot.checkInLocal()", "rule", tc.rule)
 		})
 		return base.NewTokenResultPass()
 	}
 
@@ -28,7 +28,7 @@ func (s StandaloneStatSlot) OnEntryPassed(ctx *base.EntryContext) {
 			if tc.boundStat.writeOnlyMetric != nil {
 				tc.boundStat.writeOnlyMetric.AddCount(base.MetricEventPass, int64(ctx.Input.BatchCount))
 			} else {
-				logging.Error(errors.New("nil independent write statistic"), "flow module: nil statistic for traffic control", "rule", tc.rule)
+				logging.Error(errors.New("nil independent write statistic"), "Nil statistic for traffic control in StandaloneStatSlot.OnEntryPassed()", "rule", tc.rule)
 			}
 		}
 	}
 
@@ -26,7 +26,7 @@ type entry struct {
 // NewLRU constructs an LRU of the given size
 func NewLRU(size int, onEvict EvictCallback) (*LRU, error) {
 	if size <= 0 {
-		return nil, errors.New("Must provide a positive size")
+		return nil, errors.New("must provide a positive size")
 	}
 	c := &LRU{
 		size:      size,
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ import (`
`10`	`10`	`func TraceError(entry *base.SentinelEntry, err error) {`
`11`	`11`	`defer func() {`
`12`	`12`	`if e := recover(); e != nil {`
`13`		`- logging.Error(errors.Errorf("%+v", e), "failed to TraceError")`
	`13`	`+ logging.Error(errors.Errorf("%+v", e), "Failed to api.TraceError()")`
`14`	`14`	`return`
`15`	`15`	`}`
`16`	`16`	`}()`
Original file line number	Diff line number	Diff line change
`@@ -77,15 +77,15 @@ func (e *SentinelEntry) Exit(exitOps ...ExitOption) {`
`77`	`77`	`e.exitCtl.Do(func() {`
`78`	`78`	`defer func() {`
`79`	`79`	`if err := recover(); err != nil {`
`80`		`- logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in entry exit func")`
	`80`	`+ logging.Error(errors.Errorf("%+v", err), "Sentinel internal panic in SentinelEntry.Exit()")`
`81`	`81`	`}`
`82`	`82`	`if e.sc != nil {`
`83`	`83`	`e.sc.RefurbishContext(ctx)`
`84`	`84`	`}`
`85`	`85`	`}()`
`86`	`86`	`for _, handler := range e.exitHandlers {`
`87`	`87`	`if err := handler(e, ctx); err != nil {`
`88`		`- logging.Error(err, "Fail to execute exitHandler", "resource", e.Resource().Name())`
	`88`	`+ logging.Error(err, "Fail to execute exitHandler in SentinelEntry.Exit()", "resource", e.Resource().Name())`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`if e.sc != nil {`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ func init() {`
`33`	`33`	`}`
`34`	`34`	`stat, ok := reuseStat.(*slowRequestLeapArray)`
`35`	`35`	`if !ok \|\| stat == nil {`
`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`	`+ logging.Warn("[CircuitBreaker RuleManager] Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*slowRequestLeapArray", "statType", reflect.TypeOf(stat).Name())`
`37`	`37`	`return newSlowRtCircuitBreaker(r)`
`38`	`38`	`}`
`39`	`39`	`return newSlowRtCircuitBreakerWithStat(r, stat), nil`
`@@ -48,7 +48,7 @@ func init() {`
`48`	`48`	`}`
`49`	`49`	`stat, ok := reuseStat.(*errorCounterLeapArray)`
`50`	`50`	`if !ok \|\| stat == nil {`
`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`	`+ logging.Warn("[CircuitBreaker RuleManager] Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray", "statType", reflect.TypeOf(stat).Name())`
`52`	`52`	`return newErrorRatioCircuitBreaker(r)`
`53`	`53`	`}`
`54`	`54`	`return newErrorRatioCircuitBreakerWithStat(r, stat), nil`
`@@ -63,7 +63,7 @@ func init() {`
`63`	`63`	`}`
`64`	`64`	`stat, ok := reuseStat.(*errorCounterLeapArray)`
`65`	`65`	`if !ok \|\| stat == nil {`
`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`	`+ logging.Warn("[CircuitBreaker RuleManager] Expect to generate circuit breaker with reuse statistic, but fail to do type assertion, expect:*errorCounterLeapArray", "statType", reflect.TypeOf(stat).Name())`
`67`	`67`	`return newErrorCountCircuitBreaker(r)`
`68`	`68`	`}`
`69`	`69`	`return newErrorCountCircuitBreakerWithStat(r, stat), nil`
`@@ -187,7 +187,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`187`	`187`	`continue`
`188`	`188`	`}`
`189`	`189`	`if err := IsValid(rule); err != nil {`
`190`		`- logging.Warn("Ignoring invalid circuit breaking rule when loading new rules", "rule", rule, "err", err)`
	`190`	`+ logging.Warn("[CircuitBreaker onRuleUpdate] Ignoring invalid circuit breaking rule when loading new rules", "rule", rule, "err", err)`
`191`	`191`	`continue`
`192`	`192`	`}`
`193`	`193`
`@@ -213,7 +213,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`213`	`213`	`if r := recover(); r != nil {`
`214`	`214`	`return`
`215`	`215`	`}`
`216`		`- logging.Debug("Time statistics(ns) for updating circuit breaker rule", "timeCost", util.CurrentTimeNano()-start)`
	`216`	`+ logging.Debug("[CircuitBreaker onRuleUpdate] Time statistics(ns) for updating circuit breaker rule", "timeCost", util.CurrentTimeNano()-start)`
`217`	`217`	`logRuleUpdate(newBreakerRules)`
`218`	`218`	`}()`
`219`	`219`
`@@ -238,7 +238,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`238`	`238`
`239`	`239`	`generator := cbGenFuncMap[r.Strategy]`
`240`	`240`	`if generator == nil {`
`241`		`- logging.Warn("Ignoring the rule due to unsupported circuit breaking strategy", "rule", r)`
	`241`	`+ logging.Warn("[CircuitBreaker onRuleUpdate] Ignoring the rule due to unsupported circuit breaking strategy", "rule", r)`
`242`	`242`	`continue`
`243`	`243`	`}`
`244`	`244`
`@@ -250,7 +250,7 @@ func onRuleUpdate(rules []*Rule) (err error) {`
`250`	`250`	`cb, e = generator(r, nil)`
`251`	`251`	`}`
`252`	`252`	`if cb == nil \|\| e != nil {`
`253`		`- logging.Warn("Ignoring the rule due to bad generated circuit breaker", "rule", r, "err", e)`
	`253`	`+ logging.Warn("[CircuitBreaker onRuleUpdate] Ignoring the rule due to bad generated circuit breaker", "rule", r, "err", e)`
`254`	`254`	`continue`
`255`	`255`	`}`
`256`	`256`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ func OverrideConfigFromEnvAndInitLog() error {`
`53`	`53`	`return err`
`54`	`54`	`}`
`55`	`55`
`56`		`- defer logging.Info("print effective global config", "globalConfig", *globalCfg)`
	`56`	`+ defer logging.Info("[Config] Print effective global config", "globalConfig", *globalCfg)`
`57`	`57`	`// Configured Logger is the highest priority`
`58`	`58`	`if configLogger := Logger(); configLogger != nil {`
`59`	`59`	`err = logging.ResetGlobalLogger(configLogger)`
`@@ -70,7 +70,7 @@ func OverrideConfigFromEnvAndInitLog() error {`
`70`	`70`	`if err := initializeLogConfig(logDir, LogUsePid()); err != nil {`
`71`	`71`	`return err`
`72`	`72`	`}`
`73`		`- logging.Info("App name resolved", "appName", AppName())`
	`73`	`+ logging.Info("[Config] App name resolved", "appName", AppName())`
`74`	`74`	`return nil`
`75`	`75`	`}`
`76`	`76`
`@@ -93,7 +93,7 @@ func loadGlobalConfigFromYamlFile(filePath string) error {`
`93`	`93`	`if err != nil {`
`94`	`94`	`return err`
`95`	`95`	`}`
`96`		`- logging.Info("Resolving Sentinel config from file", "file", filePath)`
	`96`	`+ logging.Info("[Config] Resolving Sentinel config from file", "file", filePath)`
`97`	`97`	`return checkConfValid(&(globalCfg.Sentinel))`
`98`	`98`	`}`
`99`	`99`
`@@ -128,7 +128,7 @@ func overrideItemsFromSystemEnv() error {`
`128`	`128`
`129`	`129`	`func initializeLogConfig(logDir string, usePid bool) (err error) {`
`130`	`130`	`if logDir == "" {`
`131`		`- return errors.New("Invalid empty log path")`
	`131`	`+ return errors.New("invalid empty log path")`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`initLogOnce.Do(func() {`
`@@ -155,7 +155,7 @@ func reconfigureRecordLogger(logBaseDir string, withPid bool) error {`
`155`	`155`	`return err`
`156`	`156`	`}`
`157`	`157`
`158`		`- logging.Info("INFO: log base directory is: " + logBaseDir)`
	`158`	`+ logging.Info("[Config] Log base directory", "baseDir", logBaseDir)`
`159`	`159`
`160`	`160`	`return nil`
`161`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ func (s StandaloneStatSlot) OnEntryPassed(ctx *base.EntryContext) {`
`28`	`28`	`if tc.boundStat.writeOnlyMetric != nil {`
`29`	`29`	`tc.boundStat.writeOnlyMetric.AddCount(base.MetricEventPass, int64(ctx.Input.BatchCount))`
`30`	`30`	`} else {`
`31`		`- logging.Error(errors.New("nil independent write statistic"), "flow module: nil statistic for traffic control", "rule", tc.rule)`
	`31`	`+ logging.Error(errors.New("nil independent write statistic"), "Nil statistic for traffic control in StandaloneStatSlot.OnEntryPassed()", "rule", tc.rule)`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ type entry struct {`
`26`	`26`	`// NewLRU constructs an LRU of the given size`
`27`	`27`	`func NewLRU(size int, onEvict EvictCallback) (*LRU, error) {`
`28`	`28`	`if size <= 0 {`
`29`		`- return nil, errors.New("Must provide a positive size")`
	`29`	`+ return nil, errors.New("must provide a positive size")`
`30`	`30`	`}`
`31`	`31`	`c := &LRU{`
`32`	`32`	`size: size,`