Settings downloader (#10530)

* initial code for downloader

* WIP fetchAndCacheSettings

* fill out request headers

* onComplete

* working fetch

* WIP tests

* working tests

* merge conflicts

* comments

* fix warning in pod-lib-lint

* logger when cache does not expire

* comments

* move os info to ApplicationInfo and fix URL's platform

* if cache does not exist, return empty dictionary instead of nil

* unshadow variable in guard-let statement

* add comment describing task.resume()

* addressing reviews

* attempt fetch every session instead of every app-start

* address last review

Author: leotianlizhan

FirebaseSessions/Sources/ApplicationInfo.swift

@@ -50,6 +50,10 @@ protocol ApplicationInfoProtocol {
   var appBuildVersion: String { get }
 
   var appDisplayVersion: String { get }
+
+  var osBuildVersion: String { get }
+
+  var osDisplayVersion: String { get }
 }
 
 class ApplicationInfo: ApplicationInfoProtocol {
@@ -100,4 +104,12 @@ class ApplicationInfo: ApplicationInfoProtocol {
   var appDisplayVersion: String {
     return Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? ""
   }
+
+  var osBuildVersion: String {
+    return FIRSESGetSysctlEntry("kern.osversion") ?? ""
+  }
+
+  var osDisplayVersion: String {
+    return GULAppEnvironmentUtil.systemVersion()
+  }
 }

FirebaseSessions/Sources/FirebaseSessions.swift

@@ -63,7 +63,14 @@ protocol SessionsProvider {
     )
     let initiator = SessionInitiator()
     let appInfo = ApplicationInfo(appID: appID)
-    let settings = Settings(appInfo: appInfo)
+    let settings = Settings(
+      appInfo: appInfo,
+      downloader: SettingsDownloader(
+        appInfo: appInfo,
+        identifiers: identifiers,
+        installations: installations
+      )
+    )
 
     self.init(appID: appID,
               identifiers: identifiers,
@@ -87,6 +94,8 @@ protocol SessionsProvider {
     super.init()
 
     self.initiator.beginListening {
+      // On each session start, first update Settings if expired
+      self.settings.fetchAndCacheSettings()
       self.identifiers.generateNewSessionID()
       let event = SessionStartEvent(identifiers: self.identifiers, appInfo: self.appInfo)
       DispatchQueue.global().async {

FirebaseSessions/Sources/FirebaseSessionsError.swift

@@ -20,4 +20,6 @@ enum FirebaseSessionsError: Error {
   case SessionSamplingError
   /// Firebase Installation ID related error
   case SessionInstallationsError
+  /// Settings related error
+  case SettingsError(String)
 }

FirebaseSessions/Sources/NanoPB/FIRSESNanoPBHelpers.h

@@ -82,6 +82,10 @@ BOOL FIRSESIsPBDataEqual(pb_bytes_array_t* _Nullable pbArray, NSData* _Nullable
 /// Swift does not support c-style macros.
 pb_size_t FIRSESGetAppleApplicationInfoTag(void);
 
+/// Returns sysctl entry, useful for obtaining OS build version from the kernel. Copied from a
+/// private method in GULAppEnvironmentUtil.
+NSString* _Nullable FIRSESGetSysctlEntry(const char* sysctlKey);
+
 /// Returns the validated MccMnc if it is available, or nil if the device does not support telephone
 NSString* _Nullable FIRSESValidateMccMnc(NSString* _Nullable mcc, NSString* _Nullable mnc);
 

FirebaseSessions/Sources/NanoPB/FIRSESNanoPBHelpers.m

@@ -24,6 +24,7 @@
 #import <nanopb/pb.h>
 #import <nanopb/pb_decode.h>
 #import <nanopb/pb_encode.h>
+#import <sys/sysctl.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -157,6 +158,22 @@ pb_size_t FIRSESGetAppleApplicationInfoTag(void) {
   return firebase_appquality_sessions_ApplicationInfo_apple_app_info_tag;
 }
 
+/// Copied from a private method in GULAppEnvironmentUtil.
+NSString *_Nullable FIRSESGetSysctlEntry(const char *sysctlKey) {
+  static NSString *entryValue;
+  size_t size;
+  sysctlbyname(sysctlKey, NULL, &size, NULL, 0);
+  if (size > 0) {
+    char *entryValueCStr = malloc(size);
+    sysctlbyname(sysctlKey, entryValueCStr, &size, NULL, 0);
+    entryValue = [NSString stringWithCString:entryValueCStr encoding:NSUTF8StringEncoding];
+    free(entryValueCStr);
+    return entryValue;
+  } else {
+    return nil;
+  }
+}
+
 NSString *_Nullable FIRSESValidateMccMnc(NSString *_Nullable mcc, NSString *_Nullable mnc) {
   // These are both nil if the target does not support mobile connectivity
   if (mcc == nil && mnc == nil) {

FirebaseSessions/Sources/Settings.swift

@@ -20,9 +20,16 @@ extension ApplicationInfoProtocol {
   var synthesizedVersion: String { return "\(appDisplayVersion) (\(appBuildVersion))" }
 }
 
+extension SettingsProtocol {
+  func fetchAndCacheSettings() {
+    return fetchAndCacheSettings(currentTime: Date())
+  }
+}
+
 /// Provides the APIs to access Settings and their configuration values
 protocol SettingsProtocol {
-  func isCacheExpired(currentTime: Date) -> Bool
+  /// Attempts to fetch settings only if the current cache is expired
+  func fetchAndCacheSettings(currentTime: Date)
   var sessionsEnabled: Bool { get }
   var samplingRate: Double { get }
   var sessionTimeout: TimeInterval { get }
@@ -32,47 +39,79 @@ 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 flagSessionTimeout = "session_timeout_seconds"
   private static let flagCacheDuration = "cache_duration"
-  private let cache: SettingsCacheClient
+  private static let flagSessionsCache = "app_quality"
   private let appInfo: ApplicationInfoProtocol
+  private let downloader: SettingsDownloadClient
+  private var cache: SettingsCacheClient
 
   var sessionsEnabled: Bool {
-    guard let enabled = cache.cacheContent?[Settings.flagSessionsEnabled] as? Bool else {
+    guard let enabled = sessionsCache[Settings.flagSessionsEnabled] as? Bool else {
       return true
     }
     return enabled
   }
 
   var samplingRate: Double {
-    guard let rate = cache.cacheContent?[Settings.flagSamplingRate] as? Double else {
+    guard let rate = sessionsCache[Settings.flagSamplingRate] as? Double else {
       return 1.0
     }
     return rate
   }
 
   var sessionTimeout: TimeInterval {
-    guard let timeout = cache.cacheContent?[Settings.flagSessionTimeout] as? Double else {
+    guard let timeout = sessionsCache[Settings.flagSessionTimeout] as? Double else {
       return 30 * 60
     }
     return timeout
   }
 
   private var cacheDurationSeconds: TimeInterval {
-    guard let duration = cache.cacheContent?[Settings.flagCacheDuration] as? Double else {
+    guard let duration = cache.cacheContent[Settings.flagCacheDuration] as? Double else {
       return Settings.cacheDurationSecondsDefault
     }
     return duration
   }
 
-  init(cache: SettingsCacheClient = SettingsCache(),
-       appInfo: ApplicationInfoProtocol) {
-    self.cache = cache
+  private var sessionsCache: [String: Any] {
+    return cache.cacheContent[Settings.flagSessionsCache] as? [String: Any] ?? [:]
+  }
+
+  init(appInfo: ApplicationInfoProtocol,
+       downloader: SettingsDownloadClient,
+       cache: SettingsCacheClient = SettingsCache()) {
     self.appInfo = appInfo
+    self.cache = cache
+    self.downloader = downloader
+  }
+
+  func fetchAndCacheSettings(currentTime: Date) {
+    // Only fetch if cache is expired, otherwise do nothing
+    guard isCacheExpired(time: currentTime) else {
+      Logger.logDebug("[Settings] Cache is not expired, no fetch will be made.")
+      return
+    }
+
+    downloader.fetch { result in
+      switch result {
+      case let .success(dictionary):
+        // Saves all newly fetched Settings to cache
+        self.cache.cacheContent = dictionary
+        // Saves a "cache-key" which carries TTL metadata about current cache
+        self.cache.cacheKey = CacheKey(
+          createdAt: currentTime,
+          googleAppID: self.appInfo.appID,
+          appVersion: self.appInfo.synthesizedVersion
+        )
+      case let .failure(error):
+        Logger.logError("[Settings] Fetching newest settings failed with error: \(error)")
+      }
+    }
   }
 
-  func isCacheExpired(currentTime: Date) -> Bool {
-    guard cache.cacheContent != nil else {
+  private func isCacheExpired(time: Date) -> Bool {
+    guard !cache.cacheContent.isEmpty else {
       cache.removeCache()
       return true
     }
@@ -87,7 +126,7 @@ class Settings: SettingsProtocol {
       cache.removeCache()
       return true
     }
-    if currentTime.timeIntervalSince(cacheKey.createdAt) > cacheDurationSeconds {
+    if time.timeIntervalSince(cacheKey.createdAt) > cacheDurationSeconds {
       Logger.logDebug("[Settings] Cache TTL expired")
       return true
     }

FirebaseSessions/Sources/SettingsCacheClient.swift

@@ -24,42 +24,59 @@ struct CacheKey: Codable {
 
 /// 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 content in O(1) time. Returns empty dictionary if it does not exist in cache.
+  var cacheContent: [String: Any] { get set }
   /// Returns in-memory cache-key, no performance guarantee because type-casting depends on size of CacheKey
-  var cacheKey: CacheKey? { get }
+  var cacheKey: CacheKey? { get set }
   /// 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"
+  private enum UserDefaultsKeys {
+    static let forContent = "firebase-sessions-settings"
+    static let forCacheKey = "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)
+  var cacheContent: [String: Any] {
+    get {
+      return cache.dictionary(forKey: UserDefaultsKeys.forContent) ?? [:]
+    }
+    set {
+      cache.set(newValue, forKey: UserDefaultsKeys.forContent)
+    }
   }
 
   /// Casting to Codable from Data is O(n)
   var cacheKey: CacheKey? {
-    if let data = cache.data(forKey: SettingsCache.key) {
+    get {
+      if let data = cache.data(forKey: UserDefaultsKeys.forCacheKey) {
+        do {
+          return try JSONDecoder().decode(CacheKey.self, from: data)
+        } catch {
+          Logger.logError("[Settings] Decoding CacheKey failed with error: \(error)")
+        }
+      }
+      return nil
+    }
+    set {
       do {
-        return try JSONDecoder().decode(CacheKey.self, from: data)
+        cache.set(try JSONEncoder().encode(newValue), forKey: UserDefaultsKeys.forCacheKey)
       } catch {
-        Logger.logError("[Settings] Decoding CacheKey failed with error: \(error)")
+        Logger.logError("[Settings] Encoding CacheKey failed with error: \(error)")
       }
     }
-    return nil
   }
 
   /// Removes stored cache
   func removeCache() {
-    cache.set(nil, forKey: SettingsCache.content)
-    cache.set(nil, forKey: SettingsCache.key)
+    cache.set(nil, forKey: UserDefaultsKeys.forContent)
+    cache.set(nil, forKey: UserDefaultsKeys.forCacheKey)
   }
 }

FirebaseSessions/Sources/SettingsDownloadClient.swift

@@ -0,0 +1,94 @@
+//
+// 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
+
+@_implementationOnly import GoogleUtilities
+
+protocol SettingsDownloadClient {
+  func fetch(completion: @escaping (Result<[String: Any], Error>) -> Void)
+}
+
+class SettingsDownloader: SettingsDownloadClient {
+  private let appInfo: ApplicationInfoProtocol
+  private let identifiers: IdentifierProvider
+  private let installations: InstallationsProtocol
+
+  init(appInfo: ApplicationInfoProtocol, identifiers: IdentifierProvider,
+       installations: InstallationsProtocol) {
+    self.appInfo = appInfo
+    self.identifiers = identifiers
+    self.installations = installations
+  }
+
+  func fetch(completion: @escaping (Result<[String: Any], Error>) -> Void) {
+    guard let validURL = url else {
+      completion(.failure(FirebaseSessionsError.SettingsError("Invalid URL")))
+      return
+    }
+
+    installations.installationID { result in
+      switch result {
+      case let .success(fiid):
+        let request = self.buildRequest(url: validURL, fiid: fiid)
+        let task = URLSession.shared.dataTask(with: request) { data, response, error in
+          if let data = data {
+            if let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+              completion(.success(dict))
+            } else {
+              completion(.failure(FirebaseSessionsError
+                  .SettingsError("Failed to parse JSON to dictionary")))
+            }
+          } else if let error = error {
+            completion(.failure(FirebaseSessionsError.SettingsError(error.localizedDescription)))
+          }
+        }
+        // Start the task that sends the network request
+        task.resume()
+      case let .failure(error):
+        completion(.failure(FirebaseSessionsError.SettingsError(error.localizedDescription)))
+      }
+    }
+  }
+
+  private var url: URL? {
+    var components = URLComponents()
+    components.scheme = "https"
+    components.host = "firebase-settings.crashlytics.com"
+    components.path = "/spi/v2/platforms/\(appInfo.osName)/gmp/\(appInfo.appID)/settings"
+    components.queryItems = [
+      URLQueryItem(name: "build_version", value: appInfo.appBuildVersion),
+      URLQueryItem(name: "display_version", value: appInfo.appDisplayVersion),
+    ]
+    return components.url
+  }
+
+  private func buildRequest(url: URL, fiid: String) -> URLRequest {
+    var request = URLRequest(url: url)
+    request.setValue("application/json", forHTTPHeaderField: "Accept")
+    request.setValue(fiid, forHTTPHeaderField: "X-Crashlytics-Installation-ID")
+    request.setValue(appInfo.deviceModel, forHTTPHeaderField: "X-Crashlytics-Device-Model")
+    request.setValue(
+      appInfo.osBuildVersion,
+      forHTTPHeaderField: "X-Crashlytics-OS-Build-Version"
+    )
+    request.setValue(
+      appInfo.osDisplayVersion,
+      forHTTPHeaderField: "X-Crashlytics-OS-Display-Version"
+    )
+    request.setValue(appInfo.sdkVersion, forHTTPHeaderField: "X-Crashlytics-API-Client-Version")
+    return request
+  }
+}