Fireperf: dropping app start events when they are prewarmed. (#9104)

* Prototype of dropping app start events when they are prewarmed.

* fixing a bug and adding tests for isApplicationPrewarmed

* remove comments

* formatting

* added a plist flag to disable double dispatch

* adding RC

* formatting

* use GULAppEnvironmentUtil for checking iOS version

* add tests

* formatting

* comment

* drop counters

* dropped _as duration counter

* formatting

* Revert "formatting"

This reverts commit bd6b82b.

* Revert "dropped _as duration counter"

This reverts commit ef8a901.

* Revert "drop counters"

This reverts commit 38d2032.

* fix most PR comments

* enum

* formatting

* move dropping all events out of isApplicationPreWarmed

* fix tests

* formatting

* default to OnlyActivePrewarm

* code review changes

* formatting

* fix names in comments

* comments

* formatting

* fix test name

Co-authored-by: Leo Zhan <[email protected]>

Author: visumickey

FirebasePerformance/Sources/AppActivity/FPRAppActivityTracker.m

@@ -24,7 +24,11 @@
 #import "FirebasePerformance/Sources/Timer/FIRTrace+Internal.h"
 #import "FirebasePerformance/Sources/Timer/FIRTrace+Private.h"
 
+#import <GoogleUtilities/GULAppEnvironmentUtil.h>
+
 static NSDate *appStartTime = nil;
+static NSDate *doubleDispatchTime = nil;
+static NSDate *applicationDidFinishLaunchTime = nil;
 static NSTimeInterval gAppStartMaxValidDuration = 60 * 60;  // 60 minutes.
 static FPRCPUGaugeData *gAppStartCPUGaugeData = nil;
 static FPRMemoryGaugeData *gAppStartMemoryGaugeData = nil;
@@ -56,6 +60,9 @@ @interface FPRAppActivityTracker ()
 /** Tracks if the gauge metrics are dispatched. */
 @property(nonatomic) BOOL appStartGaugeMetricDispatched;
 
+/** Firebase Performance Configuration object */
+@property(nonatomic) FPRConfigurations *configurations;
+
 /** Starts tracking app active sessions. */
 - (void)startAppActivityTracking;
 
@@ -66,12 +73,28 @@ @implementation FPRAppActivityTracker
 + (void)load {
   // This is an approximation of the app start time.
   appStartTime = [NSDate date];
+
+  // Double dispatch is used to detect prewarming, but if it causes hang or crash in the future
+  // developers can disable it by setting a plist flag "fireperf_disable_dd" to true
+  if ([[[NSBundle mainBundle] objectForInfoDictionaryKey:@"fireperf_disable_dd"] boolValue] == NO) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      dispatch_async(dispatch_get_main_queue(), ^{
+        doubleDispatchTime = [NSDate date];
+      });
+    });
+  }
+
   gAppStartCPUGaugeData = fprCollectCPUMetric();
   gAppStartMemoryGaugeData = fprCollectMemoryMetric();
   [[NSNotificationCenter defaultCenter] addObserver:self
                                            selector:@selector(windowDidBecomeVisible:)
                                                name:UIWindowDidBecomeVisibleNotification
                                              object:nil];
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(applicationDidFinishLaunching:)
+                                               name:UIApplicationDidFinishLaunchingNotification
+                                             object:nil];
 }
 
 + (void)windowDidBecomeVisible:(NSNotification *)notification {
@@ -83,6 +106,13 @@ + (void)windowDidBecomeVisible:(NSNotification *)notification {
                                                 object:nil];
 }
 
