fix: threading issues with locks (#130)

Author: kwasniew

Sources/UnleashProxyClientSwift/Client/UnleashProxyClientSwift.swift

@@ -3,12 +3,26 @@ import SwiftEventBus
 
 @available(macOS 10.15, *)
 public class UnleashClientBase {
-    public var context: Context
-    var timer: Timer?
+    private var _context: Context
+
+    public var context: Context {
+            get {
+                lock.lock()
+                let value = self._context
+                lock.unlock()
+                return value
+            }
+            set {
+                lock.lock()
+                self._context = newValue
+                lock.unlock()
+            }
+        }
+    var timer: DispatchSourceTimer?
     var poller: Poller
     var metrics: Metrics
     var connectionId: UUID
-    private let queue = DispatchQueue(label: "com.unleash.clientbase", attributes: .concurrent)
+    private let lock = NSLock()
 
     public init(
         unleashUrl: String,
@@ -63,9 +77,9 @@ public class UnleashClientBase {
             self.metrics = Metrics(appName: appName, metricsInterval: Double(metricsInterval), clock: { return Date() }, disableMetrics: disableMetrics, poster: urlSessionPoster, url: url, clientKey: clientKey, customHeaders: customHeaders, connectionId: connectionId)
         }
 
-        self.context = Context(appName: appName, environment: environment, sessionId: String(Int.random(in: 0..<1_000_000_000)))
+        self._context = Context(appName: appName, environment: environment, sessionId: String(Int.random(in: 0..<1_000_000_000)))
         if let providedContext = context {
-            self.context = self.calculateContext(context: providedContext)
+            self._context = self.calculateContext(context: providedContext)
         }
     }
 
@@ -75,13 +89,13 @@ public class UnleashClientBase {
         completionHandler: ((PollerError?) -> Void)? = nil
     ) -> Void {
         Printer.showPrintStatements = printToConsole
-                self.stopPolling()
-                poller.start(
-                    bootstrapping: bootstrap.toggles,
-                    context: context,
-                    completionHandler: completionHandler
-                )
-                metrics.start()
+        self.stopPolling()
+        poller.start(
+            bootstrapping: bootstrap.toggles,
+            context: context,
+            completionHandler: completionHandler
+        )
+        metrics.start()
     }
 
     private func stopPolling() -> Void {
@@ -90,55 +104,55 @@ public class UnleashClientBase {
     }
 
     public func stop() -> Void {
-        self.stopPolling();
+        self.stopPolling()
+        lock.lock()
+        timer?.cancel()
+        timer = nil
+        lock.unlock()
         UnleashEvent.allCases.forEach { self.unsubscribe($0) }
     }
 
     public func isEnabled(name: String) -> Bool {
-        return queue.sync {
-            let toggle = poller.getFeature(name: name)
-            let enabled = toggle?.enabled ?? false
-
-            metrics.count(name: name, enabled: enabled)
-
-            if let toggle = toggle, toggle.impressionData {
-                // Dispatch impression event to background queue
-                DispatchQueue.global().async {
-                    SwiftEventBus.post("impression", sender: ImpressionEvent(
-                        toggleName: name,
-                        enabled: enabled,
-                        context: self.context
-                    ))
-                }
-            }
+        let toggle = poller.getFeature(name: name)
+        let enabled = toggle?.enabled ?? false
+        let contextSnapshot = self.context
 
-            return enabled
+        metrics.count(name: name, enabled: enabled)
+
+        if let toggle = toggle, toggle.impressionData {
+            DispatchQueue.global(qos: .background).async {
+                SwiftEventBus.post("impression", sender: ImpressionEvent(
+                    toggleName: name,
+                    enabled: enabled,
+                    context: contextSnapshot
+                ))
+            }
         }
+
+        return enabled
     }
 
     public func getVariant(name: String) -> Variant {
-        return queue.sync {
-            let toggle = poller.getFeature(name: name)
-            let variant = toggle?.variant ?? .defaultDisabled
-            let enabled = toggle?.enabled ?? false
-
-            metrics.count(name: name, enabled: enabled)
-            metrics.countVariant(name: name, variant: variant.name)
-
-            if let toggle = toggle, toggle.impressionData {
-                // Dispatch impression event to background queue
-                DispatchQueue.global().async {
-                    SwiftEventBus.post("impression", sender: ImpressionEvent(
-                        toggleName: name,
-                        enabled: enabled,
-                        variant: variant,
-                        context: self.context
-                    ))
-                }
-            }
+        let toggle = poller.getFeature(name: name)
+        let variant = toggle?.variant ?? .defaultDisabled
+        let enabled = toggle?.enabled ?? false
+        let contextSnapshot = self.context
+
+        metrics.count(name: name, enabled: enabled)
+        metrics.countVariant(name: name, variant: variant.name)
 
-            return variant
+        if let toggle = toggle, toggle.impressionData {
+            DispatchQueue.global(qos: .background).async {
+                SwiftEventBus.post("impression", sender: ImpressionEvent(
+                    toggleName: name,
+                    enabled: enabled,
+                    variant: variant,
+                    context: contextSnapshot
+                ))
+            }
         }
+
+        return variant
     }
 
     public func subscribe(name: String, callback: @escaping () -> Void) {
@@ -185,15 +199,16 @@ public class UnleashClientBase {
         unsubscribe(name: event.rawValue)
     }
 
-    public func updateContext(context: [String: String], properties: [String:String]? = nil, completionHandler: ((PollerError?) -> Void)? = nil) {
-        if Thread.isMainThread {
-            self.context = self.calculateContext(context: context, properties: properties)
+    public func updateContext(
+        context: [String: String],
+        properties: [String: String]? = nil,
+        completionHandler: ((PollerError?) -> Void)? = nil
+    ) {
+        let newContext = self.calculateContext(context: context, properties: properties)
+        self.context = newContext
+
+        DispatchQueue.global(qos: .background).async {
             self.start(Printer.showPrintStatements, completionHandler: completionHandler)
-        } else {
-            DispatchQueue.main.async {
-                self.context = self.calculateContext(context: context, properties: properties)
-                self.start(Printer.showPrintStatements, completionHandler: completionHandler)
-            }
         }
     }
 
@@ -211,11 +226,13 @@ public class UnleashClientBase {
             newProperties[key] = value
         }
 
-        let sessionId = context["sessionId"] ?? self.context.sessionId;
-        
+        let currentContext = self.context
+
+        let sessionId = context["sessionId"] ?? currentContext.sessionId;
+
         let newContext = Context(
-            appName: self.context.appName,
-            environment: self.context.environment,
+            appName: currentContext.appName,
+            environment: currentContext.environment,
             userId: context["userId"],
             sessionId: sessionId,
             remoteAddress: context["remoteAddress"],
@@ -243,7 +260,7 @@ public class UnleashClient: UnleashClientBase, ObservableObject {
             }
         }
     }
-    
+
     @MainActor
     public func updateContext(
         context: [String: String],

Sources/UnleashProxyClientSwift/Metrics/Metrics.swift

@@ -9,12 +9,14 @@ public class Metrics {
     let poster: PosterHandler
     let clock: () -> Date
     var disableMetrics: Bool
-    var timer: Timer?
+    var timer: DispatchSourceTimer?
     var bucket: Bucket
     let url: URL
     let customHeaders: [String: String]
     let connectionId: UUID
 
+    private let lock = NSLock()
+
     init(appName: String,
          metricsInterval: TimeInterval,
          clock: @escaping () -> Date,
@@ -37,49 +39,82 @@ public class Metrics {
     }
 
     func start() {
-        if disableMetrics { return }
+        lock.lock()
+        let isDisabled = self.disableMetrics
+        lock.unlock()
+
+        if isDisabled { return }
+
+        lock.lock()
+        self.timer?.cancel()
+        self.timer = nil
+        let interval = self.metricsInterval
+        lock.unlock()
 
-        self.timer = Timer.scheduledTimer(withTimeInterval: metricsInterval, repeats: true) { _ in
+        let timer = DispatchSource.makeTimerSource(queue: DispatchQueue.global(qos: .background))
+        timer.schedule(deadline: .now() + interval, repeating: interval)
+        timer.setEventHandler { [weak self] in
+            guard let self = self else { return }
             self.sendMetrics()
         }
+        timer.resume()
+
+        lock.lock()
+        self.timer = timer
+        lock.unlock()
     }
 
     func stop() {
-        self.timer?.invalidate()
+        lock.lock()
+        self.timer?.cancel()
+        self.timer = nil
+        lock.unlock()
     }
-    
-    private let queue = DispatchQueue(label: "io.getunleash.metrics")
 
     func count(name: String, enabled: Bool) {
-        if disableMetrics { return }
-
-        queue.sync {
-            var toggle = bucket.toggles[name] ?? ToggleMetrics()
-            if enabled {
-                toggle.yes += 1
-            } else {
-                toggle.no += 1
-            }
-            bucket.toggles[name] = toggle
+        lock.lock()
+        let isDisabled = self.disableMetrics
+        if isDisabled {
+            lock.unlock()
+            return
         }
+
+        var toggle = bucket.toggles[name] ?? ToggleMetrics()
+        if enabled {
+            toggle.yes += 1
+        } else {
+            toggle.no += 1
+        }
+        bucket.toggles[name] = toggle
+        lock.unlock()
     }
 
     func countVariant(name: String, variant: String) {
-        if disableMetrics { return }
-
-        queue.sync {
-            var toggle = bucket.toggles[name] ?? ToggleMetrics()
-            toggle.variants[variant, default: 0] += 1
-            bucket.toggles[name] = toggle
+        lock.lock()
+        let isDisabled = self.disableMetrics
+        if isDisabled {
+            lock.unlock()
+            return
         }
+
+        var toggle = bucket.toggles[name] ?? ToggleMetrics()
+        toggle.variants[variant, default: 0] += 1
+        bucket.toggles[name] = toggle
+        lock.unlock()
     }
 
     func sendMetrics() {
+        let localBucket: Bucket
+        let clockFunction: () -> Date
+        
+        lock.lock()
         bucket.closeBucket()
-        guard !bucket.isEmpty() else { return }
+        localBucket = bucket
+        clockFunction = self.clock
+        bucket = Bucket(clock: clockFunction)
+        lock.unlock()
 
-        let localBucket = bucket
-        bucket = Bucket(clock: clock)
+        guard !localBucket.isEmpty() else { return }
 
         do {
             let payload = MetricsPayload(appName: appName, instanceId: "swift", bucket: localBucket)
@@ -111,8 +146,8 @@ public class Metrics {
         request.addValue(appName, forHTTPHeaderField: "unleash-appname")
         request.addValue(connectionId.uuidString, forHTTPHeaderField: "unleash-connection-id")
         request.setValue("unleash-client-swift:\(LibraryInfo.version)", forHTTPHeaderField: "unleash-sdk")
-        if !self.customHeaders.isEmpty {
-            for (key, value) in self.customHeaders {
+        if !customHeaders.isEmpty {
+            for (key, value) in customHeaders {
                 request.setValue(value, forHTTPHeaderField: key)
             }
         }

Sources/UnleashProxyClientSwift/Poller/DictionaryStorageProvider.swift

@@ -2,25 +2,26 @@ import Foundation
 
 public class DictionaryStorageProvider: StorageProvider {
     private var storage: [String: Toggle] = [:]
-    private let queue = DispatchQueue(label: "com.unleash.storageprovider")
+    private let lock = NSLock()
 
     public init() {}
 
     public func set(values: [String: Toggle]) {
-        queue.async {
-            self.storage = values
-        }
+        lock.lock()
+        self.storage = values
+        lock.unlock()
     }
 
     public func value(key: String) -> Toggle? {
-        queue.sync {
-            return self.storage[key]
-        }
+        lock.lock()
+        let result = self.storage[key]
+        lock.unlock()
+        return result
     }
-    
+
     public func clear() {
-        queue.sync {
-            self.storage = [:]
-        }
+        lock.lock()
+        self.storage = [:]
+        lock.unlock()
     }
 }