add support for batch UPS for decideAll & decideForKeys

pkg/client/client.go

@@ -104,6 +104,7 @@ type OptimizelyClient struct {
 	ctx                  context.Context
 	ConfigManager        config.ProjectConfigManager
 	DecisionService      decision.Service
+	UserProfileService   decision.UserProfileService
 	EventProcessor       event.Processor
 	OdpManager           odp.Manager
 	notificationCenter   notification.Center
@@ -153,6 +154,7 @@ func (o *OptimizelyClient) decide(userContext OptimizelyUserContext, key string,
 
 	decisionContext := decision.FeatureDecisionContext{
 		ForcedDecisionService: userContext.forcedDecisionService,
+		UserProfile:           userContext.userProfile,
 	}
 	projectConfig, err := o.getProjectConfig()
 	if err != nil {
@@ -268,15 +270,33 @@ func (o *OptimizelyClient) decideForKeys(userContext OptimizelyUserContext, keys
 	if len(keys) == 0 {
 		return decisionMap
 	}
+	allOptions := o.getAllOptions(options)
+
+	var userProfile *decision.UserProfile
+	userProfileLen := 0
+	ignoreUserProfileSvc := o.UserProfileService == nil || allOptions.IgnoreUserProfileService
+	if !ignoreUserProfileSvc {
+		up := o.UserProfileService.Lookup(userContext.GetUserID())
+		userProfile = &up
+		userContext.userProfile = userProfile
+		userProfileLen = len(userProfile.ExperimentBucketMap)
+	}
 
-	enabledFlagsOnly := o.getAllOptions(options).EnabledFlagsOnly
+	enabledFlagsOnly := allOptions.EnabledFlagsOnly
 	for _, key := range keys {
 		optimizelyDecision := o.decide(userContext, key, options)
 		if !enabledFlagsOnly || optimizelyDecision.Enabled {
 			decisionMap[key] = optimizelyDecision
 		}
 	}
 
+	if !ignoreUserProfileSvc {
+		isUserProfileUpdated := userProfile != nil && len(userProfile.ExperimentBucketMap) != userProfileLen
+		if isUserProfileUpdated {
+			o.UserProfileService.Save(*userProfile)
+		}
+	}
+
 	return decisionMap
 }
 

pkg/client/factory.go

@@ -145,6 +145,10 @@ func (f *OptimizelyFactory) Client(clientOptions ...OptionFunc) (*OptimizelyClie
 		appClient.EventProcessor = event.NewBatchEventProcessor(eventProcessorOptions...)
 	}
 
+	if f.userProfileService != nil {
+		appClient.UserProfileService = f.userProfileService
+	}
+
 	if f.decisionService != nil {
 		appClient.DecisionService = f.decisionService
 	} else {

pkg/client/optimizely_user_context.go

@@ -35,6 +35,7 @@ type OptimizelyUserContext struct {
 	qualifiedSegments     []string
 	optimizely            *OptimizelyClient
 	forcedDecisionService *pkgDecision.ForcedDecisionService
+	userProfile           *pkgDecision.UserProfile
 	mutex                 *sync.RWMutex
 }
 
@@ -130,7 +131,11 @@ func (o *OptimizelyUserContext) IsQualifiedFor(segment string) bool {
 func (o *OptimizelyUserContext) Decide(key string, options []decide.OptimizelyDecideOptions) OptimizelyDecision {
 	// use a copy of the user context so that any changes to the original context are not reflected inside the decision
 	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.getForcedDecisionService(), o.GetQualifiedSegments())
-	return o.optimizely.decide(userContextCopy, key, convertDecideOptions(options))
+	decision, found := o.optimizely.decideForKeys(userContextCopy, []string{key}, convertDecideOptions(options))[key]
+	if !found {
+		return NewErrorDecision(key, *o, decide.GetDecideError(decide.SDKNotReady))
+	}
+	return decision
 }
 
 // DecideAll returns a key-map of decision results for all active flag keys with options.

pkg/decision/entities.go

@@ -27,6 +27,7 @@ import (
 type ExperimentDecisionContext struct {
 	Experiment    *entities.Experiment
 	ProjectConfig config.ProjectConfig
+	UserProfile   *UserProfile
 }
 
 // FeatureDecisionContext contains the information needed to be able to make a decision for a given feature
@@ -35,6 +36,7 @@ type FeatureDecisionContext struct {
 	ProjectConfig         config.ProjectConfig
 	Variable              entities.Variable
 	ForcedDecisionService *ForcedDecisionService
+	UserProfile           *UserProfile
 }
 
 // UnsafeFeatureDecisionInfo represents response for GetDetailedFeatureDecisionUnsafe api

pkg/decision/feature_experiment_service.go

@@ -64,6 +64,7 @@ func (f FeatureExperimentService) GetDecision(decisionContext FeatureDecisionCon
 		experimentDecisionContext := ExperimentDecisionContext{
 			Experiment:    &experiment,
 			ProjectConfig: decisionContext.ProjectConfig,
+			UserProfile:   decisionContext.UserProfile,
 		}
 
 		experimentDecision, decisionReasons, err := f.compositeExperimentService.GetDecision(experimentDecisionContext, userContext, options)

pkg/decision/persisting_experiment_service.go

@@ -52,7 +52,7 @@ func (p PersistingExperimentService) GetDecision(decisionContext ExperimentDecis
 		return p.experimentBucketedService.GetDecision(decisionContext, userContext, options)
 	}
 
-	var userProfile UserProfile
+	var userProfile *UserProfile
 	var decisionReasons decide.DecisionReasons
 	// check to see if there is a saved decision for the user
 	experimentDecision, userProfile, decisionReasons = p.getSavedDecision(decisionContext, userContext, options)
@@ -66,16 +66,20 @@ func (p PersistingExperimentService) GetDecision(decisionContext ExperimentDecis
 	if experimentDecision.Variation != nil {
 		// save decision if a user profile service is provided
 		userProfile.ID = userContext.ID
-		p.saveDecision(userProfile, decisionContext.Experiment, experimentDecision)
+		p.saveDecision(userProfile, decisionContext, experimentDecision)
 	}
 
 	return experimentDecision, reasons, err
 }
 
-func (p PersistingExperimentService) getSavedDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext, options *decide.Options) (ExperimentDecision, UserProfile, decide.DecisionReasons) {
+func (p PersistingExperimentService) getSavedDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext, options *decide.Options) (ExperimentDecision, *UserProfile, decide.DecisionReasons) {
 	reasons := decide.NewDecisionReasons(options)
 	experimentDecision := ExperimentDecision{}
-	userProfile := p.userProfileService.Lookup(userContext.ID)
+	userProfile := decisionContext.UserProfile
+	if userProfile == nil {
+		up := p.userProfileService.Lookup(userContext.ID)
+		userProfile = &up
+	}
 
 	// look up experiment decision from user profile
 	decisionKey := NewUserDecisionKey(decisionContext.Experiment.ID)
@@ -97,14 +101,16 @@ func (p PersistingExperimentService) getSavedDecision(decisionContext Experiment
 	return experimentDecision, userProfile, reasons
 }
 
-func (p PersistingExperimentService) saveDecision(userProfile UserProfile, experiment *entities.Experiment, decision ExperimentDecision) {
+func (p PersistingExperimentService) saveDecision(userProfile *UserProfile, decisionContext ExperimentDecisionContext, decision ExperimentDecision) {
 	if p.userProfileService != nil {
-		decisionKey := NewUserDecisionKey(experiment.ID)
+		decisionKey := NewUserDecisionKey(decisionContext.Experiment.ID)
 		if userProfile.ExperimentBucketMap == nil {
 			userProfile.ExperimentBucketMap = map[UserDecisionKey]string{}
 		}
 		userProfile.ExperimentBucketMap[decisionKey] = decision.Variation.ID
-		p.userProfileService.Save(userProfile)
+		if decisionContext.UserProfile == nil {
+			p.userProfileService.Save(*userProfile)
+		}
 		p.logger.Debug(fmt.Sprintf(`Decision saved for user %q.`, userProfile.ID))
 	}
 }