fix(profiler): Address Perfetto profiling PR review feedback

- Re-check shouldStop in async chunk callback to avoid an extra chunk when
  stop is requested while the callback is pending
- Use a lambda instead of a method ref for meta_length (Android desugaring)
- Remove unused getStopFuture()/getActiveTraceCount() test hooks
- Send chunks via the profiling executor, running inline when already on its
  thread to avoid self-submitting into the single-threaded executor
- Use 101Hz sampling to avoid lockstep with the display refresh rate

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: markushi

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

@@ -341,7 +341,6 @@ public final class io/sentry/android/core/NetworkBreadcrumbsIntegration : io/sen
 public class io/sentry/android/core/PerfettoContinuousProfiler : io/sentry/IContinuousProfiler, io/sentry/transport/RateLimiter$IRateLimitObserver {
 	public fun <init> (Lio/sentry/ILogger;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/util/LazyEvaluator$Evaluator;Ljava/util/function/Supplier;)V
 	public fun close (Z)V
-	public fun getActiveTraceCount ()I
 	public fun getChunkId ()Lio/sentry/protocol/SentryId;
 	public fun getProfilerId ()Lio/sentry/protocol/SentryId;
 	public fun isRunning ()Z

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

@@ -71,6 +71,10 @@ public class PerfettoContinuousProfiler
     implements IContinuousProfiler, RateLimiter.IRateLimitObserver {
   private static final long MAX_CHUNK_DURATION_MILLIS = 60000;
 
+  // Matches the thread name produced by SentryExecutorService's thread factory, used to detect
+  // when we are already running on the executor thread.
+  private static final String EXECUTOR_THREAD_NAME_PREFIX = "SentryExecutorServiceThreadFactory";
+
   private final @NotNull ILogger logger;
   private final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier;
   private final @NotNull Supplier<PerfettoProfiler> perfettoProfilerFactory;
@@ -379,10 +383,12 @@ private void onChunkCollected(
 
     if (shouldRestart) {
       try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
-        if (isRunning || isClosed.get()) {
+        // shouldStop is re-checked here (not just at capture time) because a stopProfiler() or
+        // close() may have been requested while this async callback was pending.
+        if (isRunning || isClosed.get() || shouldStop) {
           logger.log(
               SentryLevel.DEBUG,
-              "Profile chunk finished, but profiler was already restarted or closed. Skipping.");
+              "Profile chunk finished, but profiler was already restarted, closed or stopped. Skipping.");
           return;
         }
         logger.log(SentryLevel.DEBUG, "Profile chunk finished. Starting a new one.");
@@ -403,32 +409,26 @@ private void sendChunk(
       final @NotNull ProfileChunk.Builder builder,
       final @NotNull IScopes scopes,
       final @NotNull SentryOptions options) {
+    final @NotNull Runnable task =
+        () -> {
+          if (isClosed.get()) {
+            return;
+          }
+          scopes.captureProfileChunk(builder.build(options));
+        };
     try {
-      options
-          .getExecutorService()
-          .submit(
-              () -> {
-                if (isClosed.get()) {
-                  return;
-                }
-                scopes.captureProfileChunk(builder.build(options));
-              });
+      // The chunk timer callback (stopInternal) already runs on the executor thread; submitting
+      // back into the same single-threaded executor from there can deadlock, so run inline instead.
+      if (Thread.currentThread().getName().startsWith(EXECUTOR_THREAD_NAME_PREFIX)) {
+        task.run();
+      } else {
+        executorServiceSupplier.evaluate().submit(task);
+      }
     } catch (Throwable e) {
       options.getLogger().log(SentryLevel.DEBUG, "Failed to send profile chunk.", e);
     }
   }
 
-  @VisibleForTesting
-  @Nullable
-  Future<?> getStopFuture() {
-    return stopFuture;
-  }
-
-  @VisibleForTesting
-  public int getActiveTraceCount() {
-    return activeTraceCount;
-  }
-
   /**
    * Collects measurements for a single profiling chunk: frame metrics (slow/frozen frames, refresh
    * rate) and performance data (CPU usage, memory footprint).

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

@@ -32,8 +32,12 @@ public class PerfettoProfiler {
   private static final String KEY_DURATION_MS = "KEY_DURATION_MS";
   private static final String KEY_FREQUENCY_HZ = "KEY_FREQUENCY_HZ";
 
-  /** Fixed sampling frequency for Perfetto stack sampling. Not configurable by the developer. */
-  private static final int PROFILING_FREQUENCY_HZ = 100;
+  /**
+   * Fixed sampling frequency for Perfetto stack sampling. Not configurable by the developer. 101Hz
+   * (rather than 100Hz) to avoid lockstep sampling with the display refresh rate (e.g. 60/120fps),
+   * matching the legacy profiler's default sampling rate.
+   */
+  private static final int PROFILING_FREQUENCY_HZ = 101;
 
   private static final long RESULT_TIMEOUT_MS = 5000;
 

sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt

@@ -15,6 +15,8 @@ import io.sentry.test.DeferredExecutorService
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.Mockito.mockStatic
@@ -170,6 +172,41 @@ class PerfettoContinuousProfilerTest {
 
   // -- Perfetto-specific tests --
 
+  @Test
+  fun `async chunk callback does not restart when stop requested while pending`() {
+    val profiler = fixture.getSut()
+
+    // Defer the endAndCollect listener to simulate the OS delivering the trace asynchronously,
+    // after the chunk timer already captured the (then-true) restart decision.
+    var pendingListener: java.util.function.Consumer<java.io.File?>? = null
+    doAnswer { invocation ->
+        pendingListener = invocation.getArgument(0)
+        null
+      }
+      .whenever(fixture.mockPerfettoProfiler)
+      .endAndCollect(any())
+
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+
+    // Chunk timer fires: stopInternal(true) captures shouldRestart=true and calls endAndCollect,
+    // but the listener is held pending instead of firing inline.
+    fixture.executor.runAll()
+    assertFalse(profiler.isRunning)
+    assertNotNull(pendingListener)
+
+    // A stop is requested while the async callback is still pending.
+    profiler.stopProfiler(ProfileLifecycle.MANUAL)
+
+    // The OS now delivers the trace. The callback must honor the late stop and not restart.
+    pendingListener!!.accept(fixture.mockTraceFile)
+    fixture.executor.runAll()
+    assertFalse(
+      profiler.isRunning,
+      "profiler must not restart when a stop was requested while the callback was pending",
+    )
+  }
+
   @Test
   fun `profiler multiple starts are ignored in manual mode`() {
     val profiler = fixture.getSut()

sentry/src/main/java/io/sentry/SentryEnvelopeItem.java

@@ -438,7 +438,9 @@ private static void ensureAttachmentSizeLimit(
             null,
             profileChunk.getPlatform(),
             null,
-            (Callable<Integer>) metaLength::get);
+            // avoid method refs on Android due to some issues with older AGP setups
+            // noinspection Convert2MethodRef
+            () -> metaLength.get());
 
     // avoid method refs on Android due to some issues with older AGP setups
     // noinspection Convert2MethodRef