wip: holdout bucketing logic added

Author: muzahidul-opti

Sources/Data Model/FeatureFlag.swift

@@ -35,8 +35,6 @@ struct FeatureFlag: Codable, Equatable, OptimizelyFeature {
         case variables
     }
 
-//    var holdoutIds: [String] = []
-    
     // MARK: - OptimizelyConfig
 
     var experimentsMap: [String: OptimizelyExperiment] = [:]

Sources/Data Model/HoldoutConfig.swift

@@ -115,4 +115,3 @@ struct HoldoutConfig {
         return holdoutIdMap[id]
     }
 }
-

Sources/Implementation/DecisionInfo.swift

@@ -22,7 +22,7 @@ struct DecisionInfo {
     let decisionType: Constants.DecisionType
 
     /// The experiment that the decision variation belongs to.
-    var experiment: Experiment?
+    var experiment: ExperimentCore?
 
     /// The variation selected by the decision.
     var variation: Variation?
@@ -58,7 +58,7 @@ struct DecisionInfo {
     var decisionEventDispatched: Bool
 
     init(decisionType: Constants.DecisionType,
-         experiment: Experiment? = nil,
+         experiment: ExperimentCore? = nil,
          variation: Variation? = nil,
          source: String? = nil,
          feature: FeatureFlag? = nil,

Sources/Implementation/DefaultBucketer.swift

@@ -120,7 +120,7 @@ class DefaultBucketer: OPTBucketer {
         return DecisionResponse(result: nil, reasons: reasons)
     }
 
-    func bucketToVariation(experiment: Experiment,
+    func bucketToVariation(experiment: ExperimentCore,
                            bucketingId: String) -> DecisionResponse<Variation> {
         let reasons = DecisionReasons()
 

Sources/Implementation/DefaultDecisionService.swift

@@ -17,7 +17,7 @@
 import Foundation
 
 struct FeatureDecision {
-    var experiment: Experiment?
+    var experiment: ExperimentCore?
     let variation: Variation
     let source: String
 }
@@ -158,7 +158,7 @@ class DefaultDecisionService: OPTDecisionService {
     }
 
     func doesMeetAudienceConditions(config: ProjectConfig,
-                                    experiment: Experiment,
+                                    experiment: ExperimentCore,
                                     user: OptimizelyUserContext,
                                     logType: Constants.EvaluationLogType = .experiment,
                                     loggingKey: String? = nil) -> DecisionResponse<Bool> {
@@ -273,13 +273,24 @@ class DefaultDecisionService: OPTDecisionService {
         return decisions
     }
 
-    
     func getVariationForFeatureExperiment(config: ProjectConfig,
                                           featureFlag: FeatureFlag,
                                           user: OptimizelyUserContext,
                                           userProfileTracker: UserProfileTracker? = nil,
                                           options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<FeatureDecision> {
         let reasons = DecisionReasons(options: options)
+        let holdouts = config.getHoldoutForFlag(id: featureFlag.id)
+        for holdout in holdouts {
+            let dicisionResponse = getVariationForHoldout(config: config,
+                                                          flagKey: featureFlag.key,
+                                                          holdout: holdout,
+                                                          user: user)
+            reasons.merge(dicisionResponse.reasons)
+            if let variation = dicisionResponse.result {
+                let featureDicision = FeatureDecision(experiment: holdout, variation: variation, source: Constants.DecisionSource.holdout.rawValue)
+                return DecisionResponse(result: featureDicision, reasons: reasons)
+            }
+        }
 
         let experimentIds = featureFlag.experimentIds
         if experimentIds.isEmpty {
@@ -363,6 +374,61 @@ class DefaultDecisionService: OPTDecisionService {
         return DecisionResponse(result: nil, reasons: reasons)
     }
 
+    func getVariationForHoldout(config: ProjectConfig,
+                                flagKey: String,
+                                holdout: Holdout,
+                                user: OptimizelyUserContext,
+                                options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<Variation> {
+        guard holdout.isActivated else {
+            return DecisionResponse(result: nil, reasons: DecisionReasons(options: options))
+        }
+        
+        let userId = user.userId
+        let attributes = user.attributes
+        let reasons = DecisionReasons(options: options)
+        
+        // ---- check if the user passes audience targeting before bucketing ----
+        let audienceResponse = doesMeetAudienceConditions(config: config,
+                                                          experiment: holdout,
+                                                          user: user)
+        
+        reasons.merge(audienceResponse.reasons)
+    
+        // Acquire bucketingId .
+        let bucketingId = getBucketingId(userId: userId, attributes: attributes)
+        var bucketedVariation: Variation?
+        
+        if audienceResponse.result ?? false {
+            let info = LogMessage.userMeetsConditionsForHoldout(userId, holdout.key)
+            logger.i(info)
+            reasons.addInfo(info)
+            
+            // bucket user into holdout variation
+            let decisionResponse = bucketer.bucketToVariation(experiment: holdout, bucketingId: bucketingId)
+            
+            reasons.merge(decisionResponse.reasons)
+            
+            bucketedVariation = decisionResponse.result
+            
+            if let variation = bucketedVariation {
+                let info = LogMessage.userBucketedIntoVariationInHoldout(userId, holdout.key, variation.key)
+                logger.i(info)
+                reasons.addInfo(info)
+            } else {
+                let info = LogMessage.userNotBucketedIntoHoldoutVariation(userId)
+                logger.i(info)
+                reasons.addInfo(info)
+            }
+            
+        } else {
+            let info = LogMessage.userDoesntMeetConditionsForHoldout(userId, holdout.key)
+            logger.i(info)
+            reasons.addInfo(info)
+        }
+        
+        return DecisionResponse(result: bucketedVariation, reasons: reasons)
+    }
+    
     func getVariationFromExperimentRule(config: ProjectConfig,
                                         flagKey: String,
                                         rule: Experiment,

Sources/Implementation/Events/BatchEventBuilder.swift

@@ -22,7 +22,7 @@ class BatchEventBuilder {
     // MARK: - Impression Event
 
     static func createImpressionEvent(config: ProjectConfig,
-                                      experiment: Experiment?,
+                                      experiment: ExperimentCore?,
                                       variation: Variation?,
                                       userId: String,
                                       attributes: OptimizelyAttributes?,

Sources/Optimizely/OptimizelyClient.swift

@@ -804,7 +804,7 @@ extension OptimizelyClient {
         return (source == Constants.DecisionSource.featureTest.rawValue && decision?.variation != nil) || config.sendFlagDecisions
     }
 
-    func sendImpressionEvent(experiment: Experiment?,
+    func sendImpressionEvent(experiment: ExperimentCore?,
                              variation: Variation?,
                              userId: String,
                              attributes: OptimizelyAttributes? = nil,
@@ -892,7 +892,7 @@ extension OptimizelyClient {
 
 extension OptimizelyClient {
 
-    func sendActivateNotification(experiment: Experiment,
+    func sendActivateNotification(experiment: ExperimentCore,
                                   variation: Variation,
                                   userId: String,
                                   attributes: OptimizelyAttributes?,

Sources/Protocols/OPTBucketer.swift

@@ -36,6 +36,15 @@ protocol OPTBucketer {
     func bucketExperiment(config: ProjectConfig,
                           experiment: Experiment,
                           bucketingId: String) -> DecisionResponse<Variation>
+    
+    /**
+     Bucket a bucketingId into an experiment.
+     - Parameter experiment: The rule in which to bucket the bucketingId.
+     - Parameter bucketingId: The ID to bucket. This must be a non-null, non-empty string.
+     - Returns: The variation the bucketingId was bucketed into.
+     */
+    func bucketToVariation(experiment: ExperimentCore,
+                           bucketingId: String) -> DecisionResponse<Variation>
 
     /**
      Hash the bucketing ID and map it to the range [0, 10000).

Sources/Utils/Constants.swift

@@ -57,6 +57,7 @@ struct Constants {
         case experiment = "experiment"
         case featureTest = "feature-test"
         case rollout = "rollout"
+        case holdout = "holdout"
     }
 
     struct DecisionInfoKeys {

Sources/Utils/LogMessage.swift

@@ -18,6 +18,7 @@ import Foundation
 
 enum LogMessage {
     case experimentNotRunning(_ key: String)
+    case holdoutNotRunning(_ key: String)
     case featureEnabledForUser(_ key: String, _ userId: String)
     case featureNotEnabledForUser(_ key: String, _ userId: String)
     case featureHasNoExperiments(_ key: String)
@@ -34,7 +35,9 @@ enum LogMessage {
     case userAssignedToBucketValue(_ bucket: Int, _ userId: String)
     case userMappedToForcedVariation(_ userId: String, _ expId: String, _ varId: String)
     case userMeetsConditionsForTargetingRule(_ userId: String, _ rule: String)
+    case userMeetsConditionsForHoldout(_ userId: String, _ holdoutKey: String)
     case userDoesntMeetConditionsForTargetingRule(_ userId: String, _ rule: String)
+    case userDoesntMeetConditionsForHoldout(_ userId: String, _ holdoutKey: String)
     case userBucketedIntoTargetingRule(_ userId: String, _ rule: String)
     case userNotBucketedIntoTargetingRule(_ userId: String, _ rule: String)
     case userHasForcedDecision(_ userId: String, _ flagKey: String, _ ruleKey: String?, _ varKey: String)
@@ -44,8 +47,10 @@ enum LogMessage {
     case userHasNoForcedVariation(_ userId: String)
     case userHasNoForcedVariationForExperiment(_ userId: String, _ expKey: String)
     case userBucketedIntoVariationInExperiment(_ userId: String, _ expKey: String, _ varKey: String)
+    case userBucketedIntoVariationInHoldout(_ userId: String, _ expKey: String, _ varKey: String)
     case userNotBucketedIntoVariation(_ userId: String)
     case userBucketedIntoInvalidVariation(_ id: String)
+    case userNotBucketedIntoHoldoutVariation(_ userId: String)
     case userBucketedIntoExperimentInGroup(_ userId: String, _ expKey: String, _ group: String)
     case userNotBucketedIntoExperimentInGroup(_ userId: String, _ expKey: String, _ group: String)
     case userNotBucketedIntoAnyExperimentInGroup(_ userId: String, _ group: String)
@@ -76,6 +81,7 @@ extension LogMessage: CustomStringConvertible {
 
         switch self {
         case .experimentNotRunning(let key):                                    message = "Experiment (\(key)) is not running."
+        case .holdoutNotRunning(let key):                                       message = "Holdout (\(key)) is not running."
         case .featureEnabledForUser(let key, let userId):                       message = "Feature (\(key)) is enabled for user (\(userId))."
         case .featureNotEnabledForUser(let key, let userId):                    message = "Feature (\(key)) is not enabled for user (\(userId))."
         case .featureHasNoExperiments(let key):                                 message = "Feature (\(key)) is not attached to any experiments."
@@ -91,10 +97,12 @@ extension LogMessage: CustomStringConvertible {
         case .savedVariationInUserProfile(let varId, let expId, let userId):    message = "Saved variation (\(varId)) of experiment (\(expId)) for user (\(userId))."
         case .userAssignedToBucketValue(let bucket, let userId):                message = "Assigned bucket (\(bucket)) to user with bucketing ID (\(userId))."
         case .userMappedToForcedVariation(let userId, let expId, let varId):    message = "Set variation (\(varId)) for experiment (\(expId)) and user (\(userId)) in the forced variation map."
-        case .userMeetsConditionsForTargetingRule(let userId, let rule):       message = "User (\(userId)) meets conditions for targeting rule (\(rule))."
-        case .userDoesntMeetConditionsForTargetingRule(let userId, let rule):  message = "User (\(userId)) does not meet conditions for targeting rule (\(rule))."
-        case .userBucketedIntoTargetingRule(let userId, let rule):             message = "User (\(userId)) is in the traffic group of targeting rule (\(rule))."
-        case .userNotBucketedIntoTargetingRule(let userId, let rule):          message = "User (\(userId)) is not in the traffic group for targeting rule (\(rule)). Checking (Everyone Else) rule now."
+        case .userMeetsConditionsForTargetingRule(let userId, let rule):        message = "User (\(userId)) meets conditions for targeting rule (\(rule))."
+        case .userMeetsConditionsForHoldout(let userId, let holdoutKey):        message = "User (\(userId)) meets conditions for holdout(\(holdoutKey))."
+        case .userDoesntMeetConditionsForTargetingRule(let userId, let rule):   message = "User (\(userId)) does not meet conditions for targeting rule (\(rule))."
+        case .userDoesntMeetConditionsForHoldout(let userId, let holdoutKey):   message = "User (\(userId)) does not meet conditions for holdout (\(holdoutKey))."
+        case .userBucketedIntoTargetingRule(let userId, let rule):              message = "User (\(userId)) is in the traffic group of targeting rule (\(rule))."
+        case .userNotBucketedIntoTargetingRule(let userId, let rule):           message = "User (\(userId)) is not in the traffic group for targeting rule (\(rule)). Checking (Everyone Else) rule now."
         case .userHasForcedDecision(let userId, let flagKey, let ruleKey, let varKey):
             let target = (ruleKey != nil) ? "flag (\(flagKey)), rule (\(ruleKey!))" : "flag (\(flagKey))"
             message = "Variation (\(varKey)) is mapped to \(target) and user (\(userId)) in the forced decision map."
@@ -106,7 +114,9 @@ extension LogMessage: CustomStringConvertible {
         case .userHasNoForcedVariation(let userId):                             message = "User (\(userId)) is not in the forced variation map."
         case .userHasNoForcedVariationForExperiment(let userId, let expKey):    message = "No experiment (\(expKey)) mapped to user (\(userId)) in the forced variation map."
         case .userBucketedIntoVariationInExperiment(let userId, let expKey, let varKey): message = "User (\(userId)) is in variation (\(varKey)) of experiment (\(expKey))"
+        case .userBucketedIntoVariationInHoldout(let userId, let holdoutKey, let varKey): message = "User (\(userId)) is in variation (\(varKey)) of holdout (\(holdoutKey))"
         case .userNotBucketedIntoVariation(let userId):                         message = "User (\(userId)) is in no variation."
+        case .userNotBucketedIntoHoldoutVariation(let userId):                  message = "User (\(userId)) is in no holdout variation."
         case .userBucketedIntoInvalidVariation(let id):                         message = "Bucketed into an invalid variation id (\(id))"
         case .userBucketedIntoExperimentInGroup(let userId, let expId, let group): message = "User (\(userId)) is in experiment (\(expId)) of group (\(group))."
         case .userNotBucketedIntoExperimentInGroup(let userId, let expKey, let group): message = "User (\(userId)) is not in experiment (\(expKey)) of group (\(group))."