From 0d34c421adef21e417b7ec9e8cab1d3e68330ccb 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 1/4] 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 822d7fbbe0..a65763490f 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";
@@ -494,6 +496,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 ba01a9ecf7..0439c51a0e 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 cb9078ac07..af3c6f0068 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3688,6 +3688,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
@@ -3809,6 +3810,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 a831a11ea8..0839ba8db5 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -622,6 +622,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
@@ -2213,6 +2220,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 960b2838e2..1d7ab20ef9 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -750,6 +750,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 86e585c1e8aa4232d7c8e84c9853e2b3174c4fa7 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 2/4] 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 788d91ad034dd9fc97e572d4b76de4e2da14dc9e 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 3/4] 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 a65763490f..0cf09dbe51 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
@@ -497,8 +497,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 022a6b2ad549197f1aeaa6d02bd8a0e0f6480cec 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 4/4] 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 af3c6f0068..11291afe36 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -2050,9 +2050,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;
@@ -2065,6 +2067,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
@@ -2073,6 +2076,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 {
@@ -2084,6 +2088,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;
@@ -2780,6 +2785,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
@@ -2794,6 +2800,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 {
@@ -2815,6 +2822,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
 }
 
@@ -3020,6 +3028,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;
@@ -3037,10 +3046,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;
@@ -3060,6 +3071,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()