Optimize the slot chain execution mechanism (#264)

* Support resource level slot chain to reduce unnecessary slot execution
* Support register the global singleton slot for all resource
* Make api.WithSlotChain have the highest priority

Co-authored-by: louyuting <[email protected]>

Author: AlexStocks

api/api.go

@@ -4,6 +4,7 @@ import (
 	"sync"
 
 	"github.com/alibaba/sentinel-golang/core/base"
+	"github.com/alibaba/sentinel-golang/core/misc"
 )
 
 var entryOptsPool = sync.Pool{
@@ -123,12 +124,15 @@ func Entry(resource string, opts ...EntryOption) (*base.SentinelEntry, *base.Blo
 		entryOptsPool.Put(options)
 	}()
 
-	options.slotChain = globalSlotChain
-
 	for _, opt := range opts {
 		opt(options)
 	}
-
+	if options.slotChain == nil {
+		options.slotChain = misc.GetResourceSlotChain(resource)
+		if options.slotChain == nil {
+			options.slotChain = globalSlotChain
+		}
+	}
 	return entry(resource, options)
 }
 

api/api_test.go

@@ -12,6 +12,10 @@ type prepareSlotMock struct {
 	mock.Mock
 }
 
+func (m *prepareSlotMock) Name() string {
+	return "mock-sentinel-prepare-slot"
+}
+
 func (m *prepareSlotMock) Prepare(ctx *base.EntryContext) {
 	m.Called(ctx)
 	return
@@ -21,6 +25,10 @@ type mockRuleCheckSlot1 struct {
 	mock.Mock
 }
 
+func (m *mockRuleCheckSlot1) Name() string {
+	return "mock-sentinel-rule-check-slot1"
+}
+
 func (m *mockRuleCheckSlot1) Check(ctx *base.EntryContext) *base.TokenResult {
 	arg := m.Called(ctx)
 	return arg.Get(0).(*base.TokenResult)
@@ -30,6 +38,10 @@ type mockRuleCheckSlot2 struct {
 	mock.Mock
 }
 
+func (m *mockRuleCheckSlot2) Name() string {
+	return "mock-sentinel-rule-check-slot2"
+}
+
 func (m *mockRuleCheckSlot2) Check(ctx *base.EntryContext) *base.TokenResult {
 	arg := m.Called(ctx)
 	return arg.Get(0).(*base.TokenResult)
@@ -39,6 +51,10 @@ type statisticSlotMock struct {
 	mock.Mock
 }
 
+func (m *statisticSlotMock) Name() string {
+	return "mock-sentinel-stat-check-slot"
+}
+
 func (m *statisticSlotMock) OnEntryPassed(ctx *base.EntryContext) {
 	m.Called(ctx)
 	return

api/slot_chain.go

@@ -7,37 +7,33 @@ import (
 	"github.com/alibaba/sentinel-golang/core/hotspot"
 	"github.com/alibaba/sentinel-golang/core/isolation"
 	"github.com/alibaba/sentinel-golang/core/log"
+	"github.com/alibaba/sentinel-golang/core/misc"
 	"github.com/alibaba/sentinel-golang/core/stat"
 	"github.com/alibaba/sentinel-golang/core/system"
 )
 
 var globalSlotChain = BuildDefaultSlotChain()
 
-// SetSlotChain replaces current slot chain with the given one.
-// Note that this operation is not thread-safe, so it should be
-// called when pre-initializing Sentinel.
-func SetSlotChain(chain *base.SlotChain) {
-	if chain != nil {
-		globalSlotChain = chain
-	}
-}
-
 func GlobalSlotChain() *base.SlotChain {
 	return globalSlotChain
 }
 
 func BuildDefaultSlotChain() *base.SlotChain {
 	sc := base.NewSlotChain()
-	sc.AddStatPrepareSlotLast(&stat.ResourceNodePrepareSlot{})
-	sc.AddRuleCheckSlotLast(&system.AdaptiveSlot{})
-	sc.AddRuleCheckSlotLast(&flow.Slot{})
-	sc.AddRuleCheckSlotLast(&isolation.Slot{})
-	sc.AddRuleCheckSlotLast(&circuitbreaker.Slot{})
-	sc.AddRuleCheckSlotLast(&hotspot.Slot{})
-	sc.AddStatSlotLast(&stat.Slot{})
-	sc.AddStatSlotLast(&log.Slot{})
-	sc.AddStatSlotLast(&circuitbreaker.MetricStatSlot{})
-	sc.AddStatSlotLast(&hotspot.ConcurrencyStatSlot{})
-	sc.AddStatSlotLast(&flow.StandaloneStatSlot{})
+	sc.AddStatPrepareSlotLast(stat.DefaultResourceNodePrepareSlot)
+
+	sc.AddRuleCheckSlotLast(system.DefaultAdaptiveSlot)
+	sc.AddRuleCheckSlotLast(flow.DefaultSlot)
+	sc.AddRuleCheckSlotLast(isolation.DefaultSlot)
+	sc.AddRuleCheckSlotLast(circuitbreaker.DefaultSlot)
+	sc.AddRuleCheckSlotLast(hotspot.DefaultSlot)
+
+	sc.AddStatSlotLast(stat.DefaultSlot)
+	sc.AddStatSlotLast(log.DefaultSlot)
+	sc.AddStatSlotLast(circuitbreaker.DefaultMetricStatSlot)
+	sc.AddStatSlotLast(hotspot.DefaultConcurrencyStatSlot)
+	sc.AddStatSlotLast(flow.DefaultStandaloneStatSlot)
+
+	misc.RegisterCustomGlobalSlotsToSc(sc)
 	return sc
 }

core/base/slot_chain.go

@@ -8,9 +8,15 @@ import (
 	"github.com/pkg/errors"
 )
 
+type NamedSlot interface {
+	// Name returns its slot name which should not be the same as other slots.
+	Name() string
+}
+
 // StatPrepareSlot is responsible for some preparation before statistic
 // For example: init structure and so on
 type StatPrepareSlot interface {
+	NamedSlot
 	// Prepare function do some initialization
 	// Such as: init statistic structure、node and etc
 	// The result of preparing would store in EntryContext
@@ -22,6 +28,7 @@ type StatPrepareSlot interface {
 // RuleCheckSlot is rule based checking strategy
 // All checking rule must implement this interface.
 type RuleCheckSlot interface {
+	NamedSlot
 	// Check function do some validation
 	// It can break off the slot pipeline
 	// Each TokenResult will return check result
@@ -32,6 +39,7 @@ type RuleCheckSlot interface {
 // StatSlot is responsible for counting all custom biz metrics.
 // StatSlot would not handle any panic, and pass up all panic to slot chain
 type StatSlot interface {
+	NamedSlot
 	// OnEntryPass function will be invoked when StatPrepareSlots and RuleCheckSlots execute pass
 	// StatSlots will do some statistic logic, such as QPS、log、etc
 	OnEntryPassed(ctx *EntryContext)
@@ -53,28 +61,32 @@ type SlotChain struct {
 	ruleChecks []RuleCheckSlot
 	stats      []StatSlot
 	// EntryContext Pool, used for reuse EntryContext object
-	ctxPool sync.Pool
+	ctxPool *sync.Pool
 }
 
+var (
+	ctxPool = &sync.Pool{
+		New: func() interface{} {
+			ctx := NewEmptyEntryContext()
+			ctx.RuleCheckResult = NewTokenResultPass()
+			ctx.Data = make(map[interface{}]interface{})
+			ctx.Input = &SentinelInput{
+				BatchCount:  1,
+				Flag:        0,
+				Args:        make([]interface{}, 0),
+				Attachments: make(map[interface{}]interface{}),
+			}
+			return ctx
+		},
+	}
+)
+
 func NewSlotChain() *SlotChain {
 	return &SlotChain{
 		statPres:   make([]StatPrepareSlot, 0, 5),
 		ruleChecks: make([]RuleCheckSlot, 0, 5),
 		stats:      make([]StatSlot, 0, 5),
-		ctxPool: sync.Pool{
-			New: func() interface{} {
-				ctx := NewEmptyEntryContext()
-				ctx.RuleCheckResult = NewTokenResultPass()
-				ctx.Data = make(map[interface{}]interface{})
-				ctx.Input = &SentinelInput{
-					BatchCount:  1,
-					Flag:        0,
-					Args:        make([]interface{}, 0),
-					Attachments: make(map[interface{}]interface{}),
-				}
-				return ctx
-			},
-		},
+		ctxPool:    ctxPool,
 	}
 }
 
@@ -92,6 +104,12 @@ func (sc *SlotChain) RefurbishContext(c *EntryContext) {
 	}
 }
 
+func (sc *SlotChain) RangeStatPrepareSlot(f func(slot StatPrepareSlot)) {
+	for _, slot := range sc.statPres {
+		f(slot)
+	}
+}
+
 func (sc *SlotChain) AddStatPrepareSlotFirst(s StatPrepareSlot) {
 	ns := make([]StatPrepareSlot, 0, len(sc.statPres)+1)
 	// add to first
@@ -103,6 +121,12 @@ func (sc *SlotChain) AddStatPrepareSlotLast(s StatPrepareSlot) {
 	sc.statPres = append(sc.statPres, s)
 }
 
+func (sc *SlotChain) RangeRuleCheckSlot(f func(slot RuleCheckSlot)) {
+	for _, slot := range sc.ruleChecks {
+		f(slot)
+	}
+}
+
 func (sc *SlotChain) AddRuleCheckSlotFirst(s RuleCheckSlot) {
 	ns := make([]RuleCheckSlot, 0, len(sc.ruleChecks)+1)
 	ns = append(ns, s)
@@ -113,6 +137,12 @@ func (sc *SlotChain) AddRuleCheckSlotLast(s RuleCheckSlot) {
 	sc.ruleChecks = append(sc.ruleChecks, s)
 }
 
+func (sc *SlotChain) RangeStatSlot(f func(slot StatSlot)) {
+	for _, slot := range sc.stats {
+		f(slot)
+	}
+}
+
 func (sc *SlotChain) AddStatSlotFirst(s StatSlot) {
 	ns := make([]StatSlot, 0, len(sc.stats)+1)
 	ns = append(ns, s)