Merge pull request #242 from splitio/FME-11061

Added fallback treatment config

Author: nmayorsplit

.github/workflows/ci.yml

@@ -39,7 +39,7 @@ jobs:
 
       - name: SonarQube Scan (Push)
         if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/development')
-        uses: SonarSource/sonarcloud-github-action@v5.0
+        uses: SonarSource/sonarqube-scan-action@v5.0
         env:
           SONAR_TOKEN: ${{ secrets.SONARQUBE_TOKEN }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -51,7 +51,7 @@ jobs:
 
       - name: SonarQube Scan (Pull Request)
         if: github.event_name == 'pull_request'
-        uses: SonarSource/sonarcloud-github-action@v5.0
+        uses: SonarSource/sonarqube-scan-action@v5.0
         env:
           SONAR_TOKEN: ${{ secrets.SONARQUBE_TOKEN }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

go.mod

@@ -3,7 +3,7 @@ module github.com/splitio/go-client/v6
 go 1.18
 
 require (
-	github.com/splitio/go-split-commons/v8 v8.0.0
+	github.com/splitio/go-split-commons/v8 v8.0.1-0.20251121153142-2cbd8bd819b0
 	github.com/splitio/go-toolkit/v5 v5.4.1
 	github.com/stretchr/testify v1.11.1
 )

go.sum

@@ -18,8 +18,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/redis/go-redis/v9 v9.0.4 h1:FC82T+CHJ/Q/PdyLW++GeCO+Ol59Y4T7R4jbgjvktgc=
 github.com/redis/go-redis/v9 v9.0.4/go.mod h1:WqMKv5vnQbRuZstUwxQI195wHy+t4PuXDOjzMvcuQHk=
-github.com/splitio/go-split-commons/v8 v8.0.0 h1:wLk5eT6WU2LfxtaWG3ZHlTbNMGWP2eYsZTb1o+tFpkI=
-github.com/splitio/go-split-commons/v8 v8.0.0/go.mod h1:vgRGPn0s4RC9/zp1nIn4KeeIEj/K3iXE2fxYQbCk/WI=
+github.com/splitio/go-split-commons/v8 v8.0.1-0.20251121153142-2cbd8bd819b0 h1:LfN3tj6Evy/G68GwjLh5Jtns7WaHs2t6KVO64xv5jVs=
+github.com/splitio/go-split-commons/v8 v8.0.1-0.20251121153142-2cbd8bd819b0/go.mod h1:vgRGPn0s4RC9/zp1nIn4KeeIEj/K3iXE2fxYQbCk/WI=
 github.com/splitio/go-toolkit/v5 v5.4.1 h1:srTyvDBJZMUcJ/KiiQDMyjCuELVgTBh2TGRVn0sOXEE=
 github.com/splitio/go-toolkit/v5 v5.4.1/go.mod h1:SifzysrOVDbzMcOE8zjX02+FG5az4FrR3Us/i5SeStw=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=

splitio/client/client_test.go

@@ -1322,6 +1322,22 @@ func TestClient(t *testing.T) {
 	cfg.LabelsEnabled = true
 	logger := logging.NewLogger(nil)
 
+	stringConfig := "flag1_config"
+	globalTreatment := "global_treatment"
+	flag1Treatment := "flag1_treatment"
+	config := &dtos.FallbackTreatmentConfig{
+		GlobalFallbackTreatment: &dtos.FallbackTreatment{
+			Treatment: &globalTreatment,
+		},
+		ByFlagFallbackTreatment: map[string]dtos.FallbackTreatment{
+			"flag1": {
+				Treatment: &flag1Treatment,
+				Config:    &stringConfig,
+			},
+		},
+	}
+	fallbackTreatmentCalculator := dtos.NewFallbackTreatmentCalculatorImp(config)
+
 	evaluator := evaluator.NewEvaluator(
 		mocks.MockSplitStorage{
 			SplitCall: func(splitName string) *dtos.SplitDTO {
@@ -1374,6 +1390,7 @@ func TestClient(t *testing.T) {
 		logger,
 		cfg.Advanced.FeatureFlagRules,
 		cfg.Advanced.RuleBasedSegmentRules,
+		fallbackTreatmentCalculator,
 	)
 
 	mockedTelemetryStorage := mocks.MockTelemetryStorage{
@@ -1409,19 +1426,19 @@ func TestClient(t *testing.T) {
 		t.Error("Wrong impression saved")
 	}
 
-	expectedTreatment(client.Treatment("invalid", "invalid", nil), "control", t)
-	if client.Treatment("invalid", "invalid", nil) != "control" {
+	expectedTreatment(client.Treatment("invalid", "invalid", nil), "global_treatment", t)
+	if client.Treatment("invalid", "invalid", nil) != "global_treatment" {
 		t.Error("Unexpected Treatment Result")
 	}
 
 	expectedTreatment(client.Treatment("invalid", "killed", nil), "defTreatment", t)
-	if isInvalidImpression(client, "invalid", "killed", "defTreatment") {
+	if isInvalidImpression(client, "invalid", "invalid", "global_treatment") {
 		t.Error("Wrong impression saved")
 	}
 
 	// Assertion Treatments
 	treatments := client.Treatments("user1", []string{"valid", "invalid", "killed"}, nil)
-	expectedTreatment(treatments["invalid"], "control", t)
+	expectedTreatment(treatments["invalid"], "global_treatment", t)
 	expectedTreatment(treatments["killed"], "defTreatment", t)
 	expectedTreatment(treatments["valid"], "on", t)
 	client.impressions.(storage.ImpressionStorage).PopN(cfg.Advanced.ImpressionsBulkSize)
@@ -1437,15 +1454,15 @@ func TestClient(t *testing.T) {
 		t.Error("Wrong impression saved")
 	}
 
-	expectedTreatmentAndConfig(client.TreatmentWithConfig("invalid", "invalid", nil), "control", "", t)
+	expectedTreatmentAndConfig(client.TreatmentWithConfig("invalid", "invalid", nil), "global_treatment", "", t)
 	expectedTreatmentAndConfig(client.TreatmentWithConfig("invalid", "killed", nil), "defTreatment", "{\"color\": \"orange\",\"size\": 15}", t)
-	if isInvalidImpression(client, "invalid", "killed", "defTreatment") {
+	if isInvalidImpression(client, "invalid", "invalid", "global_treatment") {
 		t.Error("Wrong impression saved")
 	}
 
 	// Assertion TreatmentsWithConfig
 	treatmentsWithConfigs := client.TreatmentsWithConfig("user1", []string{"valid", "invalid", "killed"}, nil)
-	expectedTreatmentAndConfig(treatmentsWithConfigs["invalid"], "control", "", t)
+	expectedTreatmentAndConfig(treatmentsWithConfigs["invalid"], "global_treatment", "", t)
 	expectedTreatmentAndConfig(treatmentsWithConfigs["killed"], "defTreatment", "{\"color\": \"orange\",\"size\": 15}", t)
 	expectedTreatmentAndConfig(treatmentsWithConfigs["valid"], "on", "{\"color\": \"blue\",\"size\": 13}", t)
 }

splitio/client/factory.go

@@ -65,27 +65,28 @@ type sdkStorages struct {
 
 // SplitFactory struct is responsible for instantiating and storing instances of client and manager.
 type SplitFactory struct {
-	startTime             time.Time // Tracking startTime
-	metadata              dtos.Metadata
-	storages              sdkStorages
-	apikey                string
-	status                atomic.Value
-	readinessSubscriptors map[int]chan int
-	operationMode         string
-	mutex                 sync.Mutex
-	cfg                   *conf.SplitSdkConfig
-	impressionListener    *impressionlistener.WrapperImpressionListener
-	logger                logging.LoggerInterface
-	syncManager           synchronizer.Manager
-	telemetrySync         telemetry.TelemetrySynchronizer // To execute SynchronizeInit
-	impressionManager     provisional.ImpressionManager
+	startTime                   time.Time // Tracking startTime
+	metadata                    dtos.Metadata
+	storages                    sdkStorages
+	apikey                      string
+	status                      atomic.Value
+	readinessSubscriptors       map[int]chan int
+	operationMode               string
+	mutex                       sync.Mutex
+	cfg                         *conf.SplitSdkConfig
+	impressionListener          *impressionlistener.WrapperImpressionListener
+	logger                      logging.LoggerInterface
+	syncManager                 synchronizer.Manager
+	telemetrySync               telemetry.TelemetrySynchronizer // To execute SynchronizeInit
+	impressionManager           provisional.ImpressionManager
+	fallbackTreatmentCalculator dtos.FallbackTreatmentCalculator
 }
 
 // Client returns the split client instantiated by the factory
 func (f *SplitFactory) Client() *SplitClient {
 	return &SplitClient{
 		logger:      f.logger,
-		evaluator:   evaluator.NewEvaluator(f.storages.splits, f.storages.segments, f.storages.ruleBasedSegments, nil, engine.NewEngine(f.logger), f.logger, f.cfg.Advanced.FeatureFlagRules, f.cfg.Advanced.RuleBasedSegmentRules),
+		evaluator:   evaluator.NewEvaluator(f.storages.splits, f.storages.segments, f.storages.ruleBasedSegments, nil, engine.NewEngine(f.logger), f.logger, f.cfg.Advanced.FeatureFlagRules, f.cfg.Advanced.RuleBasedSegmentRules, f.fallbackTreatmentCalculator),
 		impressions: f.storages.impressions,
 		events:      f.storages.events,
 		validator: inputValidation{
@@ -297,7 +298,15 @@ func setupInMemoryFactory(
 	splitAPI := api.NewSplitAPI(apikey, advanced, logger, metadata)
 
 	isProxy := splitAPI.SplitFetcher.IsProxy()
-	evaluator := evaluator.NewEvaluator(splitsStorage, segmentsStorage, ruleBasedSegmentStorage, nil, engine.NewEngine(logger), logger, cfg.Advanced.FeatureFlagRules, cfg.Advanced.RuleBasedSegmentRules)
+
+	fallbackTreatmentConf := dtos.FallbackTreatmentConfig{}
+	if cfg.Advanced.FallbackTreatment != nil {
+		fallbackTreatmentConf.GlobalFallbackTreatment = conf.SanitizeGlobalFallbackTreatment(cfg.Advanced.FallbackTreatment.GlobalFallbackTreatment, logger)
+		fallbackTreatmentConf.ByFlagFallbackTreatment = conf.SanitizeByFlagFallBackTreatment(cfg.Advanced.FallbackTreatment.ByFlagFallbackTreatment, logger)
+	}
+	fallbackTreatmentCalculator := dtos.NewFallbackTreatmentCalculatorImp(&fallbackTreatmentConf)
+
+	evaluator := evaluator.NewEvaluator(splitsStorage, segmentsStorage, ruleBasedSegmentStorage, nil, engine.NewEngine(logger), logger, cfg.Advanced.FeatureFlagRules, cfg.Advanced.RuleBasedSegmentRules, fallbackTreatmentCalculator)
 	ruleBuilder := grammar.NewRuleBuilder(segmentsStorage, ruleBasedSegmentStorage, nil, cfg.Advanced.FeatureFlagRules, cfg.Advanced.RuleBasedSegmentRules, logger, evaluator)
 	workers := synchronizer.Workers{
 		SplitUpdater:      split.NewSplitUpdater(splitsStorage, ruleBasedSegmentStorage, splitAPI.SplitFetcher, logger, telemetryStorage, dummyHC, flagSetFilter, ruleBuilder, isProxy, advanced.FlagsSpecVersion),
@@ -360,17 +369,18 @@ func setupInMemoryFactory(
 	}
 
 	splitFactory := SplitFactory{
-		startTime:             time.Now().UTC(),
-		apikey:                apikey,
-		cfg:                   cfg,
-		metadata:              metadata,
-		logger:                logger,
-		operationMode:         conf.InMemoryStandAlone,
-		storages:              storages,
-		readinessSubscriptors: make(map[int]chan int),
-		syncManager:           syncManager,
-		telemetrySync:         workers.TelemetryRecorder,
-		impressionManager:     impressionManager,
+		startTime:                   time.Now().UTC(),
+		apikey:                      apikey,
+		cfg:                         cfg,
+		metadata:                    metadata,
+		logger:                      logger,
+		operationMode:               conf.InMemoryStandAlone,
+		storages:                    storages,
+		readinessSubscriptors:       make(map[int]chan int),
+		syncManager:                 syncManager,
+		telemetrySync:               workers.TelemetryRecorder,
+		impressionManager:           impressionManager,
+		fallbackTreatmentCalculator: fallbackTreatmentCalculator,
 	}
 	splitFactory.status.Store(sdkStatusInitializing)
 	setFactory(splitFactory.apikey, splitFactory.logger)
@@ -438,18 +448,26 @@ func setupRedisFactory(apikey string, cfg *conf.SplitSdkConfig, logger logging.L
 
 	syncManager := synchronizer.NewSynchronizerManagerRedis(syncImpl, logger)
 
+	fallbackTreatmentConf := dtos.FallbackTreatmentConfig{}
+	if cfg.Advanced.FallbackTreatment != nil {
+		fallbackTreatmentConf.GlobalFallbackTreatment = conf.SanitizeGlobalFallbackTreatment(cfg.Advanced.FallbackTreatment.GlobalFallbackTreatment, logger)
+		fallbackTreatmentConf.ByFlagFallbackTreatment = conf.SanitizeByFlagFallBackTreatment(cfg.Advanced.FallbackTreatment.ByFlagFallbackTreatment, logger)
+	}
+	fallbackTreatmentCalculator := dtos.NewFallbackTreatmentCalculatorImp(&fallbackTreatmentConf)
+
 	factory := &SplitFactory{
-		startTime:             time.Now().UTC(),
-		apikey:                apikey,
-		cfg:                   cfg,
-		metadata:              metadata,
-		logger:                logger,
-		operationMode:         conf.RedisConsumer,
-		storages:              storages,
-		readinessSubscriptors: make(map[int]chan int),
-		telemetrySync:         telemetry.NewSynchronizerRedis(telemetryStorage, logger),
-		impressionManager:     impressionManager,
-		syncManager:           syncManager,
+		startTime:                   time.Now().UTC(),
+		apikey:                      apikey,
+		cfg:                         cfg,
+		metadata:                    metadata,
+		logger:                      logger,
+		operationMode:               conf.RedisConsumer,
+		storages:                    storages,
+		readinessSubscriptors:       make(map[int]chan int),
+		telemetrySync:               telemetry.NewSynchronizerRedis(telemetryStorage, logger),
+		impressionManager:           impressionManager,
+		syncManager:                 syncManager,
+		fallbackTreatmentCalculator: fallbackTreatmentCalculator,
 	}
 	factory.status.Store(sdkStatusInitializing)
 	setFactory(factory.apikey, factory.logger)
@@ -514,6 +532,13 @@ func setupLocalhostFactory(
 		return nil, err
 	}
 
+	fallbackTreatmentConf := dtos.FallbackTreatmentConfig{}
+	if cfg.Advanced.FallbackTreatment != nil {
+		fallbackTreatmentConf.GlobalFallbackTreatment = conf.SanitizeGlobalFallbackTreatment(cfg.Advanced.FallbackTreatment.GlobalFallbackTreatment, logger)
+		fallbackTreatmentConf.ByFlagFallbackTreatment = conf.SanitizeByFlagFallBackTreatment(cfg.Advanced.FallbackTreatment.ByFlagFallbackTreatment, logger)
+	}
+	fallbackTreatmentCalculator := dtos.NewFallbackTreatmentCalculatorImp(&fallbackTreatmentConf)
+
 	splitFactory := &SplitFactory{
 		startTime: time.Now().UTC(),
 		apikey:    apikey,
@@ -530,9 +555,10 @@ func setupLocalhostFactory(
 			evaluationTelemetry: telemetryStorage,
 			runtimeTelemetry:    telemetryStorage,
 		},
-		readinessSubscriptors: make(map[int]chan int),
-		syncManager:           syncManager,
-		telemetrySync:         &telemetry.NoOp{},
+		readinessSubscriptors:       make(map[int]chan int),
+		syncManager:                 syncManager,
+		telemetrySync:               &telemetry.NoOp{},
+		fallbackTreatmentCalculator: fallbackTreatmentCalculator,
 	}
 	splitFactory.status.Store(sdkStatusInitializing)
 

splitio/conf/sdkconf.go

@@ -7,10 +7,12 @@ import (
 	"math"
 	"os/user"
 	"path"
+	"regexp"
 	"strings"
 
 	impressionlistener "github.com/splitio/go-client/v6/splitio/impressionListener"
 	"github.com/splitio/go-split-commons/v8/conf"
+	"github.com/splitio/go-split-commons/v8/dtos"
 	"github.com/splitio/go-split-commons/v8/engine/grammar/constants"
 	"github.com/splitio/go-toolkit/v5/datastructures/set"
 	"github.com/splitio/go-toolkit/v5/logging"
@@ -24,6 +26,13 @@ const (
 	Localhost = "localhost"
 	// InMemoryStandAlone mode
 	InMemoryStandAlone = "inmemory-standalone"
+
+	// Max Flag name length
+	MaxFlagNameLength = 100
+	// Max Treatment length
+	MaxTreatmentLength = 100
+	// Treatment regexp
+	TreatmentRegexp = "^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$"
 )
 
 var featureFlagsRules = []string{constants.MatcherTypeAllKeys, constants.MatcherTypeInSegment, constants.MatcherTypeWhitelist, constants.MatcherTypeEqualTo, constants.MatcherTypeGreaterThanOrEqualTo, constants.MatcherTypeLessThanOrEqualTo, constants.MatcherTypeBetween,
@@ -108,6 +117,7 @@ type AdvancedConfig struct {
 	FeatureFlagRules      []string
 	RuleBasedSegmentRules []string
 	RetryEnabled          bool
+	FallbackTreatment     *dtos.FallbackTreatmentConfig
 }
 
 // Default returns a config struct with all the default values
@@ -174,6 +184,7 @@ func Default() *SplitSdkConfig {
 			FeatureFlagRules:      featureFlagsRules,
 			RuleBasedSegmentRules: ruleBasedSegmentRules,
 			RetryEnabled:          true,
+			FallbackTreatment:     nil,
 		},
 	}
 }
@@ -280,3 +291,55 @@ func Normalize(apikey string, cfg *SplitSdkConfig) error {
 
 	return validConfigRates(cfg)
 }
+
+func SanitizeGlobalFallbackTreatment(global *dtos.FallbackTreatment, logger logging.LoggerInterface) *dtos.FallbackTreatment {
+	if global == nil {
+		return nil
+	}
+	if !isValidTreatment(global) {
+		logger.Error(fmt.Sprintf("Fallback treatments - Discarded global fallback: Invalid treatment (max %d chars and comply with %s)", MaxTreatmentLength, TreatmentRegexp))
+		return nil
+	}
+	return &dtos.FallbackTreatment{
+		Treatment: global.Treatment,
+		Config:    global.Config,
+	}
+}
+
+func isValidTreatment(fallbackTreatment *dtos.FallbackTreatment) bool {
+	if fallbackTreatment == nil || fallbackTreatment.Treatment == nil {
+		return false
+	}
+	value := *fallbackTreatment.Treatment
+	pattern := regexp.MustCompile(TreatmentRegexp)
+	return len(value) <= MaxTreatmentLength && pattern.MatchString(value)
+}
+
+func SanitizeByFlagFallBackTreatment(byFlag map[string]dtos.FallbackTreatment, logger logging.LoggerInterface) map[string]dtos.FallbackTreatment {
+	sanitized := map[string]dtos.FallbackTreatment{}
+	if len(byFlag) == 0 {
+		return sanitized
+	}
+	for flagName, treatment := range byFlag {
+		if !isValidFlagName(&flagName) {
+			logger.Error(fmt.Sprintf("Fallback treatments - Discarded flag: Invalid flag name (max %d chars, no spaces)", MaxFlagNameLength))
+			continue
+		}
+		if !isValidTreatment(&treatment) {
+			logger.Error(fmt.Sprintf("Fallback treatments - Discarded global fallback: Invalid treatment (max %d chars and comply with %s)", MaxTreatmentLength, TreatmentRegexp))
+			continue
+		}
+		sanitized[flagName] = dtos.FallbackTreatment{
+			Treatment: treatment.Treatment,
+			Config:    treatment.Config,
+		}
+	}
+	return sanitized
+}
+
+func isValidFlagName(flagName *string) bool {
+	if flagName == nil {
+		return false
+	}
+	return len(*flagName) <= MaxFlagNameLength && !strings.Contains(*flagName, " ")
+}