ref(profiling): Improve thread safety in PerfettoContinuousProfiler

- Lock in isRunning(), getProfilerId(), getChunkId() so all public
  getters are synchronized with writes in startInternal/stopInternal
- Lock in reevaluateSampling()
- Remove volatile from shouldSample;  all accesses are now under the same lock
- Replace ArrayDeque with ConcurrentLinkedDeque in PerfettoProfiler for
  frame measurement collections; these are written by the FrameMetrics
  HandlerThread and read by the executor thread in endAndCollect()

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

Author: 43jay

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

@@ -41,15 +41,19 @@
  * profiling backends independent. All ProfilingManager API usage is confined to this file and {@link
  * PerfettoProfiler}.
  *
- * <p>Unlike the legacy profiler, this class is not used for app-start profiling. It is created
- * during {@code Sentry.init()}, so scopes are always available when {@link #startProfiler} is
- * called.
+ * <p>Currently, this class doesn't do app-start profiling {@link SentryPerformanceProvider}.
+ * It is created during {@code Sentry.init()}.
+ *
+ * <p>Thread safety: all mutable state is guarded by a single {@link
+ * io.sentry.util.AutoClosableReentrantLock}. Public entry points ({@link #startProfiler}, {@link
+ * #stopProfiler}, {@link #close}, {@link #onRateLimitChanged}, {@link #reevaluateSampling}, and
+ * the getters) acquire the lock themselves and are thread-safe.
+ * Private methods {@code startInternal} and {@code stopInternal} require the caller to hold the lock.
  */
 @ApiStatus.Internal
 @RequiresApi(api = Build.VERSION_CODES.VANILLA_ICE_CREAM)
 public class PerfettoContinuousProfiler
     implements IContinuousProfiler, RateLimiter.IRateLimitObserver {
-
   private static final long MAX_CHUNK_DURATION_MILLIS = 60000;
 
   private final @NotNull ILogger logger;
@@ -67,7 +71,7 @@ public class PerfettoContinuousProfiler
   private final @NotNull AtomicBoolean isClosed = new AtomicBoolean(false);
   private @NotNull SentryDate startProfileChunkTimestamp =
       new io.sentry.SentryNanotimeDate();
-  private volatile boolean shouldSample = true;
+  private boolean shouldSample = true;
   private boolean shouldStop = false;
   private boolean isSampled = false;
   private int activeTraceCount = 0;
@@ -140,10 +144,9 @@ public void stopProfiler(final @NotNull ProfileLifecycle profileLifecycle) {
   }
 
   /**
-   * Stop the profiler as soon as we are rate limited, to avoid the performance overhead
+   * Stop the profiler as soon as we are rate limited, to avoid the performance overhead.
    *
-   * @param rateLimiter this {@link RateLimiter} instance which you can use to check if the rate
-   *     limit is active for a specific category
+   * @param rateLimiter the {@link RateLimiter} instance to check categories against
    */
   @Override
   public void onRateLimitChanged(@NotNull RateLimiter rateLimiter) {
@@ -172,23 +175,31 @@ public void close(final boolean isTerminating) {
 
   @Override
   public @NotNull SentryId getProfilerId() {
-    return profilerId;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return profilerId;
+    }
   }
 
   @Override
   public @NotNull SentryId getChunkId() {
-    return chunkId;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return chunkId;
+    }
   }
 
   @Override
   public boolean isRunning() {
-    return isRunning;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return isRunning;
+    }
   }
 
   /**
    * Resolves scopes on first call. Since PerfettoContinuousProfiler is created during
    * Sentry.init() and never used for app-start profiling, scopes is guaranteed to be available by
    * the time startProfiler is called.
+   *
+   * <p>Caller must hold {@link #lock}.
    */
   private @NotNull IScopes resolveScopes() {
     if (scopes != null && scopes != NoOpScopes.getInstance()) {
@@ -344,7 +355,9 @@ private void ensureProfiler() {
   }
 
   public void reevaluateSampling() {
-    shouldSample = true;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      shouldSample = true;
+    }
   }
 
   private void sendChunk(

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

@@ -14,8 +14,8 @@
 import io.sentry.profilemeasurements.ProfileMeasurement;
 import io.sentry.profilemeasurements.ProfileMeasurementValue;
 import java.io.File;
-import java.util.ArrayDeque;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -46,12 +46,14 @@ public class PerfettoProfiler {
   private @Nullable ProfilingResult profilingResult = null;
   private @Nullable CountDownLatch resultLatch = null;
 
-  private final @NotNull ArrayDeque<ProfileMeasurementValue> slowFrameRenderMeasurements =
-      new ArrayDeque<>();
-  private final @NotNull ArrayDeque<ProfileMeasurementValue> frozenFrameRenderMeasurements =
-      new ArrayDeque<>();
-  private final @NotNull ArrayDeque<ProfileMeasurementValue> screenFrameRateMeasurements =
-      new ArrayDeque<>();
+  // ConcurrentLinkedDeque because onFrameMetricCollected (HandlerThread) and endAndCollect
+  // (executor thread) can access these concurrently.
+  private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+      slowFrameRenderMeasurements = new ConcurrentLinkedDeque<>();
+  private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+      frozenFrameRenderMeasurements = new ConcurrentLinkedDeque<>();
+  private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+      screenFrameRateMeasurements = new ConcurrentLinkedDeque<>();
   private final @NotNull Map<String, ProfileMeasurement> measurementsMap = new HashMap<>();
 
   /**