Changes in GaugeCounter

Author: tejasd

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

@@ -18,7 +18,6 @@
 import android.content.Context;
 import androidx.annotation.Keep;
 import androidx.annotation.VisibleForTesting;
-import com.google.firebase.perf.application.AppStateMonitor;
 import com.google.firebase.perf.logging.FirebaseSessionsEnforcementCheck;
 import com.google.firebase.perf.session.gauges.GaugeManager;
 import com.google.firebase.perf.v1.GaugeMetadata;
@@ -47,8 +46,7 @@ public static SessionManager getInstance() {
 
   /** Returns the currently active PerfSession. */
   public final PerfSession perfSession() {
-    FirebaseSessionsEnforcementCheck.checkSession(
-        perfSession, "PerfSession.perfSession()");
+    FirebaseSessionsEnforcementCheck.checkSession(perfSession, "PerfSession.perfSession()");
 
     return perfSession;
   }
@@ -59,8 +57,7 @@ private SessionManager() {
   }
 
   @VisibleForTesting
-  public SessionManager(
-      GaugeManager gaugeManager, PerfSession perfSession) {
+  public SessionManager(GaugeManager gaugeManager, PerfSession perfSession) {
     this.gaugeManager = gaugeManager;
     this.perfSession = perfSession;
   }
@@ -80,8 +77,7 @@ public void setApplicationContext(final Context appContext) {
    */
   public void stopGaugeCollectionIfSessionRunningTooLong() {
     FirebaseSessionsEnforcementCheck.checkSession(
-        perfSession,
-        "SessionManager.stopGaugeCollectionIfSessionRunningTooLong");
+        perfSession, "SessionManager.stopGaugeCollectionIfSessionRunningTooLong");
 
     if (perfSession.isSessionRunningTooLong()) {
       gaugeManager.stopCollectingGauges();
@@ -158,8 +154,7 @@ public void unregisterForSessionUpdates(WeakReference<SessionAwareObject> client
   }
 
   private void startOrStopCollectingGauges() {
-    FirebaseSessionsEnforcementCheck.checkSession(
-        perfSession, "startOrStopCollectingGauges");
+    FirebaseSessionsEnforcementCheck.checkSession(perfSession, "startOrStopCollectingGauges");
 
     if (perfSession.isVerbose()) {
       gaugeManager.startCollectingGauges(perfSession);

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

@@ -2,25 +2,28 @@ package com.google.firebase.perf.session.gauges
 
 import java.util.concurrent.atomic.AtomicInteger
 
-
+/**
+ * [GaugeCounter] is a threadsafe counter for gauge metrics. If the metrics count exceeds
+ * [MAX_METRIC_COUNT], it attempts to log the metrics to Firelog.
+ */
 class GaugeCounter private constructor() {
-    private val counter = AtomicInteger(0)
-    private val gaugeManager: GaugeManager = GaugeManager.getInstance()
+  private val counter = AtomicInteger(0)
+  private val gaugeManager: GaugeManager = GaugeManager.getInstance()
 
-    fun incrementCounter() {
-        val metricsCount = counter.incrementAndGet()
+  fun incrementCounter() {
+    val metricsCount = counter.incrementAndGet()
 
-        if (metricsCount >= MAX_METRIC_COUNT && gaugeManager.logGaugeMetrics()) {
-            counter.set(0)
-        }
+    if (metricsCount >= MAX_METRIC_COUNT) {
+      gaugeManager.logGaugeMetrics()
     }
+  }
 
-    fun resetCounter() {
-        counter.set(0)
-    }
+  fun decrementCounter() {
+    counter.decrementAndGet()
+  }
 
-    companion object {
-        val instance: GaugeCounter by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { GaugeCounter() }
-        const val MAX_METRIC_COUNT = 25
-    }
+  companion object {
+    val instance: GaugeCounter by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { GaugeCounter() }
+    const val MAX_METRIC_COUNT = 25
+  }
 }

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

@@ -49,7 +49,6 @@ public class GaugeManager extends AppStateUpdateHandler {
   // This is a guesstimate of the max amount of time to wait before any pending metrics' collection
   // might take.
   private static final long TIME_TO_WAIT_BEFORE_FLUSHING_GAUGES_QUEUE_MS = 20;
-  private static final long APPROX_NUMBER_OF_DATA_POINTS_PER_GAUGE_METRIC = 20;
   private static final long INVALID_GAUGE_COLLECTION_FREQUENCY = -1;
 
   private final Lazy<ScheduledExecutorService> gaugeManagerExecutor;
@@ -59,6 +58,7 @@ public class GaugeManager extends AppStateUpdateHandler {
   private final TransportManager transportManager;
 
   @Nullable private GaugeMetadataManager gaugeMetadataManager;
+  @Nullable private ScheduledFuture<?> gaugeManagerDataCollectionJob = null;
   @Nullable private PerfSession session = null;
   private ApplicationProcessState applicationProcessState =
       ApplicationProcessState.APPLICATION_PROCESS_STATE_UNKNOWN;
@@ -133,7 +133,8 @@ public void startCollectingGauges(PerfSession session) {
     }
 
     ApplicationProcessState gaugeCollectionApplicationProcessState = applicationProcessState;
-    if (gaugeCollectionApplicationProcessState == ApplicationProcessState.APPLICATION_PROCESS_STATE_UNKNOWN) {
+    if (gaugeCollectionApplicationProcessState
+        == ApplicationProcessState.APPLICATION_PROCESS_STATE_UNKNOWN) {
       logger.warn("Start collecting gauges with APPLICATION_PROCESS_STATE_UNKNOWN");
       // Since the application process state is unknown, collect gauges at the foreground frequency.
       gaugeCollectionApplicationProcessState = ApplicationProcessState.FOREGROUND;
@@ -192,39 +193,43 @@ public void stopCollectingGauges() {
     memoryGaugeCollector.get().stopCollecting();
 
     logGaugeMetrics();
-
-    // TODO(b/394127311): There might be a race condition where a final metric is collected, but
-    // isn't uploaded.
-    GaugeCounter.Companion.getInstance().resetCounter();
     this.session = null;
   }
 
   /**
    * Logs the existing GaugeMetrics to Firelog, associates it with the current {@link PerfSession}
    * and {@link ApplicationProcessState}.
+   *
+   * @return true if a new data collection job is started, false otherwise.
    */
   protected boolean logGaugeMetrics() {
     if (session == null) {
-      logger.warn("Attempted to log Gauge Metrics when session was null.");
+      logger.debug("Attempted to log Gauge Metrics when session was null.");
+      return false;
+    }
+
+    // If there's an existing gaugeManagerDataCollectionJob, this is a no-op.
+    if (gaugeManagerDataCollectionJob != null && !gaugeManagerDataCollectionJob.isDone()) {
+      logger.debug("Attempted to start an additional gauge logging operation.");
       return false;
     }
 
     logExistingGaugeMetrics(session.sessionId(), applicationProcessState);
     return true;
   }
 
-  private void logExistingGaugeMetrics(String sessionId, ApplicationProcessState applicationProcessState) {
+  private void logExistingGaugeMetrics(
+      String sessionId, ApplicationProcessState applicationProcessState) {
     // Flush any data that was collected and attach it to the given session and app state.
-    @SuppressWarnings("FutureReturnValueIgnored")
-    ScheduledFuture<?> unusedFuture =
-            gaugeManagerExecutor
-                    .get()
-                    .schedule(
-                            () -> {
-                              syncFlush(sessionId, applicationProcessState);
-                            },
-                            TIME_TO_WAIT_BEFORE_FLUSHING_GAUGES_QUEUE_MS,
-                            TimeUnit.MILLISECONDS);
+    gaugeManagerDataCollectionJob =
+        gaugeManagerExecutor
+            .get()
+            .schedule(
+                () -> {
+                  syncFlush(sessionId, applicationProcessState);
+                },
+                TIME_TO_WAIT_BEFORE_FLUSHING_GAUGES_QUEUE_MS,
+                TimeUnit.MILLISECONDS);
   }
 
   /**
@@ -236,16 +241,19 @@ private void logExistingGaugeMetrics(String sessionId, ApplicationProcessState a
    */
   private void syncFlush(String sessionId, ApplicationProcessState appState) {
     GaugeMetric.Builder gaugeMetricBuilder = GaugeMetric.newBuilder();
+    GaugeCounter gaugeCounter = GaugeCounter.Companion.getInstance();
 
     // Adding CPU metric readings.
     while (!cpuGaugeCollector.get().cpuMetricReadings.isEmpty()) {
       gaugeMetricBuilder.addCpuMetricReadings(cpuGaugeCollector.get().cpuMetricReadings.poll());
+      gaugeCounter.decrementCounter();
     }
 
     // Adding Memory metric readings.
     while (!memoryGaugeCollector.get().memoryMetricReadings.isEmpty()) {
       gaugeMetricBuilder.addAndroidMemoryReadings(
           memoryGaugeCollector.get().memoryMetricReadings.poll());
+      gaugeCounter.decrementCounter();
     }
 
     // Adding Session ID info.