Apply sampling rate settings from configs (#10647)

Author: visumickey

FirebaseSessions/Sources/FirebaseSessions.swift

@@ -38,7 +38,7 @@ protocol SessionsProvider {
   /// Top-level Classes in the Sessions SDK
   private let coordinator: SessionCoordinator
   private let initiator: SessionInitiator
-  private let identifiers: Identifiers
+  private let sessionGenerator: SessionGenerator
   private let appInfo: ApplicationInfo
   private let settings: SessionsSettings
 
@@ -54,35 +54,34 @@ protocol SessionsProvider {
 
     let fireLogger = EventGDTLogger(googleDataTransport: googleDataTransport!)
 
-    let identifiers = Identifiers()
-    let coordinator = SessionCoordinator(
-      identifiers: identifiers,
-      installations: installations,
-      fireLogger: fireLogger,
-      sampler: SessionSampler()
-    )
-
     let appInfo = ApplicationInfo(appID: appID)
     let settings = SessionsSettings(
       appInfo: appInfo,
       installations: installations
     )
+
+    let sessionGenerator = SessionGenerator(settings: settings)
+    let coordinator = SessionCoordinator(
+      installations: installations,
+      fireLogger: fireLogger
+    )
+
     let initiator = SessionInitiator(settings: settings)
 
     self.init(appID: appID,
-              identifiers: identifiers,
+              sessionGenerator: sessionGenerator,
               coordinator: coordinator,
               initiator: initiator,
               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,
+  init(appID: String, sessionGenerator: SessionGenerator, coordinator: SessionCoordinator,
        initiator: SessionInitiator, appInfo: ApplicationInfo, settings: SessionsSettings) {
     self.appID = appID
 
-    self.identifiers = identifiers
+    self.sessionGenerator = sessionGenerator
     self.coordinator = coordinator
     self.initiator = initiator
     self.appInfo = appInfo
@@ -93,10 +92,10 @@ protocol SessionsProvider {
     self.initiator.beginListening {
       // On each session start, first update Settings if expired
       self.settings.updateSettings()
-      self.identifiers.generateNewSessionID()
-      // Generate a session start event only when session data collection is enabled.
-      if self.settings.sessionsEnabled {
-        let event = SessionStartEvent(identifiers: self.identifiers, appInfo: self.appInfo)
+      let session = self.sessionGenerator.generateNewSession()
+      // Generate a session start event only when session data collection is enabled and if the session is allowed to dispatch events
+      if self.settings.sessionsEnabled, session.shouldDispatchEvents {
+        let event = SessionStartEvent(sessionInfo: session, appInfo: self.appInfo)
         DispatchQueue.global().async {
           self.coordinator.attemptLoggingSessionStart(event: event) { result in
           }

FirebaseSessions/Sources/Identifiers.swift

@@ -19,19 +19,13 @@ import Foundation
 /// involved with sending a Session Start event.
 ///
 class SessionCoordinator {
-  let identifiers: IdentifierProvider
   let installations: InstallationsProtocol
   let fireLogger: EventGDTLoggerProtocol
-  let sampler: SessionSamplerProtocol
 
-  init(identifiers: IdentifierProvider,
-       installations: InstallationsProtocol,
-       fireLogger: EventGDTLoggerProtocol,
-       sampler: SessionSamplerProtocol) {
-    self.identifiers = identifiers
+  init(installations: InstallationsProtocol,
+       fireLogger: EventGDTLoggerProtocol) {
     self.installations = installations
     self.fireLogger = fireLogger
-    self.sampler = sampler
   }
 
   // Begins the process of logging a SessionStartEvent to FireLog, while taking into account Data Collection, Sampling, and fetching Settings
@@ -41,38 +35,30 @@ class SessionCoordinator {
     /// 1. Check if the session can be sent. If yes, move to 2. Else, drop the event.
     /// 2. Fetch the installations Id. If successful, move to 3. Else, drop sending the event.
     /// 3. Log the event. If successful, all is good. Else, log the message with error.
-    if sampler.shouldSendEventForSession(sessionId: identifiers.sessionID) {
-      installations.installationID { result in
-        switch result {
-        case let .success(fiid):
-          event.setInstallationID(installationId: fiid)
-          self.fireLogger.logEvent(event: event) { logResult in
-            switch logResult {
-            case .success():
-              Logger.logInfo("Successfully logged Session Start event to GoogleDataTransport")
-              callback(.success(()))
-            case let .failure(error):
-              Logger
-                .logError(
-                  "Error logging Session Start event to GoogleDataTransport: \(error)."
-                )
-              callback(.failure(error))
-            }
+    installations.installationID { result in
+      switch result {
+      case let .success(fiid):
+        event.setInstallationID(installationId: fiid)
+        self.fireLogger.logEvent(event: event) { logResult in
+          switch logResult {
+          case .success():
+            Logger.logInfo("Successfully logged Session Start event to GoogleDataTransport")
+            callback(.success(()))
+          case let .failure(error):
+            Logger
+              .logError(
+                "Error logging Session Start event to GoogleDataTransport: \(error)."
+              )
+            callback(.failure(error))
           }
-        case let .failure(error):
-          Logger
-            .logError(
-              "Error getting Firebase Installation ID: \(error). Skip sending event."
-            )
-          callback(.failure(FirebaseSessionsError.SessionInstallationsError))
         }
+      case let .failure(error):
+        Logger
+          .logError(
+            "Error getting Firebase Installation ID: \(error). Skip sending event."
+          )
+        callback(.failure(FirebaseSessionsError.SessionInstallationsError))
       }
-    } else {
-      Logger
-        .logInfo(
-          "Session event dropped due to sampling."
-        )
-      callback(.failure(FirebaseSessionsError.SessionSamplingError))
     }
   }
 }

FirebaseSessions/Sources/SessionCoordinator.swift

@@ -0,0 +1,68 @@
+//
+// 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 FirebaseInstallations
+
+struct SessionInfo {
+  let sessionId: String
+  let previousSessionId: String?
+  let shouldDispatchEvents: Bool
+
+  init(sessionId: String, previousSessionId: String?, dispatchEvents: Bool) {
+    self.sessionId = sessionId
+    self.previousSessionId = previousSessionId
+    shouldDispatchEvents = dispatchEvents
+  }
+}
+
+///
+/// Generator is responsible for:
+///   1) Generating the Session ID
+///   2) Persisting and reading the Session ID from the last session
+///   (Maybe) 3) Persisting, reading, and incrementing an increasing index
+///
+class SessionGenerator {
+  private var thisSession: SessionInfo?
+  private var settings: SessionsSettings
+
+  init(settings: SessionsSettings) {
+    self.settings = settings
+  }
+
+  // Generates a new Session ID. If there was already a generated Session ID
+  // from the last session during the app's lifecycle, it will also set the last Session ID
+  func generateNewSession() -> SessionInfo {
+    let newSessionId = UUID().uuidString.replacingOccurrences(of: "-", with: "").lowercased()
+
+    var collectEvents = true
+    let randomValue = Double.random(in: 0 ... 1)
+
+    if randomValue > settings.samplingRate {
+      collectEvents = false
+    }
+
+    let newSession = SessionInfo(sessionId: newSessionId,
+                                 previousSessionId: thisSession?.sessionId,
+                                 dispatchEvents: collectEvents)
+    thisSession = newSession
+    return newSession
+  }
+
+  func currentSession() -> SessionInfo? {
+    return thisSession
+  }
+}

FirebaseSessions/Sources/SessionGenerator.swift

@@ -35,15 +35,15 @@ import Foundation
 class SessionStartEvent: NSObject, GDTCOREventDataObject {
   var proto: firebase_appquality_sessions_SessionEvent
 
-  init(identifiers: IdentifierProvider, appInfo: ApplicationInfoProtocol,
+  init(sessionInfo: SessionInfo, appInfo: ApplicationInfoProtocol,
        time: TimeProvider = Time()) {
     proto = firebase_appquality_sessions_SessionEvent()
 
     super.init()
 
     proto.event_type = firebase_appquality_sessions_EventType_SESSION_START
-    proto.session_data.session_id = makeProtoString(identifiers.sessionID)
-    proto.session_data.previous_session_id = makeProtoStringOrNil(identifiers.previousSessionID)
+    proto.session_data.session_id = makeProtoString(sessionInfo.sessionId)
+    proto.session_data.previous_session_id = makeProtoStringOrNil(sessionInfo.previousSessionId)
     proto.session_data.event_timestamp_us = time.timestampUS
 
     proto.application_info.app_id = makeProtoString(appInfo.appID)

FirebaseSessions/Sources/SessionSampler.swift

@@ -22,23 +22,34 @@ class LocalOverrideSettings: SettingsProvider, SettingsProtocol {
   static let PlistKey_sessions_samplingRate = "FirebaseSessionsSampingRate"
 
   var sessionsEnabled: Bool? {
-    return plistValueForConfig(configName: LocalOverrideSettings.PlistKey_sessions_enabled) as? Bool
+    let session_enabled = plistValueForConfig(configName: LocalOverrideSettings
+      .PlistKey_sessions_enabled) as? Bool
+    if session_enabled != nil {
+      return Bool(session_enabled!)
+    }
+    return nil
   }
 
   var sessionTimeout: TimeInterval? {
-    return
-      plistValueForConfig(configName: LocalOverrideSettings
-        .PlistKey_sessions_timeout) as? TimeInterval
+    let timeout = plistValueForConfig(configName: LocalOverrideSettings
+      .PlistKey_sessions_timeout) as? String
+    if timeout != nil {
+      return Double(timeout!)
+    }
+    return nil
   }
 
   var samplingRate: Double? {
-    return
-      plistValueForConfig(configName: LocalOverrideSettings
-        .PlistKey_sessions_samplingRate) as? Double
+    let rate = plistValueForConfig(configName: LocalOverrideSettings
+      .PlistKey_sessions_samplingRate) as? String
+    if rate != nil {
+      return Double(rate!)
+    }
+    return nil
   }
 
   private func plistValueForConfig(configName: String) -> Any? {
-    return Bundle.main.object(forInfoDictionaryKey: configName)
+    return Bundle.main.infoDictionary?[configName]
   }
 }