++ (void)applicationDidFinishLaunching:(NSNotification *)notification {
+  applicationDidFinishLaunchTime = [NSDate date];
+  [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                  name:UIApplicationDidFinishLaunchingNotification
+                                                object:nil];
+}
+
 + (instancetype)sharedInstance {
   static FPRAppActivityTracker *instance;
   static dispatch_once_t onceToken;
@@ -99,6 +129,7 @@ - (instancetype)initAppActivityTracker {
   self = [super init];
   _applicationState = FPRApplicationStateUnknown;
   _appStartGaugeMetricDispatched = NO;
+  _configurations = [FPRConfigurations sharedInstance];
   return self;
 }
 
@@ -121,6 +152,70 @@ - (FIRTrace *)activeTrace {
   return self.backgroundSessionTrace;
 }
 
+/**
+ * Checks if prewarming is available for the platform on current device.
+ * It is available when running iOS 15 and above.
+ *
+ * @return true if the platform could prewarm apps on the current device
+ */
++ (BOOL)isPrewarmAvailable {
+  if (![[[GULAppEnvironmentUtil applePlatform] lowercaseString] isEqualToString:@"ios"]) {
+    return NO;
+  }
+  NSString *systemVersion = [GULAppEnvironmentUtil systemVersion];
+  if ([systemVersion length] == 0) {
+    return NO;
+  }
+  return [systemVersion compare:@"15" options:NSNumericSearch] != NSOrderedAscending;
+}
+
+/**
+ RC flag for dropping all app start events
+ */
+- (BOOL)isAppStartEnabled {
+  return [self.configurations prewarmDetectionMode] != PrewarmDetectionModeKeepNone;
+}
+
+/**
+ RC flag for enabling prewarm-detection using ActivePrewarm environment variable
+ */
+- (BOOL)isActivePrewarmEnabled {
+  PrewarmDetectionMode mode = [self.configurations prewarmDetectionMode];
+  return (mode == PrewarmDetectionModeActivePrewarm ||
+          mode == PrewarmDetectionModeActivePrewarmOrDoubleDispatch);
+}
+
+/**
+ RC flag for enabling prewarm-detection using double dispatch method
+ */
+- (BOOL)isDoubleDispatchEnabled {
+  PrewarmDetectionMode mode = [self.configurations prewarmDetectionMode];
+  return (mode == PrewarmDetectionModeDoubleDispatch ||
+          mode == PrewarmDetectionModeActivePrewarmOrDoubleDispatch);
+}
+
+/**
+ Checks if the current app start is a prewarmed app start
+ */
+- (BOOL)isApplicationPreWarmed {
+  if (![FPRAppActivityTracker isPrewarmAvailable]) {
+    return NO;
+  }
+
+  NSDictionary<NSString *, NSString *> *environment = [NSProcessInfo processInfo].environment;
+  BOOL activePrewarmFlagValue = [environment[@"ActivePrewarm"] boolValue];
+  if ([self isActivePrewarmEnabled] && activePrewarmFlagValue == YES) {
+    return YES;
+  }
+
+  if ([self isDoubleDispatchEnabled] &&
+      [doubleDispatchTime compare:applicationDidFinishLaunchTime] == NSOrderedAscending) {
+    return YES;
+  }
+
+  return NO;
+}
+
 /**
  * This gets called whenever the app becomes active. A new trace will be created to track the active
  * foreground session. Any background session trace that was running in the past will be stopped.
@@ -173,7 +268,8 @@ - (void)appDidBecomeActiveNotification:(NSNotification *)notification {
       // happens a lot later.
       // Dropping the app start trace in such situations where the launch time is taking more than
       // 60 minutes. This is an approximation, but a more agreeable timelimit for app start.
-      if (currentTimeSinceEpoch - startTimeSinceEpoch < gAppStartMaxValidDuration) {
+      if ((currentTimeSinceEpoch - startTimeSinceEpoch < gAppStartMaxValidDuration) &&
+          [self isAppStartEnabled] && ![self isApplicationPreWarmed]) {
         [self.appStartTrace stop];
       } else {
         [self.appStartTrace cancel];

FirebasePerformance/Sources/Configurations/FPRConfigurations.h

@@ -16,6 +16,22 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+/**
+ * Different modes of prewarm-detection
+ * KeepNone = No app start events are allowed
+ * ActivePrewarm = Only detect prewarming using ActivePrewarm environment
+ * DoubleDispatch = Only detect prewarming using double dispatch method
+ * ActivePrewarmOrDoubleDispatch = Detect prewarming using both ActivePrewarm and double dispatch
+ * KeepAll = All app start events are allowed
+ */
+typedef NS_ENUM(NSInteger, PrewarmDetectionMode) {
+  PrewarmDetectionModeKeepNone = 0,
+  PrewarmDetectionModeActivePrewarm = 1,
+  PrewarmDetectionModeDoubleDispatch = 2,
+  PrewarmDetectionModeActivePrewarmOrDoubleDispatch = 3,
+  PrewarmDetectionModeKeepAll = 4
+};
+
 /** A typedef for ensuring that config names are one of the below specified strings. */
 typedef NSString* const FPRConfigName;
 
@@ -62,6 +78,14 @@ FOUNDATION_EXTERN FPRConfigName kFPRConfigInstrumentationEnabled;
 
 #pragma mark - Configuration fetcher methods.
 
+/**
+ * Returns the mode that prewarm-detection should drop events in.
+ *
+ * @see PrewarmDetectionMode
+ * @return filter mode of app start traces prewarm-detection
+ */
+- (PrewarmDetectionMode)prewarmDetectionMode;
+
 /**
  * Returns the percentage of instances that would send trace events. Range [0-1].
  *

FirebasePerformance/Sources/Configurations/FPRConfigurations.m

@@ -300,6 +300,15 @@ - (int)logSource {
   return logSource;
 }
 
+- (PrewarmDetectionMode)prewarmDetectionMode {
+  PrewarmDetectionMode mode = PrewarmDetectionModeActivePrewarm;
+  if (self.remoteConfigFlags) {
+    mode = [self.remoteConfigFlags getIntValueForFlag:@"fpr_prewarm_detection"
+                                         defaultValue:(int)mode];
+  }
+  return mode;
+}
+
 #pragma mark - Log sampling configurations.
 
 - (float)logTraceSamplingRate {

FirebasePerformance/Sources/Configurations/FPRRemoteConfigFlags.m

@@ -103,6 +103,7 @@ - (instancetype)initWithRemoteConfig:(FIRRemoteConfig *)config {
     [keysToCache setObject:@(FPRConfigValueTypeInteger)
                     forKey:@"fpr_session_gauge_memory_capture_frequency_bg_ms"];
     [keysToCache setObject:@(FPRConfigValueTypeInteger) forKey:@"fpr_session_max_duration_min"];
+    [keysToCache setObject:@(FPRConfigValueTypeInteger) forKey:@"fpr_prewarm_detection"];
     self.configKeys = [keysToCache copy];
 
     [self update];

FirebasePerformance/Tests/Unit/Configurations/FPRConfigurationsTest.m

@@ -539,4 +539,30 @@ - (void)testSessionMaxLengthDurationRemoteConfigOverrides {
   [configFlags resetCache];
 }
 
+- (void)testPrewarmDetectionRemoteConfigOverrides {
+  FPRConfigurations *configurations =
+      [[FPRConfigurations alloc] initWithSources:FPRConfigurationSourceRemoteConfig];
+
+  FPRFakeRemoteConfig *remoteConfig = [[FPRFakeRemoteConfig alloc] init];
+  FPRRemoteConfigFlags *configFlags =
+      [[FPRRemoteConfigFlags alloc] initWithRemoteConfig:(FIRRemoteConfig *)remoteConfig];
+  configurations.remoteConfigFlags = configFlags;
+  configFlags.lastFetchedTime = [NSDate date];
+
+  NSUserDefaults *userDefaults = [[NSUserDefaults alloc] init];
+  configFlags.userDefaults = userDefaults;
+
+  NSString *configKey =
+      [NSString stringWithFormat:@"%@.%@", kFPRConfigPrefix, @"fpr_prewarm_detection"];
+  [userDefaults setObject:@(0) forKey:configKey];
+  XCTAssertEqual([configurations prewarmDetectionMode], 0);
+
+  [userDefaults setObject:@(1) forKey:configKey];
+  XCTAssertEqual([configurations prewarmDetectionMode], 1);
+
+  [userDefaults setObject:@(2) forKey:configKey];
+  XCTAssertEqual([configurations prewarmDetectionMode], 2);
+  [configFlags resetCache];
+}
+
 @end