Settings cache reader (#10442)

* loadCache

* SettingsFileManager

* code compiles and test successful

* ApplicationInfo.synthesizedVersion

* SettingsProtocol

* properties

* broken test

* fix test and add lots of tests

* conflict

* style

* remove unnecessary explicit type

* synchronize settings for thread-safety

* fix macOS and Catalyst url.appending compatibility

* fix compatibility attempt 2

* exclude macOS and Catalyst

* attempt 4

* PR review

* migrate to NSUserDefaults

* cleanup

* review

* add comments

* constants

Author: leotianlizhan

FirebaseSessions/Sources/ApplicationInfo.swift

@@ -46,6 +46,10 @@ protocol ApplicationInfoProtocol {
 
   /// Development environment on which the application is running.
   var environment: DevEnvironment { get }
+
+  var appBuildVersion: String { get }
+
+  var appDisplayVersion: String { get }
 }
 
 class ApplicationInfo: ApplicationInfoProtocol {
@@ -92,4 +96,12 @@ class ApplicationInfo: ApplicationInfoProtocol {
     }
     return DevEnvironment.prod
   }
+
+  var appBuildVersion: String {
+    return Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? ""
+  }
+
+  var appDisplayVersion: String {
+    return Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? ""
+  }
 }

FirebaseSessions/Sources/FirebaseSessions.swift

