init

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/SessionManager.java

@@ -19,6 +19,7 @@
 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;
@@ -32,7 +33,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 +67,7 @@ public SessionManager(
     this.gaugeManager = gaugeManager;
     this.perfSession = perfSession;
     this.appStateMonitor = appStateMonitor;
+    registerForAppState();
   }
 
   /**
@@ -76,6 +78,20 @@ 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;
+    }
+    
+    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 +108,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 +120,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 +132,6 @@ public void updatePerfSession(PerfSession perfSession) {
         }
       }
     }
-
-    // Start of stop the gauge data collection.
-    startOrStopCollectingGauges(appStateMonitor.getAppState());
   }
 
   /**
@@ -133,7 +141,9 @@ public void updatePerfSession(PerfSession perfSession) {
    * this does not reset the perfSession.
    */
   public void initializeGaugeCollection() {
-    startOrStopCollectingGauges(ApplicationProcessState.FOREGROUND);
+    if (perfSession.isVerbose()) {
+      updateGaugeCollection(ApplicationProcessState.FOREGROUND);
+    }
   }
 
   /**
@@ -160,17 +170,25 @@ 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);
   }
 
+//  private void startOrStopCollectingGauges(ApplicationProcessState appState) {
+//    FirebaseSessionsEnforcementCheck.checkSession(
+//        perfSession, "Session is not ready while trying to startOrStopCollectingGauges");
+//
+//    if (perfSession.isGaugeAndEventCollectionEnabled()) {
+//      gaugeManager.startCollectingGauges(perfSession, appState);
+//    } else {
+//      gaugeManager.stopCollectingGauges();
+//    }
+//  }
+
   @VisibleForTesting
   public void setPerfSession(PerfSession perfSession) {
     this.perfSession = perfSession;

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,32 @@ 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 +218,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 +247,7 @@ public void stopCollectingGauges() {
                 TimeUnit.MILLISECONDS);
 
     this.sessionId = null;
+    this.isCollectingGauges = false;
     this.applicationProcessState = ApplicationProcessState.APPLICATION_PROCESS_STATE_UNKNOWN;
   }
 
@@ -253,16 +282,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 +364,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 +450,8 @@ private long getMemoryGaugeCollectionFrequencyMs(
       return memoryGaugeCollectionFrequency;
     }
   }
+
+  private long getGaugeLoggingFrequency(ApplicationProcessState applicationProcessState) {
+    return Math.min(getMemoryGaugeCollectionFrequencyMs(applicationProcessState), getCpuGaugeCollectionFrequencyMs(applicationProcessState));
+  }
 }