Merge 8102e0f into 8fe1383

Author: tejasd

firebase-perf/src/main/java/com/google/firebase/perf/FirebasePerfEarly.java

@@ -51,12 +51,8 @@ public FirebasePerfEarly(
       uiExecutor.execute(new AppStartTrace.StartFromBackgroundRunnable(appStartTrace));
     }
 
-    // TODO: Bring back Firebase Sessions dependency to watch for updates to sessions.
+    // In the case of a cold start, we initialize gauge collection with a legacy PerfSession.
 
-    // In the case of cold start, we create a session and start collecting gauges as early as
-    // possible.
-    // There is code in SessionManager that prevents us from resetting the session twice in case
-    // of app cold start.
     SessionManager.getInstance().initializeGaugeCollection();
   }
 }

firebase-perf/src/main/java/com/google/firebase/perf/session/FirebasePerformanceSessionSubscriber.kt

@@ -28,12 +28,19 @@ class FirebasePerformanceSessionSubscriber(override val isDataCollectionEnabled:
 
   override fun onSessionChanged(sessionDetails: SessionSubscriber.SessionDetails) {
     val currentPerfSession = SessionManager.getInstance().perfSession()
-    // TODO(b/394127311): Add logic to deal with app start gauges.
     FirebaseSessionsEnforcementCheck.checkSession(currentPerfSession, "onSessionChanged")
 
+    if (currentPerfSession.isLegacy() && currentPerfSession.isVerbose) {
+      GaugeManager.getInstance()
+        .logGaugeMetadata(sessionDetails.sessionId, ApplicationProcessState.FOREGROUND)
+      GaugeManager.getInstance()
+        .logExistingGaugeMetrics(sessionDetails.sessionId, ApplicationProcessState.FOREGROUND)
+    }
+
     val updatedSession = PerfSession.createWithId(sessionDetails.sessionId)
     SessionManager.getInstance().updatePerfSession(updatedSession)
     GaugeManager.getInstance()
       .logGaugeMetadata(updatedSession.sessionId(), ApplicationProcessState.FOREGROUND)
+    SessionManager.getInstance().updateGaugeCollectionOnNewSession()
   }
 }

firebase-perf/src/main/java/com/google/firebase/perf/session/PerfSession.java

