Continuous Profiling - stop when app goes in background

CHANGELOG.md

@@ -4,13 +4,20 @@
 
 ### Features
 
+- Continuous Profiling - stop when app goes in background ([#4311](https://github.com/getsentry/sentry-java/pull/4311))
+- Continuous Profiling - Add delayed stop ([#4293](https://github.com/getsentry/sentry-java/pull/4293))
 - Increase http timeouts from 5s to 30s to have a better chance of events being delivered without retry ([#4276](https://github.com/getsentry/sentry-java/pull/4276))
 
 ### Fixes
 
 - Do not override user-defined `SentryOptions` ([#4262](https://github.com/getsentry/sentry-java/pull/4262))
 - Session Replay: Change bitmap config to `ARGB_8888` for screenshots ([#4282](https://github.com/getsentry/sentry-java/pull/4282))
 
+### Internal
+
+- Added `platform` to SentryEnvelopeItemHeader ([#4287](https://github.com/getsentry/sentry-java/pull/4287))
+  - Set `android` platform to ProfileChunk envelope item header
+
 ### Dependencies
 
 - Bump Native SDK from v0.8.1 to v0.8.2 ([#4267](https://github.com/getsentry/sentry-java/pull/4267))

sentry-android-core/api/sentry-android-core.api

@@ -49,6 +49,7 @@ public class io/sentry/android/core/AndroidContinuousProfiler : io/sentry/IConti
 	public fun onRateLimitChanged (Lio/sentry/transport/RateLimiter;)V
 	public fun reevaluateSampling ()V
 	public fun startProfiler (Lio/sentry/ProfileLifecycle;Lio/sentry/TracesSampler;)V
+	public fun stopAllProfiles ()V
 	public fun stopProfiler (Lio/sentry/ProfileLifecycle;)V
 }
 

sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java

@@ -11,6 +11,7 @@
 import io.sentry.ILogger;
 import io.sentry.IScopes;
 import io.sentry.ISentryExecutorService;
+import io.sentry.ISentryLifecycleToken;
 import io.sentry.NoOpScopes;
 import io.sentry.PerformanceCollectionData;
 import io.sentry.ProfileChunk;
@@ -24,6 +25,7 @@
 import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
 import io.sentry.protocol.SentryId;
 import io.sentry.transport.RateLimiter;
+import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.SentryRandom;
 import java.util.ArrayList;
 import java.util.List;
@@ -58,9 +60,13 @@ public class AndroidContinuousProfiler
   private final @NotNull AtomicBoolean isClosed = new AtomicBoolean(false);
   private @NotNull SentryDate startProfileChunkTimestamp = new SentryNanotimeDate();
   private boolean shouldSample = true;
+  private boolean shouldStop = false;
   private boolean isSampled = false;
   private int rootSpanCounter = 0;
 
+  private final AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
+  private final AutoClosableReentrantLock payloadLock = new AutoClosableReentrantLock();
+
   public AndroidContinuousProfiler(
       final @NotNull BuildInfoProvider buildInfoProvider,
       final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
@@ -106,42 +112,46 @@ private void init() {
   }
 
   @Override
-  public synchronized void startProfiler(
+  public void startProfiler(
       final @NotNull ProfileLifecycle profileLifecycle,
       final @NotNull TracesSampler tracesSampler) {
-    if (shouldSample) {
-      isSampled = tracesSampler.sampleSessionProfile(SentryRandom.current().nextDouble());
-      shouldSample = false;
-    }
-    if (!isSampled) {
-      logger.log(SentryLevel.DEBUG, "Profiler was not started due to sampling decision.");
-      return;
-    }
-    switch (profileLifecycle) {
-      case TRACE:
-        // rootSpanCounter should never be negative, unless the user changed profile lifecycle while
-        // the profiler is running or close() is called. This is just a safety check.
-        if (rootSpanCounter < 0) {
-          rootSpanCounter = 0;
-        }
-        rootSpanCounter++;
-        break;
-      case MANUAL:
-        // We check if the profiler is already running and log a message only in manual mode, since
-        // in trace mode we can have multiple concurrent traces
-        if (isRunning()) {
-          logger.log(SentryLevel.DEBUG, "Profiler is already running.");
-          return;
-        }
-        break;
-    }
-    if (!isRunning()) {
-      logger.log(SentryLevel.DEBUG, "Started Profiler.");
-      start();
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      if (shouldSample) {
+        isSampled = tracesSampler.sampleSessionProfile(SentryRandom.current().nextDouble());
+        shouldSample = false;
+      }
+      if (!isSampled) {
+        logger.log(SentryLevel.DEBUG, "Profiler was not started due to sampling decision.");
+        return;
+      }
+      switch (profileLifecycle) {
+        case TRACE:
+          // rootSpanCounter should never be negative, unless the user changed profile lifecycle
+          // while
+          // the profiler is running or close() is called. This is just a safety check.
+          if (rootSpanCounter < 0) {
+            rootSpanCounter = 0;
+          }
+          rootSpanCounter++;
+          break;
+        case MANUAL:
+          // We check if the profiler is already running and log a message only in manual mode,
+          // since
+          // in trace mode we can have multiple concurrent traces
+          if (isRunning()) {
+            logger.log(SentryLevel.DEBUG, "Profiler is already running.");
+            return;
+          }
+          break;
+      }
+      if (!isRunning()) {
+        logger.log(SentryLevel.DEBUG, "Started Profiler.");
+        start();
+      }
     }
   }
 
-  private synchronized void start() {
+  private void start() {
     if ((scopes == null || scopes == NoOpScopes.getInstance())
         && Sentry.getCurrentScopes() != NoOpScopes.getInstance()) {
       this.scopes = Sentry.getCurrentScopes();
@@ -213,103 +223,121 @@ private synchronized void start() {
           SentryLevel.ERROR,
           "Failed to schedule profiling chunk finish. Did you call Sentry.close()?",
           e);
+      shouldStop = true;
     }
   }
 
   @Override
-  public synchronized void stopProfiler(final @NotNull ProfileLifecycle profileLifecycle) {
-    switch (profileLifecycle) {
-      case TRACE:
-        rootSpanCounter--;
-        // If there are active spans, and profile lifecycle is trace, we don't stop the profiler
-        if (rootSpanCounter > 0) {
-          return;
-        }
-        // rootSpanCounter should never be negative, unless the user changed profile lifecycle while
-        // the profiler is running or close() is called. This is just a safety check.
-        if (rootSpanCounter < 0) {
-          rootSpanCounter = 0;
-        }
-        stop(false);
-        break;
-      case MANUAL:
-        stop(false);
-        break;
+  public void stopProfiler(final @NotNull ProfileLifecycle profileLifecycle) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      switch (profileLifecycle) {
+        case TRACE:
+          rootSpanCounter--;
+          // If there are active spans, and profile lifecycle is trace, we don't stop the profiler
+          if (rootSpanCounter > 0) {
+            return;
+          }
+          // rootSpanCounter should never be negative, unless the user changed profile lifecycle
+          // while the profiler is running or close() is called. This is just a safety check.
+          if (rootSpanCounter < 0) {
+            rootSpanCounter = 0;
+          }
+          shouldStop = true;
+          break;
+        case MANUAL:
+          shouldStop = true;
+          break;
+      }
     }
   }
 
-  private synchronized void stop(final boolean restartProfiler) {
-    if (stopFuture != null) {
-      stopFuture.cancel(true);
-    }
-    // check if profiler was created and it's running
-    if (profiler == null || !isRunning) {
-      // When the profiler is stopped due to an error (e.g. offline or rate limited), reset the ids
-      profilerId = SentryId.EMPTY_ID;
-      chunkId = SentryId.EMPTY_ID;
-      return;
-    }
-
-    // onTransactionStart() is only available since Lollipop_MR1
-    // and SystemClock.elapsedRealtimeNanos() since Jelly Bean
-    if (buildInfoProvider.getSdkInfoVersion() < Build.VERSION_CODES.LOLLIPOP_MR1) {
-      return;
-    }
+  private void stop(final boolean restartProfiler) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      if (stopFuture != null) {
+        stopFuture.cancel(true);
+      }
+      // check if profiler was created and it's running
+      if (profiler == null || !isRunning) {
+        // When the profiler is stopped due to an error (e.g. offline or rate limited), reset the
+        // ids
+        profilerId = SentryId.EMPTY_ID;
+        chunkId = SentryId.EMPTY_ID;
+        return;
+      }
 
-    List<PerformanceCollectionData> performanceCollectionData = null;
-    if (performanceCollector != null) {
-      performanceCollectionData = performanceCollector.stop(chunkId.toString());
-    }
+      // onTransactionStart() is only available since Lollipop_MR1
+      // and SystemClock.elapsedRealtimeNanos() since Jelly Bean
+      if (buildInfoProvider.getSdkInfoVersion() < Build.VERSION_CODES.LOLLIPOP_MR1) {
+        return;
+      }
 
-    final AndroidProfiler.ProfileEndData endData =
-        profiler.endAndCollect(false, performanceCollectionData);
+      List<PerformanceCollectionData> performanceCollectionData = null;
+      if (performanceCollector != null) {
+        performanceCollectionData = performanceCollector.stop(chunkId.toString());
+      }
 
-    // check if profiler end successfully
-    if (endData == null) {
-      logger.log(
-          SentryLevel.ERROR,
-          "An error occurred while collecting a profile chunk, and it won't be sent.");
-    } else {
-      // The scopes can be null if the profiler is started before the SDK is initialized (app start
-      //  profiling), meaning there's no scopes to send the chunks. In that case, we store the data
-      //  in a list and send it when the next chunk is finished.
-      synchronized (payloadBuilders) {
-        payloadBuilders.add(
-            new ProfileChunk.Builder(
-                profilerId,
-                chunkId,
-                endData.measurementsMap,
-                endData.traceFile,
-                startProfileChunkTimestamp));
+      final AndroidProfiler.ProfileEndData endData =
+          profiler.endAndCollect(false, performanceCollectionData);
+
+      // check if profiler end successfully
+      if (endData == null) {
+        logger.log(
+            SentryLevel.ERROR,
+            "An error occurred while collecting a profile chunk, and it won't be sent.");
+      } else {
+        // The scopes can be null if the profiler is started before the SDK is initialized (app
+        // start profiling), meaning there's no scopes to send the chunks. In that case, we store
+        // the data in a list and send it when the next chunk is finished.
+        try (final @NotNull ISentryLifecycleToken ignored2 = payloadLock.acquire()) {
+          payloadBuilders.add(
+              new ProfileChunk.Builder(
+                  profilerId,
+                  chunkId,
+                  endData.measurementsMap,
+                  endData.traceFile,
+                  startProfileChunkTimestamp));
+        }
       }
-    }
 
-    isRunning = false;
-    // A chunk is finished. Next chunk will have a different id.
-    chunkId = SentryId.EMPTY_ID;
+      isRunning = false;
+      // A chunk is finished. Next chunk will have a different id.
+      chunkId = SentryId.EMPTY_ID;
 
-    if (scopes != null) {
-      sendChunks(scopes, scopes.getOptions());
-    }
+      if (scopes != null) {
+        sendChunks(scopes, scopes.getOptions());
+      }
 
-    if (restartProfiler) {
-      logger.log(SentryLevel.DEBUG, "Profile chunk finished. Starting a new one.");
-      start();
-    } else {
-      // When the profiler is stopped manually, we have to reset its id
-      profilerId = SentryId.EMPTY_ID;
-      logger.log(SentryLevel.DEBUG, "Profile chunk finished.");
+      if (restartProfiler && !shouldStop) {
+        logger.log(SentryLevel.DEBUG, "Profile chunk finished. Starting a new one.");
+        start();
+      } else {
+        // When the profiler is stopped manually, we have to reset its id
+        profilerId = SentryId.EMPTY_ID;
+        logger.log(SentryLevel.DEBUG, "Profile chunk finished.");
+      }
     }
   }
 
-  public synchronized void reevaluateSampling() {
+  public void reevaluateSampling() {
     shouldSample = true;
   }
 
-  public synchronized void close() {
-    rootSpanCounter = 0;
-    stop(false);
-    isClosed.set(true);
+  @Override
+  public void stopAllProfiles() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      rootSpanCounter = 0;
+      shouldStop = true;
+    }
+  }
+
+  @Override
+  public void close() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      rootSpanCounter = 0;
+      shouldStop = true;
+      stop(false);
+      isClosed.set(true);
+    }
   }
 
   @Override
@@ -328,7 +356,7 @@ private void sendChunks(final @NotNull IScopes scopes, final @NotNull SentryOpti
                   return;
                 }
                 final ArrayList<ProfileChunk> payloads = new ArrayList<>(payloadBuilders.size());
-                synchronized (payloadBuilders) {
+                try (final @NotNull ISentryLifecycleToken ignored = payloadLock.acquire()) {
                   for (ProfileChunk.Builder builder : payloadBuilders) {
                     payloads.add(builder.build(options));
                   }

sentry-android-core/src/main/java/io/sentry/android/core/LifecycleWatcher.java

@@ -122,6 +122,7 @@ public void run() {
                   scopes.endSession();
                 }
                 scopes.getOptions().getReplayController().stop();
+                scopes.getOptions().getContinuousProfiler().stopAllProfiles();
               }
             };