2528

Committed 16 Aug 2021 09:43PM UTC coverage: 95.652%. First build

Build # 2528

Build Type

Pull #431

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/optimizely/swift-sdk/commit/<a class=hub.com/optimizely/swift-sdk/commit/b6994ad6c960ea45706b8497ff794b6d7bc1d021">b6994ad6c<a href="https://github.com/optimizely/swift-sdk/commit/b6994ad6c960ea45706b8497ff794b6d7bc1d021">">Merge </a><a class="double-link" href="https://github.com/optimizely/swift-sdk/commit/<a class="double-link" href="https://github.com/optimizely/swift-sdk/commit/447d4655f46e85af9905cd939d15e860fa6b80a4">447d4655f</a>">447d4655f</a><a href="https://github.com/optimizely/swift-sdk/commit/b6994ad6c960ea45706b8497ff794b6d7bc1d021"> into e7680cdf2">e7680cdf2</a>

Pull Request Pull Request #431: feat(ForcedDecisions): add forced-decisions APIs to OptimizelyUserContext

Run Details

20 of 20 new or added lines in 5 files covered. (100.0%)

594 of 621 relevant lines covered (95.65%)

7099.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.78

/Sources/Implementation/DefaultDecisionService.swift

//
// Copyright 2019-2021, 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.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

import Foundation

struct FeatureDecision {
    var experiment: Experiment?
    let variation: Variation
    let source: String
}

class DefaultDecisionService: OPTDecisionService {
    
    let bucketer: OPTBucketer
    let userProfileService: OPTUserProfileService
    
    // thread-safe lazy logger load (after HandlerRegisterService ready)
    private var loggerInstance: OPTLogger?
    var logger: OPTLogger {
        return OPTLoggerFactory.getLoggerThreadSafe(&loggerInstance)
    }
    
    // user-profile-service read-modify-write lock for supporting multiple clients
    static let upsRMWLock = DispatchQueue(label: "ups-rmw")
    
    init(userProfileService: OPTUserProfileService) {
        self.bucketer = DefaultBucketer()
        self.userProfileService = userProfileService
    }
    