@@ -30,7 +30,7 @@
 public class PerfSession implements Parcelable {
   private final Timer creationTime;
   private final String sessionId;
-  private boolean isGaugeAndEventCollectionEnabled = false;
+  private boolean isGaugeAndEventCollectionEnabled = true;
 
   /*
    * Creates a PerfSession object and decides what metrics to collect.

firebase-perf/src/main/java/com/google/firebase/perf/session/SessionManager.java

@@ -19,11 +19,10 @@
 import androidx.annotation.Keep;
 import androidx.annotation.VisibleForTesting;
 import com.google.firebase.perf.application.AppStateMonitor;
+import com.google.firebase.perf.application.AppStateUpdateHandler;
 import com.google.firebase.perf.logging.FirebaseSessionsEnforcementCheck;
 import com.google.firebase.perf.session.gauges.GaugeManager;
 import com.google.firebase.perf.v1.ApplicationProcessState;
-import com.google.firebase.perf.v1.GaugeMetadata;
-import com.google.firebase.perf.v1.GaugeMetric;
 import java.lang.ref.WeakReference;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -32,7 +31,7 @@
 
 /** Session manager to generate sessionIDs and broadcast to the application. */
 @Keep // Needed because of b/117526359.
-public class SessionManager {
+public class SessionManager extends AppStateUpdateHandler {
   @SuppressLint("StaticFieldLeak")
   private static final SessionManager instance = new SessionManager();
 
@@ -66,6 +65,7 @@ public SessionManager(
     this.gaugeManager = gaugeManager;
     this.perfSession = perfSession;
     this.appStateMonitor = appStateMonitor;
+    registerForAppState();
   }
 
   /**
@@ -76,6 +76,21 @@ public void setApplicationContext(final Context appContext) {
     gaugeManager.initializeGaugeMetadataManager(appContext);
   }
 
+  @Override
+  public void onUpdateAppState(ApplicationProcessState newAppState) {
+    super.onUpdateAppState(newAppState);
+    if (appStateMonitor.isColdStart()) {
+      // Ignore the app state change if it's a cold start.
+      return;
+    }
+
+    // TODO(b/394127311): Verify if this is called after a new session.
+    if (this.perfSession.isVerbose()) {
+      long collectionFrequency = updateGaugeCollection(newAppState);
+      updateGaugeLogging(perfSession.sessionId(), newAppState, collectionFrequency);
+    }
+  }
+
   /**
    * Checks if the current {@link PerfSession} is expired/timed out. If so, stop collecting gauges.
    *
@@ -92,12 +107,10 @@ public void stopGaugeCollectionIfSessionRunningTooLong() {
   }
 
   /**
-   * Updates the currently associated {@link #perfSession} and broadcast the change.
-   *
-   * <p>Uses the provided PerfSession {@link PerfSession}, log the {@link GaugeMetadata} and
-   * start/stop the collection of {@link GaugeMetric} depending upon Session verbosity.
+   * Updates the currently associated {@link #perfSession} and broadcast the change to relevant
+   * traces.
    *
-   * @see PerfSession#isVerbose()
+   * <p>Uses the provided PerfSession {@link PerfSession}.
    */
   public void updatePerfSession(PerfSession perfSession) {
     // Do not update the perf session if it is the exact same sessionId.
@@ -106,9 +119,6 @@ public void updatePerfSession(PerfSession perfSession) {
     }
 
     this.perfSession = perfSession;
-
-    // TODO(b/394127311): Update/verify behavior for Firebase Sessions.
-
     synchronized (clients) {
       for (Iterator<WeakReference<SessionAwareObject>> i = clients.iterator(); i.hasNext(); ) {
         SessionAwareObject callback = i.next().get();
@@ -121,9 +131,6 @@ public void updatePerfSession(PerfSession perfSession) {
         }
       }
     }
-
-    // Start of stop the gauge data collection.
-    startOrStopCollectingGauges(appStateMonitor.getAppState());
   }
 
   /**
@@ -133,7 +140,16 @@ public void updatePerfSession(PerfSession perfSession) {
    * this does not reset the perfSession.
    */
   public void initializeGaugeCollection() {
-    startOrStopCollectingGauges(ApplicationProcessState.FOREGROUND);
+    if (perfSession.isVerbose()) {
+      updateGaugeCollection(ApplicationProcessState.FOREGROUND);
+    }
+  }
+
+  public void updateGaugeCollectionOnNewSession() {
+    if (perfSession.isVerbose()) {
+      long frequency = updateGaugeCollection(ApplicationProcessState.FOREGROUND);
+      updateGaugeLogging(perfSession.sessionId(), ApplicationProcessState.FOREGROUND, frequency);
+    }
   }
 
   /**
@@ -160,15 +176,13 @@ public void unregisterForSessionUpdates(WeakReference<SessionAwareObject> client
     }
   }
 
-  private void startOrStopCollectingGauges(ApplicationProcessState appState) {
-    FirebaseSessionsEnforcementCheck.checkSession(
-        perfSession, "Session is not ready while trying to startOrStopCollectingGauges");
+  private long updateGaugeCollection(ApplicationProcessState applicationProcessState) {
+    return gaugeManager.updateGaugeCollection(applicationProcessState, perfSession.getTimer());
+  }
 
-    if (perfSession.isGaugeAndEventCollectionEnabled()) {
-      gaugeManager.startCollectingGauges(perfSession, appState);
-    } else {
-      gaugeManager.stopCollectingGauges();
-    }
+  private void updateGaugeLogging(
+      String sessionId, ApplicationProcessState applicationProcessState, long collectionFrequency) {
+    gaugeManager.updateGaugeLogging(sessionId, applicationProcessState, collectionFrequency);
   }
 
   @VisibleForTesting

firebase-perf/src/main/java/com/google/firebase/perf/session/gauges/GaugeManager.java

@@ -59,8 +59,10 @@ public class GaugeManager {
   private final TransportManager transportManager;
 
   @Nullable private GaugeMetadataManager gaugeMetadataManager;
-  @Nullable private ScheduledFuture gaugeManagerDataCollectionJob = null;
+  @Nullable private ScheduledFuture<?> gaugeManagerDataCollectionJob = null;
   @Nullable private String sessionId = null;
+
+  private boolean isCollectingGauges = false;
   private ApplicationProcessState applicationProcessState =
       ApplicationProcessState.APPLICATION_PROCESS_STATE_UNKNOWN;
 
@@ -103,6 +105,34 @@ public static synchronized GaugeManager getInstance() {
     return instance;
   }
 
+  public void updateGaugeLogging(
+      String sessionId, ApplicationProcessState applicationProcessState, long collectionFrequency) {
+    try {
+      gaugeManagerDataCollectionJob =
+          gaugeManagerExecutor
+              .get()
+              .scheduleWithFixedDelay(
+                  () -> {
+                    syncFlush(sessionId, applicationProcessState);
+                  },
+                  /* initialDelay= */ collectionFrequency
+                      * APPROX_NUMBER_OF_DATA_POINTS_PER_GAUGE_METRIC,
+                  /* period= */ collectionFrequency * APPROX_NUMBER_OF_DATA_POINTS_PER_GAUGE_METRIC,
+                  TimeUnit.MILLISECONDS);
+
+    } catch (RejectedExecutionException e) {
+      logger.warn("Unable to start collecting Gauges: " + e.getMessage());
+    }
+  }
+
+  public long updateGaugeCollection(
+      ApplicationProcessState applicationProcessState, Timer gaugeCollectionTimer) {
+    if (isCollectingGauges) {
+      stopCollectingGauges();
+    }
+    return startCollectingGauges(applicationProcessState, gaugeCollectionTimer);
+  }
+
   /**
    * Starts the collection of available gauges for the given {@code sessionId} and {@code
    * applicationProcessState}. The collected Gauge Metrics will be flushed at regular intervals.
@@ -190,7 +220,7 @@ private long startCollectingGauges(ApplicationProcessState appState, Timer refer
    *     this.stopCollectingGauges()} should always be called from the same thread.
    */
   public void stopCollectingGauges() {
-    if (this.sessionId == null) {
+    if (!this.isCollectingGauges) {
       return;
     }
 
@@ -219,6 +249,7 @@ public void stopCollectingGauges() {
                 TimeUnit.MILLISECONDS);
 
     this.sessionId = null;
+    this.isCollectingGauges = false;
     this.applicationProcessState = ApplicationProcessState.APPLICATION_PROCESS_STATE_UNKNOWN;
   }
 
@@ -253,16 +284,16 @@ private void syncFlush(String sessionId, ApplicationProcessState appState) {
   /**
    * Log the Gauge Metadata information to the transport.
    *
-   * @param aqsSessionId The {@link PerfSession#aqsSessionId()} ()} to which the collected Gauge Metrics
+   * @param sessionId The {@link PerfSession#sessionId()} ()} to which the collected Gauge Metrics
    *     should be associated with.
    * @param appState The {@link ApplicationProcessState} for which these gauges are collected.
    * @return true if GaugeMetadata was logged, false otherwise.
    */
-  public boolean logGaugeMetadata(String aqsSessionId, ApplicationProcessState appState) {
+  public boolean logGaugeMetadata(String sessionId, ApplicationProcessState appState) {
     if (gaugeMetadataManager != null) {
       GaugeMetric gaugeMetric =
           GaugeMetric.newBuilder()
-              .setSessionId(aqsSessionId)
+              .setSessionId(sessionId)
               .setGaugeMetadata(getGaugeMetadata())
               .build();
       transportManager.log(gaugeMetric, appState);
@@ -335,6 +366,22 @@ public void collectGaugeMetricOnce(Timer referenceTime) {
     collectGaugeMetricOnce(cpuGaugeCollector.get(), memoryGaugeCollector.get(), referenceTime);
   }
 
+  public void logExistingGaugeMetrics(
+      String sessionId, ApplicationProcessState applicationProcessState) {
+    // Flush any data that was collected and associate it with the given session ID and
+    // applicationProcessState.
+    @SuppressWarnings("FutureReturnValueIgnored")
+    ScheduledFuture<?> unusedFuture =
+        gaugeManagerExecutor
+            .get()
+            .schedule(
+                () -> {
+                  syncFlush(sessionId, applicationProcessState);
+                },
+                TIME_TO_WAIT_BEFORE_FLUSHING_GAUGES_QUEUE_MS,
+                TimeUnit.MILLISECONDS);
+  }
+
   private static void collectGaugeMetricOnce(
       CpuGaugeCollector cpuGaugeCollector,
       MemoryGaugeCollector memoryGaugeCollector,
@@ -405,4 +452,10 @@ private long getMemoryGaugeCollectionFrequencyMs(
       return memoryGaugeCollectionFrequency;
     }
   }
+
+  private long getGaugeLoggingFrequency(ApplicationProcessState applicationProcessState) {
+    return Math.min(
+        getMemoryGaugeCollectionFrequencyMs(applicationProcessState),
+        getCpuGaugeCollectionFrequencyMs(applicationProcessState));
+  }
 }