@@ -40,6 +40,7 @@ protocol SessionsProvider {
   private let initiator: SessionInitiator
   private let identifiers: Identifiers
   private let appInfo: ApplicationInfo
+  private let settings: SettingsProtocol
 
   // MARK: - Initializers
 
@@ -57,23 +58,26 @@ protocol SessionsProvider {
     let coordinator = SessionCoordinator(identifiers: identifiers, fireLogger: fireLogger)
     let initiator = SessionInitiator()
     let appInfo = ApplicationInfo(appID: appID)
+    let settings = Settings(appInfo: appInfo)
 
     self.init(appID: appID,
               identifiers: identifiers,
               coordinator: coordinator,
               initiator: initiator,
-              appInfo: appInfo)
+              appInfo: appInfo,
+              settings: settings)
   }
 
   // Initializes the SDK and begines the process of listening for lifecycle events and logging events
   init(appID: String, identifiers: Identifiers, coordinator: SessionCoordinator,
-       initiator: SessionInitiator, appInfo: ApplicationInfo) {
+       initiator: SessionInitiator, appInfo: ApplicationInfo, settings: SettingsProtocol) {
     self.appID = appID
 
     self.identifiers = identifiers
     self.coordinator = coordinator
     self.initiator = initiator
     self.appInfo = appInfo
+    self.settings = settings
 
     super.init()
 

FirebaseSessions/Sources/Settings.swift

@@ -0,0 +1,100 @@
+//
+// Copyright 2022 Google LLC
+//
+// 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
+
+/// Extends ApplicationInfoProtocol to string-format a combined appDisplayVersion and appBuildVersion
+extension ApplicationInfoProtocol {
+  var synthesizedVersion: String { return "\(appDisplayVersion) (\(appBuildVersion))" }
+}
+
+/// Provides the APIs to access Settings and their configuration values
+protocol SettingsProtocol {
+  func isCacheExpired(currentTime: Date) -> Bool
+  var sessionsEnabled: Bool { get }
+  var samplingRate: Double { get }
+  var sessionTimeout: TimeInterval { get }
+}
+
+class Settings: SettingsProtocol {
+  private static let cacheDurationSecondsDefault: TimeInterval = 60 * 60
+  private static let flagSessionsEnabled = "sessions_enabled"
+  private static let flagSamplingRate = "sampling_rate"
+  private static let flagSessionTimeout = "session_timeout"
+  private static let flagCacheDuration = "cache_duration"
+  private let cache: SettingsCacheClient
+  private let appInfo: ApplicationInfoProtocol
+
+  var sessionsEnabled: Bool {
+    guard let enabled = cache.cacheContent?[Settings.flagSessionsEnabled] as? Bool else {
+      return true
+    }
+    return enabled
+  }
+
+  var samplingRate: Double {
+    guard let rate = cache.cacheContent?[Settings.flagSamplingRate] as? Double else {
+      return 1.0
+    }
+    return rate
+  }
+
+  var sessionTimeout: TimeInterval {
+    guard let timeout = cache.cacheContent?[Settings.flagSessionTimeout] as? Double else {
+      return 30 * 60
+    }
+    return timeout
+  }
+
+  private var cacheDurationSeconds: TimeInterval {
+    guard let duration = cache.cacheContent?[Settings.flagCacheDuration] as? Double else {
+      return Settings.cacheDurationSecondsDefault
+    }
+    return duration
+  }
+
+  init(cache: SettingsCacheClient = SettingsCache(),
+       appInfo: ApplicationInfoProtocol) {
+    self.cache = cache
+    self.appInfo = appInfo
+  }
+
+  func isCacheExpired(currentTime: Date) -> Bool {
+    guard cache.cacheContent != nil else {
+      cache.removeCache()
+      return true
+    }
+    guard let cacheKey = cache.cacheKey else {
+      Logger.logError("[Settings] Could not load settings cache key")
+      cache.removeCache()
+      return true
+    }
+    guard cacheKey.googleAppID == appInfo.appID else {
+      Logger
+        .logDebug("[Settings] Cache expired because Google App ID changed")
+      cache.removeCache()
+      return true
+    }
+    if currentTime.timeIntervalSince(cacheKey.createdAt) > cacheDurationSeconds {
+      Logger.logDebug("[Settings] Cache TTL expired")
+      return true
+    }
+    if appInfo.synthesizedVersion != cacheKey.appVersion {
+      Logger.logDebug("[Settings] Cache expired because app version changed")
+      return true
+    }
+    return false
+  }
+}

FirebaseSessions/Sources/SettingsCacheClient.swift

@@ -0,0 +1,65 @@
+//
+// Copyright 2022 Google LLC
+//
+// 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
+
+/// CacheKey is like a "key" to a "safe". It provides necessary metadata about the current cache to know if it should be expired.
+struct CacheKey: Codable {
+  var createdAt: Date
+  var googleAppID: String
+  var appVersion: String
+}
+
+/// SettingsCacheClient is responsible for accessing the cache that Settings are stored in.
+protocol SettingsCacheClient {
+  /// Returns in-memory cache content in O(1) time
+  var cacheContent: [String: Any]? { get }
+  /// Returns in-memory cache-key, no performance guarantee because type-casting depends on size of CacheKey
+  var cacheKey: CacheKey? { get }
+  /// Removes all cache content and cache-key
+  func removeCache()
+}
+
+/// SettingsCache uses UserDefaults to store Settings on-disk, but also directly query UserDefaults when accessing Settings values during run-time. This is because UserDefaults encapsulates both in-memory and persisted-on-disk storage, allowing fast synchronous access in-app while hiding away the complexity of managing persistence asynchronously.
+class SettingsCache: SettingsCacheClient {
+  private static let settingsVersion: Int = 1
+  private static let content: String = "firebase-sessions-settings"
+  private static let key: String = "firebase-sessions-cache-key"
+  /// UserDefaults holds values in memory, making access O(1) and synchronous within the app, while abstracting away async disk IO.
+  private let cache: UserDefaults = .standard
+
+  /// Converting to dictionary is O(1) because object conversion is O(1)
+  var cacheContent: [String: Any]? {
+    return cache.dictionary(forKey: SettingsCache.content)
+  }
+
+  /// Casting to Codable from Data is O(n)
+  var cacheKey: CacheKey? {
+    if let data = cache.data(forKey: SettingsCache.key) {
+      do {
+        return try JSONDecoder().decode(CacheKey.self, from: data)
+      } catch {
+        Logger.logError("[Settings] Decoding CacheKey failed with error: \(error)")
+      }
+    }
+    return nil
+  }
+
+  /// Removes stored cache
+  func removeCache() {
+    cache.set(nil, forKey: SettingsCache.content)
+    cache.set(nil, forKey: SettingsCache.key)
+  }
+}

FirebaseSessions/Tests/Unit/Mocks/MockApplicationInfo.swift

@@ -32,13 +32,19 @@ class MockApplicationInfo: ApplicationInfoProtocol {
 
   var environment: DevEnvironment = .prod
 
+  var appBuildVersion: String = ""
+
+  var appDisplayVersion: String = ""
+
   static let testAppID = "testAppID"
   static let testBundleID = "testBundleID"
   static let testSDKVersion = "testSDKVersion"
   static let testOSName = "ios"
   static let testMCCMNC = "testMCCMNC"
   static let testDeviceModel = "testDeviceModel"
   static let testEnvironment: DevEnvironment = .prod
+  static let testAppBuildVersion = "testAppBuildVersion"
+  static let testAppDisplayVersion = "testAppDisplayVersion"
 
   func mockAllInfo() {
     appID = MockApplicationInfo.testAppID
@@ -48,5 +54,7 @@ class MockApplicationInfo: ApplicationInfoProtocol {
     mccMNC = MockApplicationInfo.testMCCMNC
     deviceModel = MockApplicationInfo.testDeviceModel
     environment = MockApplicationInfo.testEnvironment
+    appBuildVersion = MockApplicationInfo.testAppBuildVersion
+    appDisplayVersion = MockApplicationInfo.testAppDisplayVersion
   }
 }