    func getVariation(config: ProjectConfig,
                      experiment: Experiment,
                      user: OptimizelyUserContext,
                      options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<Variation> {
        let reasons = DecisionReasons(options: options)
        
        let userId = user.userId
        let attributes = user.attributes
        let experimentId = experiment.id
        
        // Acquire bucketingId .
        let bucketingId = getBucketingId(userId: userId, attributes: attributes)
        
        // ---- check if the experiment is running ----
        if !experiment.isActivated {
            let info = LogMessage.experimentNotRunning(experiment.key)
            logger.i(info)
            reasons.addInfo(info)
            return DecisionResponse(result: nil, reasons: reasons)
        }
        
        // ---- check if the user is forced into a variation ----
        let decisionResponse = config.getForcedVariation(experimentKey: experiment.key, userId: userId)
        reasons.merge(decisionResponse.reasons)
        if let variationId = decisionResponse.result?.id,
           let variation = experiment.getVariation(id: variationId) {
            return DecisionResponse(result: variation, reasons: reasons)
        }
        
        // ---- check to see if user is white-listed for a certain variation ----
        if let variationKey = experiment.forcedVariations[userId] {
            if let variation = experiment.getVariation(key: variationKey) {
                let info = LogMessage.forcedVariationFound(variationKey, userId)
                logger.i(info)
                reasons.addInfo(info)
                return DecisionResponse(result: variation, reasons: reasons)
            }
            
            // mapped to invalid variation - ignore and continue for other deciesions
            let info = LogMessage.forcedVariationFoundButInvalid(variationKey, userId)
            logger.e(info)
            reasons.addInfo(info)
        }
        
        // ---- check if a valid variation is stored in the user profile ----
        let ignoreUPS = (options ?? []).contains(.ignoreUserProfileService)
        
        if !ignoreUPS,
           let variationId = getVariationIdFromProfile(userId: userId, experimentId: experimentId),
           let variation = experiment.getVariation(id: variationId) {
            
            let info = LogMessage.gotVariationFromUserProfile(variation.key, experiment.key, userId)
            logger.i(info)
            reasons.addInfo(info)
            return DecisionResponse(result: variation, reasons: reasons)
        }
        
        var bucketedVariation: Variation?
        // ---- check if the user passes audience targeting before bucketing ----
        let audienceResponse = doesMeetAudienceConditions(config: config,
                                                          experiment: experiment,
                                                          userId: userId,
                                                          attributes: attributes)
        reasons.merge(audienceResponse.reasons)
        if audienceResponse.result ?? false {
            // bucket user into a variation
            let decisionResponse = bucketer.bucketExperiment(config: config,
                                                             experiment: experiment,
                                                             bucketingId: bucketingId)
            reasons.merge(decisionResponse.reasons)
            bucketedVariation = decisionResponse.result
            
            if let variation = bucketedVariation {
                let info = LogMessage.userBucketedIntoVariationInExperiment(userId, experiment.key, variation.key)
                logger.i(info)
                reasons.addInfo(info)
                // save to user profile
                if !ignoreUPS {
                    self.saveProfile(userId: userId, experimentId: experimentId, variationId: variation.id)
                }
            } else {
                let info = LogMessage.userNotBucketedIntoVariation(userId)
                logger.i(info)
                reasons.addInfo(info)
            }
            
        } else {
            let info = LogMessage.userNotInExperiment(userId, experiment.key)
            logger.i(info)
            reasons.addInfo(info)
        }
        
        return DecisionResponse(result: bucketedVariation, reasons: reasons)
    }
    
    func doesMeetAudienceConditions(config: ProjectConfig,
                                    experiment: Experiment,
                                    userId: String,
                                    attributes: OptimizelyAttributes,
                                    logType: Constants.EvaluationLogType = .experiment,
                                    loggingKey: String? = nil) -> DecisionResponse<Bool> {
        let reasons = DecisionReasons()
        
        var result = true   // success as default (no condition, etc)
        let evType = logType.rawValue
        let finalLoggingKey = loggingKey ?? experiment.key
        
        do {
            if let conditions = experiment.audienceConditions {
                logger.d { () -> String in
                    return LogMessage.evaluatingAudiencesCombined(evType, finalLoggingKey, Utils.getConditionString(conditions: conditions)).description
                }
                switch conditions {
                case .array(let arrConditions):
                    if arrConditions.count > 0 {
                        result = try conditions.evaluate(project: config.project, attributes: attributes)
                    } else {
                        // empty conditions (backward compatibility with "audienceIds" is ignored if exists even though empty
                        result = true
                    }
                case .leaf:
                    result = try conditions.evaluate(project: config.project, attributes: attributes)
                default:
                    result = true
                }
            }
            // backward compatibility with audienceIds list
            else if experiment.audienceIds.count > 0 {
                var holder = [ConditionHolder]()
                holder.append(.logicalOp(.or))
                for id in experiment.audienceIds {
                    holder.append(.leaf(.audienceId(id)))
                }
                logger.d { () -> String in
                    return LogMessage.evaluatingAudiencesCombined(evType, finalLoggingKey, Utils.getConditionString(conditions: holder)).description
                }
                result = try holder.evaluate(project: config.project, attributes: attributes)
            }
        } catch {
            if let error = error as? OptimizelyError {
                logger.i(error)
                reasons.addInfo(error)
            }
            result = false
        }
        
        logger.i(.audienceEvaluationResultCombined(evType, finalLoggingKey, result.description))
        
        return DecisionResponse(result: result, reasons: reasons)
    }
    
    func getVariationForFeature(config: ProjectConfig,
                                featureFlag: FeatureFlag,
                                user: OptimizelyUserContext,
                                options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<FeatureDecision> {
        let reasons = DecisionReasons(options: options)
        
        // Evaluate in this order:
        
        // 1. Attempt to bucket user into experiment using feature flag.
        // Check if the feature flag is under an experiment and the the user is bucketed into one of these experiments
        var decisionResponse = getVariationForFeatureExperiment(config: config,
                                                                featureFlag: featureFlag,
                                                                user: user,
                                                                options: options)
        reasons.merge(decisionResponse.reasons)
        if let decision = decisionResponse.result {
            return DecisionResponse(result: decision, reasons: reasons)
        }
        
        // 2. Attempt to bucket user into rollout using the feature flag.
        // Check if the feature flag has rollout and the user is bucketed into one of it's rules
        decisionResponse = getVariationForFeatureRollout(config: config,
                                                         featureFlag: featureFlag,
                                                         user: user,
                                                         options: options)
        reasons.merge(decisionResponse.reasons)
        if let decision = decisionResponse.result {
            return DecisionResponse(result: decision, reasons: reasons)
        }
        
        return DecisionResponse(result: nil, reasons: reasons)
    }
    
    func getVariationForFeatureExperiment(config: ProjectConfig,
                                          featureFlag: FeatureFlag,
                                          user: OptimizelyUserContext,
                                          options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<FeatureDecision> {
        let reasons = DecisionReasons(options: options)
        
        let experimentIds = featureFlag.experimentIds
        if experimentIds.isEmpty {
            let info = LogMessage.featureHasNoExperiments(featureFlag.key)
            logger.d(info)
            reasons.addInfo(info)
        }
        
        // Check if there are any experiment IDs inside feature flag
        // Evaluate each experiment ID and return the first bucketed experiment variation
        for experimentId in experimentIds {
            if let experiment = config.getExperiment(id: experimentId) {
                let decisionResponse = getVariationFromExperimentRule(config: config,
                                                                      flagKey: featureFlag.key,
                                                                      rule: experiment,
                                                                      user: user,
                                                                      options: options)
                reasons.merge(decisionResponse.reasons)
                if let variation = decisionResponse.result {
                    let featureDecision = FeatureDecision(experiment: experiment, variation: variation, source: Constants.DecisionSource.featureTest.rawValue)
                    return DecisionResponse(result: featureDecision, reasons: reasons)
                }
            }
        }
        
        return DecisionResponse(result: nil, reasons: reasons)
    }
    
    func getVariationForFeatureRollout(config: ProjectConfig,
                                       featureFlag: FeatureFlag,
                                       user: OptimizelyUserContext,
                                       options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<FeatureDecision> {
        let reasons = DecisionReasons(options: options)
        
        let rolloutId = featureFlag.rolloutId.trimmingCharacters(in: CharacterSet.whitespaces)
        
        guard !rolloutId.isEmpty else {
            let info = LogMessage.noRolloutExists(featureFlag.key)
            logger.d(info)
            reasons.addInfo(info)
            return DecisionResponse(result: nil, reasons: reasons)
        }
        
        guard let rollout = config.getRollout(id: rolloutId) else {
            let info = OptimizelyError.rolloutIdInvalid(rolloutId, featureFlag.key)
            logger.d(info)
            reasons.addInfo(info)
            return DecisionResponse(result: nil, reasons: reasons)
        }
        
        let rolloutRules = rollout.experiments
        if rolloutRules.isEmpty {
            let info = LogMessage.rolloutHasNoExperiments(rolloutId)
            logger.e(info)
            reasons.addInfo(info)
            return DecisionResponse(result: nil, reasons: reasons)
        }
        
        var index = 0
        while index < rolloutRules.count {
            let decisionResponse = getVariationFromDeliveryRule(config: config,
                                                                flagKey: featureFlag.key,
                                                                rules: rolloutRules,
                                                                ruleIndex: index,
                                                                user: user,
                                                                options: options)
            reasons.merge(decisionResponse.reasons)
            let (variation, skipToEveryoneElse) = decisionResponse.result!
            
            if let variation = variation {
                let rule = rolloutRules[index]
                let featureDecision = FeatureDecision(experiment: rule, variation: variation, source: Constants.DecisionSource.rollout.rawValue)
                return DecisionResponse(result: featureDecision, reasons: reasons)
            }
            
            // the last rule is special for "Everyone Else"
            index = skipToEveryoneElse ? (rolloutRules.count - 1) : (index + 1)
        }
        
        return DecisionResponse(result: nil, reasons: reasons)
    }
    
    func getVariationFromExperimentRule(config: ProjectConfig,
                                        flagKey: String,
                                        rule: Experiment,
                                        user: OptimizelyUserContext,
                                        options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<Variation> {
        let reasons = DecisionReasons(options: options)
        
        // check forced-decision first
        
        let forcedDecisionResponse = user.findValidatedForcedDecision(flagKey: flagKey, ruleKey: rule.key, options: options)
        reasons.merge(forcedDecisionResponse.reasons)
        
        if let variation = forcedDecisionResponse.result {
            return DecisionResponse(result: variation, reasons: reasons)
        }
        
        // regular decision
        
        let decisionResponse = getVariation(config: config,
                                            experiment: rule,
                                            user: user,
                                            options: options)
        reasons.merge(decisionResponse.reasons)
        let variation = decisionResponse.result
        
        return DecisionResponse(result: variation, reasons: reasons)
    }
    
    func getVariationFromDeliveryRule(config: ProjectConfig,
                                      flagKey: String,
                                      rules: [Experiment],
                                      ruleIndex: Int,
                                      user: OptimizelyUserContext,
                                      options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<(Variation?, Bool)> {
        let reasons = DecisionReasons(options: options)
        var skipToEveryoneElse = false

        // check forced-decision first
        
        let rule = rules[ruleIndex]
        let forcedDecisionResponse = user.findValidatedForcedDecision(flagKey: flagKey, ruleKey: rule.key, options: options)
        reasons.merge(forcedDecisionResponse.reasons)
        
        if let variation = forcedDecisionResponse.result {
            return DecisionResponse(result: (variation, skipToEveryoneElse), reasons: reasons)
        }
        
        // regular decision
        
        let userId = user.userId
        let attributes = user.attributes
        let bucketingId = getBucketingId(userId: userId, attributes: attributes)
        
        let everyoneElse = (ruleIndex == rules.count - 1)
        let loggingKey = everyoneElse ? "Everyone Else" : String(ruleIndex + 1)
        
        var bucketedVariation: Variation?
        
        let audienceDecisionResponse = doesMeetAudienceConditions(config: config,
                                                                  experiment: rule,
                                                                  userId: userId,
                                                                  attributes: attributes,
                                                                  logType: .rolloutRule,
                                                                  loggingKey: loggingKey)
        reasons.merge(audienceDecisionResponse.reasons)
        if audienceDecisionResponse.result ?? false {
            var info = LogMessage.userMeetsConditionsForTargetingRule(userId, loggingKey)
            logger.d(info)
            reasons.addInfo(info)
            
            let decisionResponse = bucketer.bucketExperiment(config: config,
                                                             experiment: rule,
                                                             bucketingId: bucketingId)
            reasons.merge(decisionResponse.reasons)
            bucketedVariation = decisionResponse.result
            
            if bucketedVariation != nil {
                info = LogMessage.userBucketedIntoTargetingRule(userId, loggingKey)
                logger.d(info)
                reasons.addInfo(info)
            } else if !everyoneElse {
                // skip this logging for EveryoneElse since this has a message not for EveryoneElse
                info = LogMessage.userNotBucketedIntoTargetingRule(userId, loggingKey)
                logger.d(info)
                reasons.addInfo(info)
                
                // skip the rest of rollout rules to the everyone-else rule if audience matches but not bucketed.
                skipToEveryoneElse = true
            }
        } else {
            let info = LogMessage.userDoesntMeetConditionsForTargetingRule(userId, loggingKey)
            logger.d(info)
            reasons.addInfo(info)
        }
        
        return DecisionResponse(result: (bucketedVariation, skipToEveryoneElse), reasons: reasons)
    }
    
    func getBucketingId(userId: String, attributes: OptimizelyAttributes) -> String {
        
        // By default, the bucketing ID should be the user ID .
        var bucketingId = userId
        // If the bucketing ID key is defined in attributes, then use that
        // in place of the userID for the murmur hash key
        if let newBucketingId = attributes[Constants.Attributes.OptimizelyBucketIdAttribute] as? String {
            bucketingId = newBucketingId
        }
        
        return bucketingId
    }
    
}

// MARK: - UserProfileService Helpers

extension DefaultDecisionService {
    
    func getVariationIdFromProfile(userId: String,
                                   experimentId: String) -> String? {
        if let profile = userProfileService.lookup(userId: userId),
           let bucketMap = profile[UserProfileKeys.kBucketMap] as? OPTUserProfileService.UPBucketMap,
           let experimentMap = bucketMap[experimentId],
           let variationId = experimentMap[UserProfileKeys.kVariationId] {
            return variationId
        } else {
            return nil
        }
    }
    
    func saveProfile(userId: String,
                     experimentId: String,
                     variationId: String) {
        DefaultDecisionService.upsRMWLock.sync {
            var profile = self.userProfileService.lookup(userId: userId) ?? OPTUserProfileService.UPProfile()
            
            var bucketMap = profile[UserProfileKeys.kBucketMap] as? OPTUserProfileService.UPBucketMap ?? OPTUserProfileService.UPBucketMap()
            bucketMap[experimentId] = [UserProfileKeys.kVariationId: variationId]
            
            profile[UserProfileKeys.kBucketMap] = bucketMap
            profile[UserProfileKeys.kUserId] = userId
            
            self.userProfileService.save(userProfile: profile)
            
            self.logger.i(.savedVariationInUserProfile(variationId, experimentId, userId))
        }
    }
    
}

1	//
2	// Copyright 2019-2021, Optimizely, Inc. and contributors
3	//
4	// Licensed under the Apache License, Version 2.0 (the "License");
5	// you may not use this file except in compliance with the License.
6	// You may obtain a copy of the License at
7	//
8	// http://www.apache.org/licenses/LICENSE-2.0
9	//
10	// Unless required by applicable law or agreed to in writing, software
11	// distributed under the License is distributed on an "AS IS" BASIS,
12	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	// See the License for the specific language governing permissions and
14	// limitations under the License.
15	//
16
17	import Foundation
18
19	struct FeatureDecision {
20	var experiment: Experiment?
21	let variation: Variation
22	let source: String
23	}
24
25	class DefaultDecisionService: OPTDecisionService {
26
27	let bucketer: OPTBucketer
28	let userProfileService: OPTUserProfileService
29
30	// thread-safe lazy logger load (after HandlerRegisterService ready)
31	private var loggerInstance: OPTLogger?
32	var logger: OPTLogger {	16,344✔
33	return OPTLoggerFactory.getLoggerThreadSafe(&loggerInstance)
34	}
35
36	// user-profile-service read-modify-write lock for supporting multiple clients
37	static let upsRMWLock = DispatchQueue(label: "ups-rmw")
38
39	init(userProfileService: OPTUserProfileService) {	263✔
40	self.bucketer = DefaultBucketer()
41	self.userProfileService = userProfileService
42	}
43
44	func getVariation(config: ProjectConfig,
45	experiment: Experiment,
46	user: OptimizelyUserContext,
47	options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<Variation> {	3,556✔
48	let reasons = DecisionReasons(options: options)
49
50	let userId = user.userId
51	let attributes = user.attributes
52	let experimentId = experiment.id
53
54	// Acquire bucketingId .
55	let bucketingId = getBucketingId(userId: userId, attributes: attributes)
56
57	// ---- check if the experiment is running ----
58	if !experiment.isActivated {
59	let info = LogMessage.experimentNotRunning(experiment.key)
60	logger.i(info)
61	reasons.addInfo(info)
62	return DecisionResponse(result: nil, reasons: reasons)
63	}
64
65	// ---- check if the user is forced into a variation ----
66	let decisionResponse = config.getForcedVariation(experimentKey: experiment.key, userId: userId)
67	reasons.merge(decisionResponse.reasons)
68	if let variationId = decisionResponse.result?.id,
69	let variation = experiment.getVariation(id: variationId) {
70	return DecisionResponse(result: variation, reasons: reasons)
71	}
72
73	// ---- check to see if user is white-listed for a certain variation ----
74	if let variationKey = experiment.forcedVariations[userId] {
75	if let variation = experiment.getVariation(key: variationKey) {
76	let info = LogMessage.forcedVariationFound(variationKey, userId)
77	logger.i(info)
78	reasons.addInfo(info)
79	return DecisionResponse(result: variation, reasons: reasons)
80	}
81
82	// mapped to invalid variation - ignore and continue for other deciesions
83	let info = LogMessage.forcedVariationFoundButInvalid(variationKey, userId)
84	logger.e(info)
85	reasons.addInfo(info)
86	}
87
88	// ---- check if a valid variation is stored in the user profile ----
89	let ignoreUPS = (options ?? []).contains(.ignoreUserProfileService)	3,041✔
90
91	if !ignoreUPS,
92	let variationId = getVariationIdFromProfile(userId: userId, experimentId: experimentId),
93	let variation = experiment.getVariation(id: variationId) {
94
95	let info = LogMessage.gotVariationFromUserProfile(variation.key, experiment.key, userId)
96	logger.i(info)
97	reasons.addInfo(info)
98	return DecisionResponse(result: variation, reasons: reasons)
99	}
100
101	var bucketedVariation: Variation?
102	// ---- check if the user passes audience targeting before bucketing ----
103	let audienceResponse = doesMeetAudienceConditions(config: config,
104	experiment: experiment,
105	userId: userId,
106	attributes: attributes)
107	reasons.merge(audienceResponse.reasons)
108	if audienceResponse.result ?? false {	×
109	// bucket user into a variation
110	let decisionResponse = bucketer.bucketExperiment(config: config,
111	experiment: experiment,
112	bucketingId: bucketingId)
113	reasons.merge(decisionResponse.reasons)
114	bucketedVariation = decisionResponse.result
115
116	if let variation = bucketedVariation {
117	let info = LogMessage.userBucketedIntoVariationInExperiment(userId, experiment.key, variation.key)
118	logger.i(info)
119	reasons.addInfo(info)
120	// save to user profile
121	if !ignoreUPS {
122	self.saveProfile(userId: userId, experimentId: experimentId, variationId: variation.id)
123	}
124	} else {
125	let info = LogMessage.userNotBucketedIntoVariation(userId)
126	logger.i(info)
127	reasons.addInfo(info)
128	}
129
130	} else {
131	let info = LogMessage.userNotInExperiment(userId, experiment.key)
132	logger.i(info)
133	reasons.addInfo(info)
134	}
135
136	return DecisionResponse(result: bucketedVariation, reasons: reasons)
137	}
138
139	func doesMeetAudienceConditions(config: ProjectConfig,
140	experiment: Experiment,
141	userId: String,
142	attributes: OptimizelyAttributes,
143	logType: Constants.EvaluationLogType = .experiment,
144	loggingKey: String? = nil) -> DecisionResponse<Bool> {
145	let reasons = DecisionReasons()
146
147	var result = true // success as default (no condition, etc)
148	let evType = logType.rawValue
149	let finalLoggingKey = loggingKey ?? experiment.key
150
151	do {
152	if let conditions = experiment.audienceConditions {
153	logger.d { () -> String in	×
154	return LogMessage.evaluatingAudiencesCombined(evType, finalLoggingKey, Utils.getConditionString(conditions: conditions)).description
155	}
156	switch conditions {
157	case .array(let arrConditions):
158	if arrConditions.count > 0 {
159	result = try conditions.evaluate(project: config.project, attributes: attributes)
160	} else {
161	// empty conditions (backward compatibility with "audienceIds" is ignored if exists even though empty
162	result = true
163	}
164	case .leaf:
165	result = try conditions.evaluate(project: config.project, attributes: attributes)
166	default:
167	result = true
168	}
169	}
170	// backward compatibility with audienceIds list
171	else if experiment.audienceIds.count > 0 {
172	var holder = [ConditionHolder]()
173	holder.append(.logicalOp(.or))
174	for id in experiment.audienceIds {
175	holder.append(.leaf(.audienceId(id)))
176	}
177	logger.d { () -> String in	×
178	return LogMessage.evaluatingAudiencesCombined(evType, finalLoggingKey, Utils.getConditionString(conditions: holder)).description
179	}
180	result = try holder.evaluate(project: config.project, attributes: attributes)
181	}
182	} catch {
183	if let error = error as? OptimizelyError {
184	logger.i(error)
185	reasons.addInfo(error)
186	}
187	result = false
188	}
189
190	logger.i(.audienceEvaluationResultCombined(evType, finalLoggingKey, result.description))
191
192	return DecisionResponse(result: result, reasons: reasons)
193	}
194
195	func getVariationForFeature(config: ProjectConfig,
196	featureFlag: FeatureFlag,
197	user: OptimizelyUserContext,
198	options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<FeatureDecision> {	3,874✔
199	let reasons = DecisionReasons(options: options)
200
201	// Evaluate in this order:
202
203	// 1. Attempt to bucket user into experiment using feature flag.
204	// Check if the feature flag is under an experiment and the the user is bucketed into one of these experiments
205	var decisionResponse = getVariationForFeatureExperiment(config: config,
206	featureFlag: featureFlag,
207	user: user,
208	options: options)
209	reasons.merge(decisionResponse.reasons)
210	if let decision = decisionResponse.result {
211	return DecisionResponse(result: decision, reasons: reasons)
212	}
213
214	// 2. Attempt to bucket user into rollout using the feature flag.
215	// Check if the feature flag has rollout and the user is bucketed into one of it's rules
216	decisionResponse = getVariationForFeatureRollout(config: config,
217	featureFlag: featureFlag,
218	user: user,
219	options: options)
220	reasons.merge(decisionResponse.reasons)
221	if let decision = decisionResponse.result {
222	return DecisionResponse(result: decision, reasons: reasons)
223	}
224
225	return DecisionResponse(result: nil, reasons: reasons)
226	}
227
228	func getVariationForFeatureExperiment(config: ProjectConfig,
229	featureFlag: FeatureFlag,
230	user: OptimizelyUserContext,
231	options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<FeatureDecision> {	3,872✔
232	let reasons = DecisionReasons(options: options)
233
234	let experimentIds = featureFlag.experimentIds
235	if experimentIds.isEmpty {
236	let info = LogMessage.featureHasNoExperiments(featureFlag.key)
237	logger.d(info)
238	reasons.addInfo(info)
239	}
240
241	// Check if there are any experiment IDs inside feature flag
242	// Evaluate each experiment ID and return the first bucketed experiment variation
243	for experimentId in experimentIds {
244	if let experiment = config.getExperiment(id: experimentId) {
245	let decisionResponse = getVariationFromExperimentRule(config: config,
246	flagKey: featureFlag.key,
247	rule: experiment,
248	user: user,
249	options: options)
250	reasons.merge(decisionResponse.reasons)
251	if let variation = decisionResponse.result {
252	let featureDecision = FeatureDecision(experiment: experiment, variation: variation, source: Constants.DecisionSource.featureTest.rawValue)
253	return DecisionResponse(result: featureDecision, reasons: reasons)
254	}
255	}
256	}
257
258	return DecisionResponse(result: nil, reasons: reasons)
259	}
260
261	func getVariationForFeatureRollout(config: ProjectConfig,
262	featureFlag: FeatureFlag,
263	user: OptimizelyUserContext,
264	options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<FeatureDecision> {	2,955✔
265	let reasons = DecisionReasons(options: options)
266
267	let rolloutId = featureFlag.rolloutId.trimmingCharacters(in: CharacterSet.whitespaces)
268
269	guard !rolloutId.isEmpty else {
270	let info = LogMessage.noRolloutExists(featureFlag.key)
271	logger.d(info)
272	reasons.addInfo(info)
273	return DecisionResponse(result: nil, reasons: reasons)
274	}
275
276	guard let rollout = config.getRollout(id: rolloutId) else {
277	let info = OptimizelyError.rolloutIdInvalid(rolloutId, featureFlag.key)
278	logger.d(info)
279	reasons.addInfo(info)
280	return DecisionResponse(result: nil, reasons: reasons)
281	}
282
283	let rolloutRules = rollout.experiments
284	if rolloutRules.isEmpty {
285	let info = LogMessage.rolloutHasNoExperiments(rolloutId)
286	logger.e(info)
287	reasons.addInfo(info)
288	return DecisionResponse(result: nil, reasons: reasons)
289	}
290
291	var index = 0
292	while index < rolloutRules.count {
293	let decisionResponse = getVariationFromDeliveryRule(config: config,
294	flagKey: featureFlag.key,
295	rules: rolloutRules,
296	ruleIndex: index,
297	user: user,
298	options: options)
299	reasons.merge(decisionResponse.reasons)
300	let (variation, skipToEveryoneElse) = decisionResponse.result!
301
302	if let variation = variation {
303	let rule = rolloutRules[index]
304	let featureDecision = FeatureDecision(experiment: rule, variation: variation, source: Constants.DecisionSource.rollout.rawValue)
305	return DecisionResponse(result: featureDecision, reasons: reasons)
306	}
307
308	// the last rule is special for "Everyone Else"
309	index = skipToEveryoneElse ? (rolloutRules.count - 1) : (index + 1)
310	}
311
312	return DecisionResponse(result: nil, reasons: reasons)
313	}
314
315	func getVariationFromExperimentRule(config: ProjectConfig,
316	flagKey: String,
317	rule: Experiment,
318	user: OptimizelyUserContext,
319	options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<Variation> {	998✔
320	let reasons = DecisionReasons(options: options)
321
322	// check forced-decision first
323
324	let forcedDecisionResponse = user.findValidatedForcedDecision(flagKey: flagKey, ruleKey: rule.key, options: options)
325	reasons.merge(forcedDecisionResponse.reasons)
326
327	if let variation = forcedDecisionResponse.result {
328	return DecisionResponse(result: variation, reasons: reasons)
329	}
330
331	// regular decision
332
333	let decisionResponse = getVariation(config: config,
334	experiment: rule,
335	user: user,
336	options: options)
337	reasons.merge(decisionResponse.reasons)
338	let variation = decisionResponse.result
339
340	return DecisionResponse(result: variation, reasons: reasons)
341	}
342
343	func getVariationFromDeliveryRule(config: ProjectConfig,
344	flagKey: String,
345	rules: [Experiment],
346	ruleIndex: Int,
347	user: OptimizelyUserContext,
348	options: [OptimizelyDecideOption]? = nil) -> DecisionResponse<(Variation?, Bool)> {	2,662✔
349	let reasons = DecisionReasons(options: options)
350	var skipToEveryoneElse = false
351
352	// check forced-decision first
353
354	let rule = rules[ruleIndex]
355	let forcedDecisionResponse = user.findValidatedForcedDecision(flagKey: flagKey, ruleKey: rule.key, options: options)
356	reasons.merge(forcedDecisionResponse.reasons)
357
358	if let variation = forcedDecisionResponse.result {
359	return DecisionResponse(result: (variation, skipToEveryoneElse), reasons: reasons)
360	}
361
362	// regular decision
363
364	let userId = user.userId
365	let attributes = user.attributes
366	let bucketingId = getBucketingId(userId: userId, attributes: attributes)
367
368	let everyoneElse = (ruleIndex == rules.count - 1)
369	let loggingKey = everyoneElse ? "Everyone Else" : String(ruleIndex + 1)
370
371	var bucketedVariation: Variation?
372
373	let audienceDecisionResponse = doesMeetAudienceConditions(config: config,
374	experiment: rule,
375	userId: userId,
376	attributes: attributes,
377	logType: .rolloutRule,
378	loggingKey: loggingKey)
379	reasons.merge(audienceDecisionResponse.reasons)
380	if audienceDecisionResponse.result ?? false {	×
381	var info = LogMessage.userMeetsConditionsForTargetingRule(userId, loggingKey)
382	logger.d(info)
383	reasons.addInfo(info)
384
385	let decisionResponse = bucketer.bucketExperiment(config: config,
386	experiment: rule,
387	bucketingId: bucketingId)
388	reasons.merge(decisionResponse.reasons)
389	bucketedVariation = decisionResponse.result
390
391	if bucketedVariation != nil {
392	info = LogMessage.userBucketedIntoTargetingRule(userId, loggingKey)
393	logger.d(info)
394	reasons.addInfo(info)
395	} else if !everyoneElse {
396	// skip this logging for EveryoneElse since this has a message not for EveryoneElse
397	info = LogMessage.userNotBucketedIntoTargetingRule(userId, loggingKey)
398	logger.d(info)
399	reasons.addInfo(info)
400
401	// skip the rest of rollout rules to the everyone-else rule if audience matches but not bucketed.
402	skipToEveryoneElse = true
403	}
404	} else {
405	let info = LogMessage.userDoesntMeetConditionsForTargetingRule(userId, loggingKey)
406	logger.d(info)
407	reasons.addInfo(info)
408	}
409
410	return DecisionResponse(result: (bucketedVariation, skipToEveryoneElse), reasons: reasons)
411	}
412
413	func getBucketingId(userId: String, attributes: OptimizelyAttributes) -> String {
414
415	// By default, the bucketing ID should be the user ID .
416	var bucketingId = userId
417	// If the bucketing ID key is defined in attributes, then use that
418	// in place of the userID for the murmur hash key
419	if let newBucketingId = attributes[Constants.Attributes.OptimizelyBucketIdAttribute] as? String {
420	bucketingId = newBucketingId
421	}
422
423	return bucketingId
424	}
425
426	}
427
428	// MARK: - UserProfileService Helpers
429
430	extension DefaultDecisionService {
431
432	func getVariationIdFromProfile(userId: String,
433	experimentId: String) -> String? {	3,717✔
434	if let profile = userProfileService.lookup(userId: userId),
435	let bucketMap = profile[UserProfileKeys.kBucketMap] as? OPTUserProfileService.UPBucketMap,
436	let experimentMap = bucketMap[experimentId],
437	let variationId = experimentMap[UserProfileKeys.kVariationId] {
438	return variationId
439	} else {
440	return nil
441	}
442	}
443
444	func saveProfile(userId: String,
445	experimentId: String,
446	variationId: String) {	656✔
447	DefaultDecisionService.upsRMWLock.sync {	656✔
448	var profile = self.userProfileService.lookup(userId: userId) ?? OPTUserProfileService.UPProfile()	372✔
449
450	var bucketMap = profile[UserProfileKeys.kBucketMap] as? OPTUserProfileService.UPBucketMap ?? OPTUserProfileService.UPBucketMap()	372✔
451	bucketMap[experimentId] = [UserProfileKeys.kVariationId: variationId]
452
453	profile[UserProfileKeys.kBucketMap] = bucketMap
454	profile[UserProfileKeys.kUserId] = userId
455
456	self.userProfileService.save(userProfile: profile)
457
458	self.logger.i(.savedVariationInUserProfile(variationId, experimentId, userId))
459	}
460	}
461
462	}

optimizely / swift-sdk / 2528

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous