Add Continuous Profiling support (v8)

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

@@ -36,6 +36,15 @@ public final class io/sentry/android/core/ActivityLifecycleIntegration : android
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
+public class io/sentry/android/core/AndroidContinuousProfiler : io/sentry/IContinuousProfiler {
+	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 isRunning ()Z
+	public fun start ()V
+	public fun stop ()V
+}
+
 public final class io/sentry/android/core/AndroidCpuCollector : io/sentry/IPerformanceSnapshotCollector {
 	public fun <init> (Lio/sentry/ILogger;)V
 	public fun collect (Lio/sentry/PerformanceCollectionData;)V
@@ -438,6 +447,7 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public fun addActivityLifecycleTimeSpans (Lio/sentry/android/core/performance/ActivityLifecycleTimeSpan;)V
 	public fun clear ()V
 	public fun getActivityLifecycleTimeSpans ()Ljava/util/List;
+	public fun getAppStartContinuousProfiler ()Lio/sentry/IContinuousProfiler;
 	public fun getAppStartProfiler ()Lio/sentry/ITransactionProfiler;
 	public fun getAppStartSamplingDecision ()Lio/sentry/TracesSamplingDecision;
 	public fun getAppStartTimeSpan ()Lio/sentry/android/core/performance/TimeSpan;
@@ -456,6 +466,7 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public static fun onContentProviderPostCreate (Landroid/content/ContentProvider;)V
 	public fun registerApplicationForegroundCheck (Landroid/app/Application;)V
 	public fun setAppLaunchedInForeground (Z)V
+	public fun setAppStartContinuousProfiler (Lio/sentry/IContinuousProfiler;)V
 	public fun setAppStartProfiler (Lio/sentry/ITransactionProfiler;)V
 	public fun setAppStartSamplingDecision (Lio/sentry/TracesSamplingDecision;)V
 	public fun setAppStartType (Lio/sentry/android/core/performance/AppStartMetrics$AppStartType;)V

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

@@ -0,0 +1,245 @@
+package io.sentry.android.core;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import android.annotation.SuppressLint;
+import android.os.Build;
+import io.sentry.CompositePerformanceCollector;
+import io.sentry.IContinuousProfiler;
+import io.sentry.ILogger;
+import io.sentry.IScopes;
+import io.sentry.ISentryExecutorService;
+import io.sentry.NoOpScopes;
+import io.sentry.PerformanceCollectionData;
+import io.sentry.ProfileChunk;
+import io.sentry.Sentry;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
+import io.sentry.protocol.SentryId;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.VisibleForTesting;
+
+@ApiStatus.Internal
+public class AndroidContinuousProfiler implements IContinuousProfiler {
+  private static final long MAX_CHUNK_DURATION_MILLIS = 10000;
+
+  private final @NotNull ILogger logger;
+  private final @Nullable String profilingTracesDirPath;
+  private final int profilingTracesHz;
+  private final @NotNull ISentryExecutorService executorService;
+  private final @NotNull BuildInfoProvider buildInfoProvider;
+  private boolean isInitialized = false;
+  private final @NotNull SentryFrameMetricsCollector frameMetricsCollector;
+  private @Nullable AndroidProfiler profiler = null;
+  private boolean isRunning = false;
+  private @Nullable IScopes scopes;
+  private @Nullable Future<?> stopFuture;
+  private @Nullable CompositePerformanceCollector performanceCollector;
+  private final @NotNull List<ProfileChunk.Builder> payloadBuilders = new ArrayList<>();
+  private @NotNull SentryId profilerId = SentryId.EMPTY_ID;
+  private @NotNull SentryId chunkId = SentryId.EMPTY_ID;
+
+  public AndroidContinuousProfiler(
+      final @NotNull BuildInfoProvider buildInfoProvider,
+      final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
+      final @NotNull ILogger logger,
+      final @Nullable String profilingTracesDirPath,
+      final int profilingTracesHz,
+      final @NotNull ISentryExecutorService executorService) {
+    this.logger = logger;
+    this.frameMetricsCollector = frameMetricsCollector;
+    this.buildInfoProvider = buildInfoProvider;
+    this.profilingTracesDirPath = profilingTracesDirPath;
+    this.profilingTracesHz = profilingTracesHz;
+    this.executorService = executorService;
+  }
+
+  private void init() {
+    // We initialize it only once
+    if (isInitialized) {
+      return;
+    }
+    isInitialized = true;
+    if (profilingTracesDirPath == null) {
+      logger.log(
+          SentryLevel.WARNING,
+          "Disabling profiling because no profiling traces dir path is defined in options.");
+      return;
+    }
+    if (profilingTracesHz <= 0) {
+      logger.log(
+          SentryLevel.WARNING,
+          "Disabling profiling because trace rate is set to %d",
+          profilingTracesHz);
+      return;
+    }
+
+    profiler =
+        new AndroidProfiler(
+            profilingTracesDirPath,
+            (int) SECONDS.toMicros(1) / profilingTracesHz,
+            frameMetricsCollector,
+            null,
+            logger);
+  }
+
+  public synchronized void start() {
+    if ((scopes == null || scopes != NoOpScopes.getInstance())
+        && Sentry.getCurrentScopes() != NoOpScopes.getInstance()) {
+      this.scopes = Sentry.getCurrentScopes();
+      this.performanceCollector =
+          Sentry.getCurrentScopes().getOptions().getCompositePerformanceCollector();
+    }
+
+    // Debug.startMethodTracingSampling() is only available since Lollipop, but Android Profiler
+    // causes crashes on api 21 -> https://github.com/getsentry/sentry-java/issues/3392
+    if (buildInfoProvider.getSdkInfoVersion() < Build.VERSION_CODES.LOLLIPOP_MR1) return;
+
+    // Let's initialize trace folder and profiling interval
+    init();
+    // init() didn't create profiler, should never happen
+    if (profiler == null) {
+      return;
+    }
+
+    final AndroidProfiler.ProfileStartData startData = profiler.start();
+    // check if profiling started
+    if (startData == null) {
+      return;
+    }
+
+    isRunning = true;
+
+    if (profilerId == SentryId.EMPTY_ID) {
+      profilerId = new SentryId();
+    }
+
+    if (chunkId == SentryId.EMPTY_ID) {
+      chunkId = new SentryId();
+    }
+
+    if (performanceCollector != null) {
+      performanceCollector.start(chunkId.toString());
+    }
+
+    try {
+      stopFuture = executorService.schedule(() -> stop(true), MAX_CHUNK_DURATION_MILLIS);
+    } catch (RejectedExecutionException e) {
+      logger.log(
+          SentryLevel.ERROR,
+          "Failed to schedule profiling chunk finish. Did you call Sentry.close()?",
+          e);
+    }
+  }
+
+  public synchronized void stop() {
+    stop(false);
+  }
+
+  @SuppressLint("NewApi")
+  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) {
+      return;
+    }
+
+    // onTransactionStart() is only available since Lollipop_MR1
+    // and SystemClock.elapsedRealtimeNanos() since Jelly Bean
+    if (buildInfoProvider.getSdkInfoVersion() < Build.VERSION_CODES.LOLLIPOP_MR1) {
+      return;
+    }
+
+    List<PerformanceCollectionData> performanceCollectionData = null;
+    if (performanceCollector != null) {
+      performanceCollectionData = performanceCollector.stop(chunkId.toString());
+    }
+
+    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.
+      synchronized (payloadBuilders) {
+        payloadBuilders.add(
+            new ProfileChunk.Builder(
+                profilerId, chunkId, endData.measurementsMap, endData.traceFile));
+      }
+    }
+
+    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 (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.");
+    }
+  }
+
+  public synchronized void close() {
+    stop();
+  }
+
+  @Override
+  public @NotNull SentryId getProfilerId() {
+    return profilerId;
+  }
+
+  private void sendChunks(final @NotNull IScopes scopes, final @NotNull SentryOptions options) {
+    try {
+      options
+          .getExecutorService()
+          .submit(
+              () -> {
+                final ArrayList<ProfileChunk> payloads = new ArrayList<>(payloadBuilders.size());
+                synchronized (payloadBuilders) {
+                  for (ProfileChunk.Builder builder : payloadBuilders) {
+                    payloads.add(builder.build(options));
+                  }
+                  payloadBuilders.clear();
+                }
+                for (ProfileChunk payload : payloads) {
+                  scopes.captureProfileChunk(payload);
+                }
+              });
+    } catch (Throwable e) {
+      options.getLogger().log(SentryLevel.DEBUG, "Failed to send profile chunks.", e);
+    }
+  }
+
+  @Override
+  public boolean isRunning() {
+    return isRunning;
+  }
+
+  @VisibleForTesting
+  @Nullable
+  Future<?> getStopFuture() {
+    return stopFuture;
+  }
+}

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

