[FSSDK-11589] Add go-sdk logic to support agent for cmab

pkg/client/client.go

@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright 2019-2024, Optimizely, Inc. and contributors                   *
+ * Copyright 2019-2025, Optimizely, Inc. and contributors                   *
  *                                                                          *
  * Licensed under the Apache License, Version 2.0 (the "License");          *
  * you may not use this file except in compliance with the License.         *
@@ -28,6 +28,7 @@ import (
 
 	"github.com/hashicorp/go-multierror"
 
+	"github.com/optimizely/go-sdk/v2/pkg/cmab"
 	"github.com/optimizely/go-sdk/v2/pkg/config"
 	"github.com/optimizely/go-sdk/v2/pkg/decide"
 	"github.com/optimizely/go-sdk/v2/pkg/decision"
@@ -112,6 +113,7 @@ type OptimizelyClient struct {
 	logger               logging.OptimizelyLogProducer
 	defaultDecideOptions *decide.Options
 	tracer               tracing.Tracer
+	cmabService          cmab.Service
 }
 
 // CreateUserContext creates a context of the user for which decision APIs will be called.
@@ -173,75 +175,143 @@ func (o *OptimizelyClient) decide(userContext *OptimizelyUserContext, key string
 		Attributes:        userContext.GetUserAttributes(),
 		QualifiedSegments: userContext.GetQualifiedSegments(),
 	}
-	var variationKey string
-	var eventSent, flagEnabled bool
+
 	allOptions := o.getAllOptions(options)
 	decisionReasons := decide.NewDecisionReasons(&allOptions)
 	decisionContext.Variable = entities.Variable{}
 	var featureDecision decision.FeatureDecision
-	var reasons decide.DecisionReasons
-	var experimentID string
-	var variationID string
-
-	// To avoid cyclo-complexity warning
-	findRegularDecision := func() {
-		// regular decision
-		featureDecision, reasons, err = o.DecisionService.GetFeatureDecision(decisionContext, usrContext, &allOptions)
-		decisionReasons.Append(reasons)
-	}
+	var decisionReasonsList decide.DecisionReasons // Fix shadowing - renamed from "reasons"
+
+	// Try CMAB decision first
+	useCMAB := o.tryGetCMABDecision(feature, projectConfig, usrContext, &allOptions, decisionReasons, &featureDecision)
+
+	// Fall back to other decision types if CMAB didn't work
+	if !useCMAB {
+		// To avoid cyclo-complexity warning - forced decision logic
+		findForcedDecision := func() bool {
+			if userContext.forcedDecisionService != nil {
+				var variation *entities.Variation
+				var forcedErr error
+				variation, decisionReasonsList, forcedErr = userContext.forcedDecisionService.FindValidatedForcedDecision(projectConfig, decision.OptimizelyDecisionContext{FlagKey: key, RuleKey: ""}, &allOptions) // Fix shadowing by using assignment instead of declaration
+				decisionReasons.Append(decisionReasonsList)
+				if forcedErr != nil {
+					return false
+				}
+				featureDecision = decision.FeatureDecision{Decision: decision.Decision{Reason: pkgReasons.ForcedDecisionFound}, Variation: variation, Source: decision.FeatureTest}
+				return true
+			}
+			return false
+		}
 
-	// check forced-decisions first
-	// Passing empty rule-key because checking mapping with flagKey only
-	if userContext.forcedDecisionService != nil {
-		var variation *entities.Variation
-		variation, reasons, err = userContext.forcedDecisionService.FindValidatedForcedDecision(projectConfig, decision.OptimizelyDecisionContext{FlagKey: key, RuleKey: ""}, &allOptions)
-		decisionReasons.Append(reasons)
-		if err != nil {
+		// To avoid cyclo-complexity warning - regular decision logic
+		findRegularDecision := func() {
+			// regular decision
+			featureDecision, decisionReasonsList, err = o.DecisionService.GetFeatureDecision(decisionContext, usrContext, &allOptions)
+			decisionReasons.Append(decisionReasonsList)
+		}
+
+		if !findForcedDecision() {
 			findRegularDecision()
-		} else {
-			featureDecision = decision.FeatureDecision{Decision: decision.Decision{Reason: pkgReasons.ForcedDecisionFound}, Variation: variation, Source: decision.FeatureTest}
 		}
-	} else {
-		findRegularDecision()
 	}
 
 	if err != nil {
 		return o.handleDecisionServiceError(err, key, *userContext)
 	}
 
+	return o.buildDecisionResponse(featureDecision, feature, key, userContext, &allOptions, decisionReasons, decisionContext)
+}
+
+// tryGetCMABDecision attempts to get a CMAB decision for the feature
+func (o *OptimizelyClient) tryGetCMABDecision(feature entities.Feature, projectConfig config.ProjectConfig, usrContext entities.UserContext, options *decide.Options, decisionReasons decide.DecisionReasons, featureDecision *decision.FeatureDecision) bool {
+	if o.cmabService == nil {
+		return false
+	}
+
+	for _, experimentID := range feature.ExperimentIDs {
+		experiment, expErr := projectConfig.GetExperimentByID(experimentID) // Fix shadowing
+
+		// Handle CMAB error properly - check for errors BEFORE using the experiment
+		if expErr == nil && experiment.Cmab != nil {
+			cmabDecision, cmabErr := o.cmabService.GetDecision(projectConfig, usrContext, experiment.ID, options)
+
+			// Handle CMAB service errors gracefully - log and continue to next experiment
+			if cmabErr != nil {
+				o.logger.Warning(fmt.Sprintf("CMAB decision failed for experiment %s: %v", experiment.ID, cmabErr))
+				continue
+			}
+
+			// Validate CMAB response - ensure variation exists before using it
+			if selectedVariation, exists := experiment.Variations[cmabDecision.VariationID]; exists {
+				*featureDecision = decision.FeatureDecision{
+					Decision:   decision.Decision{Reason: "CMAB decision"},
+					Variation:  &selectedVariation,
+					Experiment: experiment,
+					Source:     decision.FeatureTest,
+					CmabUUID:   &cmabDecision.CmabUUID, // Include CMAB UUID for tracking
+				}
+				decisionReasons.AddInfo("Used CMAB service for decision")
+				return true
+			}
+			// Log invalid variation ID returned by CMAB service
+			o.logger.Warning(fmt.Sprintf("CMAB returned invalid variation ID %s for experiment %s", cmabDecision.VariationID, experiment.ID))
+		}
+	}
+	return false
+}
+
+// buildDecisionResponse constructs the final OptimizelyDecision response
+func (o *OptimizelyClient) buildDecisionResponse(featureDecision decision.FeatureDecision, feature entities.Feature, key string, userContext *OptimizelyUserContext, options *decide.Options, decisionReasons decide.DecisionReasons, decisionContext decision.FeatureDecisionContext) OptimizelyDecision {
+	var variationKey string
+	var eventSent, flagEnabled bool
+	var experimentID, variationID string
+
 	if featureDecision.Variation != nil {
 		variationKey = featureDecision.Variation.Key
 		flagEnabled = featureDecision.Variation.FeatureEnabled
 		experimentID = featureDecision.Experiment.ID
 		variationID = featureDecision.Variation.ID
 	}
 
-	if !allOptions.DisableDecisionEvent {
+	usrContext := entities.UserContext{
+		ID:                userContext.GetUserID(),
+		Attributes:        userContext.GetUserAttributes(),
+		QualifiedSegments: userContext.GetQualifiedSegments(),
+	}
+
+	// Send impression event
+	if !options.DisableDecisionEvent {
 		if ue, ok := event.CreateImpressionUserEvent(decisionContext.ProjectConfig, featureDecision.Experiment,
 			featureDecision.Variation, usrContext, key, featureDecision.Experiment.Key, featureDecision.Source, flagEnabled, featureDecision.CmabUUID); ok {
 			o.EventProcessor.ProcessEvent(ue)
 			eventSent = true
 		}
 	}
 
+	// Get variable map
 	variableMap := map[string]interface{}{}
-	if !allOptions.ExcludeVariables {
+	if !options.ExcludeVariables {
+		var reasons decide.DecisionReasons
 		variableMap, reasons = o.getDecisionVariableMap(feature, featureDecision.Variation, flagEnabled)
 		decisionReasons.Append(reasons)
 	}
-	optimizelyJSON := optimizelyjson.NewOptimizelyJSONfromMap(variableMap)
-	reasonsToReport := decisionReasons.ToReport()
-	ruleKey := featureDecision.Experiment.Key
 
+	// Send notification
 	if o.notificationCenter != nil {
+		reasonsToReport := decisionReasons.ToReport()
+		ruleKey := featureDecision.Experiment.Key
 		decisionNotification := decision.FlagNotification(key, variationKey, ruleKey, experimentID, variationID, flagEnabled, eventSent, usrContext, variableMap, reasonsToReport)
 		o.logger.Debug(fmt.Sprintf(`Feature %q is enabled for user %q? %v`, key, usrContext.ID, flagEnabled))
 		if e := o.notificationCenter.Send(notification.Decision, *decisionNotification); e != nil {
 			o.logger.Warning("Problem with sending notification")
 		}
 	}
 
-	return NewOptimizelyDecision(variationKey, ruleKey, key, flagEnabled, optimizelyJSON, *userContext, reasonsToReport)
+	optimizelyJSON := optimizelyjson.NewOptimizelyJSONfromMap(variableMap)
+	reasonsToReport := decisionReasons.ToReport()
+	ruleKey := featureDecision.Experiment.Key
+
+	return NewOptimizelyDecision(variationKey, ruleKey, key, flagEnabled, optimizelyJSON, *userContext, reasonsToReport, featureDecision.CmabUUID)
 }
 
 func (o *OptimizelyClient) decideForKeys(userContext OptimizelyUserContext, keys []string, options *decide.Options) map[string]OptimizelyDecision {
@@ -469,7 +539,7 @@ func (o *OptimizelyClient) Activate(experimentKey string, userContext entities.U
 }
 
 // IsFeatureEnabled returns true if the feature is enabled for the given user. If the user is part of a feature test
-// then an impression event will be queued up to be sent to the Optimizely log endpoint for results processing.
+// then an impression event will be queued up to the Optimizely log endpoint for results processing.
 func (o *OptimizelyClient) IsFeatureEnabled(featureKey string, userContext entities.UserContext) (result bool, err error) {
 
 	defer func() {
@@ -1072,7 +1142,7 @@ func (o *OptimizelyClient) getFeatureDecision(featureKey, variableKey string, us
 	featureDecision, _, err = o.DecisionService.GetFeatureDecision(decisionContext, userContext, options)
 	if err != nil {
 		o.logger.Warning(fmt.Sprintf(`Received error while making a decision for feature %q: %s`, featureKey, err))
-		return decisionContext, featureDecision, nil
+		return decisionContext, featureDecision, err
 	}
 
 	return decisionContext, featureDecision, nil
@@ -1264,5 +1334,6 @@ func (o *OptimizelyClient) handleDecisionServiceError(err error, key string, use
 		Enabled:      false,
 		Variables:    optimizelyjson.NewOptimizelyJSONfromMap(map[string]interface{}{}),
 		Reasons:      []string{err.Error()},
+		CmabUUID:     nil,
 	}
 }