Add continuous profiling ProfileLifecycle (#4202)

* Added ProfileLifecycle
* Sentry.startProfileSession() will work only in MANUAL mode
* Tracer start will start profiler only in TRACE mode
* Tracer and spans now attach profilerId only when sampled

Author: stefanosiano

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

@@ -40,11 +40,12 @@ public class io/sentry/android/core/AndroidContinuousProfiler : io/sentry/IConti
 	public fun <init> (Lio/sentry/android/core/BuildInfoProvider;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;Ljava/lang/String;ILio/sentry/ISentryExecutorService;)V
 	public fun close ()V
 	public fun getProfilerId ()Lio/sentry/protocol/SentryId;
+	public fun getRootSpanCounter ()I
 	public fun isRunning ()Z
 	public fun onRateLimitChanged (Lio/sentry/transport/RateLimiter;)V
 	public fun reevaluateSampling ()V
-	public fun start (Lio/sentry/TracesSampler;)V
-	public fun stop ()V
+	public fun startProfileSession (Lio/sentry/ProfileLifecycle;Lio/sentry/TracesSampler;)V
+	public fun stopProfileSession (Lio/sentry/ProfileLifecycle;)V
 }
 
 public final class io/sentry/android/core/AndroidCpuCollector : io/sentry/IPerformanceSnapshotCollector {

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

@@ -4,7 +4,6 @@
 import static io.sentry.IConnectionStatusProvider.ConnectionStatus.DISCONNECTED;
 import static java.util.concurrent.TimeUnit.SECONDS;
 
-import android.annotation.SuppressLint;
 import android.os.Build;
 import io.sentry.CompositePerformanceCollector;
 import io.sentry.DataCategory;
@@ -15,6 +14,7 @@
 import io.sentry.NoOpScopes;
 import io.sentry.PerformanceCollectionData;
 import io.sentry.ProfileChunk;
+import io.sentry.ProfileLifecycle;
 import io.sentry.Sentry;
 import io.sentry.SentryDate;
 import io.sentry.SentryLevel;
@@ -58,6 +58,7 @@ public class AndroidContinuousProfiler
   private @NotNull SentryDate startProfileChunkTimestamp = new SentryNanotimeDate();
   private boolean shouldSample = true;
   private boolean isSampled = false;
+  private int rootSpanCounter = 0;
 
   public AndroidContinuousProfiler(
       final @NotNull BuildInfoProvider buildInfoProvider,
@@ -103,7 +104,10 @@ private void init() {
             logger);
   }
 
-  public synchronized void start(final @NotNull TracesSampler tracesSampler) {
+  @Override
+  public synchronized void startProfileSession(
+      final @NotNull ProfileLifecycle profileLifecycle,
+      final @NotNull TracesSampler tracesSampler) {
     if (shouldSample) {
       isSampled = tracesSampler.sampleSessionProfile();
       shouldSample = false;
@@ -112,15 +116,31 @@ public synchronized void start(final @NotNull TracesSampler tracesSampler) {
       logger.log(SentryLevel.DEBUG, "Profiler was not started due to sampling decision.");
       return;
     }
-    if (isRunning()) {
-      logger.log(SentryLevel.DEBUG, "Profiler is already running.");
-      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();
     }
-    logger.log(SentryLevel.DEBUG, "Started Profiler.");
-    startProfile();
   }
 
-  private synchronized void startProfile() {
+  private synchronized void start() {
     if ((scopes == null || scopes == NoOpScopes.getInstance())
         && Sentry.getCurrentScopes() != NoOpScopes.getInstance()) {
       this.scopes = Sentry.getCurrentScopes();
@@ -150,15 +170,15 @@ private synchronized void startProfile() {
               || rateLimiter.isActiveForCategory(DataCategory.ProfileChunk))) {
         logger.log(SentryLevel.WARNING, "SDK is rate limited. Stopping profiler.");
         // Let's stop and reset profiler id, as the profile is now broken anyway
-        stop();
+        stop(false);
         return;
       }
 
       // If device is offline, we don't start the profiler, to avoid flooding the cache
       if (scopes.getOptions().getConnectionStatusProvider().getConnectionStatus() == DISCONNECTED) {
         logger.log(SentryLevel.WARNING, "Device is offline. Stopping profiler.");
         // Let's stop and reset profiler id, as the profile is now broken anyway
-        stop();
+        stop(false);
         return;
       }
       startProfileChunkTimestamp = scopes.getOptions().getDateProvider().now();
@@ -195,11 +215,28 @@ private synchronized void startProfile() {
     }
   }
 
-  public synchronized void stop() {
-    stop(false);
+  @Override
+  public synchronized void stopProfileSession(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;
+    }
   }
 
-  @SuppressLint("NewApi")
   private synchronized void stop(final boolean restartProfiler) {
     if (stopFuture != null) {
       stopFuture.cancel(true);
@@ -256,7 +293,7 @@ private synchronized void stop(final boolean restartProfiler) {
 
     if (restartProfiler) {
       logger.log(SentryLevel.DEBUG, "Profile chunk finished. Starting a new one.");
-      startProfile();
+      start();
     } else {
       // When the profiler is stopped manually, we have to reset its id
       profilerId = SentryId.EMPTY_ID;
@@ -269,7 +306,8 @@ public synchronized void reevaluateSampling() {
   }
 
   public synchronized void close() {
-    stop();
+    rootSpanCounter = 0;
+    stop(false);
     isClosed.set(true);
   }
 
@@ -315,13 +353,18 @@ Future<?> getStopFuture() {
     return stopFuture;
   }
 
+  @VisibleForTesting
+  public int getRootSpanCounter() {
+    return rootSpanCounter;
+  }
+
   @Override
   public void onRateLimitChanged(@NotNull RateLimiter rateLimiter) {
     // We stop the profiler as soon as we are rate limited, to avoid the performance overhead
     if (rateLimiter.isActiveForCategory(All)
         || rateLimiter.isActiveForCategory(DataCategory.ProfileChunk)) {
       logger.log(SentryLevel.WARNING, "SDK is rate limited. Stopping profiler.");
-      stop();
+      stop(false);
     }
     // If we are not rate limited anymore, we don't do anything: the profile is broken, so it's
     // useless to restart it automatically

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

@@ -6,6 +6,7 @@
 import android.os.Bundle;
 import io.sentry.ILogger;
 import io.sentry.InitPriority;
+import io.sentry.ProfileLifecycle;
 import io.sentry.SentryIntegrationPackageStorage;
 import io.sentry.SentryLevel;
 import io.sentry.protocol.SdkVersion;
@@ -67,6 +68,8 @@ final class ManifestMetadataReader {
   static final String PROFILE_SESSION_SAMPLE_RATE =
       "io.sentry.traces.profiling.session-sample-rate";
 
+  static final String PROFILE_LIFECYCLE = "io.sentry.traces.profiling.lifecycle";
+
   @ApiStatus.Experimental static final String TRACE_SAMPLING = "io.sentry.traces.trace-sampling";
   static final String TRACE_PROPAGATION_TARGETS = "io.sentry.traces.trace-propagation-targets";
 
@@ -326,6 +329,19 @@ static void applyMetadata(
           }
         }
 
+        final String profileLifecycle =
+            readString(
+                metadata,
+                logger,
+                PROFILE_LIFECYCLE,
+                options.getProfileLifecycle().name().toLowerCase(Locale.ROOT));
+        if (profileLifecycle != null) {
+          options
+              .getExperimental()
+              .setProfileLifecycle(
+                  ProfileLifecycle.valueOf(profileLifecycle.toUpperCase(Locale.ROOT)));
+        }
+
         options.setEnableUserInteractionTracing(
             readBool(metadata, logger, TRACES_UI_ENABLE, options.isEnableUserInteractionTracing()));
 

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

@@ -186,7 +186,8 @@ private void createAndStartContinuousProfiler(
     sentryOptions
         .getExperimental()
         .setProfileSessionSampleRate(profilingOptions.isContinuousProfileSampled() ? 1.0 : 0.0);
-    appStartContinuousProfiler.start(new TracesSampler(sentryOptions));
+    appStartContinuousProfiler.startProfileSession(
+        profilingOptions.getProfileLifecycle(), new TracesSampler(sentryOptions));
   }
 
   private void createAndStartTransactionProfiler(