@@ -8,6 +8,7 @@
 import io.sentry.IPerformanceSnapshotCollector;
 import io.sentry.PerformanceCollectionData;
 import io.sentry.SentryLevel;
+import io.sentry.SentryNanotimeDate;
 import io.sentry.util.FileUtils;
 import io.sentry.util.Objects;
 import java.io.File;
@@ -73,7 +74,7 @@ public void collect(final @NotNull PerformanceCollectionData performanceCollecti
 
     CpuCollectionData cpuData =
         new CpuCollectionData(
-            System.currentTimeMillis(), (cpuUsagePercentage / (double) numCores) * 100.0);
+            (cpuUsagePercentage / (double) numCores) * 100.0, new SentryNanotimeDate());
 
     performanceCollectionData.addCpuData(cpuData);
   }

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

@@ -4,6 +4,7 @@
 import io.sentry.IPerformanceSnapshotCollector;
 import io.sentry.MemoryCollectionData;
 import io.sentry.PerformanceCollectionData;
+import io.sentry.SentryNanotimeDate;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
@@ -15,10 +16,10 @@ public void setup() {}
 
   @Override
   public void collect(final @NotNull PerformanceCollectionData performanceCollectionData) {
-    long now = System.currentTimeMillis();
     long usedMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
     long usedNativeMemory = Debug.getNativeHeapSize() - Debug.getNativeHeapFreeSize();
-    MemoryCollectionData memoryData = new MemoryCollectionData(now, usedMemory, usedNativeMemory);
+    MemoryCollectionData memoryData =
+        new MemoryCollectionData(usedMemory, usedNativeMemory, new SentryNanotimeDate());
     performanceCollectionData.addMemoryData(memoryData);
   }
 }