From 9a60ad1c951221a26a552ed0936775cee4308004 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Fri, 27 Mar 2026 13:12:36 -0400
Subject: [PATCH 01/14] feat(profiling): Add useProfilingManager option
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds a new boolean option `useProfilingManager` that gates whether
the SDK uses Android's ProfilingManager API (API 35+) for Perfetto-based
profiling. On devices below API 35 where ProfilingManager is not
available, no profiling data is collected — the legacy Debug-based
profiler is not used as a fallback.

Wired through SentryOptions and ManifestMetadataReader (AndroidManifest
meta-data). Defaults to false (opt-in).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../android/core/ManifestMetadataReader.java  |  6 +++++
 .../core/ManifestMetadataReaderTest.kt        | 25 ++++++++++++++++++
 sentry/api/sentry.api                         |  2 ++
 .../main/java/io/sentry/SentryOptions.java    | 26 +++++++++++++++++++
 .../test/java/io/sentry/SentryOptionsTest.kt  | 11 ++++++++
 5 files changed, 70 insertions(+)

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 6d90bb5ca8..ce0bdfd7c9 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -108,6 +108,8 @@ final class ManifestMetadataReader {
 
   static final String ENABLE_APP_START_PROFILING = "io.sentry.profiling.enable-app-start";
 
+  static final String USE_PROFILING_MANAGER = "io.sentry.profiling.use-profiling-manager";
+
   static final String ENABLE_SCOPE_PERSISTENCE = "io.sentry.enable-scope-persistence";
 
   static final String REPLAYS_SESSION_SAMPLE_RATE = "io.sentry.session-replay.session-sample-rate";
@@ -497,6 +499,10 @@ static void applyMetadata(
             readBool(
                 metadata, logger, ENABLE_APP_START_PROFILING, options.isEnableAppStartProfiling()));
 
+        options.setUseProfilingManager(
+            readBool(
+                metadata, logger, USE_PROFILING_MANAGER, options.isUseProfilingManager()));
+
         options.setEnableScopePersistence(
             readBool(
                 metadata, logger, ENABLE_SCOPE_PERSISTENCE, options.isEnableScopePersistence()));
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index 81b73d5dea..0881c138e8 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -1469,6 +1469,31 @@ class ManifestMetadataReaderTest {
     assertFalse(fixture.options.isEnableAppStartProfiling)
   }
 
+  @Test
+  fun `applyMetadata reads useProfilingManager flag to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.USE_PROFILING_MANAGER to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.isUseProfilingManager)
+  }
+
+  @Test
+  fun `applyMetadata reads useProfilingManager flag to options and keeps default if not found`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertFalse(fixture.options.isUseProfilingManager)
+  }
+
   @Test
   fun `applyMetadata reads enableScopePersistence flag to options`() {
     // Arrange
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index b9cbb2ae1b..89f9dd5949 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3710,6 +3710,7 @@ public class io/sentry/SentryOptions {
 	public fun isTraceOptionsRequests ()Z
 	public fun isTraceSampling ()Z
 	public fun isTracingEnabled ()Z
+	public fun isUseProfilingManager ()Z
 	public fun merge (Lio/sentry/ExternalOptions;)V
 	public fun setAttachServerName (Z)V
 	public fun setAttachStacktrace (Z)V
@@ -3835,6 +3836,7 @@ public class io/sentry/SentryOptions {
 	public fun setTransactionProfiler (Lio/sentry/ITransactionProfiler;)V
 	public fun setTransportFactory (Lio/sentry/ITransportFactory;)V
 	public fun setTransportGate (Lio/sentry/transport/ITransportGate;)V
+	public fun setUseProfilingManager (Z)V
 	public fun setVersionDetector (Lio/sentry/IVersionDetector;)V
 	public fun setViewHierarchyExporters (Ljava/util/List;)V
 }
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 86086f8816..a8205f1972 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -642,6 +642,13 @@ public class SentryOptions {
    */
   private boolean startProfilerOnAppStart = false;
 
+  /**
+   * When true, the SDK uses Android's {@code ProfilingManager} (Perfetto-based stack sampling) on
+   * API 35+ devices. On older devices where ProfilingManager is not available, no profiling data is
+   * collected — the legacy {@code Debug}-based profiler is not used as a fallback.
+   */
+  private boolean useProfilingManager = false;
+
   /**
    * Controls the deadline timeout in milliseconds for automatic transactions. When set to a
    * positive value, that value is used as the deadline timeout. When set to a value less than or
@@ -2233,6 +2240,25 @@ public void setStartProfilerOnAppStart(final boolean startProfilerOnAppStart) {
     this.startProfilerOnAppStart = startProfilerOnAppStart;
   }
 
+  /**
+   * Whether to use Android's ProfilingManager (Perfetto) for profiling on Android 35+.
+   *
+   * @return true if ProfilingManager-based profiling is enabled.
+   */
+  public boolean isUseProfilingManager() {
+    return useProfilingManager;
+  }
+
+  /**
+   * Set whether to use Android's ProfilingManager (Perfetto) for profiling on Android 35+. On
+   * devices below API 35 where ProfilingManager is not available, no profiling data is collected.
+   *
+   * @param useProfilingManager true to use ProfilingManager-based profiling.
+   */
+  public void setUseProfilingManager(final boolean useProfilingManager) {
+    this.useProfilingManager = useProfilingManager;
+  }
+
   public long getDeadlineTimeout() {
     return deadlineTimeout;
   }
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index da014b30f7..10937bb804 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -757,6 +757,17 @@ class SentryOptionsTest {
     assertTrue(options.isEnableAppStartProfiling)
   }
 
+  @Test
+  fun `when options are initialized, useProfilingManager is set to false by default`() {
+    assertFalse(SentryOptions().isUseProfilingManager)
+  }
+
+  @Test
+  fun `when setUseProfilingManager is called, value is set`() {
+    val options = SentryOptions().apply { isUseProfilingManager = true }
+    assertTrue(options.isUseProfilingManager)
+  }
+
   @Test
   fun `when options are initialized, profilingTracesHz is set to 101 by default`() {
     assertEquals(101, SentryOptions().profilingTracesHz)

From 1250aa1b1317fe1459ecb0cc6261596bb2e9b25e Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Fri, 27 Mar 2026 13:15:37 -0400
Subject: [PATCH 02/14] chore(samples): Update sample app to support Perfetto
 profiling testing

Adds UI controls to the profiling sample activity for testing both
legacy and Perfetto profiling paths. Enables useProfilingManager
flag in the sample manifest for API 35+ testing.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../src/main/AndroidManifest.xml              |  4 ++
 .../samples/android/ProfilingActivity.kt      | 42 ++++++++++++++++++-
 .../main/res/layout/activity_profiling.xml    | 31 ++++++++++++--
 .../src/main/res/values/strings.xml           |  8 +++-
 4 files changed, 79 insertions(+), 6 deletions(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 548e5e8ac0..10f63ef8c4 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -163,6 +163,10 @@
     <meta-data
       android:name="io.sentry.traces.profiling.start-on-app-start"
       android:value="true" />
+    <!-- Enable ProfilingManager (Perfetto) on API 35+ -->
+    <meta-data
+      android:name="io.sentry.profiling.use-profiling-manager"
+      android:value="true" />
 
     <!--    how to disable the Activity auto instrumentation for tracing-->
     <!--    <meta-data android:name="io.sentry.traces.activity.enable" android:value="false" />-->
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
index 8626c12c6c..00789b412b 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
@@ -1,5 +1,6 @@
 package io.sentry.samples.android
 
+import android.os.Build
 import android.os.Bundle
 import android.view.View
 import android.widget.SeekBar
@@ -22,6 +23,7 @@ class ProfilingActivity : AppCompatActivity() {
   private lateinit var binding: ActivityProfilingBinding
   private val executors = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())
   private var profileFinished = true
+  private var manualProfilingActive = false
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
@@ -30,7 +32,7 @@ class ProfilingActivity : AppCompatActivity() {
       this,
       object : OnBackPressedCallback(true) {
         override fun handleOnBackPressed() {
-          if (profileFinished) {
+          if (profileFinished && !manualProfilingActive) {
             isEnabled = false
             onBackPressedDispatcher.onBackPressed()
           } else {
@@ -42,6 +44,16 @@ class ProfilingActivity : AppCompatActivity() {
     )
     binding = ActivityProfilingBinding.inflate(layoutInflater)
 
+    // Show which profiler backend is active
+    val options = Sentry.getCurrentScopes().options
+    val isPerfetto = options.isUseProfilingManager && Build.VERSION.SDK_INT >= 35
+    binding.profilingStatus.text =
+      if (isPerfetto) {
+        getString(R.string.profiling_status_perfetto)
+      } else {
+        getString(R.string.profiling_status_legacy)
+      }
+
     binding.profilingDurationSeekbar.setOnSeekBarChangeListener(
       object : SeekBar.OnSeekBarChangeListener {
         override fun onProgressChanged(p0: SeekBar, p1: Int, p2: Boolean) {
@@ -76,6 +88,7 @@ class ProfilingActivity : AppCompatActivity() {
     binding.profilingList.adapter = ProfilingListAdapter()
     binding.profilingList.layoutManager = LinearLayoutManager(this)
 
+    // Transaction-based profiling (existing)
     binding.profilingStart.setOnClickListener {
       binding.profilingProgressBar.visibility = View.VISIBLE
       profileFinished = false
@@ -92,6 +105,33 @@ class ProfilingActivity : AppCompatActivity() {
         }
         .start()
     }
+
+    // Manual continuous profiling (exercises Perfetto path on API 35+)
+    binding.profilingStartManual.setOnClickListener {
+      if (!manualProfilingActive) {
+        Sentry.startProfiler()
+        manualProfilingActive = true
+        profileFinished = false
+        binding.profilingStartManual.text = getString(R.string.profiling_stop_manual)
+        binding.profilingProgressBar.visibility = View.VISIBLE
+
+        // Start background work to generate interesting profile data
+        val threads = getBackgroundThreads()
+        repeat(threads) { executors.submit { runMathOperations() } }
+        executors.submit { swipeList() }
+
+        binding.profilingResult.text = getString(R.string.profiling_manual_started)
+      } else {
+        Sentry.stopProfiler()
+        manualProfilingActive = false
+        profileFinished = true
+        binding.profilingStartManual.text = getString(R.string.profiling_start_manual)
+        binding.profilingProgressBar.visibility = View.GONE
+
+        binding.profilingResult.text = getString(R.string.profiling_manual_stopped)
+      }
+    }
+
     setContentView(binding.root)
     Sentry.reportFullyDisplayed()
   }
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
index 8100834f78..3dca64b6d2 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
@@ -38,11 +38,34 @@
     android:gravity="center"
     android:text="@string/profiling_result" />
 
-  <Button
-    android:id="@+id/profiling_start"
-    android:layout_width="wrap_content"
+  <TextView
+    android:id="@+id/profiling_status"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:gravity="center"
+    android:textStyle="bold"
+    android:paddingTop="8dp"
+    android:paddingBottom="4dp" />
+
+  <LinearLayout
+    android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:text="@string/profiling_start" />
+    android:orientation="horizontal"
+    android:gravity="center">
+
+    <Button
+      android:id="@+id/profiling_start"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="@string/profiling_start" />
+
+    <Button
+      android:id="@+id/profiling_start_manual"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="@string/profiling_start_manual" />
+
+  </LinearLayout>
 
   <ProgressBar
     android:id="@+id/profiling_progress_bar"
diff --git a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
index 690e6ea725..3cd5436ddf 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
@@ -51,7 +51,13 @@ Nulla interdum gravida augue, vel fringilla lorem bibendum vel. In hac habitasse
   <string name="profiling_threads">Background threads to use: %d</string>
   <string name="profiling_running">Profiling is running</string>
   <string name="profiling_no_dir_set">No profiling dir path set</string>
-  <string name="profiling_start">Start Profiling</string>
+  <string name="profiling_start">Start (Transaction)</string>
+  <string name="profiling_start_manual">Start (Manual)</string>
+  <string name="profiling_stop_manual">Stop (Manual)</string>
+  <string name="profiling_status_perfetto">Profiler: Perfetto (ProfilingManager API 35+)</string>
+  <string name="profiling_status_legacy">Profiler: Legacy (simpleperf)</string>
+  <string name="profiling_manual_started">Manual profiler started</string>
+  <string name="profiling_manual_stopped">Manual profiler stopped — chunk sent to Sentry</string>
   <string name="profiling_result">Profile trace file size = %d bytes \nItem payload size = %d bytes \nData sent to Sentry size = %d bytes</string>
   <string name="open_camera_activity">Open Camera Activity</string>
   <string name="open_http_request_activity">Open Trigger HTTP Request Activity</string>

From 05d73b1bfb67b2098671e751c666f668bc16daa8 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Tue, 7 Apr 2026 16:18:25 -0400
Subject: [PATCH 03/14] chore(samples): Improve ProfilingActivity UI for
 Perfetto testing

- Show active profiler status line with (i) info button to show
  SDK config (sample rates, lifecycle mode, use-profiling-manager)
- Conditionally show Start(Manual) or Start(Transaction) button based
  on profileLifecycle mode, since each is a no-op in the wrong mode
- Hide duration seekbar in MANUAL mode (only affects transaction length)
- Remove inline profiling result TextView; show results via Toast and
  in the (i) dialog instead
- Apply AppTheme.Main to fix edge-to-edge clipping on API 35+
- Add indices to the bitmap list items so user can see the list view
  jumping around

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../src/main/AndroidManifest.xml              |  3 +-
 .../samples/android/ProfilingActivity.kt      | 64 +++++++++++++++----
 .../samples/android/ProfilingListAdapter.kt   |  3 +
 .../main/res/layout/activity_profiling.xml    | 48 ++++++++------
 .../main/res/layout/profiling_item_list.xml   | 13 +++-
 .../src/main/res/values/strings.xml           |  8 ++-
 6 files changed, 102 insertions(+), 37 deletions(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 10f63ef8c4..438fdfcb80 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -66,7 +66,8 @@
 
     <activity
       android:name=".ProfilingActivity"
-      android:exported="false" />
+      android:exported="false"
+      android:theme="@style/AppTheme.Main" />
 
     <activity
       android:name=".CustomTabsActivity"
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
index 00789b412b..427b33a793 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
@@ -6,9 +6,11 @@ import android.view.View
 import android.widget.SeekBar
 import android.widget.Toast
 import androidx.activity.OnBackPressedCallback
+import androidx.appcompat.app.AlertDialog
 import androidx.appcompat.app.AppCompatActivity
 import androidx.recyclerview.widget.LinearLayoutManager
 import io.sentry.ITransaction
+import io.sentry.ProfileLifecycle
 import io.sentry.ProfilingTraceData
 import io.sentry.Sentry
 import io.sentry.SentryEnvelopeItem
@@ -24,6 +26,7 @@ class ProfilingActivity : AppCompatActivity() {
   private val executors = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())
   private var profileFinished = true
   private var manualProfilingActive = false
+  private var lastProfilingResult: String? = null
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
@@ -44,15 +47,49 @@ class ProfilingActivity : AppCompatActivity() {
     )
     binding = ActivityProfilingBinding.inflate(layoutInflater)
 
-    // Show which profiler backend is active
     val options = Sentry.getCurrentScopes().options
     val isPerfetto = options.isUseProfilingManager && Build.VERSION.SDK_INT >= 35
+    val isContinuousEnabled = options.isContinuousProfilingEnabled
+    val lifecycle = options.profileLifecycle
+
+    // Status line: summarize the active profiler
     binding.profilingStatus.text =
-      if (isPerfetto) {
-        getString(R.string.profiling_status_perfetto)
-      } else {
-        getString(R.string.profiling_status_legacy)
+      when {
+        !isContinuousEnabled -> getString(R.string.profiling_status_none)
+        isPerfetto -> getString(R.string.profiling_status_perfetto)
+        else -> getString(R.string.profiling_status_legacy)
+      }
+
+    // Info button: show detailed config and last result in a dialog
+    binding.profilingInfo.setOnClickListener {
+      val config = buildString {
+        appendLine("traces.profiling.lifecycle: ${lifecycle.name}")
+        appendLine("profiling.use-profiling-manager: ${options.isUseProfilingManager}")
+        appendLine("Build.VERSION.SDK_INT: ${Build.VERSION.SDK_INT}")
+        appendLine("traces.profiling.session-sample-rate: ${options.profileSessionSampleRate}")
+        appendLine("traces.sample-rate: ${options.tracesSampleRate}")
+        if (lastProfilingResult != null) {
+          appendLine()
+          append(lastProfilingResult)
+        }
       }
+      AlertDialog.Builder(this)
+        .setTitle(R.string.profiling_config_title)
+        .setMessage(config)
+        .setPositiveButton(android.R.string.ok, null)
+        .show()
+    }
+
+    // Show only the controls relevant to the current lifecycle mode
+    when (lifecycle) {
+      ProfileLifecycle.MANUAL -> {
+        binding.profilingStartTransaction.visibility = View.GONE
+        // Duration slider only controls transaction length — irrelevant for manual mode
+        binding.profilingDurationText.visibility = View.GONE
+        binding.profilingDurationSeekbar.visibility = View.GONE
+      }
+      ProfileLifecycle.TRACE -> binding.profilingStartTransactionManual.visibility = View.GONE
+    }
 
     binding.profilingDurationSeekbar.setOnSeekBarChangeListener(
       object : SeekBar.OnSeekBarChangeListener {
@@ -89,7 +126,7 @@ class ProfilingActivity : AppCompatActivity() {
     binding.profilingList.layoutManager = LinearLayoutManager(this)
 
     // Transaction-based profiling (existing)
-    binding.profilingStart.setOnClickListener {
+    binding.profilingStartTransaction.setOnClickListener {
       binding.profilingProgressBar.visibility = View.VISIBLE
       profileFinished = false
       val seconds = getProfileDuration()
@@ -107,12 +144,12 @@ class ProfilingActivity : AppCompatActivity() {
     }
 
     // Manual continuous profiling (exercises Perfetto path on API 35+)
-    binding.profilingStartManual.setOnClickListener {
+    binding.profilingStartTransactionManual.setOnClickListener {
       if (!manualProfilingActive) {
         Sentry.startProfiler()
         manualProfilingActive = true
         profileFinished = false
-        binding.profilingStartManual.text = getString(R.string.profiling_stop_manual)
+        binding.profilingStartTransactionManual.text = getString(R.string.profiling_stop_manual)
         binding.profilingProgressBar.visibility = View.VISIBLE
 
         // Start background work to generate interesting profile data
@@ -120,15 +157,15 @@ class ProfilingActivity : AppCompatActivity() {
         repeat(threads) { executors.submit { runMathOperations() } }
         executors.submit { swipeList() }
 
-        binding.profilingResult.text = getString(R.string.profiling_manual_started)
+        Toast.makeText(this, R.string.profiling_manual_started, Toast.LENGTH_SHORT).show()
       } else {
         Sentry.stopProfiler()
         manualProfilingActive = false
         profileFinished = true
-        binding.profilingStartManual.text = getString(R.string.profiling_start_manual)
+        binding.profilingStartTransactionManual.text = getString(R.string.profiling_start_manual)
         binding.profilingProgressBar.visibility = View.GONE
 
-        binding.profilingResult.text = getString(R.string.profiling_manual_stopped)
+        Toast.makeText(this, R.string.profiling_manual_stopped, Toast.LENGTH_SHORT).show()
       }
     }
 
@@ -176,9 +213,10 @@ class ProfilingActivity : AppCompatActivity() {
       val bos = ByteArrayOutputStream()
       GZIPOutputStream(bos).bufferedWriter().use { it.write(String(itemData)) }
 
+      lastProfilingResult =
+        getString(R.string.profiling_result, profileLength, itemData.size, bos.toByteArray().size)
       binding.root.post {
-        binding.profilingResult.text =
-          getString(R.string.profiling_result, profileLength, itemData.size, bos.toByteArray().size)
+        Toast.makeText(this, "Profile captured — tap (i) for details", Toast.LENGTH_SHORT).show()
       }
     } catch (e: Exception) {
       e.printStackTrace()
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingListAdapter.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingListAdapter.kt
index bf025118c8..75617be69a 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingListAdapter.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingListAdapter.kt
@@ -5,6 +5,7 @@ import android.graphics.Color
 import android.view.LayoutInflater
 import android.view.ViewGroup
 import android.widget.ImageView
+import android.widget.TextView
 import androidx.recyclerview.widget.RecyclerView
 import io.sentry.samples.android.databinding.ProfilingItemListBinding
 import kotlin.random.Random
@@ -17,6 +18,7 @@ class ProfilingListAdapter : RecyclerView.Adapter<ViewHolder>() {
   }
 
   override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+    holder.indexView.text = "${position + 1}"
     holder.imageView.setImageBitmap(generateBitmap())
   }
 
@@ -37,5 +39,6 @@ class ProfilingListAdapter : RecyclerView.Adapter<ViewHolder>() {
 }
 
 class ViewHolder(binding: ProfilingItemListBinding) : RecyclerView.ViewHolder(binding.root) {
+  val indexView: TextView = binding.benchmarkItemListIndex
   val imageView: ImageView = binding.benchmarkItemListImage
 }
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
index 3dca64b6d2..8207d9d228 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
@@ -3,7 +3,33 @@
   xmlns:tools="http://schemas.android.com/tools"
   android:orientation="vertical"
   android:layout_width="match_parent"
-  android:layout_height="match_parent">
+  android:layout_height="match_parent"
+  android:fitsSystemWindows="true">
+
+  <LinearLayout
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="horizontal"
+    android:gravity="center"
+    android:paddingTop="8dp"
+    android:paddingBottom="4dp">
+
+    <TextView
+      android:id="@+id/profiling_status"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:textStyle="bold" />
+
+    <ImageButton
+      android:id="@+id/profiling_info"
+      android:layout_width="32dp"
+      android:layout_height="32dp"
+      android:layout_marginStart="4dp"
+      android:src="@android:drawable/ic_dialog_info"
+      android:background="?android:attr/selectableItemBackgroundBorderless"
+      android:contentDescription="@string/profiling_config_title" />
+
+  </LinearLayout>
 
   <TextView
     android:id="@+id/profiling_duration_text"
@@ -31,22 +57,6 @@
     android:layout_height="wrap_content"
     android:max="4" />
 
-  <TextView
-    android:id="@+id/profiling_result"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:gravity="center"
-    android:text="@string/profiling_result" />
-
-  <TextView
-    android:id="@+id/profiling_status"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:gravity="center"
-    android:textStyle="bold"
-    android:paddingTop="8dp"
-    android:paddingBottom="4dp" />
-
   <LinearLayout
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
@@ -54,13 +64,13 @@
     android:gravity="center">
 
     <Button
-      android:id="@+id/profiling_start"
+      android:id="@+id/profiling_start_transaction"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/profiling_start" />
 
     <Button
-      android:id="@+id/profiling_start_manual"
+      android:id="@+id/profiling_start_transaction_manual"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/profiling_start_manual" />
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/profiling_item_list.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/profiling_item_list.xml
index b5d7e77625..ff21b5332a 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/profiling_item_list.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/profiling_item_list.xml
@@ -4,9 +4,20 @@
   android:layout_width="match_parent"
   android:layout_height="wrap_content">
 
+  <TextView
+    android:id="@+id/benchmark_item_list_index"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_gravity="center_vertical"
+    android:paddingStart="8dp"
+    android:paddingEnd="4dp"
+    android:textStyle="bold"
+    tools:text="42" />
+
   <ImageView
     android:id="@+id/benchmark_item_list_image"
-    android:layout_width="match_parent"
+    android:layout_width="0dp"
+    android:layout_weight="1"
     android:layout_height="wrap_content"
     android:scaleType="centerCrop"
     android:layout_margin="8dp"
diff --git a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
index 3cd5436ddf..7e79a841fb 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
@@ -48,14 +48,16 @@ Nulla interdum gravida augue, vel fringilla lorem bibendum vel. In hac habitasse
   <string name="camera_permission">Camera Permission</string>
   <string name="write_permission">Write External Storage Permission</string>
   <string name="profiling_duration">Duration of profile %.1f seconds</string>
-  <string name="profiling_threads">Background threads to use: %d</string>
+  <string name="profiling_threads">CPU load threads (fibonacci): %d</string>
   <string name="profiling_running">Profiling is running</string>
   <string name="profiling_no_dir_set">No profiling dir path set</string>
   <string name="profiling_start">Start (Transaction)</string>
   <string name="profiling_start_manual">Start (Manual)</string>
   <string name="profiling_stop_manual">Stop (Manual)</string>
-  <string name="profiling_status_perfetto">Profiler: Perfetto (ProfilingManager API 35+)</string>
-  <string name="profiling_status_legacy">Profiler: Legacy (simpleperf)</string>
+  <string name="profiling_status_perfetto">Active Profiler: Perfetto (ProfilingManager)</string>
+  <string name="profiling_status_legacy">Active Profiler: Legacy (simpleperf)</string>
+  <string name="profiling_status_none">Active Profiler: None (disabled)</string>
+  <string name="profiling_config_title">Profiling Configuration</string>
   <string name="profiling_manual_started">Manual profiler started</string>
   <string name="profiling_manual_stopped">Manual profiler stopped — chunk sent to Sentry</string>
   <string name="profiling_result">Profile trace file size = %d bytes \nItem payload size = %d bytes \nData sent to Sentry size = %d bytes</string>

From 5f894d01193b9c53d03e506ad58f1cda8331b4e3 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Fri, 27 Mar 2026 13:42:23 -0400
Subject: [PATCH 04/14] feat(profiling): Skip legacy app-start profiling when
 useProfilingManager is set

When useProfilingManager is true, SentryPerformanceProvider now skips
creating the legacy Debug-based profiler at app start. This ensures
AndroidOptionsInitializer creates a Perfetto profiler instead, without
needing special handover logic between the two profiling engines.

The useProfilingManager flag is persisted in SentryAppStartProfilingOptions
(written at end of Sentry.init(), read on next app launch) so the
decision is available before SDK initialization.

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

squash into options commit
---
 .../android/core/ManifestMetadataReader.java  |  3 +--
 .../core/SentryPerformanceProvider.java       | 10 +++++++++-
 .../SentryAppStartProfilingOptions.java       | 19 +++++++++++++++++++
 3 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index ce0bdfd7c9..6b41532aa6 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -500,8 +500,7 @@ static void applyMetadata(
                 metadata, logger, ENABLE_APP_START_PROFILING, options.isEnableAppStartProfiling()));
 
         options.setUseProfilingManager(
-            readBool(
-                metadata, logger, USE_PROFILING_MANAGER, options.isUseProfilingManager()));
+            readBool(metadata, logger, USE_PROFILING_MANAGER, options.isUseProfilingManager()));
 
         options.setEnableScopePersistence(
             readBool(
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
index 7e43d626b3..51799998c6 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
@@ -129,6 +129,14 @@ private void launchAppStartProfiler(final @NotNull AppStartMetrics appStartMetri
         return;
       }
 
+      if (profilingOptions.isUseProfilingManager()) {
+        logger.log(
+            SentryLevel.DEBUG,
+            "useProfilingManager is enabled. Skipping legacy app-start profiling — "
+                + "ProfilingManager will be initialized after Sentry.init().");
+        return;
+      }
+
       if (profilingOptions.isContinuousProfilingEnabled()
           && profilingOptions.isStartProfilerOnAppStart()) {
         createAndStartContinuousProfiler(context, profilingOptions, appStartMetrics);
@@ -163,7 +171,7 @@ private void createAndStartContinuousProfiler(
 
     final @NotNull SentryExecutorService startupExecutorService = new SentryExecutorService();
     final @NotNull IContinuousProfiler appStartContinuousProfiler =
-        new AndroidContinuousProfiler(
+        AndroidContinuousProfiler.createLegacy(
             buildInfoProvider,
             new SentryFrameMetricsCollector(
                 context.getApplicationContext(), logger, buildInfoProvider),
diff --git a/sentry/src/main/java/io/sentry/SentryAppStartProfilingOptions.java b/sentry/src/main/java/io/sentry/SentryAppStartProfilingOptions.java
index ccacccf9c0..f88c9d5b06 100644
--- a/sentry/src/main/java/io/sentry/SentryAppStartProfilingOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryAppStartProfilingOptions.java
@@ -24,6 +24,7 @@ public final class SentryAppStartProfilingOptions implements JsonUnknown, JsonSe
   boolean continuousProfileSampled;
   boolean isEnableAppStartProfiling;
   boolean isStartProfilerOnAppStart;
+  boolean useProfilingManager;
   @NotNull ProfileLifecycle profileLifecycle;
 
   private @Nullable Map<String, Object> unknown;
@@ -42,6 +43,7 @@ public SentryAppStartProfilingOptions() {
     profilingTracesHz = 0;
     isEnableAppStartProfiling = true;
     isStartProfilerOnAppStart = false;
+    useProfilingManager = false;
   }
 
   SentryAppStartProfilingOptions(
@@ -62,6 +64,7 @@ public SentryAppStartProfilingOptions() {
     profilingTracesHz = options.getProfilingTracesHz();
     isEnableAppStartProfiling = options.isEnableAppStartProfiling();
     isStartProfilerOnAppStart = options.isStartProfilerOnAppStart();
+    useProfilingManager = options.isUseProfilingManager();
   }
 
   public void setProfileSampled(final boolean profileSampled) {
@@ -160,6 +163,14 @@ public boolean isStartProfilerOnAppStart() {
     return isStartProfilerOnAppStart;
   }
 
+  public void setUseProfilingManager(final boolean useProfilingManager) {
+    this.useProfilingManager = useProfilingManager;
+  }
+
+  public boolean isUseProfilingManager() {
+    return useProfilingManager;
+  }
+
   // JsonSerializable
 
   public static final class JsonKeys {
@@ -175,6 +186,7 @@ public static final class JsonKeys {
     public static final String PROFILING_TRACES_HZ = "profiling_traces_hz";
     public static final String IS_ENABLE_APP_START_PROFILING = "is_enable_app_start_profiling";
     public static final String IS_START_PROFILER_ON_APP_START = "is_start_profiler_on_app_start";
+    public static final String USE_PROFILING_MANAGER = "use_profiling_manager";
   }
 
   @Override
@@ -195,6 +207,7 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
     writer.name(JsonKeys.PROFILING_TRACES_HZ).value(logger, profilingTracesHz);
     writer.name(JsonKeys.IS_ENABLE_APP_START_PROFILING).value(logger, isEnableAppStartProfiling);
     writer.name(JsonKeys.IS_START_PROFILER_ON_APP_START).value(logger, isStartProfilerOnAppStart);
+    writer.name(JsonKeys.USE_PROFILING_MANAGER).value(logger, useProfilingManager);
 
     if (unknown != null) {
       for (String key : unknown.keySet()) {
@@ -308,6 +321,12 @@ public static final class Deserializer
               options.isStartProfilerOnAppStart = isStartProfilerOnAppStart;
             }
             break;
+          case JsonKeys.USE_PROFILING_MANAGER:
+            @Nullable Boolean useProfilingManager = reader.nextBooleanOrNull();
+            if (useProfilingManager != null) {
+              options.useProfilingManager = useProfilingManager;
+            }
+            break;
           default:
             if (unknown == null) {
               unknown = new ConcurrentHashMap<>();

From c2a4442ea2ead380b93068519149a448f216947f Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 30 Mar 2026 15:03:43 -0400
Subject: [PATCH 05/14] feat(profiling): Add PerfettoProfiler and wire into
 AndroidContinuousProfiler

Introduces PerfettoProfiler, which uses Android's ProfilingManager system
service (API 35+) for Perfetto-based stack sampling. When useProfilingManager
is enabled, AndroidContinuousProfiler selects PerfettoProfiler at init time
via createWithProfilingManager(); on older devices no profiling data is
collected and the legacy Debug-based profiler is not used as a fallback.

Key changes:
- PerfettoProfiler: calls requestProfiling(STACK_SAMPLING), waits for
  ProfilingResult via CountDownLatch, reads .pftrace via getResultFilePath()
- AndroidContinuousProfiler: factory methods createLegacy() /
  createWithProfilingManager() replace the public constructor; init() split
  into initLegacy() / initProfilingManager() for clarity; stopFuture uses
  cancel(false) to avoid interrupting the Perfetto result wait
- AndroidOptionsInitializer: branches on isUseProfilingManager() to select
  the correct factory method
- SentryEnvelopeItem: fromPerfettoProfileChunk() builds a single envelope
  item with meta_length header separating JSON metadata from binary .pftrace
- SentryEnvelopeItemHeader: adds metaLength field for the binary format
- ProfileChunk: adds contentType and version fields; Builder.setContentType()
- SentryClient: routes Perfetto chunks to fromPerfettoProfileChunk()

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../api/sentry-android-core.api               |   9 +-
 .../core/AndroidContinuousProfiler.java       | 123 +++++++-
 .../core/AndroidOptionsInitializer.java       |  26 +-
 .../sentry/android/core/PerfettoProfiler.java | 287 ++++++++++++++++++
 .../core/AndroidContinuousProfilerTest.kt     |   2 +-
 sentry/api/sentry.api                         |  12 +
 .../src/main/java/io/sentry/ProfileChunk.java |  45 ++-
 .../src/main/java/io/sentry/SentryClient.java |  13 +-
 .../java/io/sentry/SentryEnvelopeItem.java    |  66 ++++
 .../io/sentry/SentryEnvelopeItemHeader.java   |  81 ++++-
 .../java/io/sentry/SentryEnvelopeItemTest.kt  |  64 ++++
 11 files changed, 701 insertions(+), 27 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java

diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 0d83082548..b813726bcf 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -41,8 +41,9 @@ public final class io/sentry/android/core/ActivityLifecycleIntegration : android
 }
 
 public class io/sentry/android/core/AndroidContinuousProfiler : io/sentry/IContinuousProfiler, io/sentry/transport/RateLimiter$IRateLimitObserver {
-	public fun <init> (Lio/sentry/android/core/BuildInfoProvider;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;Ljava/lang/String;ILio/sentry/util/LazyEvaluator$Evaluator;)V
 	public fun close (Z)V
+	public static fun createLegacy (Lio/sentry/android/core/BuildInfoProvider;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;Ljava/lang/String;ILio/sentry/util/LazyEvaluator$Evaluator;)Lio/sentry/android/core/AndroidContinuousProfiler;
+	public static fun createWithProfilingManager (Landroid/content/Context;Lio/sentry/android/core/BuildInfoProvider;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;Lio/sentry/util/LazyEvaluator$Evaluator;)Lio/sentry/android/core/AndroidContinuousProfiler;
 	public fun getChunkId ()Lio/sentry/protocol/SentryId;
 	public fun getProfilerId ()Lio/sentry/protocol/SentryId;
 	public fun getRootSpanCounter ()I
@@ -338,6 +339,12 @@ public final class io/sentry/android/core/NetworkBreadcrumbsIntegration : io/sen
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
+public class io/sentry/android/core/PerfettoProfiler {
+	public fun <init> (Landroid/content/Context;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;)V
+	public fun endAndCollect ()Lio/sentry/android/core/AndroidProfiler$ProfileEndData;
+	public fun start (J)Lio/sentry/android/core/AndroidProfiler$ProfileStartData;
+}
+
 public final class io/sentry/android/core/ScreenshotEventProcessor : io/sentry/EventProcessor {
 	public fun <init> (Lio/sentry/android/core/SentryAndroidOptions;Lio/sentry/android/core/BuildInfoProvider;Z)V
 	public fun getOrder ()Ljava/lang/Long;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
index 41362c9d93..6995d8e311 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
@@ -4,6 +4,8 @@
 import static io.sentry.IConnectionStatusProvider.ConnectionStatus.DISCONNECTED;
 import static java.util.concurrent.TimeUnit.SECONDS;
 
+import android.annotation.SuppressLint;
+import android.content.Context;
 import android.os.Build;
 import io.sentry.CompositePerformanceCollector;
 import io.sentry.DataCategory;
@@ -51,6 +53,10 @@ public class AndroidContinuousProfiler
   private boolean isInitialized = false;
   private final @NotNull SentryFrameMetricsCollector frameMetricsCollector;
   private @Nullable AndroidProfiler profiler = null;
+  private @Nullable PerfettoProfiler perfettoProfiler = null;
+  private final boolean useProfilingManager;
+  private final @Nullable Context context;
+  private boolean isPerfettoActive = false;
   private boolean isRunning = false;
   private @Nullable IScopes scopes;
   private @Nullable Future<?> stopFuture;
@@ -68,27 +74,91 @@ public class AndroidContinuousProfiler
   private final AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
   private final AutoClosableReentrantLock payloadLock = new AutoClosableReentrantLock();
 
-  public AndroidContinuousProfiler(
+  /**
+   * Creates a profiler using the legacy Debug.startMethodTracingSampling engine. This is the
+   * default path used for app-start profiling and devices below API 35.
+   */
+  public static AndroidContinuousProfiler createLegacy(
       final @NotNull BuildInfoProvider buildInfoProvider,
       final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
       final @NotNull ILogger logger,
       final @Nullable String profilingTracesDirPath,
       final int profilingTracesHz,
       final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier) {
+    return new AndroidContinuousProfiler(
+        buildInfoProvider,
+        frameMetricsCollector,
+        executorServiceSupplier,
+        logger,
+        null,
+        false,
+        profilingTracesHz,
+        profilingTracesDirPath);
+  }
+
+  /**
+   * Creates a profiler using Android's ProfilingManager (Perfetto) on API 35+. On older devices, no
+   * profiling data is collected — the legacy Debug-based profiler is not used as a fallback.
+   */
+  public static AndroidContinuousProfiler createWithProfilingManager(
+      final @NotNull Context context,
+      final @NotNull BuildInfoProvider buildInfoProvider,
+      final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
+      final @NotNull ILogger logger,
+      final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier) {
+    return new AndroidContinuousProfiler(
+        buildInfoProvider,
+        frameMetricsCollector,
+        executorServiceSupplier,
+        logger,
+        context,
+        true,
+        0,
+        null);
+  }
+
+  private AndroidContinuousProfiler(
+      final @NotNull BuildInfoProvider buildInfoProvider,
+      final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
+      final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier,
+      final @NotNull ILogger logger,
+      final @Nullable Context context,
+      final boolean useProfilingManager,
+      final int profilingTracesHz,
+      final @Nullable String profilingTracesDirPath) {
     this.logger = logger;
     this.frameMetricsCollector = frameMetricsCollector;
     this.buildInfoProvider = buildInfoProvider;
     this.profilingTracesDirPath = profilingTracesDirPath;
     this.profilingTracesHz = profilingTracesHz;
     this.executorServiceSupplier = executorServiceSupplier;
+    this.useProfilingManager = useProfilingManager;
+    this.context = context;
   }
 
+  @SuppressLint("NewApi")
   private void init() {
+    logger.log(
+        SentryLevel.DEBUG,
+        "AndroidContinuousProfiler.init() isInitialized=%s, useProfilingManager=%s, apiLevel=%d",
+        isInitialized,
+        useProfilingManager,
+        buildInfoProvider.getSdkInfoVersion());
+
     // We initialize it only once
     if (isInitialized) {
       return;
     }
     isInitialized = true;
+
+    if (useProfilingManager) {
+      initProfilingManager();
+    } else {
+      initLegacy();
+    }
+  }
+
+  private void initLegacy() {
     if (profilingTracesDirPath == null) {
       logger.log(
           SentryLevel.WARNING,
@@ -112,6 +182,20 @@ private void init() {
             logger);
   }
 
+  @SuppressLint("NewApi")
+  private void initProfilingManager() {
+    if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.VANILLA_ICE_CREAM
+        && context != null) {
+      perfettoProfiler = new PerfettoProfiler(context, frameMetricsCollector, logger);
+      logger.log(SentryLevel.DEBUG, "Using Perfetto profiler (ProfilingManager).");
+    } else {
+      logger.log(
+          SentryLevel.WARNING,
+          "useProfilingManager requested but not available (requires API 35+). "
+              + "No profiling data will be collected.");
+    }
+  }
+
   @Override
   public void startProfiler(
       final @NotNull ProfileLifecycle profileLifecycle,
@@ -175,7 +259,7 @@ private void start() {
     // Let's initialize trace folder and profiling interval
     init();
     // init() didn't create profiler, should never happen
-    if (profiler == null) {
+    if (profiler == null && perfettoProfiler == null) {
       return;
     }
 
@@ -202,7 +286,14 @@ private void start() {
     } else {
       startProfileChunkTimestamp = new SentryNanotimeDate();
     }
-    final AndroidProfiler.ProfileStartData startData = profiler.start();
+    final AndroidProfiler.ProfileStartData startData;
+    if (perfettoProfiler != null) {
+      startData = perfettoProfiler.start(MAX_CHUNK_DURATION_MILLIS);
+      isPerfettoActive = startData != null;
+    } else {
+      startData = profiler.start();
+      isPerfettoActive = false;
+    }
     // check if profiling started
     if (startData == null) {
       return;
@@ -262,10 +353,10 @@ private void stop(final boolean restartProfiler) {
     initScopes();
     try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
       if (stopFuture != null) {
-        stopFuture.cancel(true);
+        stopFuture.cancel(false);
       }
       // check if profiler was created and it's running
-      if (profiler == null || !isRunning) {
+      if ((profiler == null && perfettoProfiler == null) || !isRunning) {
         // When the profiler is stopped due to an error (e.g. offline or rate limited), reset the
         // ids
         profilerId = SentryId.EMPTY_ID;
@@ -284,8 +375,18 @@ private void stop(final boolean restartProfiler) {
         performanceCollectionData = performanceCollector.stop(chunkId.toString());
       }
 
-      final AndroidProfiler.ProfileEndData endData =
-          profiler.endAndCollect(false, performanceCollectionData);
+      final AndroidProfiler.ProfileEndData endData;
+      final String platform;
+      if (isPerfettoActive && perfettoProfiler != null) {
+        endData = perfettoProfiler.endAndCollect();
+        platform = ProfileChunk.PLATFORM_ANDROID;
+      } else if (profiler != null) {
+        endData = profiler.endAndCollect(false, performanceCollectionData);
+        platform = ProfileChunk.PLATFORM_ANDROID;
+      } else {
+        endData = null;
+        platform = ProfileChunk.PLATFORM_ANDROID;
+      }
 
       // check if profiler end successfully
       if (endData == null) {
@@ -297,14 +398,18 @@ private void stop(final boolean restartProfiler) {
         // 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(
+          final ProfileChunk.Builder builder =
               new ProfileChunk.Builder(
                   profilerId,
                   chunkId,
                   endData.measurementsMap,
                   endData.traceFile,
                   startProfileChunkTimestamp,
-                  ProfileChunk.PLATFORM_ANDROID));
+                  platform);
+          if (isPerfettoActive) {
+            builder.setContentType("perfetto");
+          }
+          payloadBuilders.add(builder);
         }
       }
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 5f7fad69b5..357fbfcae8 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -335,16 +335,24 @@ private static void setupProfiler(
           performanceCollector.start(chunkId.toString());
         }
       } else {
+        final @NotNull SentryFrameMetricsCollector frameMetricsCollector =
+            Objects.requireNonNull(
+                options.getFrameMetricsCollector(), "options.getFrameMetricsCollector is required");
         options.setContinuousProfiler(
-            new AndroidContinuousProfiler(
-                buildInfoProvider,
-                Objects.requireNonNull(
-                    options.getFrameMetricsCollector(),
-                    "options.getFrameMetricsCollector is required"),
-                options.getLogger(),
-                options.getProfilingTracesDirPath(),
-                options.getProfilingTracesHz(),
-                () -> options.getExecutorService()));
+            options.isUseProfilingManager()
+                ? AndroidContinuousProfiler.createWithProfilingManager(
+                    context,
+                    buildInfoProvider,
+                    frameMetricsCollector,
+                    options.getLogger(),
+                    () -> options.getExecutorService())
+                : AndroidContinuousProfiler.createLegacy(
+                    buildInfoProvider,
+                    frameMetricsCollector,
+                    options.getLogger(),
+                    options.getProfilingTracesDirPath(),
+                    options.getProfilingTracesHz(),
+                    () -> options.getExecutorService()));
       }
     }
   }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
new file mode 100644
index 0000000000..439a8f913c
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
@@ -0,0 +1,287 @@
+package io.sentry.android.core;
+
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.ProfilingManager;
+import android.os.ProfilingResult;
+import androidx.annotation.RequiresApi;
+import io.sentry.ILogger;
+import io.sentry.SentryLevel;
+import io.sentry.SentryNanotimeDate;
+import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
+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.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+@RequiresApi(api = Build.VERSION_CODES.VANILLA_ICE_CREAM)
+public class PerfettoProfiler {
+
+  private static final long RESULT_TIMEOUT_SECONDS = 5;
+
+  // Bundle keys matching ProfilingManager constants
+  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;
+
+  private final @NotNull Context context;
+  private final @NotNull SentryFrameMetricsCollector frameMetricsCollector;
+  private final @NotNull ILogger logger;
+  private @Nullable CancellationSignal cancellationSignal = null;
+  private @Nullable String frameMetricsCollectorId;
+  private volatile boolean isRunning = false;
+  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<>();
+  private final @NotNull Map<String, ProfileMeasurement> measurementsMap = new HashMap<>();
+
+  /**
+   * Callback invoked exactly once per {@code requestProfiling} call, either on success (with a file
+   * path) or on error (with an error code). Cancelling via {@link CancellationSignal} also triggers
+   * this callback.
+   */
+  private final @NotNull Consumer<ProfilingResult> profilingResultListener;
+
+  public PerfettoProfiler(
+      final @NotNull Context context,
+      final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
+      final @NotNull ILogger logger) {
+    this.context = context;
+    this.frameMetricsCollector = frameMetricsCollector;
+    this.logger = logger;
+    this.profilingResultListener =
+        result -> {
+          logger.log(
+              SentryLevel.DEBUG,
+              "Perfetto ProfilingResult received: errorCode=%d, filePath=%s",
+              result.getErrorCode(),
+              result.getResultFilePath());
+          profilingResult = result;
+          if (resultLatch != null) {
+            resultLatch.countDown();
+          }
+        };
+  }
+
+  public @Nullable AndroidProfiler.ProfileStartData start(final long durationMs) {
+    if (isRunning) {
+      logger.log(SentryLevel.WARNING, "Perfetto profiling has already started...");
+      return null;
+    }
+
+    final @Nullable ProfilingManager profilingManager =
+        (ProfilingManager) context.getSystemService(Context.PROFILING_SERVICE);
+    if (profilingManager == null) {
+      logger.log(SentryLevel.WARNING, "ProfilingManager is not available.");
+      return null;
+    }
+
+    measurementsMap.clear();
+    slowFrameRenderMeasurements.clear();
+    frozenFrameRenderMeasurements.clear();
+    screenFrameRateMeasurements.clear();
+
+    cancellationSignal = new CancellationSignal();
+    resultLatch = new CountDownLatch(1);
+    profilingResult = null;
+
+    final Consumer<ProfilingResult> listener =
+        result -> {
+          profilingResult = result;
+          if (resultLatch != null) {
+            resultLatch.countDown();
+          }
+        };
+
+    final Bundle params = new Bundle();
+    params.putInt(KEY_DURATION_MS, (int) durationMs);
+    params.putInt(KEY_FREQUENCY_HZ, PROFILING_FREQUENCY_HZ);
+
+    try {
+      profilingManager.requestProfiling(
+          ProfilingManager.PROFILING_TYPE_STACK_SAMPLING,
+          params,
+          "sentry-profiling",
+          cancellationSignal,
+          Runnable::run,
+          listener);
+    } catch (Throwable e) {
+      logger.log(SentryLevel.ERROR, "Failed to request Perfetto profiling.", e);
+      cancellationSignal = null;
+      resultLatch = null;
+      return null;
+    }
+
+    frameMetricsCollectorId =
+        frameMetricsCollector.startCollection(
+            new SentryFrameMetricsCollector.FrameMetricsCollectorListener() {
+              float lastRefreshRate = 0;
+
+              @Override
+              public void onFrameMetricCollected(
+                  final long frameStartNanos,
+                  final long frameEndNanos,
+                  final long durationNanos,
+                  final long delayNanos,
+                  final boolean isSlow,
+                  final boolean isFrozen,
+                  final float refreshRate) {
+                final long timestampNanos = new SentryNanotimeDate().nanoTimestamp();
+                if (isFrozen) {
+                  frozenFrameRenderMeasurements.addLast(
+                      new ProfileMeasurementValue(frameEndNanos, durationNanos, timestampNanos));
+                } else if (isSlow) {
+                  slowFrameRenderMeasurements.addLast(
+                      new ProfileMeasurementValue(frameEndNanos, durationNanos, timestampNanos));
+                }
+                if (refreshRate != lastRefreshRate) {
+                  lastRefreshRate = refreshRate;
+                  screenFrameRateMeasurements.addLast(
+                      new ProfileMeasurementValue(frameEndNanos, refreshRate, timestampNanos));
+                }
+              }
+            });
+
+    isRunning = true;
+    return new AndroidProfiler.ProfileStartData(
+        System.nanoTime(),
+        android.os.Process.getElapsedCpuTime(),
+        io.sentry.DateUtils.getCurrentDateTime());
+  }
+
+  public @Nullable AndroidProfiler.ProfileEndData endAndCollect() {
+    if (!isRunning) {
+      logger.log(SentryLevel.WARNING, "Perfetto profiler not running");
+      return null;
+    }
+    isRunning = false;
+
+    frameMetricsCollector.stopCollection(frameMetricsCollectorId);
+
+    if (cancellationSignal != null) {
+      cancellationSignal.cancel();
+      cancellationSignal = null;
+    }
+
+    if (resultLatch != null) {
+      try {
+        if (!resultLatch.await(RESULT_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
+          logger.log(SentryLevel.WARNING, "Timed out waiting for Perfetto profiling result.");
+          return null;
+        }
+      } catch (InterruptedException e) {
+        logger.log(SentryLevel.WARNING, "Interrupted while waiting for Perfetto profiling result.");
+        Thread.currentThread().interrupt();
+        return null;
+      }
+    }
+
+    if (profilingResult == null) {
+      logger.log(SentryLevel.WARNING, "Perfetto profiling result is null.");
+      return null;
+    }
+
+    final int errorCode = profilingResult.getErrorCode();
+    if (errorCode != ProfilingResult.ERROR_NONE) {
+      switch (errorCode) {
+        case ProfilingResult.ERROR_FAILED_RATE_LIMIT_PROCESS:
+        case ProfilingResult.ERROR_FAILED_RATE_LIMIT_SYSTEM:
+          logger.log(
+              SentryLevel.DEBUG,
+              "Perfetto profiling failed: %s."
+                  + " To disable during development run:"
+                  + " adb shell device_config put profiling_testing rate_limiter.disabled true",
+              errorCodeToString(errorCode));
+          break;
+        default:
+          logger.log(
+              SentryLevel.WARNING,
+              "Perfetto profiling failed with %s (error code %d): %s."
+                  + " See https://developer.android.com/reference/android/os/ProfilingResult",
+              errorCodeToString(errorCode),
+              errorCode,
+              profilingResult.getErrorMessage());
+          break;
+      }
+      return null;
+    }
+
+    final @Nullable String resultFilePath = profilingResult.getResultFilePath();
+    if (resultFilePath == null) {
+      logger.log(SentryLevel.WARNING, "Perfetto profiling result file path is null.");
+      return null;
+    }
+
+    final File traceFile = new File(resultFilePath);
+    if (!traceFile.exists() || traceFile.length() == 0) {
+      logger.log(SentryLevel.WARNING, "Perfetto trace file does not exist or is empty.");
+      return null;
+    }
+
+    if (!slowFrameRenderMeasurements.isEmpty()) {
+      measurementsMap.put(
+          ProfileMeasurement.ID_SLOW_FRAME_RENDERS,
+          new ProfileMeasurement(ProfileMeasurement.UNIT_NANOSECONDS, slowFrameRenderMeasurements));
+    }
+    if (!frozenFrameRenderMeasurements.isEmpty()) {
+      measurementsMap.put(
+          ProfileMeasurement.ID_FROZEN_FRAME_RENDERS,
+          new ProfileMeasurement(
+              ProfileMeasurement.UNIT_NANOSECONDS, frozenFrameRenderMeasurements));
+    }
+    if (!screenFrameRateMeasurements.isEmpty()) {
+      measurementsMap.put(
+          ProfileMeasurement.ID_SCREEN_FRAME_RATES,
+          new ProfileMeasurement(ProfileMeasurement.UNIT_HZ, screenFrameRateMeasurements));
+    }
+
+    return new AndroidProfiler.ProfileEndData(
+        System.nanoTime(),
+        android.os.Process.getElapsedCpuTime(),
+        false,
+        traceFile,
+        measurementsMap);
+  }
+
+  boolean isRunning() {
+    return isRunning;
+  }
+
+  private static @NotNull String errorCodeToString(final int errorCode) {
+    switch (errorCode) {
+      case ProfilingResult.ERROR_FAILED_RATE_LIMIT_PROCESS:
+        return "ERROR_FAILED_RATE_LIMIT_PROCESS";
+      case ProfilingResult.ERROR_FAILED_RATE_LIMIT_SYSTEM:
+        return "ERROR_FAILED_RATE_LIMIT_SYSTEM";
+      case ProfilingResult.ERROR_FAILED_INVALID_REQUEST:
+        return "ERROR_FAILED_INVALID_REQUEST";
+      case ProfilingResult.ERROR_FAILED_PROFILING_IN_PROGRESS:
+        return "ERROR_FAILED_PROFILING_IN_PROGRESS";
+      case ProfilingResult.ERROR_FAILED_POST_PROCESSING:
+        return "ERROR_FAILED_POST_PROCESSING";
+      case ProfilingResult.ERROR_UNKNOWN:
+        return "ERROR_UNKNOWN";
+      default:
+        return "UNKNOWN_ERROR_CODE";
+    }
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
index 162e56c36e..a35d2cf503 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
@@ -92,7 +92,7 @@ class AndroidContinuousProfilerTest {
       transaction1 = SentryTracer(TransactionContext("", ""), scopes)
       transaction2 = SentryTracer(TransactionContext("", ""), scopes)
       transaction3 = SentryTracer(TransactionContext("", ""), scopes)
-      return AndroidContinuousProfiler(
+      return AndroidContinuousProfiler.createLegacy(
         buildInfoProvider,
         frameMetricsCollector,
         options.logger,
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 89f9dd5949..37c5d2d6a4 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -2065,9 +2065,11 @@ public final class io/sentry/ProfileChunk : io/sentry/JsonSerializable, io/sentr
 	public fun equals (Ljava/lang/Object;)Z
 	public fun getChunkId ()Lio/sentry/protocol/SentryId;
 	public fun getClientSdk ()Lio/sentry/protocol/SdkVersion;
+	public fun getContentType ()Ljava/lang/String;
 	public fun getDebugMeta ()Lio/sentry/protocol/DebugMeta;
 	public fun getEnvironment ()Ljava/lang/String;
 	public fun getMeasurements ()Ljava/util/Map;
+	public fun getMetaLength ()I
 	public fun getPlatform ()Ljava/lang/String;
 	public fun getProfilerId ()Lio/sentry/protocol/SentryId;
 	public fun getRelease ()Ljava/lang/String;
@@ -2080,6 +2082,7 @@ public final class io/sentry/ProfileChunk : io/sentry/JsonSerializable, io/sentr
 	public fun hashCode ()I
 	public fun serialize (Lio/sentry/ObjectWriter;Lio/sentry/ILogger;)V
 	public fun setDebugMeta (Lio/sentry/protocol/DebugMeta;)V
+	public fun setMetaLength (I)V
 	public fun setSampledProfile (Ljava/lang/String;)V
 	public fun setSentryProfile (Lio/sentry/protocol/profiling/SentryProfile;)V
 	public fun setUnknown (Ljava/util/Map;)V
@@ -2088,6 +2091,7 @@ public final class io/sentry/ProfileChunk : io/sentry/JsonSerializable, io/sentr
 public final class io/sentry/ProfileChunk$Builder {
 	public fun <init> (Lio/sentry/protocol/SentryId;Lio/sentry/protocol/SentryId;Ljava/util/Map;Ljava/io/File;Lio/sentry/SentryDate;Ljava/lang/String;)V
 	public fun build (Lio/sentry/SentryOptions;)Lio/sentry/ProfileChunk;
+	public fun setContentType (Ljava/lang/String;)Lio/sentry/ProfileChunk$Builder;
 }
 
 public final class io/sentry/ProfileChunk$Deserializer : io/sentry/JsonDeserializer {
@@ -2099,6 +2103,7 @@ public final class io/sentry/ProfileChunk$Deserializer : io/sentry/JsonDeseriali
 public final class io/sentry/ProfileChunk$JsonKeys {
 	public static final field CHUNK_ID Ljava/lang/String;
 	public static final field CLIENT_SDK Ljava/lang/String;
+	public static final field CONTENT_TYPE Ljava/lang/String;
 	public static final field DEBUG_META Ljava/lang/String;
 	public static final field ENVIRONMENT Ljava/lang/String;
 	public static final field MEASUREMENTS Ljava/lang/String;
@@ -2797,6 +2802,7 @@ public final class io/sentry/SentryAppStartProfilingOptions : io/sentry/JsonSeri
 	public fun isProfilingEnabled ()Z
 	public fun isStartProfilerOnAppStart ()Z
 	public fun isTraceSampled ()Z
+	public fun isUseProfilingManager ()Z
 	public fun serialize (Lio/sentry/ObjectWriter;Lio/sentry/ILogger;)V
 	public fun setContinuousProfileSampled (Z)V
 	public fun setContinuousProfilingEnabled (Z)V
@@ -2811,6 +2817,7 @@ public final class io/sentry/SentryAppStartProfilingOptions : io/sentry/JsonSeri
 	public fun setTraceSampleRate (Ljava/lang/Double;)V
 	public fun setTraceSampled (Z)V
 	public fun setUnknown (Ljava/util/Map;)V
+	public fun setUseProfilingManager (Z)V
 }
 
 public final class io/sentry/SentryAppStartProfilingOptions$Deserializer : io/sentry/JsonDeserializer {
@@ -2832,6 +2839,7 @@ public final class io/sentry/SentryAppStartProfilingOptions$JsonKeys {
 	public static final field PROFILING_TRACES_HZ Ljava/lang/String;
 	public static final field TRACE_SAMPLED Ljava/lang/String;
 	public static final field TRACE_SAMPLE_RATE Ljava/lang/String;
+	public static final field USE_PROFILING_MANAGER Ljava/lang/String;
 	public fun <init> ()V
 }
 
@@ -3037,6 +3045,7 @@ public final class io/sentry/SentryEnvelopeItem {
 	public static fun fromEvent (Lio/sentry/ISerializer;Lio/sentry/SentryBaseEvent;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromLogs (Lio/sentry/ISerializer;Lio/sentry/SentryLogEvents;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromMetrics (Lio/sentry/ISerializer;Lio/sentry/SentryMetricsEvents;)Lio/sentry/SentryEnvelopeItem;
+	public static fun fromPerfettoProfileChunk (Lio/sentry/ProfileChunk;Lio/sentry/ISerializer;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromProfileChunk (Lio/sentry/ProfileChunk;Lio/sentry/ISerializer;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromProfileChunk (Lio/sentry/ProfileChunk;Lio/sentry/ISerializer;Lio/sentry/IProfileConverter;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromProfilingTrace (Lio/sentry/ProfilingTraceData;JLio/sentry/ISerializer;)Lio/sentry/SentryEnvelopeItem;
@@ -3054,10 +3063,12 @@ public final class io/sentry/SentryEnvelopeItem {
 
 public final class io/sentry/SentryEnvelopeItemHeader : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
 	public fun <init> (Lio/sentry/SentryItemType;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Integer;)V
+	public fun <init> (Lio/sentry/SentryItemType;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Integer;)V
 	public fun getAttachmentType ()Ljava/lang/String;
 	public fun getContentType ()Ljava/lang/String;
 	public fun getFileName ()Ljava/lang/String;
 	public fun getLength ()I
+	public fun getMetaLength ()Ljava/lang/Integer;
 	public fun getPlatform ()Ljava/lang/String;
 	public fun getType ()Lio/sentry/SentryItemType;
 	public fun getUnknown ()Ljava/util/Map;
@@ -3077,6 +3088,7 @@ public final class io/sentry/SentryEnvelopeItemHeader$JsonKeys {
 	public static final field FILENAME Ljava/lang/String;
 	public static final field ITEM_COUNT Ljava/lang/String;
 	public static final field LENGTH Ljava/lang/String;
+	public static final field META_LENGTH Ljava/lang/String;
 	public static final field PLATFORM Ljava/lang/String;
 	public static final field TYPE Ljava/lang/String;
 	public fun <init> ()V
diff --git a/sentry/src/main/java/io/sentry/ProfileChunk.java b/sentry/src/main/java/io/sentry/ProfileChunk.java
index a6145ca8e9..e4feb5d251 100644
--- a/sentry/src/main/java/io/sentry/ProfileChunk.java
+++ b/sentry/src/main/java/io/sentry/ProfileChunk.java
@@ -34,6 +34,9 @@ public final class ProfileChunk implements JsonUnknown, JsonSerializable {
   private @NotNull String version;
   private double timestamp;
 
+  /** Content type of the profile data. Set to "perfetto" for Perfetto traces. */
+  private @Nullable String contentType;
+
   private final @Nullable File traceFile;
 
   /** Profile trace encoded with Base64. */
@@ -131,6 +134,24 @@ public double getTimestamp() {
     return version;
   }
 
+  public @Nullable String getContentType() {
+    return contentType;
+  }
+
+  /**
+   * The length of the JSON metadata prefix in the binary envelope payload. Set during lazy
+   * serialization of Perfetto profile chunks so the envelope item header can read it.
+   */
+  private transient int metaLength = 0;
+
+  public int getMetaLength() {
+    return metaLength;
+  }
+
+  public void setMetaLength(final int metaLength) {
+    this.metaLength = metaLength;
+  }
+
   public @Nullable SentryProfile getSentryProfile() {
     return sentryProfile;
   }
@@ -181,8 +202,8 @@ public static final class Builder {
     private final @NotNull Map<String, ProfileMeasurement> measurements;
     private final @NotNull File traceFile;
     private final double timestamp;
-
     private final @NotNull String platform;
+    private @Nullable String contentType;
 
     public Builder(
         final @NotNull SentryId profilerId,
@@ -199,9 +220,17 @@ public Builder(
       this.platform = platform;
     }
 
+    public Builder setContentType(final @Nullable String contentType) {
+      this.contentType = contentType;
+      return this;
+    }
+
     public ProfileChunk build(SentryOptions options) {
-      return new ProfileChunk(
-          profilerId, chunkId, traceFile, measurements, timestamp, platform, options);
+      final ProfileChunk chunk =
+          new ProfileChunk(
+              profilerId, chunkId, traceFile, measurements, timestamp, platform, options);
+      chunk.contentType = contentType;
+      return chunk;
     }
   }
 
@@ -220,6 +249,7 @@ public static final class JsonKeys {
     public static final String SAMPLED_PROFILE = "sampled_profile";
     public static final String TIMESTAMP = "timestamp";
     public static final String SENTRY_PROFILE = "profile";
+    public static final String CONTENT_TYPE = "content_type";
   }
 
   @Override
@@ -248,6 +278,9 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
       writer.name(JsonKeys.ENVIRONMENT).value(logger, environment);
     }
     writer.name(JsonKeys.VERSION).value(logger, version);
+    if (contentType != null) {
+      writer.name(JsonKeys.CONTENT_TYPE).value(logger, contentType);
+    }
     if (sampledProfile != null) {
       writer.name(JsonKeys.SAMPLED_PROFILE).value(logger, sampledProfile);
     }
@@ -358,6 +391,12 @@ public static final class Deserializer implements JsonDeserializer<ProfileChunk>
               data.timestamp = timestamp;
             }
             break;
+          case JsonKeys.CONTENT_TYPE:
+            String contentType = reader.nextStringOrNull();
+            if (contentType != null) {
+              data.contentType = contentType;
+            }
+            break;
           case JsonKeys.SENTRY_PROFILE:
             SentryProfile sentryProfile =
                 reader.nextOrNull(logger, new SentryProfile.Deserializer());
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index b8178e3551..97f42b1fd7 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -1058,12 +1058,19 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
     // BeforeSend and EventProcessors are not supported at the moment for Profile Chunks
 
     try {
+      final SentryEnvelopeItem envelopeItem;
+      if ("perfetto".equals(profileChunk.getContentType())) {
+        envelopeItem =
+            SentryEnvelopeItem.fromPerfettoProfileChunk(profileChunk, options.getSerializer());
+      } else {
+        envelopeItem =
+            SentryEnvelopeItem.fromProfileChunk(
+                profileChunk, options.getSerializer(), options.getProfilerConverter());
+      }
       final @NotNull SentryEnvelope envelope =
           new SentryEnvelope(
               new SentryEnvelopeHeader(sentryId, options.getSdkVersion(), null),
-              Collections.singletonList(
-                  SentryEnvelopeItem.fromProfileChunk(
-                      profileChunk, options.getSerializer(), options.getProfilerConverter())));
+              Collections.singletonList(envelopeItem));
       sentryId = sendEnvelope(envelope, null);
     } catch (IOException | SentryEnvelopeException e) {
       options
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
index dd47d2b99d..5938d37091 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
@@ -372,6 +372,72 @@ private static void ensureAttachmentSizeLimit(
     return new SentryEnvelopeItem(itemHeader, () -> cachedItem.getBytes());
   }
 
+  public static @NotNull SentryEnvelopeItem fromPerfettoProfileChunk(
+      final @NotNull ProfileChunk profileChunk, final @NotNull ISerializer serializer)
+      throws SentryEnvelopeException {
+
+    final @Nullable File traceFile = profileChunk.getTraceFile();
+
+    if (traceFile == null || !traceFile.exists()) {
+      throw new SentryEnvelopeException(
+          String.format(
+              "Dropping perfetto profile chunk, because the trace file '%s' doesn't exist",
+              traceFile != null ? traceFile.getName() : "null"));
+    }
+
+    final CachedItem cachedItem =
+        new CachedItem(
+            () -> {
+              // Serialize JSON metadata
+              final byte[] metadataBytes;
+              try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
+                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                serializer.serialize(profileChunk, writer);
+                metadataBytes = stream.toByteArray();
+              } catch (IOException e) {
+                throw new SentryEnvelopeException(
+                    String.format(
+                        "Failed to serialize perfetto profile chunk\n%s", e.getMessage()));
+              }
+
+              // Read binary Perfetto trace
+              final byte[] traceBytes;
+              try {
+                traceBytes = readBytesFromFile(traceFile.getPath(), MAX_PROFILE_CHUNK_SIZE);
+              } catch (IOException e) {
+                throw new SentryEnvelopeException(
+                    String.format("Failed to read perfetto trace file\n%s", e.getMessage()));
+              } finally {
+                traceFile.delete();
+              }
+
+              // Concatenate: [JSON metadata bytes][raw .pftrace binary bytes]
+              final byte[] payload = new byte[metadataBytes.length + traceBytes.length];
+              System.arraycopy(metadataBytes, 0, payload, 0, metadataBytes.length);
+              System.arraycopy(traceBytes, 0, payload, metadataBytes.length, traceBytes.length);
+
+              // Store metaLength so the header callable can read it after lazy evaluation
+              profileChunk.setMetaLength(metadataBytes.length);
+
+              return payload;
+            });
+
+    SentryEnvelopeItemHeader itemHeader =
+        new SentryEnvelopeItemHeader(
+            SentryItemType.ProfileChunk,
+            () -> cachedItem.getBytes().length,
+            "application/octet-stream",
+            traceFile.getName(),
+            null,
+            profileChunk.getPlatform(),
+            null,
+            (Callable<Integer>) () -> profileChunk.getMetaLength());
+
+    // avoid method refs on Android due to some issues with older AGP setups
+    // noinspection Convert2MethodRef
+    return new SentryEnvelopeItem(itemHeader, () -> cachedItem.getBytes());
+  }
+
   public static @NotNull SentryEnvelopeItem fromProfilingTrace(
       final @NotNull ProfilingTraceData profilingTraceData,
       final long maxTraceFileSize,
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
index 25f1e893fc..43989259da 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
@@ -21,6 +21,8 @@ public final class SentryEnvelopeItemHeader implements JsonSerializable, JsonUnk
   private final int length;
   @Nullable private final Callable<Integer> getLength;
   private final @Nullable String attachmentType;
+  private final @Nullable Integer metaLength;
+  @Nullable private final Callable<Integer> getMetaLength;
 
   private @Nullable Map<String, Object> unknown;
 
@@ -52,6 +54,17 @@ public int getLength() {
     return platform;
   }
 
+  public @Nullable Integer getMetaLength() {
+    if (getMetaLength != null) {
+      try {
+        return getMetaLength.call();
+      } catch (Throwable ignored) {
+        return null;
+      }
+    }
+    return metaLength;
+  }
+
   @ApiStatus.Internal
   public SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
@@ -61,6 +74,19 @@ public SentryEnvelopeItemHeader(
       final @Nullable String attachmentType,
       final @Nullable String platform,
       final @Nullable Integer itemCount) {
+    this(type, length, contentType, fileName, attachmentType, platform, itemCount, null);
+  }
+
+  @ApiStatus.Internal
+  public SentryEnvelopeItemHeader(
+      final @NotNull SentryItemType type,
+      int length,
+      final @Nullable String contentType,
+      final @Nullable String fileName,
+      final @Nullable String attachmentType,
+      final @Nullable String platform,
+      final @Nullable Integer itemCount,
+      final @Nullable Integer metaLength) {
     this.type = Objects.requireNonNull(type, "type is required");
     this.contentType = contentType;
     this.length = length;
@@ -69,6 +95,8 @@ public SentryEnvelopeItemHeader(
     this.attachmentType = attachmentType;
     this.platform = platform;
     this.itemCount = itemCount;
+    this.metaLength = metaLength;
+    this.getMetaLength = null;
   }
 
   SentryEnvelopeItemHeader(
@@ -88,6 +116,47 @@ public SentryEnvelopeItemHeader(
       final @Nullable String attachmentType,
       final @Nullable String platform,
       final @Nullable Integer itemCount) {
+    this(
+        type,
+        getLength,
+        contentType,
+        fileName,
+        attachmentType,
+        platform,
+        itemCount,
+        (Integer) null);
+  }
+
+  SentryEnvelopeItemHeader(
+      final @NotNull SentryItemType type,
+      final @Nullable Callable<Integer> getLength,
+      final @Nullable String contentType,
+      final @Nullable String fileName,
+      final @Nullable String attachmentType,
+      final @Nullable String platform,
+      final @Nullable Integer itemCount,
+      final @Nullable Integer metaLength) {
+    this.type = Objects.requireNonNull(type, "type is required");
+    this.contentType = contentType;
+    this.length = -1;
+    this.fileName = fileName;
+    this.getLength = getLength;
+    this.attachmentType = attachmentType;
+    this.platform = platform;
+    this.itemCount = itemCount;
+    this.metaLength = metaLength;
+    this.getMetaLength = null;
+  }
+
+  SentryEnvelopeItemHeader(
+      final @NotNull SentryItemType type,
+      final @Nullable Callable<Integer> getLength,
+      final @Nullable String contentType,
+      final @Nullable String fileName,
+      final @Nullable String attachmentType,
+      final @Nullable String platform,
+      final @Nullable Integer itemCount,
+      final @Nullable Callable<Integer> getMetaLength) {
     this.type = Objects.requireNonNull(type, "type is required");
     this.contentType = contentType;
     this.length = -1;
@@ -96,6 +165,8 @@ public SentryEnvelopeItemHeader(
     this.attachmentType = attachmentType;
     this.platform = platform;
     this.itemCount = itemCount;
+    this.metaLength = null;
+    this.getMetaLength = getMetaLength;
   }
 
   SentryEnvelopeItemHeader(
@@ -125,6 +196,7 @@ public static final class JsonKeys {
     public static final String LENGTH = "length";
     public static final String PLATFORM = "platform";
     public static final String ITEM_COUNT = "item_count";
+    public static final String META_LENGTH = "meta_length";
   }
 
   @Override
@@ -147,6 +219,9 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
     if (itemCount != null) {
       writer.name(JsonKeys.ITEM_COUNT).value(itemCount);
     }
+    if (metaLength != null) {
+      writer.name(JsonKeys.META_LENGTH).value(metaLength);
+    }
     writer.name(JsonKeys.LENGTH).value(getLength());
     if (unknown != null) {
       for (String key : unknown.keySet()) {
@@ -171,6 +246,7 @@ public static final class Deserializer implements JsonDeserializer<SentryEnvelop
       String attachmentType = null;
       String platform = null;
       Integer itemCount = null;
+      Integer metaLength = null;
       Map<String, Object> unknown = null;
 
       while (reader.peek() == JsonToken.NAME) {
@@ -197,6 +273,9 @@ public static final class Deserializer implements JsonDeserializer<SentryEnvelop
           case JsonKeys.ITEM_COUNT:
             itemCount = reader.nextIntegerOrNull();
             break;
+          case JsonKeys.META_LENGTH:
+            metaLength = reader.nextIntegerOrNull();
+            break;
           default:
             if (unknown == null) {
               unknown = new HashMap<>();
@@ -210,7 +289,7 @@ public static final class Deserializer implements JsonDeserializer<SentryEnvelop
       }
       SentryEnvelopeItemHeader sentryEnvelopeItemHeader =
           new SentryEnvelopeItemHeader(
-              type, length, contentType, fileName, attachmentType, platform, itemCount);
+              type, length, contentType, fileName, attachmentType, platform, itemCount, metaLength);
       sentryEnvelopeItemHeader.setUnknown(unknown);
       reader.endObject();
       return sentryEnvelopeItemHeader;
diff --git a/sentry/src/test/java/io/sentry/SentryEnvelopeItemTest.kt b/sentry/src/test/java/io/sentry/SentryEnvelopeItemTest.kt
index 858ca43ab1..1a295aa4e1 100644
--- a/sentry/src/test/java/io/sentry/SentryEnvelopeItemTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryEnvelopeItemTest.kt
@@ -2,6 +2,7 @@ package io.sentry
 
 import io.sentry.exception.SentryEnvelopeException
 import io.sentry.protocol.ReplayRecordingSerializationTest
+import io.sentry.protocol.SentryId
 import io.sentry.protocol.SentryReplayEventSerializationTest
 import io.sentry.protocol.User
 import io.sentry.protocol.ViewHierarchy
@@ -596,6 +597,69 @@ class SentryEnvelopeItemTest {
     )
   }
 
+  @Test
+  fun `fromPerfettoProfileChunk creates single item with meta_length header`() {
+    val traceFile = tmpDir.newFile("trace.pftrace")
+    val traceBytes = byteArrayOf(0x50, 0x65, 0x72, 0x66) // "Perf"
+    traceFile.writeBytes(traceBytes)
+
+    val profileChunk =
+      ProfileChunk.Builder(
+          SentryId(),
+          SentryId(),
+          emptyMap(),
+          traceFile,
+          SentryNanotimeDate(),
+          ProfileChunk.PLATFORM_ANDROID,
+        )
+        .setContentType("perfetto")
+        .build(fixture.options)
+
+    val item = SentryEnvelopeItem.fromPerfettoProfileChunk(profileChunk, fixture.serializer)
+
+    assertEquals(SentryItemType.ProfileChunk, item.header.type)
+    assertEquals("application/octet-stream", item.header.contentType)
+    assertNotNull(item.header.metaLength)
+    assertEquals("android", item.header.platform)
+
+    val payload = item.data
+    val metaLength = item.header.metaLength!!
+    // Payload should be: [JSON metadata][binary trace]
+    val metadataBytes = payload.copyOfRange(0, metaLength)
+    val binaryBytes = payload.copyOfRange(metaLength, payload.size)
+
+    // Metadata should be valid JSON containing content_type: "perfetto"
+    val metadataJson = String(metadataBytes, Charsets.UTF_8)
+    assert(metadataJson.contains("\"content_type\":\"perfetto\""))
+    assert(metadataJson.contains("\"version\":\"2\""))
+
+    // Binary bytes should match original trace file
+    assertArrayEquals(traceBytes, binaryBytes)
+
+    // Trace file should be deleted
+    assertFalse(traceFile.exists())
+  }
+
+  @Test
+  fun `fromPerfettoProfileChunk with missing file throws`() {
+    val traceFile = File("nonexistent.pftrace")
+    val profileChunk =
+      ProfileChunk.Builder(
+          SentryId(),
+          SentryId(),
+          emptyMap(),
+          traceFile,
+          SentryNanotimeDate(),
+          ProfileChunk.PLATFORM_ANDROID,
+        )
+        .setContentType("perfetto")
+        .build(fixture.options)
+
+    assertFailsWith<SentryEnvelopeException> {
+      SentryEnvelopeItem.fromPerfettoProfileChunk(profileChunk, fixture.serializer)
+    }
+  }
+
   @Test
   fun `fromReplay encodes payload into msgpack`() {
     val file = Files.createTempFile("replay", "").toFile()

From dde70a4f8a353dd78a52b7faf002e14cc97000ca Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Thu, 9 Apr 2026 15:53:29 -0400
Subject: [PATCH 06/14] fix(profiling): Fix meta_length not serialized in
 Perfetto envelope header
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SentryEnvelopeItemHeader.serialize() checked the raw metaLength field
instead of calling getMetaLength(), so the callable path used by
Perfetto profile chunks was never invoked and meta_length was never
written to the envelope header JSON.

Refactor SentryEnvelopeItemHeader to remove the metaLength field
entirely — all constructors now store a single calculateMetaLength
callable. Eager constructors (deserializer) wrap the Integer in a
lambda. All constructors delegate to one private primary constructor.

In fromPerfettoProfileChunk, replace the round-trip through
ProfileChunk.setMetaLength/getMetaLength with a local AtomicInteger
shared between the CachedItem lambda and the header callable, keeping
meta_length as an envelope transport concern rather than in
ProfileChunk

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../src/main/java/io/sentry/ProfileChunk.java |  14 ---
 .../java/io/sentry/SentryEnvelopeItem.java    |  13 ++-
 .../io/sentry/SentryEnvelopeItemHeader.java   | 107 +++++++-----------
 3 files changed, 53 insertions(+), 81 deletions(-)

diff --git a/sentry/src/main/java/io/sentry/ProfileChunk.java b/sentry/src/main/java/io/sentry/ProfileChunk.java
index e4feb5d251..300860e97c 100644
--- a/sentry/src/main/java/io/sentry/ProfileChunk.java
+++ b/sentry/src/main/java/io/sentry/ProfileChunk.java
@@ -138,20 +138,6 @@ public double getTimestamp() {
     return contentType;
   }
 
-  /**
-   * The length of the JSON metadata prefix in the binary envelope payload. Set during lazy
-   * serialization of Perfetto profile chunks so the envelope item header can read it.
-   */
-  private transient int metaLength = 0;
-
-  public int getMetaLength() {
-    return metaLength;
-  }
-
-  public void setMetaLength(final int metaLength) {
-    this.metaLength = metaLength;
-  }
-
   public @Nullable SentryProfile getSentryProfile() {
     return sentryProfile;
   }
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
index 5938d37091..d506d28e3c 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
@@ -28,6 +28,7 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -385,6 +386,12 @@ private static void ensureAttachmentSizeLimit(
               traceFile != null ? traceFile.getName() : "null"));
     }
 
+    // Perfetto profile chunks are serialized as [JSON metadata][raw .pftrace bytes] with no
+    // delimiter. The server needs meta_length in the envelope header to know where the JSON
+    // ends and the binary begins. meta_length is not known until the CachedItem payload lambda
+    // runs, so we track it here as an envelope serialization concern rather than on ProfileChunk.
+    final AtomicInteger metaLength = new AtomicInteger(-1);
+
     final CachedItem cachedItem =
         new CachedItem(
             () -> {
@@ -394,6 +401,7 @@ private static void ensureAttachmentSizeLimit(
                   final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
                 serializer.serialize(profileChunk, writer);
                 metadataBytes = stream.toByteArray();
+                metaLength.set(metadataBytes.length);
               } catch (IOException e) {
                 throw new SentryEnvelopeException(
                     String.format(
@@ -416,9 +424,6 @@ private static void ensureAttachmentSizeLimit(
               System.arraycopy(metadataBytes, 0, payload, 0, metadataBytes.length);
               System.arraycopy(traceBytes, 0, payload, metadataBytes.length, traceBytes.length);
 
-              // Store metaLength so the header callable can read it after lazy evaluation
-              profileChunk.setMetaLength(metadataBytes.length);
-
               return payload;
             });
 
@@ -431,7 +436,7 @@ private static void ensureAttachmentSizeLimit(
             null,
             profileChunk.getPlatform(),
             null,
-            (Callable<Integer>) () -> profileChunk.getMetaLength());
+            (Callable<Integer>) metaLength::get);
 
     // avoid method refs on Android due to some issues with older AGP setups
     // noinspection Convert2MethodRef
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
index 43989259da..60da203084 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
@@ -21,8 +21,7 @@ public final class SentryEnvelopeItemHeader implements JsonSerializable, JsonUnk
   private final int length;
   @Nullable private final Callable<Integer> getLength;
   private final @Nullable String attachmentType;
-  private final @Nullable Integer metaLength;
-  @Nullable private final Callable<Integer> getMetaLength;
+  @Nullable private final Callable<Integer> calculateMetaLength;
 
   private @Nullable Map<String, Object> unknown;
 
@@ -54,31 +53,41 @@ public int getLength() {
     return platform;
   }
 
-  public @Nullable Integer getMetaLength() {
-    if (getMetaLength != null) {
+  @Nullable Integer getMetaLength() {
+    if (calculateMetaLength != null) {
       try {
-        return getMetaLength.call();
+        return calculateMetaLength.call();
       } catch (Throwable ignored) {
         return null;
       }
     }
-    return metaLength;
+    return null;
   }
 
-  @ApiStatus.Internal
-  public SentryEnvelopeItemHeader(
+  private SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
       int length,
+      final @Nullable Callable<Integer> getLength,
       final @Nullable String contentType,
       final @Nullable String fileName,
       final @Nullable String attachmentType,
       final @Nullable String platform,
-      final @Nullable Integer itemCount) {
-    this(type, length, contentType, fileName, attachmentType, platform, itemCount, null);
+      final @Nullable Integer itemCount,
+      final @Nullable Callable<Integer> calculateMetaLength) {
+    this.type = Objects.requireNonNull(type, "type is required");
+    this.contentType = contentType;
+    this.length = length;
+    this.fileName = fileName;
+    this.getLength = getLength;
+    this.attachmentType = attachmentType;
+    this.platform = platform;
+    this.itemCount = itemCount;
+    this.calculateMetaLength = calculateMetaLength;
   }
 
+  /** Eager constructor used internally by {@link Deserializer#deserialize}. */
   @ApiStatus.Internal
-  public SentryEnvelopeItemHeader(
+  private SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
       int length,
       final @Nullable String contentType,
@@ -87,27 +96,27 @@ public SentryEnvelopeItemHeader(
       final @Nullable String platform,
       final @Nullable Integer itemCount,
       final @Nullable Integer metaLength) {
-    this.type = Objects.requireNonNull(type, "type is required");
-    this.contentType = contentType;
-    this.length = length;
-    this.fileName = fileName;
-    this.getLength = null;
-    this.attachmentType = attachmentType;
-    this.platform = platform;
-    this.itemCount = itemCount;
-    this.metaLength = metaLength;
-    this.getMetaLength = null;
+    this(
+        type, length, null, contentType, fileName, attachmentType, platform, itemCount,
+        metaLength != null ? () -> metaLength : null);
   }
 
-  SentryEnvelopeItemHeader(
+  @ApiStatus.Internal
+  public SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
-      final @Nullable Callable<Integer> getLength,
+      int length,
       final @Nullable String contentType,
       final @Nullable String fileName,
-      final @Nullable String attachmentType) {
-    this(type, getLength, contentType, fileName, attachmentType, null, null);
+      final @Nullable String attachmentType,
+      final @Nullable String platform,
+      final @Nullable Integer itemCount) {
+    this(type, length, contentType, fileName, attachmentType, platform, itemCount, null);
   }
 
+  /**
+   * Lazy constructor. Both length and metaLength are computed lazily as these depend on
+   * the Item having been evaluated.
+   */
   SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
       final @Nullable Callable<Integer> getLength,
@@ -115,16 +124,9 @@ public SentryEnvelopeItemHeader(
       final @Nullable String fileName,
       final @Nullable String attachmentType,
       final @Nullable String platform,
-      final @Nullable Integer itemCount) {
-    this(
-        type,
-        getLength,
-        contentType,
-        fileName,
-        attachmentType,
-        platform,
-        itemCount,
-        (Integer) null);
+      final @Nullable Integer itemCount,
+      final @Nullable Callable<Integer> calculateMetaLength) {
+    this(type, -1, getLength, contentType, fileName, attachmentType, platform, itemCount, calculateMetaLength);
   }
 
   SentryEnvelopeItemHeader(
@@ -134,18 +136,8 @@ public SentryEnvelopeItemHeader(
       final @Nullable String fileName,
       final @Nullable String attachmentType,
       final @Nullable String platform,
-      final @Nullable Integer itemCount,
-      final @Nullable Integer metaLength) {
-    this.type = Objects.requireNonNull(type, "type is required");
-    this.contentType = contentType;
-    this.length = -1;
-    this.fileName = fileName;
-    this.getLength = getLength;
-    this.attachmentType = attachmentType;
-    this.platform = platform;
-    this.itemCount = itemCount;
-    this.metaLength = metaLength;
-    this.getMetaLength = null;
+      final @Nullable Integer itemCount) {
+    this(type, getLength, contentType, fileName, attachmentType, platform, itemCount, null);
   }
 
   SentryEnvelopeItemHeader(
@@ -153,20 +145,8 @@ public SentryEnvelopeItemHeader(
       final @Nullable Callable<Integer> getLength,
       final @Nullable String contentType,
       final @Nullable String fileName,
-      final @Nullable String attachmentType,
-      final @Nullable String platform,
-      final @Nullable Integer itemCount,
-      final @Nullable Callable<Integer> getMetaLength) {
-    this.type = Objects.requireNonNull(type, "type is required");
-    this.contentType = contentType;
-    this.length = -1;
-    this.fileName = fileName;
-    this.getLength = getLength;
-    this.attachmentType = attachmentType;
-    this.platform = platform;
-    this.itemCount = itemCount;
-    this.metaLength = null;
-    this.getMetaLength = getMetaLength;
+      final @Nullable String attachmentType) {
+    this(type, getLength, contentType, fileName, attachmentType, null, null);
   }
 
   SentryEnvelopeItemHeader(
@@ -219,8 +199,9 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
     if (itemCount != null) {
       writer.name(JsonKeys.ITEM_COUNT).value(itemCount);
     }
-    if (metaLength != null) {
-      writer.name(JsonKeys.META_LENGTH).value(metaLength);
+    final @Nullable Integer resolvedMetaLength = getMetaLength();
+    if (resolvedMetaLength != null) {
+      writer.name(JsonKeys.META_LENGTH).value(resolvedMetaLength);
     }
     writer.name(JsonKeys.LENGTH).value(getLength());
     if (unknown != null) {

From 02fd189565513a77dd404f3c025a291f3fb1572a Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Wed, 1 Apr 2026 15:53:29 -0400
Subject: [PATCH 07/14] ref(profiling): Extract PerfettoContinuousProfiler from
 AndroidContinuousProfiler

Separate the Perfetto/ProfilingManager profiling backend into its own
IContinuousProfiler implementation to keep the two backends independent.

- AndroidContinuousProfiler is restored to legacy-only (no Perfetto fields,
  no conditional branches, no @SuppressLint annotations)
- PerfettoContinuousProfiler is a new @RequiresApi(35) class that delegates
  to PerfettoProfiler and always sets content_type="perfetto"
- AndroidOptionsInitializer branches on useProfilingManager to pick the
  right implementation
- Consistent locking: startInternal/stopInternal both require caller to
  hold the lock, with callers wrapped accordingly
- Renamed rootSpanCounter to activeTraceCount in PerfettoContinuousProfiler
- Extracted tryResolveScopes/onScopesAvailable from initScopes in both classes
- Fixed duplicate listener bug in PerfettoProfiler (was using local lambda
  instead of class-scope profilingResultListener)
---
 .../core/AndroidContinuousProfiler.java       | 124 +-----
 .../core/AndroidOptionsInitializer.java       |  11 +-
 .../core/PerfettoContinuousProfiler.java      | 388 ++++++++++++++++++
 .../sentry/android/core/PerfettoProfiler.java |  10 +-
 4 files changed, 416 insertions(+), 117 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
index 6995d8e311..30c9a503bd 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
@@ -4,8 +4,6 @@
 import static io.sentry.IConnectionStatusProvider.ConnectionStatus.DISCONNECTED;
 import static java.util.concurrent.TimeUnit.SECONDS;
 
-import android.annotation.SuppressLint;
-import android.content.Context;
 import android.os.Build;
 import io.sentry.CompositePerformanceCollector;
 import io.sentry.DataCategory;
@@ -53,10 +51,6 @@ public class AndroidContinuousProfiler
   private boolean isInitialized = false;
   private final @NotNull SentryFrameMetricsCollector frameMetricsCollector;
   private @Nullable AndroidProfiler profiler = null;
-  private @Nullable PerfettoProfiler perfettoProfiler = null;
-  private final boolean useProfilingManager;
-  private final @Nullable Context context;
-  private boolean isPerfettoActive = false;
   private boolean isRunning = false;
   private @Nullable IScopes scopes;
   private @Nullable Future<?> stopFuture;
@@ -74,10 +68,6 @@ public class AndroidContinuousProfiler
   private final AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
   private final AutoClosableReentrantLock payloadLock = new AutoClosableReentrantLock();
 
-  /**
-   * Creates a profiler using the legacy Debug.startMethodTracingSampling engine. This is the
-   * default path used for app-start profiling and devices below API 35.
-   */
   public static AndroidContinuousProfiler createLegacy(
       final @NotNull BuildInfoProvider buildInfoProvider,
       final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
@@ -90,40 +80,15 @@ public static AndroidContinuousProfiler createLegacy(
         frameMetricsCollector,
         executorServiceSupplier,
         logger,
-        null,
-        false,
         profilingTracesHz,
         profilingTracesDirPath);
   }
 
-  /**
-   * Creates a profiler using Android's ProfilingManager (Perfetto) on API 35+. On older devices, no
-   * profiling data is collected — the legacy Debug-based profiler is not used as a fallback.
-   */
-  public static AndroidContinuousProfiler createWithProfilingManager(
-      final @NotNull Context context,
-      final @NotNull BuildInfoProvider buildInfoProvider,
-      final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
-      final @NotNull ILogger logger,
-      final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier) {
-    return new AndroidContinuousProfiler(
-        buildInfoProvider,
-        frameMetricsCollector,
-        executorServiceSupplier,
-        logger,
-        context,
-        true,
-        0,
-        null);
-  }
-
   private AndroidContinuousProfiler(
       final @NotNull BuildInfoProvider buildInfoProvider,
       final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
       final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier,
       final @NotNull ILogger logger,
-      final @Nullable Context context,
-      final boolean useProfilingManager,
       final int profilingTracesHz,
       final @Nullable String profilingTracesDirPath) {
     this.logger = logger;
@@ -132,33 +97,15 @@ private AndroidContinuousProfiler(
     this.profilingTracesDirPath = profilingTracesDirPath;
     this.profilingTracesHz = profilingTracesHz;
     this.executorServiceSupplier = executorServiceSupplier;
-    this.useProfilingManager = useProfilingManager;
-    this.context = context;
   }
 
-  @SuppressLint("NewApi")
   private void init() {
-    logger.log(
-        SentryLevel.DEBUG,
-        "AndroidContinuousProfiler.init() isInitialized=%s, useProfilingManager=%s, apiLevel=%d",
-        isInitialized,
-        useProfilingManager,
-        buildInfoProvider.getSdkInfoVersion());
-
     // We initialize it only once
     if (isInitialized) {
       return;
     }
     isInitialized = true;
 
-    if (useProfilingManager) {
-      initProfilingManager();
-    } else {
-      initLegacy();
-    }
-  }
-
-  private void initLegacy() {
     if (profilingTracesDirPath == null) {
       logger.log(
           SentryLevel.WARNING,
@@ -182,20 +129,6 @@ private void initLegacy() {
             logger);
   }
 
-  @SuppressLint("NewApi")
-  private void initProfilingManager() {
-    if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.VANILLA_ICE_CREAM
-        && context != null) {
-      perfettoProfiler = new PerfettoProfiler(context, frameMetricsCollector, logger);
-      logger.log(SentryLevel.DEBUG, "Using Perfetto profiler (ProfilingManager).");
-    } else {
-      logger.log(
-          SentryLevel.WARNING,
-          "useProfilingManager requested but not available (requires API 35+). "
-              + "No profiling data will be collected.");
-    }
-  }
-
   @Override
   public void startProfiler(
       final @NotNull ProfileLifecycle profileLifecycle,
@@ -236,21 +169,24 @@ public void startProfiler(
     }
   }
 
-  private void initScopes() {
+  private void tryResolveScopes() {
     if ((scopes == null || scopes == NoOpScopes.getInstance())
         && Sentry.getCurrentScopes() != NoOpScopes.getInstance()) {
-      this.scopes = Sentry.getCurrentScopes();
-      this.performanceCollector =
-          Sentry.getCurrentScopes().getOptions().getCompositePerformanceCollector();
-      final @Nullable RateLimiter rateLimiter = scopes.getRateLimiter();
-      if (rateLimiter != null) {
-        rateLimiter.addRateLimitObserver(this);
-      }
+      onScopesAvailable(Sentry.getCurrentScopes());
+    }
+  }
+
+  private void onScopesAvailable(final @NotNull IScopes resolvedScopes) {
+    this.scopes = resolvedScopes;
+    this.performanceCollector = resolvedScopes.getOptions().getCompositePerformanceCollector();
+    final @Nullable RateLimiter rateLimiter = resolvedScopes.getRateLimiter();
+    if (rateLimiter != null) {
+      rateLimiter.addRateLimitObserver(this);
     }
   }
 
   private void start() {
-    initScopes();
+    tryResolveScopes();
 
     // Debug.startMethodTracingSampling() is only available since Lollipop, but Android Profiler
     // causes crashes on api 21 -> https://github.com/getsentry/sentry-java/issues/3392
@@ -259,7 +195,7 @@ private void start() {
     // Let's initialize trace folder and profiling interval
     init();
     // init() didn't create profiler, should never happen
-    if (profiler == null && perfettoProfiler == null) {
+    if (profiler == null) {
       return;
     }
 
@@ -286,14 +222,7 @@ private void start() {
     } else {
       startProfileChunkTimestamp = new SentryNanotimeDate();
     }
-    final AndroidProfiler.ProfileStartData startData;
-    if (perfettoProfiler != null) {
-      startData = perfettoProfiler.start(MAX_CHUNK_DURATION_MILLIS);
-      isPerfettoActive = startData != null;
-    } else {
-      startData = profiler.start();
-      isPerfettoActive = false;
-    }
+    final AndroidProfiler.ProfileStartData startData = profiler.start();
     // check if profiling started
     if (startData == null) {
       return;
@@ -350,13 +279,13 @@ public void stopProfiler(final @NotNull ProfileLifecycle profileLifecycle) {
   }
 
   private void stop(final boolean restartProfiler) {
-    initScopes();
+    tryResolveScopes();
     try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
       if (stopFuture != null) {
-        stopFuture.cancel(false);
+        stopFuture.cancel(true);
       }
       // check if profiler was created and it's running
-      if ((profiler == null && perfettoProfiler == null) || !isRunning) {
+      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;
@@ -375,18 +304,8 @@ private void stop(final boolean restartProfiler) {
         performanceCollectionData = performanceCollector.stop(chunkId.toString());
       }
 
-      final AndroidProfiler.ProfileEndData endData;
-      final String platform;
-      if (isPerfettoActive && perfettoProfiler != null) {
-        endData = perfettoProfiler.endAndCollect();
-        platform = ProfileChunk.PLATFORM_ANDROID;
-      } else if (profiler != null) {
-        endData = profiler.endAndCollect(false, performanceCollectionData);
-        platform = ProfileChunk.PLATFORM_ANDROID;
-      } else {
-        endData = null;
-        platform = ProfileChunk.PLATFORM_ANDROID;
-      }
+      final AndroidProfiler.ProfileEndData endData =
+          profiler.endAndCollect(false, performanceCollectionData);
 
       // check if profiler end successfully
       if (endData == null) {
@@ -405,10 +324,7 @@ private void stop(final boolean restartProfiler) {
                   endData.measurementsMap,
                   endData.traceFile,
                   startProfileChunkTimestamp,
-                  platform);
-          if (isPerfettoActive) {
-            builder.setContentType("perfetto");
-          }
+                  ProfileChunk.PLATFORM_ANDROID);
           payloadBuilders.add(builder);
         }
       }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 357fbfcae8..d8b5a77e2a 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -2,6 +2,7 @@
 
 import static io.sentry.android.core.NdkIntegration.SENTRY_NDK_CLASS_NAME;
 
+import android.annotation.SuppressLint;
 import android.app.Application;
 import android.content.Context;
 import android.content.pm.PackageInfo;
@@ -293,6 +294,7 @@ static void initializeIntegrationsAndProcessors(
   }
 
   /** Setup the correct profiler (transaction or continuous) based on the options. */
+  @SuppressLint("NewApi")
   private static void setupProfiler(
       final @NotNull SentryAndroidOptions options,
       final @NotNull Context context,
@@ -340,12 +342,13 @@ private static void setupProfiler(
                 options.getFrameMetricsCollector(), "options.getFrameMetricsCollector is required");
         options.setContinuousProfiler(
             options.isUseProfilingManager()
-                ? AndroidContinuousProfiler.createWithProfilingManager(
-                    context,
+                ? new PerfettoContinuousProfiler(
                     buildInfoProvider,
-                    frameMetricsCollector,
                     options.getLogger(),
-                    () -> options.getExecutorService())
+                    () -> options.getExecutorService(),
+                    () ->
+                        new PerfettoProfiler(
+                            context.getApplicationContext(), frameMetricsCollector, options.getLogger()))
                 : AndroidContinuousProfiler.createLegacy(
                     buildInfoProvider,
                     frameMetricsCollector,
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
new file mode 100644
index 0000000000..ecec2d0fbc
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
@@ -0,0 +1,388 @@
+package io.sentry.android.core;
+
+import static io.sentry.DataCategory.All;
+import static io.sentry.IConnectionStatusProvider.ConnectionStatus.DISCONNECTED;
+
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+import io.sentry.CompositePerformanceCollector;
+import io.sentry.DataCategory;
+import io.sentry.IContinuousProfiler;
+import io.sentry.ILogger;
+import io.sentry.IScopes;
+import io.sentry.ISentryExecutorService;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.NoOpScopes;
+import io.sentry.ProfileChunk;
+import io.sentry.ProfileLifecycle;
+import io.sentry.Sentry;
+import io.sentry.SentryDate;
+import io.sentry.SentryLevel;
+import io.sentry.SentryNanotimeDate;
+import io.sentry.SentryOptions;
+import io.sentry.TracesSampler;
+import io.sentry.protocol.SentryId;
+import io.sentry.transport.RateLimiter;
+import io.sentry.util.AutoClosableReentrantLock;
+import io.sentry.util.LazyEvaluator;
+import io.sentry.util.SentryRandom;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.VisibleForTesting;
+
+/**
+ * Continuous profiler that uses Android's {@link android.os.ProfilingManager} (API 35+) to capture
+ * Perfetto stack-sampling traces.
+ *
+ * <p>This class is intentionally separate from {@link AndroidContinuousProfiler} to keep the two
+ * profiling backends independent. All ProfilingManager API usage is confined to this file and
+ * {@link PerfettoProfiler}.
+ */
+@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;
+  private final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier;
+  private final @NotNull BuildInfoProvider buildInfoProvider;
+  private final @NotNull LazyEvaluator.Evaluator<PerfettoProfiler> perfettoProfilerSupplier;
+
+  private @Nullable PerfettoProfiler perfettoProfiler = 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;
+  private final @NotNull AtomicBoolean isClosed = new AtomicBoolean(false);
+  private @NotNull SentryDate startProfileChunkTimestamp = new SentryNanotimeDate();
+  private volatile boolean shouldSample = true;
+  private boolean shouldStop = false;
+  private boolean isSampled = false;
+  private int activeTraceCount = 0;
+
+  private final AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
+  private final AutoClosableReentrantLock payloadLock = new AutoClosableReentrantLock();
+
+  public PerfettoContinuousProfiler(
+      final @NotNull BuildInfoProvider buildInfoProvider,
+      final @NotNull ILogger logger,
+      final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier,
+      final @NotNull LazyEvaluator.Evaluator<PerfettoProfiler> perfettoProfilerSupplier) {
+    this.buildInfoProvider = buildInfoProvider;
+    this.logger = logger;
+    this.executorServiceSupplier = executorServiceSupplier;
+    this.perfettoProfilerSupplier = perfettoProfilerSupplier;
+  }
+
+  @Override
+  public void startProfiler(
+      final @NotNull ProfileLifecycle profileLifecycle,
+      final @NotNull TracesSampler tracesSampler) {
+    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:
+          activeTraceCount = Math.max(0, activeTraceCount); // safety check.
+          activeTraceCount++;
+          break;
+        case MANUAL:
+          if (isRunning()) {
+            logger.log(
+                SentryLevel.WARNING,
+                "Unexpected call to startProfiler(MANUAL) while profiler already running. Skipping.");
+            return;
+          }
+          break;
+      }
+      if (!isRunning()) {
+        logger.log(SentryLevel.DEBUG, "Started Profiler.");
+        startInternal();
+      }
+    }
+  }
+
+  @Override
+  public void stopProfiler(final @NotNull ProfileLifecycle profileLifecycle) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      switch (profileLifecycle) {
+        case TRACE:
+          activeTraceCount--;
+          activeTraceCount = Math.max(0, activeTraceCount); // safety check
+          // If there are active spans, and profile lifecycle is trace, we don't stop the profiler
+          if (activeTraceCount > 0) {
+            return;
+          }
+          shouldStop = true;
+          break;
+        case MANUAL:
+          shouldStop = true;
+          break;
+      }
+    }
+  }
+
+  /**
+   * 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
+   */
+  @Override
+  public void onRateLimitChanged(@NotNull RateLimiter rateLimiter) {
+    if (rateLimiter.isActiveForCategory(All)
+        || rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi)) {
+      try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+        logger.log(SentryLevel.WARNING, "SDK is rate limited. Stopping profiler.");
+        stopInternal(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
+  }
+
+  @Override
+  public void close(final boolean isTerminating) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      activeTraceCount = 0;
+      shouldStop = true;
+      if (isTerminating) {
+        stopInternal(false);
+        isClosed.set(true);
+      }
+    }
+  }
+
+  @Override
+  public @NotNull SentryId getProfilerId() {
+    return profilerId;
+  }
+
+  @Override
+  public @NotNull SentryId getChunkId() {
+    return chunkId;
+  }
+
+  @Override
+  public boolean isRunning() {
+    return isRunning;
+  }
+
+  /** Caller must hold {@link #lock}. */
+  private void startInternal() {
+    tryResolveScopes();
+    ensureProfiler();
+
+    if (perfettoProfiler == null) {
+      return;
+    }
+
+    if (scopes != null) {
+      final @Nullable RateLimiter rateLimiter = scopes.getRateLimiter();
+      if (rateLimiter != null
+          && (rateLimiter.isActiveForCategory(All)
+              || rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi))) {
+        logger.log(SentryLevel.WARNING, "SDK is rate limited. Stopping profiler.");
+        // Let's stop and reset profiler id, as the profile is now broken anyway
+        stopInternal(false);
+        return;
+      }
+
+      // If device is offline, we don't start the profiler, to avoid flooding the cache
+      // TODO .getConnectionStatus() may be blocking, investigate if this can be done async
+      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
+        stopInternal(false);
+        return;
+      }
+      startProfileChunkTimestamp = scopes.getOptions().getDateProvider().now();
+    } else {
+      startProfileChunkTimestamp = new SentryNanotimeDate();
+    }
+
+    final AndroidProfiler.ProfileStartData startData =
+        perfettoProfiler.start(MAX_CHUNK_DURATION_MILLIS);
+    if (startData == null) {
+      logger.log(
+          SentryLevel.ERROR,
+          "Failed to start Perfetto profiling. PerfettoProfiler.start() returned null.");
+      return;
+    }
+
+    isRunning = true;
+
+    if (profilerId.equals(SentryId.EMPTY_ID)) {
+      profilerId = new SentryId();
+    }
+
+    if (chunkId.equals(SentryId.EMPTY_ID)) {
+      chunkId = new SentryId();
+    }
+
+    if (performanceCollector != null) {
+      performanceCollector.start(chunkId.toString());
+    }
+
+    try {
+      stopFuture =
+          executorServiceSupplier
+              .evaluate()
+              .schedule(
+                  () -> {
+                    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+                      stopInternal(true);
+                    }
+                  },
+                  MAX_CHUNK_DURATION_MILLIS);
+    } catch (RejectedExecutionException e) {
+      logger.log(
+          SentryLevel.ERROR,
+          "Failed to schedule profiling chunk finish. Did you call Sentry.close()?",
+          e);
+      shouldStop = true;
+    }
+  }
+
+  /** Caller must hold {@link #lock}. */
+  private void stopInternal(final boolean restartProfiler) {
+    tryResolveScopes();
+    if (stopFuture != null) {
+      stopFuture.cancel(false);
+    }
+    // check if profiler was created and it's running
+    if (perfettoProfiler == 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;
+    }
+
+    final AndroidProfiler.ProfileEndData endData = perfettoProfiler.endAndCollect();
+
+    // check if profiler ended 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()) {
+        final ProfileChunk.Builder builder =
+            new ProfileChunk.Builder(
+                profilerId,
+                chunkId,
+                endData.measurementsMap,
+                endData.traceFile,
+                startProfileChunkTimestamp,
+                ProfileChunk.PLATFORM_ANDROID);
+        builder.setContentType("perfetto");
+        payloadBuilders.add(builder);
+      }
+    }
+
+    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 && !shouldStop) {
+      logger.log(SentryLevel.DEBUG, "Profile chunk finished. Starting a new one.");
+      startInternal();
+    } else {
+      // When the profiler is stopped manually, we have to reset its id
+      profilerId = SentryId.EMPTY_ID;
+      logger.log(SentryLevel.DEBUG, "Profile chunk finished.");
+    }
+  }
+
+  private void tryResolveScopes() {
+    if ((scopes == null || scopes == NoOpScopes.getInstance())
+        && Sentry.getCurrentScopes() != NoOpScopes.getInstance()) {
+      onScopesAvailable(Sentry.getCurrentScopes());
+    }
+  }
+
+  private void onScopesAvailable(final @NotNull IScopes resolvedScopes) {
+    this.scopes = resolvedScopes;
+    this.performanceCollector = resolvedScopes.getOptions().getCompositePerformanceCollector();
+    final @Nullable RateLimiter rateLimiter = resolvedScopes.getRateLimiter();
+    if (rateLimiter != null) {
+      rateLimiter.addRateLimitObserver(this);
+    }
+  }
+
+  private void ensureProfiler() {
+    if (perfettoProfiler == null) {
+      logger.log(
+          SentryLevel.DEBUG,
+          "PerfettoContinuousProfiler: creating PerfettoProfiler (apiLevel=%d)",
+          buildInfoProvider.getSdkInfoVersion());
+      perfettoProfiler = perfettoProfilerSupplier.evaluate();
+    }
+  }
+
+  public void reevaluateSampling() {
+    shouldSample = true;
+  }
+
+  private void sendChunks(final @NotNull IScopes scopes, final @NotNull SentryOptions options) {
+    try {
+      options
+          .getExecutorService()
+          .submit(
+              () -> {
+                // SDK is closed, we don't send the chunks
+                if (isClosed.get()) {
+                  return;
+                }
+                final ArrayList<ProfileChunk> payloads = new ArrayList<>(payloadBuilders.size());
+                try (final @NotNull ISentryLifecycleToken ignored = payloadLock.acquire()) {
+                  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);
+    }
+  }
+
+  @VisibleForTesting
+  @Nullable
+  Future<?> getStopFuture() {
+    return stopFuture;
+  }
+
+  @VisibleForTesting
+  public int getActiveTraceCount() {
+    return activeTraceCount;
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
index 439a8f913c..8c8197df12 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
@@ -104,14 +104,6 @@ public PerfettoProfiler(
     resultLatch = new CountDownLatch(1);
     profilingResult = null;
 
-    final Consumer<ProfilingResult> listener =
-        result -> {
-          profilingResult = result;
-          if (resultLatch != null) {
-            resultLatch.countDown();
-          }
-        };
-
     final Bundle params = new Bundle();
     params.putInt(KEY_DURATION_MS, (int) durationMs);
     params.putInt(KEY_FREQUENCY_HZ, PROFILING_FREQUENCY_HZ);
@@ -123,7 +115,7 @@ public PerfettoProfiler(
           "sentry-profiling",
           cancellationSignal,
           Runnable::run,
-          listener);
+          profilingResultListener);
     } catch (Throwable e) {
       logger.log(SentryLevel.ERROR, "Failed to request Perfetto profiling.", e);
       cancellationSignal = null;

From 7c4b52e5c8b6242dfdeff90151f0eec073223c33 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Wed, 1 Apr 2026 15:53:37 -0400
Subject: [PATCH 08/14] test(profiling): Add unit test for
 PerfettoContinuousProfiler rate limiting

Verify that onRateLimitChanged stops the profiler, resets profiler/chunk
IDs, and logs the expected warning.

Run with:
  ./gradlew :sentry-android-core:testDebugUnitTest --tests "io.sentry.android.core.PerfettoContinuousProfilerTest"
---
 .../core/PerfettoContinuousProfilerTest.kt    | 110 ++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt

diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
new file mode 100644
index 0000000000..b01e865545
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
@@ -0,0 +1,110 @@
+package io.sentry.android.core
+
+import android.content.Context
+import android.os.Build
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.DataCategory
+import io.sentry.ILogger
+import io.sentry.IScopes
+import io.sentry.ProfileLifecycle
+import io.sentry.Sentry
+import io.sentry.SentryLevel
+import io.sentry.TracesSampler
+import io.sentry.protocol.SentryId
+import io.sentry.test.DeferredExecutorService
+import io.sentry.transport.RateLimiter
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import org.junit.runner.RunWith
+import org.mockito.Mockito.mockStatic
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@RunWith(AndroidJUnit4::class)
+class PerfettoContinuousProfilerTest {
+  private lateinit var context: Context
+  private val fixture = Fixture()
+
+  private class Fixture {
+    private val mockDsn = "http://key@localhost/proj"
+    val buildInfo =
+      mock<BuildInfoProvider> {
+        whenever(it.sdkInfoVersion).thenReturn(Build.VERSION_CODES.VANILLA_ICE_CREAM)
+      }
+    val executor = DeferredExecutorService()
+    val mockedSentry = mockStatic(Sentry::class.java)
+    val mockLogger = mock<ILogger>()
+    val mockTracesSampler = mock<TracesSampler>()
+    val mockPerfettoProfiler = mock<PerfettoProfiler>()
+
+    val scopes: IScopes = mock()
+
+    val options =
+      spy(SentryAndroidOptions()).apply {
+        dsn = mockDsn
+        profilesSampleRate = 1.0
+        isDebug = true
+        setLogger(mockLogger)
+      }
+
+    init {
+      whenever(mockTracesSampler.sampleSessionProfile(any())).thenReturn(true)
+      whenever(mockPerfettoProfiler.start(any())).thenReturn(
+        AndroidProfiler.ProfileStartData(
+          System.nanoTime(),
+          0L,
+          io.sentry.DateUtils.getCurrentDateTime(),
+        ),
+      )
+    }
+
+    fun getSut(): PerfettoContinuousProfiler {
+      options.executorService = executor
+      whenever(scopes.options).thenReturn(options)
+      return PerfettoContinuousProfiler(
+        buildInfo,
+        mockLogger,
+        { options.executorService },
+        { mockPerfettoProfiler },
+      )
+    }
+  }
+
+  @BeforeTest
+  fun `set up`() {
+    context = ApplicationProvider.getApplicationContext()
+    Sentry.setCurrentScopes(fixture.scopes)
+    fixture.mockedSentry.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(fixture.scopes)
+  }
+
+  @AfterTest
+  fun clear() {
+    fixture.mockedSentry.close()
+  }
+
+  @Test
+  fun `profiler stops when rate limited`() {
+    val profiler = fixture.getSut()
+    val rateLimiter = mock<RateLimiter>()
+    whenever(rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi)).thenReturn(true)
+
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+
+    profiler.onRateLimitChanged(rateLimiter)
+    assertFalse(profiler.isRunning)
+    assertEquals(SentryId.EMPTY_ID, profiler.profilerId)
+    assertEquals(SentryId.EMPTY_ID, profiler.chunkId)
+    verify(fixture.mockLogger)
+      .log(eq(SentryLevel.WARNING), eq("SDK is rate limited. Stopping profiler."))
+  }
+}

From 9595dbc966b135ab48b260d7eee932b55572ef91 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Tue, 7 Apr 2026 14:22:05 -0400
Subject: [PATCH 09/14] ref(profiling): Remove app-start profiling logic from
 PerfettoContinuousProfiler

Currently PerfettoContinuousProfiler is not doing app-start profiling.
Because of this, scopes are always available. Remove the
legacy patterns that were carried over from AndroidContinuousProfiler:

- Replace tryResolveScopes/onScopesAvailable with resolveScopes() that
  returns @NotNull IScopes and logs an error if scopes is unexpectedly
  unavailable
- Remove payloadBuilders list, payloadLock, and sendChunks() buffering;
  replace with sendChunk() that sends a single chunk immediately
- Remove scopes != null guards and SentryNanotimeDate fallback

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../core/PerfettoContinuousProfiler.java      | 155 +++++++++---------
 1 file changed, 73 insertions(+), 82 deletions(-)

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
index ecec2d0fbc..4364805f49 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
@@ -18,7 +18,6 @@
 import io.sentry.Sentry;
 import io.sentry.SentryDate;
 import io.sentry.SentryLevel;
-import io.sentry.SentryNanotimeDate;
 import io.sentry.SentryOptions;
 import io.sentry.TracesSampler;
 import io.sentry.protocol.SentryId;
@@ -26,8 +25,6 @@
 import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.LazyEvaluator;
 import io.sentry.util.SentryRandom;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -41,8 +38,12 @@
  * Perfetto stack-sampling traces.
  *
  * <p>This class is intentionally separate from {@link AndroidContinuousProfiler} to keep the two
- * profiling backends independent. All ProfilingManager API usage is confined to this file and
- * {@link PerfettoProfiler}.
+ * 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.
  */
 @ApiStatus.Internal
 @RequiresApi(api = Build.VERSION_CODES.VANILLA_ICE_CREAM)
@@ -59,20 +60,19 @@ public class PerfettoContinuousProfiler
   private @Nullable PerfettoProfiler perfettoProfiler = 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 @Nullable Future<?> stopFuture;
   private @NotNull SentryId profilerId = SentryId.EMPTY_ID;
   private @NotNull SentryId chunkId = SentryId.EMPTY_ID;
   private final @NotNull AtomicBoolean isClosed = new AtomicBoolean(false);
-  private @NotNull SentryDate startProfileChunkTimestamp = new SentryNanotimeDate();
+  private @NotNull SentryDate startProfileChunkTimestamp =
+      new io.sentry.SentryNanotimeDate();
   private volatile boolean shouldSample = true;
   private boolean shouldStop = false;
   private boolean isSampled = false;
   private int activeTraceCount = 0;
 
   private final AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
-  private final AutoClosableReentrantLock payloadLock = new AutoClosableReentrantLock();
 
   public PerfettoContinuousProfiler(
       final @NotNull BuildInfoProvider buildInfoProvider,
@@ -185,39 +185,58 @@ public boolean isRunning() {
     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.
+   */
+  private @NotNull IScopes resolveScopes() {
+    if (scopes != null && scopes != NoOpScopes.getInstance()) {
+      return scopes;
+    }
+    final @NotNull IScopes currentScopes = Sentry.getCurrentScopes();
+    if (currentScopes == NoOpScopes.getInstance()) {
+      logger.log(
+          SentryLevel.ERROR,
+          "PerfettoContinuousProfiler: scopes not available. This is unexpected.");
+      return currentScopes;
+    }
+    this.scopes = currentScopes;
+    this.performanceCollector = currentScopes.getOptions().getCompositePerformanceCollector();
+    final @Nullable RateLimiter rateLimiter = currentScopes.getRateLimiter();
+    if (rateLimiter != null) {
+      rateLimiter.addRateLimitObserver(this);
+    }
+    return scopes;
+  }
+
   /** Caller must hold {@link #lock}. */
   private void startInternal() {
-    tryResolveScopes();
+    final @NotNull IScopes scopes = resolveScopes();
     ensureProfiler();
 
     if (perfettoProfiler == null) {
       return;
     }
 
-    if (scopes != null) {
-      final @Nullable RateLimiter rateLimiter = scopes.getRateLimiter();
-      if (rateLimiter != null
-          && (rateLimiter.isActiveForCategory(All)
-              || rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi))) {
-        logger.log(SentryLevel.WARNING, "SDK is rate limited. Stopping profiler.");
-        // Let's stop and reset profiler id, as the profile is now broken anyway
-        stopInternal(false);
-        return;
-      }
+    final @Nullable RateLimiter rateLimiter = scopes.getRateLimiter();
+    if (rateLimiter != null
+        && (rateLimiter.isActiveForCategory(All)
+            || rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi))) {
+      logger.log(SentryLevel.WARNING, "SDK is rate limited. Stopping profiler.");
+      stopInternal(false);
+      return;
+    }
 
-      // If device is offline, we don't start the profiler, to avoid flooding the cache
-      // TODO .getConnectionStatus() may be blocking, investigate if this can be done async
-      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
-        stopInternal(false);
-        return;
-      }
-      startProfileChunkTimestamp = scopes.getOptions().getDateProvider().now();
-    } else {
-      startProfileChunkTimestamp = new SentryNanotimeDate();
+    // 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.");
+      stopInternal(false);
+      return;
     }
 
+    startProfileChunkTimestamp = scopes.getOptions().getDateProvider().now();
+
     final AndroidProfiler.ProfileStartData startData =
         perfettoProfiler.start(MAX_CHUNK_DURATION_MILLIS);
     if (startData == null) {
@@ -263,19 +282,23 @@ private void startInternal() {
 
   /** Caller must hold {@link #lock}. */
   private void stopInternal(final boolean restartProfiler) {
-    tryResolveScopes();
     if (stopFuture != null) {
       stopFuture.cancel(false);
     }
     // check if profiler was created and it's running
     if (perfettoProfiler == 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;
     }
 
+    final @NotNull IScopes scopes = resolveScopes();
+    final @NotNull SentryOptions options = scopes.getOptions();
+
+    if (performanceCollector != null) {
+      performanceCollector.stop(chunkId.toString());
+    }
+
     final AndroidProfiler.ProfileEndData endData = perfettoProfiler.endAndCollect();
 
     // check if profiler ended successfully
@@ -284,31 +307,22 @@ private void stopInternal(final boolean restartProfiler) {
           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()) {
-        final ProfileChunk.Builder builder =
-            new ProfileChunk.Builder(
-                profilerId,
-                chunkId,
-                endData.measurementsMap,
-                endData.traceFile,
-                startProfileChunkTimestamp,
-                ProfileChunk.PLATFORM_ANDROID);
-        builder.setContentType("perfetto");
-        payloadBuilders.add(builder);
-      }
+      final ProfileChunk.Builder builder =
+          new ProfileChunk.Builder(
+              profilerId,
+              chunkId,
+              endData.measurementsMap,
+              endData.traceFile,
+              startProfileChunkTimestamp,
+              ProfileChunk.PLATFORM_ANDROID);
+      builder.setContentType("perfetto");
+      sendChunk(builder, scopes, options);
     }
 
     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 && !shouldStop) {
       logger.log(SentryLevel.DEBUG, "Profile chunk finished. Starting a new one.");
       startInternal();
@@ -319,22 +333,6 @@ private void stopInternal(final boolean restartProfiler) {
     }
   }
 
-  private void tryResolveScopes() {
-    if ((scopes == null || scopes == NoOpScopes.getInstance())
-        && Sentry.getCurrentScopes() != NoOpScopes.getInstance()) {
-      onScopesAvailable(Sentry.getCurrentScopes());
-    }
-  }
-
-  private void onScopesAvailable(final @NotNull IScopes resolvedScopes) {
-    this.scopes = resolvedScopes;
-    this.performanceCollector = resolvedScopes.getOptions().getCompositePerformanceCollector();
-    final @Nullable RateLimiter rateLimiter = resolvedScopes.getRateLimiter();
-    if (rateLimiter != null) {
-      rateLimiter.addRateLimitObserver(this);
-    }
-  }
-
   private void ensureProfiler() {
     if (perfettoProfiler == null) {
       logger.log(
@@ -349,29 +347,22 @@ public void reevaluateSampling() {
     shouldSample = true;
   }
 
-  private void sendChunks(final @NotNull IScopes scopes, final @NotNull SentryOptions options) {
+  private void sendChunk(
+      final @NotNull ProfileChunk.Builder builder,
+      final @NotNull IScopes scopes,
+      final @NotNull SentryOptions options) {
     try {
       options
           .getExecutorService()
           .submit(
               () -> {
-                // SDK is closed, we don't send the chunks
                 if (isClosed.get()) {
                   return;
                 }
-                final ArrayList<ProfileChunk> payloads = new ArrayList<>(payloadBuilders.size());
-                try (final @NotNull ISentryLifecycleToken ignored = payloadLock.acquire()) {
-                  for (ProfileChunk.Builder builder : payloadBuilders) {
-                    payloads.add(builder.build(options));
-                  }
-                  payloadBuilders.clear();
-                }
-                for (ProfileChunk payload : payloads) {
-                  scopes.captureProfileChunk(payload);
-                }
+                scopes.captureProfileChunk(builder.build(options));
               });
     } catch (Throwable e) {
-      options.getLogger().log(SentryLevel.DEBUG, "Failed to send profile chunks.", e);
+      options.getLogger().log(SentryLevel.DEBUG, "Failed to send profile chunk.", e);
     }
   }
 

From aced65750f014d61dde4a9aed039194a03e75cb0 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Tue, 7 Apr 2026 14:32:46 -0400
Subject: [PATCH 10/14] 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>
---
 .../core/PerfettoContinuousProfiler.java      | 37 +++++++++++++------
 .../sentry/android/core/PerfettoProfiler.java | 16 ++++----
 2 files changed, 34 insertions(+), 19 deletions(-)

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
index 4364805f49..56407e2437 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
+++ b/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(
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
index 8c8197df12..8df191809b 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
+++ b/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<>();
 
   /**

From 4549c86e3076670eefc3f13cb93570de8bc0d8f0 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Tue, 7 Apr 2026 16:37:49 -0400
Subject: [PATCH 11/14] chore: Run spotlessApply and apiDump

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 sentry-android-core/api/sentry-android-core.api   | 14 +++++++++++++-
 .../android/core/PerfettoContinuousProfiler.java  | 13 ++++++-------
 .../io/sentry/android/core/PerfettoProfiler.java  |  2 +-
 .../core/PerfettoContinuousProfilerTest.kt        | 15 ++++++++-------
 4 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index b813726bcf..0b0ea05200 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -43,7 +43,6 @@ public final class io/sentry/android/core/ActivityLifecycleIntegration : android
 public class io/sentry/android/core/AndroidContinuousProfiler : io/sentry/IContinuousProfiler, io/sentry/transport/RateLimiter$IRateLimitObserver {
 	public fun close (Z)V
 	public static fun createLegacy (Lio/sentry/android/core/BuildInfoProvider;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;Ljava/lang/String;ILio/sentry/util/LazyEvaluator$Evaluator;)Lio/sentry/android/core/AndroidContinuousProfiler;
-	public static fun createWithProfilingManager (Landroid/content/Context;Lio/sentry/android/core/BuildInfoProvider;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;Lio/sentry/util/LazyEvaluator$Evaluator;)Lio/sentry/android/core/AndroidContinuousProfiler;
 	public fun getChunkId ()Lio/sentry/protocol/SentryId;
 	public fun getProfilerId ()Lio/sentry/protocol/SentryId;
 	public fun getRootSpanCounter ()I
@@ -339,6 +338,19 @@ public final class io/sentry/android/core/NetworkBreadcrumbsIntegration : io/sen
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
+public class io/sentry/android/core/PerfettoContinuousProfiler : io/sentry/IContinuousProfiler, io/sentry/transport/RateLimiter$IRateLimitObserver {
+	public fun <init> (Landroid/content/Context;Lio/sentry/android/core/BuildInfoProvider;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;Lio/sentry/util/LazyEvaluator$Evaluator;)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
+	public fun onRateLimitChanged (Lio/sentry/transport/RateLimiter;)V
+	public fun reevaluateSampling ()V
+	public fun startProfiler (Lio/sentry/ProfileLifecycle;Lio/sentry/TracesSampler;)V
+	public fun stopProfiler (Lio/sentry/ProfileLifecycle;)V
+}
+
 public class io/sentry/android/core/PerfettoProfiler {
 	public fun <init> (Landroid/content/Context;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/ILogger;)V
 	public fun endAndCollect ()Lio/sentry/android/core/AndroidProfiler$ProfileEndData;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
index 56407e2437..247dce9dd0 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
@@ -38,8 +38,8 @@
  * Perfetto stack-sampling traces.
  *
  * <p>This class is intentionally separate from {@link AndroidContinuousProfiler} to keep the two
- * profiling backends independent. All ProfilingManager API usage is confined to this file and {@link
- * PerfettoProfiler}.
+ * profiling backends independent. All ProfilingManager API usage is confined to this file and
+ * {@link PerfettoProfiler}.
  *
  * <p>Currently, this class doesn't do app-start profiling {@link SentryPerformanceProvider}.
  * It is created during {@code Sentry.init()}.
@@ -69,8 +69,7 @@ public class PerfettoContinuousProfiler
   private @NotNull SentryId profilerId = SentryId.EMPTY_ID;
   private @NotNull SentryId chunkId = SentryId.EMPTY_ID;
   private final @NotNull AtomicBoolean isClosed = new AtomicBoolean(false);
-  private @NotNull SentryDate startProfileChunkTimestamp =
-      new io.sentry.SentryNanotimeDate();
+  private @NotNull SentryDate startProfileChunkTimestamp = new io.sentry.SentryNanotimeDate();
   private boolean shouldSample = true;
   private boolean shouldStop = false;
   private boolean isSampled = false;
@@ -195,9 +194,9 @@ public boolean 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.
+   * 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}.
    */
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
index 8df191809b..a5053eda74 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
@@ -15,8 +15,8 @@
 import io.sentry.profilemeasurements.ProfileMeasurementValue;
 import java.io.File;
 import java.util.HashMap;
-import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.Map;
+import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
index b01e865545..1bdd6fce92 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
@@ -58,13 +58,14 @@ class PerfettoContinuousProfilerTest {
 
     init {
       whenever(mockTracesSampler.sampleSessionProfile(any())).thenReturn(true)
-      whenever(mockPerfettoProfiler.start(any())).thenReturn(
-        AndroidProfiler.ProfileStartData(
-          System.nanoTime(),
-          0L,
-          io.sentry.DateUtils.getCurrentDateTime(),
-        ),
-      )
+      whenever(mockPerfettoProfiler.start(any()))
+        .thenReturn(
+          AndroidProfiler.ProfileStartData(
+            System.nanoTime(),
+            0L,
+            io.sentry.DateUtils.getCurrentDateTime(),
+          )
+        )
     }
 
     fun getSut(): PerfettoContinuousProfiler {

From b4f1c3b16ff5ba8bf30bd0b9a478d11a06349ffa Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Wed, 8 Apr 2026 15:44:20 -0400
Subject: [PATCH 12/14] fix(profiling): PerfettoContinuousProfiler Reset
 shouldStop=false on startProfiler

shouldStop was always true, so we'd ever only collect max one
profile session (startProfiler(MANUAL)->stopProfiler(MANUAL)
plus one more chunk before profiler stopped itself.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../core/PerfettoContinuousProfiler.java      |  1 +
 .../core/PerfettoContinuousProfilerTest.kt    | 25 +++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
index 247dce9dd0..33b427b2a0 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
@@ -93,6 +93,7 @@ public void startProfiler(
       final @NotNull ProfileLifecycle profileLifecycle,
       final @NotNull TracesSampler tracesSampler) {
     try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      shouldStop = false;
       if (shouldSample) {
         isSampled = tracesSampler.sampleSessionProfile(SentryRandom.current().nextDouble());
         shouldSample = false;
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
index 1bdd6fce92..0961d8e524 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
@@ -108,4 +108,29 @@ class PerfettoContinuousProfilerTest {
     verify(fixture.mockLogger)
       .log(eq(SentryLevel.WARNING), eq("SDK is rate limited. Stopping profiler."))
   }
+
+  @Test
+  fun `manual profiler can be started again after a full start-stop cycle`() {
+    // DeferredExecutorService captures scheduled runnables instead of waiting.
+    // executor.runAll() fires them immediately, simulating the 60s chunk timer elapsing.
+    val profiler = fixture.getSut()
+
+    // Session 1: start profiling, then stop it
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+    profiler.stopProfiler(ProfileLifecycle.MANUAL)
+    // Simulate the 60s chunk timer firing — stopInternal(restartProfiler=true) runs,
+    // sees shouldStop=true, and does NOT restart. Profiler stops.
+    fixture.executor.runAll()
+    assertFalse(profiler.isRunning)
+
+    // Session 2: start profiling again
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+    // Simulate the 60s chunk timer firing — stopInternal(restartProfiler=true) runs.
+    // shouldStop must have been reset to false by startProfiler, so the profiler
+    // should restart for the next chunk.
+    fixture.executor.runAll()
+    assertTrue(profiler.isRunning, "Profiler should continue running after chunk restart — shouldStop must be reset on start")
+  }
 }

From 83b1f1a76a40e67a1369008154a93fd81f6e6d33 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Wed, 8 Apr 2026 16:34:46 -0400
Subject: [PATCH 13/14] fix(profiling): AndroidContinuousProfiler Reset
 shouldStop flag on startProfiler
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Same fix as PerfettoContinuousProfiler — shouldStop was never reset to
false after stopProfiler, so a stop/start cycle would leave
shouldStop=true and silently stop the profiler after one chunk.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../core/AndroidContinuousProfiler.java        |  1 +
 .../core/AndroidContinuousProfilerTest.kt      | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
index 30c9a503bd..6a8b14b2b3 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
@@ -134,6 +134,7 @@ public void startProfiler(
       final @NotNull ProfileLifecycle profileLifecycle,
       final @NotNull TracesSampler tracesSampler) {
     try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      shouldStop = false;
       if (shouldSample) {
         isSampled = tracesSampler.sampleSessionProfile(SentryRandom.current().nextDouble());
         shouldSample = false;
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
index a35d2cf503..0c570b8e8e 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
@@ -556,6 +556,24 @@ class AndroidContinuousProfilerTest {
       .log(eq(SentryLevel.WARNING), eq("Device is offline. Stopping profiler."))
   }
 
+  @Test
+  fun `manual profiler can be started again after a full start-stop cycle`() {
+    val profiler = fixture.getSut()
+
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+    profiler.stopProfiler(ProfileLifecycle.MANUAL)
+    // Triggers the scheduled executor task that collects perf metrics and finalizes the chunk
+    fixture.executor.runAll()
+    assertFalse(profiler.isRunning)
+
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+    // Triggers the scheduled executor task that collects perf metrics and finalizes the chunk
+    fixture.executor.runAll()
+    assertTrue(profiler.isRunning, "shouldStop must be reset on start")
+  }
+
   fun withMockScopes(closure: () -> Unit) =
     Mockito.mockStatic(Sentry::class.java).use {
       it.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(fixture.scopes)

From 10c415fb8205be1325712cbebd5030a874d3a869 Mon Sep 17 00:00:00 2001
From: Sentry Github Bot <bot+github-bot@sentry.io>
Date: Thu, 9 Apr 2026 20:39:51 +0000
Subject: [PATCH 14/14] Format code

---
 .../core/AndroidOptionsInitializer.java       |  4 ++-
 .../core/PerfettoContinuousProfiler.java      | 10 +++----
 .../core/PerfettoContinuousProfilerTest.kt    |  5 +++-
 .../io/sentry/SentryEnvelopeItemHeader.java   | 27 +++++++++++++++----
 4 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index d8b5a77e2a..687c51fae2 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -348,7 +348,9 @@ private static void setupProfiler(
                     () -> options.getExecutorService(),
                     () ->
                         new PerfettoProfiler(
-                            context.getApplicationContext(), frameMetricsCollector, options.getLogger()))
+                            context.getApplicationContext(),
+                            frameMetricsCollector,
+                            options.getLogger()))
                 : AndroidContinuousProfiler.createLegacy(
                     buildInfoProvider,
                     frameMetricsCollector,
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
index 33b427b2a0..f664413a22 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
@@ -41,14 +41,14 @@
  * profiling backends independent. All ProfilingManager API usage is confined to this file and
  * {@link PerfettoProfiler}.
  *
- * <p>Currently, this class doesn't do app-start profiling {@link SentryPerformanceProvider}.
- * It is created during {@code Sentry.init()}.
+ * <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.
+ * #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)
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
index 0961d8e524..70752dbae3 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
@@ -131,6 +131,9 @@ class PerfettoContinuousProfilerTest {
     // shouldStop must have been reset to false by startProfiler, so the profiler
     // should restart for the next chunk.
     fixture.executor.runAll()
-    assertTrue(profiler.isRunning, "Profiler should continue running after chunk restart — shouldStop must be reset on start")
+    assertTrue(
+      profiler.isRunning,
+      "Profiler should continue running after chunk restart — shouldStop must be reset on start",
+    )
   }
 }
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
index 60da203084..3bd1946930 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
@@ -53,7 +53,8 @@ public int getLength() {
     return platform;
   }
 
-  @Nullable Integer getMetaLength() {
+  @Nullable
+  Integer getMetaLength() {
     if (calculateMetaLength != null) {
       try {
         return calculateMetaLength.call();
@@ -97,7 +98,14 @@ private SentryEnvelopeItemHeader(
       final @Nullable Integer itemCount,
       final @Nullable Integer metaLength) {
     this(
-        type, length, null, contentType, fileName, attachmentType, platform, itemCount,
+        type,
+        length,
+        null,
+        contentType,
+        fileName,
+        attachmentType,
+        platform,
+        itemCount,
         metaLength != null ? () -> metaLength : null);
   }
 
@@ -114,8 +122,8 @@ public SentryEnvelopeItemHeader(
   }
 
   /**
-   * Lazy constructor. Both length and metaLength are computed lazily as these depend on
-   * the Item having been evaluated.
+   * Lazy constructor. Both length and metaLength are computed lazily as these depend on the Item
+   * having been evaluated.
    */
   SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
@@ -126,7 +134,16 @@ public SentryEnvelopeItemHeader(
       final @Nullable String platform,
       final @Nullable Integer itemCount,
       final @Nullable Callable<Integer> calculateMetaLength) {
-    this(type, -1, getLength, contentType, fileName, attachmentType, platform, itemCount, calculateMetaLength);
+    this(
+        type,
+        -1,
+        getLength,
+        contentType,
+        fileName,
+        attachmentType,
+        platform,
+        itemCount,
+        calculateMetaLength);
   }
 
   SentryEnvelopeItemHeader(