feat: add user control for assignment event tracking

Author: vaibhav-jain-exp

Sources/Experiment/ExperimentClient.swift

@@ -47,8 +47,8 @@ internal class DefaultExperimentClient : NSObject, ExperimentClient {
     internal let flags: LoadStoreCache<EvaluationFlag>
     private let flagsStorageQueue = DispatchQueue(label: "com.amplitude.experiment.VariantsStorageQueue", attributes: .concurrent)
 
-    internal let fetchOptions: LoadStoreCache<FetchOptions>
-    private let fetchOptionsStorageQueue = DispatchQueue(label: "com.amplitude.experiment.FetchOptionsStorageQueue", attributes: .concurrent)
+    public let trackingOption: LoadStoreCache<String>
+    private let trackingOptionStorageQueue = DispatchQueue(label: "com.amplitude.experiment.TrackingOptionStorageQueue", attributes: .concurrent)
 
     internal let config: ExperimentConfig
     private let engine = EvaluationEngine()
@@ -101,8 +101,8 @@ internal class DefaultExperimentClient : NSObject, ExperimentClient {
         self.flags = getFlagStorage(apiKey: self.apiKey, instanceName: self.config.instanceName, storage: storage)
         self.flags.load()
         self.flags.mergeInitialFlagsWithStorage(config.initialFlags)
-        self.fetchOptions = getFetchOptionsStorage(apiKey: self.apiKey, instanceName: self.config.instanceName, storage: storage)
-        self.fetchOptions.load()
+        self.trackingOption = getTrackingOptionStorage(apiKey: self.apiKey, instanceName: self.config.instanceName, storage: storage)
+        self.trackingOption.load()
     }
 
     public func start(_ user: ExperimentUser? = nil, completion: ((Error?) -> Void)? = nil) -> Void {
@@ -513,10 +513,10 @@ internal class DefaultExperimentClient : NSObject, ExperimentClient {
             request.setValue(flagKeysB64EncodedUrl, forHTTPHeaderField: "X-Amp-Exp-Flag-Keys")
         }
 
-        // Add tracking option from stored fetch options or from current options
-        let trackingOption = options?.trackingOption ?? fetchOptionsStorageQueue.sync { fetchOptions.get(key: "default")?.trackingOption }
-        if let trackingOption = trackingOption {
-            request.setValue(trackingOption, forHTTPHeaderField: "X-Amp-Exp-Tracking-Option")
+        // Add tracking option from current options or from stored setting
+        let trackingOptionValue = options?.trackingOption ?? trackingOptionStorageQueue.sync { trackingOption.get(key: "default") }
+        if let trackingOptionValue = trackingOptionValue {
+            request.setValue(trackingOptionValue, forHTTPHeaderField: "X-Amp-Exp-Track")
         }
         request.timeoutInterval = Double(timeoutMillis) / 1000.0
 
@@ -705,10 +705,9 @@ internal class DefaultExperimentClient : NSObject, ExperimentClient {
 
     public func setTrackAssignmentEvent(_ track: Bool) {
         let trackingOption = track ? "track" : "no-track"
-        let fetchOptions = FetchOptions(nil, trackingOption: trackingOption)
-        fetchOptionsStorageQueue.async(flags: .barrier) {
-            self.fetchOptions.put(key: "default", value: fetchOptions)
-            self.fetchOptions.store()
+        trackingOptionStorageQueue.sync(flags: .barrier) {
+            self.trackingOption.put(key: "default", value: trackingOption)
+            self.trackingOption.store(async: false)
         }
     }
 }

Sources/Experiment/FetchOptions.swift

@@ -7,29 +7,12 @@
 
 import Foundation
 
-@objc public class FetchOptions : NSObject, Codable {
+@objc public class FetchOptions : NSObject {
     @objc public let flagKeys: [String]?
     @objc public let trackingOption: String?
 
     @objc public init(_ flagKeys: [String]? = nil, trackingOption: String? = nil) {
         self.flagKeys = flagKeys
         self.trackingOption = trackingOption
     }
-    
-    private enum CodingKeys: String, CodingKey {
-        case flagKeys
-        case trackingOption
-    }
-    
-    public required init(from decoder: Decoder) throws {
-        let container = try decoder.container(keyedBy: CodingKeys.self)
-        flagKeys = try container.decodeIfPresent([String].self, forKey: .flagKeys)
-        trackingOption = try container.decodeIfPresent(String.self, forKey: .trackingOption)
-    }
-    
-    public func encode(to encoder: Encoder) throws {
-        var container = encoder.container(keyedBy: CodingKeys.self)
-        try container.encodeIfPresent(flagKeys, forKey: .flagKeys)
-        try container.encodeIfPresent(trackingOption, forKey: .trackingOption)
-    }
 }

Sources/Experiment/Storage.swift

@@ -17,8 +17,8 @@ internal func getFlagStorage(apiKey: String, instanceName: String, storage: Stor
     return LoadStoreCache(namespace: namespace, storage: storage)
 }
 
-internal func getFetchOptionsStorage(apiKey: String, instanceName: String, storage: Storage) -> LoadStoreCache<FetchOptions> {
-    let namespace = "com.amplituide.experiment.fetchOptions.\(instanceName).\(apiKey.suffix(6))"
+internal func getTrackingOptionStorage(apiKey: String, instanceName: String, storage: Storage) -> LoadStoreCache<String> {
+    let namespace = "com.amplituide.experiment.trackingOption.\(instanceName).\(apiKey.suffix(6))"
     return LoadStoreCache(namespace: namespace, storage: storage)
 }
 

Tests/ExperimentTests/ExperimentClientTests.swift

@@ -1255,107 +1255,8 @@ class ExperimentClientTests: XCTestCase {
         let client = DefaultExperimentClient(apiKey: "", config: config, storage: InMemoryStorage())
         XCTAssertEqual(900000, client.config.flagConfigPollingIntervalMillis)
     }
-}
-
-class TestAnalyticsProvider : ExperimentAnalyticsProvider {
-    var didExposureGetTracked = false
-    var didUserPropertyGetSet = false
-    var didUserPropertyGetUnset = false
-    let _track: (ExperimentAnalyticsEvent) -> ()
-    let _setUserProperty: (ExperimentAnalyticsEvent) -> ()
-    let _unsetUserProperty: (ExperimentAnalyticsEvent) -> ()
-    init(track: @escaping (ExperimentAnalyticsEvent) -> (), setUserProperty: @escaping (ExperimentAnalyticsEvent) -> (), unsetUserProperty: @escaping (ExperimentAnalyticsEvent) -> ()) {
-        self._track = track
-        self._setUserProperty = setUserProperty
-        self._unsetUserProperty = unsetUserProperty
-    }
-    func track(_ event: ExperimentAnalyticsEvent) {
-        _track(event)
-        didExposureGetTracked = true
-    }
-    func setUserProperty(_ event: ExperimentAnalyticsEvent) {
-        _setUserProperty(event)
-        didUserPropertyGetSet = true
-    }
-    func unsetUserProperty(_ event: ExperimentAnalyticsEvent) {
-        _unsetUserProperty(event)
-        didUserPropertyGetUnset = true
-    }
-}
 
-class TestUserProvider : ExperimentUserProvider {
-    func getUser() -> ExperimentUser {
-        return ExperimentUserBuilder()
-            .deviceId("")
-            .version("version2")
-            .language("")
-            .build()
-    }
-}
-
-class InMemoryStorage: Storage {
-    private var store: [String: Data] = [:]
-    func get(key: String) -> Data? {
-        return store[key]
-    }
-    
-    func put(key: String, value: Data) {
-        store[key] = value
-    }
-    
-    func delete(key: String) {
-        store.removeValue(forKey: key)
-    }
-}
-
-extension DefaultExperimentClient {
-    func startBlocking(user: ExperimentUser) {
-        let s = DispatchSemaphore(value: 0)
-        start(user) { error in
-            if let error = error {
-                XCTFail(error.localizedDescription)
-            }
-            s.signal()
-        }
-        switch s.wait(timeout: .now() + .seconds(20)) {
-        case .timedOut: XCTFail("start request timed out")
-        case .success: return
-        }
-    }
-    func startBlockingThrows(user: ExperimentUser) throws {
-        let s = DispatchSemaphore(value: 0)
-        var err: Error?
-        start(user) { error in
-            if let error = error {
-                err = error
-            }
-            s.signal()
-        }
-        switch s.wait(timeout: .now() + .seconds(20)) {
-        case .timedOut: XCTFail("start request timed out")
-        case .success:
-            if let error = err {
-                throw error
-            }
-        }
-    }
-    func fetchBlocking(user: ExperimentUser, isTestRetry: Bool = false) {
-        let s = DispatchSemaphore(value: 0)
-        fetch(user: user) { _, error in
-            if let error = error {
-                if (!isTestRetry) {
-                    XCTFail(error.localizedDescription)
-                }
-            }
-            s.signal()
-        }
-        switch s.wait(timeout: .now() + .seconds(20)) {
-        case .timedOut: XCTFail("start request timed out")
-        case .success: return
-        }
-    }
-    
-    func testSetTrackAssignmentEvent() {
+        func testSetTrackAssignmentEvent() {
         let client = DefaultExperimentClient(
             apiKey: API_KEY,
             config: ExperimentConfigBuilder()
@@ -1368,17 +1269,15 @@ extension DefaultExperimentClient {
         client.setTrackAssignmentEvent(true)
 
         // Verify the setting was stored
-        let storedOptions = client.fetchOptions.get(key: "default")
-        XCTAssertNotNil(storedOptions)
-        XCTAssertEqual(storedOptions?.trackingOption, "track")
+        let storedOption = client.trackingOption.get(key: "default")
+        XCTAssertEqual(storedOption, "track")
 
         // Test setting track assignment event to false
         client.setTrackAssignmentEvent(false)
 
         // Verify the setting was updated
-        let updatedOptions = client.fetchOptions.get(key: "default")
-        XCTAssertNotNil(updatedOptions)
-        XCTAssertEqual(updatedOptions?.trackingOption, "no-track")
+        let updatedOption = client.trackingOption.get(key: "default")
+        XCTAssertEqual(updatedOption, "no-track")
     }
 
     func testSetTrackAssignmentEventPersistence() {
@@ -1404,9 +1303,8 @@ extension DefaultExperimentClient {
         )
 
         // Verify the setting was persisted and loaded by the second client
-        let storedOptions = client2.fetchOptions.get(key: "default")
-        XCTAssertNotNil(storedOptions)
-        XCTAssertEqual(storedOptions?.trackingOption, "track")
+        let storedOption = client2.trackingOption.get(key: "default")
+        XCTAssertEqual(storedOption, "track")
     }
 
     func testSetTrackAssignmentEventMultipleCalls() {
@@ -1423,9 +1321,8 @@ extension DefaultExperimentClient {
         client.setTrackAssignmentEvent(false)
 
         // Verify the latest setting is used
-        let storedOptions = client.fetchOptions.get(key: "default")
-        XCTAssertNotNil(storedOptions)
-        XCTAssertEqual(storedOptions?.trackingOption, "no-track")
+        let storedOption = client.trackingOption.get(key: "default")
+        XCTAssertEqual(storedOption, "no-track")
     }
 
     func testSetTrackAssignmentEventWithFetchOptions() {
@@ -1458,8 +1355,8 @@ extension DefaultExperimentClient {
         )
 
         // Verify default behavior when setTrackAssignmentEvent is not called
-        let storedOptions = client.fetchOptions.get(key: "default")
-        XCTAssertNil(storedOptions)
+        let storedOption = client.trackingOption.get(key: "default")
+        XCTAssertNil(storedOption)
     }
 
     func testSetTrackAssignmentEventWithFetch() {
@@ -1484,3 +1381,102 @@ extension DefaultExperimentClient {
         s.wait()
     }
 }
+
+class TestAnalyticsProvider : ExperimentAnalyticsProvider {
+    var didExposureGetTracked = false
+    var didUserPropertyGetSet = false
+    var didUserPropertyGetUnset = false
+    let _track: (ExperimentAnalyticsEvent) -> ()
+    let _setUserProperty: (ExperimentAnalyticsEvent) -> ()
+    let _unsetUserProperty: (ExperimentAnalyticsEvent) -> ()
+    init(track: @escaping (ExperimentAnalyticsEvent) -> (), setUserProperty: @escaping (ExperimentAnalyticsEvent) -> (), unsetUserProperty: @escaping (ExperimentAnalyticsEvent) -> ()) {
+        self._track = track
+        self._setUserProperty = setUserProperty
+        self._unsetUserProperty = unsetUserProperty
+    }
+    func track(_ event: ExperimentAnalyticsEvent) {
+        _track(event)
+        didExposureGetTracked = true
+    }
+    func setUserProperty(_ event: ExperimentAnalyticsEvent) {
+        _setUserProperty(event)
+        didUserPropertyGetSet = true
+    }
+    func unsetUserProperty(_ event: ExperimentAnalyticsEvent) {
+        _unsetUserProperty(event)
+        didUserPropertyGetUnset = true
+    }
+}
+
+class TestUserProvider : ExperimentUserProvider {
+    func getUser() -> ExperimentUser {
+        return ExperimentUserBuilder()
+            .deviceId("")
+            .version("version2")
+            .language("")
+            .build()
+    }
+}
+
+class InMemoryStorage: Storage {
+    private var store: [String: Data] = [:]
+    func get(key: String) -> Data? {
+        return store[key]
+    }
+    
+    func put(key: String, value: Data) {
+        store[key] = value
+    }
+    
+    func delete(key: String) {
+        store.removeValue(forKey: key)
+    }
+}
+
+extension DefaultExperimentClient {
+    func startBlocking(user: ExperimentUser) {
+        let s = DispatchSemaphore(value: 0)
+        start(user) { error in
+            if let error = error {
+                XCTFail(error.localizedDescription)
+            }
+            s.signal()
+        }
+        switch s.wait(timeout: .now() + .seconds(20)) {
+        case .timedOut: XCTFail("start request timed out")
+        case .success: return
+        }
+    }
+    func startBlockingThrows(user: ExperimentUser) throws {
+        let s = DispatchSemaphore(value: 0)
+        var err: Error?
+        start(user) { error in
+            if let error = error {
+                err = error
+            }
+            s.signal()
+        }
+        switch s.wait(timeout: .now() + .seconds(20)) {
+        case .timedOut: XCTFail("start request timed out")
+        case .success:
+            if let error = err {
+                throw error
+            }
+        }
+    }
+    func fetchBlocking(user: ExperimentUser, isTestRetry: Bool = false) {
+        let s = DispatchSemaphore(value: 0)
+        fetch(user: user) { _, error in
+            if let error = error {
+                if (!isTestRetry) {
+                    XCTFail(error.localizedDescription)
+                }
+            }
+            s.signal()
+        }
+        switch s.wait(timeout: .now() + .seconds(20)) {
+        case .timedOut: XCTFail("start request timed out")
+        case .success: return
+        }
+    }
+}