feat: Honor polling interval between restarts

.github/workflows/ci.yml

@@ -14,6 +14,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     strategy:
+      fail-fast: false
       matrix:
         include:
           - xcode-version: 15.0.1

ContractTests/Source/Controllers/SdkController.swift

@@ -1,5 +1,5 @@
 import Vapor
-import LaunchDarkly
+@testable import LaunchDarkly
 
 final class SdkController: RouteCollection {
     private var clients: [Int: LDClient] = [:]
@@ -50,6 +50,8 @@ final class SdkController: RouteCollection {
             // TODO(mmk) Need to hook up initialRetryDelayMs
         } else if let polling = createInstance.configuration.polling {
             config.streamingMode = .polling
+            config.ignorePollingMinimum = true
+            config.flagPollingInterval = 0.5
             if let baseUri = polling.baseUri {
                 config.baseUrl = URL(string: baseUri)!
             }

LaunchDarkly/GeneratedCode/mocks.generated.swift

@@ -247,8 +247,8 @@ final class FeatureFlagCachingMock: FeatureFlagCaching {
     var getCachedDataCallCount = 0
     var getCachedDataCallback: (() throws -> Void)?
     var getCachedDataReceivedCacheKey: String?
-    var getCachedDataReturnValue: (items: StoredItems?, etag: String?)!
-    func getCachedData(cacheKey: String) -> (items: StoredItems?, etag: String?) {
+    var getCachedDataReturnValue: (items: StoredItems?, etag: String?, lastUpdated: Date?)!
+    func getCachedData(cacheKey: String) -> (items: StoredItems?, etag: String?, lastUpdated: Date?) {
         getCachedDataCallCount += 1
         getCachedDataReceivedCacheKey = cacheKey
         try! getCachedDataCallback?()

LaunchDarkly/LaunchDarkly/LDClient.swift

@@ -202,13 +202,16 @@ public class LDClient {
                 return
             }
 
+            let cachedData = self.flagCache.getCachedData(cacheKey: self.context.contextHash())
+
             let willSetSynchronizerOnline = isOnline && isInSupportedRunMode
             flagSynchronizer.isOnline = false
             let streamingModeVar = ConnectionInformation.effectiveStreamingMode(config: config, ldClient: self)
             connectionInformation = ConnectionInformation.backgroundBehavior(connectionInformation: connectionInformation, streamingMode: streamingModeVar, goOnline: willSetSynchronizerOnline)
             flagSynchronizer = serviceFactory.makeFlagSynchronizer(streamingMode: streamingModeVar,
                                                                    pollingInterval: config.flagPollingInterval(runMode: runMode),
                                                                    useReport: config.useReport,
+                                                                   lastUpdated: cachedData.lastUpdated,
                                                                    service: service,
                                                                    onSyncComplete: onFlagSyncComplete)
             flagSynchronizer.isOnline = willSetSynchronizerOnline
@@ -404,6 +407,7 @@ public class LDClient {
             flagSynchronizer = serviceFactory.makeFlagSynchronizer(streamingMode: ConnectionInformation.effectiveStreamingMode(config: config, ldClient: self),
                                                                    pollingInterval: config.flagPollingInterval(runMode: runMode),
                                                                    useReport: config.useReport,
+                                                                   lastUpdated: cachedData.lastUpdated,
                                                                    service: self.service,
                                                                    onSyncComplete: self.onFlagSyncComplete)
 
@@ -591,6 +595,10 @@ public class LDClient {
         case .upToDate:
             connectionInformation.lastKnownFlagValidity = Date()
             flagChangeNotifier.notifyUnchanged()
+            // If a polling request receives a 304 not modified, we still need
+            // to update the "last updated" field of the cache so subsequent
+            // restarts will honor the appropriate polling delay.
+            self.updateCacheFreshness(context: self.context)
         case .error(let synchronizingError):
             process(synchronizingError, logPrefix: typeName(and: #function))
         }
@@ -610,6 +618,17 @@ public class LDClient {
         flagChangeNotifier.notifyObservers(oldFlags: oldStoredItems.featureFlags, newFlags: flagStore.storedItems.featureFlags)
     }
 
+    /**
+     This method will update the lastUpdated timestamp on the cache with the current time.
+
+     When a polling request returns a 304 not modified, we need to update this value so subsequent restarts still honor the appropriate polling interval delay.
+
+     In other words, if we get confirmation our cache is still fresh, then we shouldn't poll again for another <pollingInterval> seconds. If we didn't update this, we would poll immediately on restart.
+    */
+    private func updateCacheFreshness(context: LDContext) {
+        flagCache.saveCachedData(flagStore.storedItems, cacheKey: context.contextHash(), lastUpdated: Date(), etag: nil)
+    }
+
     // MARK: Events
 
     /**
@@ -820,9 +839,11 @@ public class LDClient {
         diagnosticReporter = self.serviceFactory.makeDiagnosticReporter(service: service, environmentReporter: environmentReporter)
         eventReporter = self.serviceFactory.makeEventReporter(service: service)
         connectionInformation = self.serviceFactory.makeConnectionInformation()
+        let cachedData = flagCache.getCachedData(cacheKey: context.contextHash())
         flagSynchronizer = self.serviceFactory.makeFlagSynchronizer(streamingMode: config.allowStreamingMode ? config.streamingMode : .polling,
                                                                     pollingInterval: config.flagPollingInterval(runMode: runMode),
                                                                     useReport: config.useReport,
+                                                                    lastUpdated: cachedData.lastUpdated,
                                                                     service: service)
 
         if let backgroundNotification = SystemCapabilities.backgroundNotification {
@@ -835,11 +856,11 @@ public class LDClient {
         NotificationCenter.default.addObserver(self, selector: #selector(didCloseEventSource), name: Notification.Name(FlagSynchronizer.Constants.didCloseEventSourceName), object: nil)
 
         eventReporter = self.serviceFactory.makeEventReporter(service: service, onSyncComplete: onEventSyncComplete)
-        let cachedData = flagCache.getCachedData(cacheKey: context.contextHash())
         service.resetFlagResponseCache(etag: cachedData.etag)
         flagSynchronizer = self.serviceFactory.makeFlagSynchronizer(streamingMode: config.allowStreamingMode ? config.streamingMode : .polling,
                                                                     pollingInterval: config.flagPollingInterval(runMode: runMode),
                                                                     useReport: config.useReport,
+                                                                    lastUpdated: cachedData.lastUpdated,
                                                                     service: service,
                                                                     onSyncComplete: onFlagSyncComplete)
 

LaunchDarkly/LaunchDarkly/Models/LDConfig.swift

@@ -371,6 +371,10 @@ public struct LDConfig {
     /// Enables logging for debugging. (Default: false)
     public var isDebugMode: Bool = Defaults.debugMode
 
+    /// Used by the contract tests to override the default 5 minute polling interval. This should never be used outside
+    /// of the contract tests.
+    internal var ignorePollingMinimum: Bool = false
+
     /// Enables requesting evaluation reasons for all flags. (Default: false)
     public var evaluationReasons: Bool = Defaults.evaluationReasons
 
@@ -492,6 +496,10 @@ public struct LDConfig {
 
     // Determine the effective flag polling interval based on runMode, configured foreground & background polling interval, and minimum foreground & background polling interval.
     func flagPollingInterval(runMode: LDClientRunMode) -> TimeInterval {
+        if ignorePollingMinimum {
+            return runMode == .foreground ? flagPollingInterval : backgroundFlagPollingInterval
+        }
+
         return runMode == .foreground ? max(flagPollingInterval, minima.flagPollingInterval) : max(backgroundFlagPollingInterval, minima.backgroundFlagPollingInterval)
     }
 

LaunchDarkly/LaunchDarkly/ServiceObjects/Cache/FeatureFlagCache.swift

@@ -5,7 +5,18 @@ protocol FeatureFlagCaching {
     // sourcery: defaultMockValue = KeyedValueCachingMock()
     var keyedValueCache: KeyedValueCaching { get }
 
-    func getCachedData(cacheKey: String) -> (items: StoredItems?, etag: String?)
+    /// Retrieve all cached data for the given cache key.
+    ///
+    /// - parameter cacheKey: The unique key into the local cache store.
+    /// - returns: Returns a tuple of cached value information.
+    ///     items: This is the associated flag evaluation results associated with this context.
+    ///     etag: The last known e-tag value from a polling request (see saveCachedData
+    ///           comments) for more informmation.
+    ///     lastUpdated: The date the cache was last considered up-to-date. If there are no cached
+    ///            values, this should return nil.
+    ///
+    ///
+    func getCachedData(cacheKey: String) -> (items: StoredItems?, etag: String?, lastUpdated: Date?)
 
     // When we update the cache, we save the flag data and if we have it, an
     // etag. For polling, we should always have the flag data and an etag
@@ -42,16 +53,24 @@ final class FeatureFlagCache: FeatureFlagCaching {
         self.maxCachedContexts = maxCachedContexts
     }
 
-    func getCachedData(cacheKey: String) -> (items: StoredItems?, etag: String?) {
+    func getCachedData(cacheKey: String) -> (items: StoredItems?, etag: String?, lastUpdated: Date?) {
         guard let cachedFlagsData = keyedValueCache.data(forKey: "flags-\(cacheKey)"),
               let cachedFlags = try? JSONDecoder().decode(StoredItemCollection.self, from: cachedFlagsData)
-        else { return (items: nil, etag: nil) }
+        else { return (items: nil, etag: nil, lastUpdated: nil) }
 
         guard let cachedETagData = keyedValueCache.data(forKey: "etag-\(cacheKey)"),
               let etag = try? JSONDecoder().decode(String.self, from: cachedETagData)
-        else { return (items: cachedFlags.flags, etag: nil) }
+        else { return (items: cachedFlags.flags, etag: nil, lastUpdated: nil) }
 
-        return (items: cachedFlags.flags, etag: etag)
+        var cachedContexts: [String: Int64] = [:]
+        if let cacheMetadata = keyedValueCache.data(forKey: "cached-contexts") {
+            cachedContexts = (try? JSONDecoder().decode([String: Int64].self, from: cacheMetadata)) ?? [:]
+        }
+
+        guard let lastUpdated = cachedContexts[cacheKey]
+        else { return (items: cachedFlags.flags, etag: etag, lastUpdated: nil) }
+
+        return (items: cachedFlags.flags, etag: etag, lastUpdated: Date(timeIntervalSince1970: TimeInterval(lastUpdated / 1_000)))
     }
 
     func saveCachedData(_ storedItems: StoredItems, cacheKey: String, lastUpdated: Date, etag: String?) {

LaunchDarkly/LaunchDarkly/ServiceObjects/ClientServiceFactory.swift

@@ -7,10 +7,11 @@ protocol ClientServiceCreating {
     func makeFeatureFlagCache(mobileKey: String, maxCachedContexts: Int) -> FeatureFlagCaching
     func makeCacheConverter() -> CacheConverting
     func makeDarklyServiceProvider(config: LDConfig, context: LDContext, envReporter: EnvironmentReporting) -> DarklyServiceProvider
-    func makeFlagSynchronizer(streamingMode: LDStreamingMode, pollingInterval: TimeInterval, useReport: Bool, service: DarklyServiceProvider) -> LDFlagSynchronizing
+    func makeFlagSynchronizer(streamingMode: LDStreamingMode, pollingInterval: TimeInterval, useReport: Bool, lastUpdated: Date?, service: DarklyServiceProvider) -> LDFlagSynchronizing
     func makeFlagSynchronizer(streamingMode: LDStreamingMode,
                               pollingInterval: TimeInterval,
                               useReport: Bool,
+                              lastUpdated: Date?,
                               service: DarklyServiceProvider,
                               onSyncComplete: FlagSyncCompleteClosure?) -> LDFlagSynchronizing
     func makeFlagChangeNotifier() -> FlagChangeNotifying
@@ -48,16 +49,17 @@ final class ClientServiceFactory: ClientServiceCreating {
       DarklyService(config: config, context: context, envReporter: envReporter, serviceFactory: self)
     }
 
-    func makeFlagSynchronizer(streamingMode: LDStreamingMode, pollingInterval: TimeInterval, useReport: Bool, service: DarklyServiceProvider) -> LDFlagSynchronizing {
-        makeFlagSynchronizer(streamingMode: streamingMode, pollingInterval: pollingInterval, useReport: useReport, service: service, onSyncComplete: nil)
+    func makeFlagSynchronizer(streamingMode: LDStreamingMode, pollingInterval: TimeInterval, useReport: Bool, lastUpdated: Date?, service: DarklyServiceProvider) -> LDFlagSynchronizing {
+        makeFlagSynchronizer(streamingMode: streamingMode, pollingInterval: pollingInterval, useReport: useReport, lastUpdated: lastUpdated, service: service, onSyncComplete: nil)
     }
 
     func makeFlagSynchronizer(streamingMode: LDStreamingMode,
                               pollingInterval: TimeInterval,
                               useReport: Bool,
+                              lastUpdated: Date?,
                               service: DarklyServiceProvider,
                               onSyncComplete: FlagSyncCompleteClosure?) -> LDFlagSynchronizing {
-        FlagSynchronizer(streamingMode: streamingMode, pollingInterval: pollingInterval, useReport: useReport, service: service, onSyncComplete: onSyncComplete)
+        FlagSynchronizer(streamingMode: streamingMode, pollingInterval: pollingInterval, useReport: useReport, lastUpdated: lastUpdated, service: service, onSyncComplete: onSyncComplete)
     }
 
     func makeFlagChangeNotifier() -> FlagChangeNotifying {

LaunchDarkly/LaunchDarkly/ServiceObjects/FlagSynchronizer.swift

@@ -79,18 +79,21 @@ class FlagSynchronizer: LDFlagSynchronizing, EventHandler {
     private var isOnlineQueue = DispatchQueue(label: "com.launchdarkly.FlagSynchronizer.isOnlineQueue")
     let pollingInterval: TimeInterval
     let useReport: Bool
+    private var lastCachedRequestedTime: Date?
 
     private var syncQueue = DispatchQueue(label: Constants.queueName, qos: .utility)
     private var eventSourceStarted: Date?
 
     init(streamingMode: LDStreamingMode,
          pollingInterval: TimeInterval,
          useReport: Bool,
+         lastUpdated: Date?,
          service: DarklyServiceProvider,
          onSyncComplete: FlagSyncCompleteClosure?) {
         self.streamingMode = streamingMode
         self.pollingInterval = pollingInterval
         self.useReport = useReport
+        self.lastCachedRequestedTime = lastUpdated
         self.service = service
         self.onSyncComplete = onSyncComplete
         os_log("%s streamingMode: %s pollingInterval: %s useReport: %s", log: service.config.logger, type: .debug, typeName(and: #function), String(describing: streamingMode), String(describing: pollingInterval), useReport.description)
@@ -151,9 +154,17 @@ class FlagSynchronizer: LDFlagSynchronizing, EventHandler {
             return
         }
 
+        // We should fire right away, unless we know how fresh the cache is and can
+        // adjust accordingly.
+        var fireAt = Date.distantPast
+        if let lastTime = self.lastCachedRequestedTime {
+            fireAt = lastTime.addingTimeInterval(pollingInterval)
+            // If we do consider the cached values already fresh enough, we should 
+            // signal completion immediately
+            syncQueue.async { [self] in reportSyncComplete(.upToDate) }
+        }
+        flagRequestTimer = LDTimer(withTimeInterval: pollingInterval, fireQueue: syncQueue, fireAt: fireAt, execute: processTimer)
         os_log("%s", log: service.config.logger, type: .debug, typeName(and: #function))
-        flagRequestTimer = LDTimer(withTimeInterval: pollingInterval, fireQueue: syncQueue, execute: processTimer)
-        makeFlagRequest(isOnline: true)
     }
 
     private func stopPolling() {
@@ -184,6 +195,9 @@ class FlagSynchronizer: LDFlagSynchronizing, EventHandler {
         os_log("%s starting", log: service.config.logger, type: .debug, typeName(and: #function))
         let context = (useReport: useReport,
                        logPrefix: typeName(and: #function))
+        // We blank this value here so that future `startPolling` requests do
+        // not prematurely trigger the sync completion.
+        self.lastCachedRequestedTime = nil
         service.getFeatureFlags(useReport: useReport) { [weak self] serviceResponse in
             if FlagSynchronizer.shouldRetryFlagRequest(useReport: context.useReport, statusCode: (serviceResponse.urlResponse as? HTTPURLResponse)?.statusCode) {
                 if let myself = self {

LaunchDarkly/LaunchDarkly/ServiceObjects/LDTimer.swift

@@ -3,7 +3,7 @@ import Foundation
 protocol TimeResponding {
     var fireDate: Date? { get }
 
-    init(withTimeInterval: TimeInterval, fireQueue: DispatchQueue, execute: @escaping () -> Void)
+    init(withTimeInterval: TimeInterval, fireQueue: DispatchQueue, fireAt: Date?, execute: @escaping () -> Void)
     func cancel()
 }
 
@@ -15,12 +15,17 @@ final class LDTimer: TimeResponding {
     private (set) var isCancelled: Bool = false
     var fireDate: Date? { timer?.fireDate }
 
-    init(withTimeInterval timeInterval: TimeInterval, fireQueue: DispatchQueue = DispatchQueue.main, execute: @escaping () -> Void) {
+    init(withTimeInterval timeInterval: TimeInterval, fireQueue: DispatchQueue = DispatchQueue.main, fireAt: Date? = nil, execute: @escaping () -> Void) {
         self.fireQueue = fireQueue
         self.execute = execute
 
         // the run loop retains the timer, so the property is weak to avoid a retain cycle. Setting the timer to a strong reference is important so that the timer doesn't get nil'd before it's added to the run loop.
-        let timer = Timer(timeInterval: timeInterval, target: self, selector: #selector(timerFired), userInfo: nil, repeats: true)
+        let timer: Timer
+        if let at = fireAt {
+            timer = Timer(fireAt: at, interval: timeInterval, target: self, selector: #selector(timerFired), userInfo: nil, repeats: true)
+        } else {
+            timer = Timer(timeInterval: timeInterval, target: self, selector: #selector(timerFired), userInfo: nil, repeats: true)
+        }
         self.timer = timer
         RunLoop.main.add(timer, forMode: RunLoop.Mode.default)
     }