From b8555e2ab79dfe63af37fba249eee710ccacf31f Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Tue, 7 Oct 2025 14:00:50 -0400
Subject: [PATCH 01/28] Update dsn for testing

---
 .../sentry-samples-android/src/main/AndroidManifest.xml         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 65445d85706..ece0dae2d6a 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -76,7 +76,7 @@
         android:exported="false"/>
 
         <!--    NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard-->
-        <meta-data android:name="io.sentry.dsn" android:value="https://1053864c67cc410aa1ffc9701bd6f93d@o447951.ingest.us.sentry.io/5428559" />
+        <meta-data android:name="io.sentry.dsn" android:value="https://502f25099c204a2fbf4cb16edc5975d1@o447951.ingest.us.sentry.io/5428563" />
 
         <!--    how to enable Sentry's debug mode-->
         <meta-data android:name="io.sentry.debug" android:value="${sentryDebug}" />

From ca280403304595d7783e35cfd302228b8f25c8e3 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Tue, 7 Oct 2025 14:02:01 -0400
Subject: [PATCH 02/28] Enable replay verbose logging

---
 .../sentry-samples-android/src/main/AndroidManifest.xml         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index ece0dae2d6a..370c5338883 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -82,7 +82,7 @@
         <meta-data android:name="io.sentry.debug" android:value="${sentryDebug}" />
 
         <!--    how to disable verbose logging of the session replay feature-->
-        <meta-data android:name="io.sentry.session-replay.debug" android:value="false" />
+        <meta-data android:name="io.sentry.session-replay.debug" android:value="true" />
 
         <!--    how to set a custom debug level-->
         <!--    <meta-data android:name="io.sentry.debug.level" android:value="info" />-->

From 5397e9dc8498f603a0e0bb9971f1e887aacbae01 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Tue, 7 Oct 2025 14:07:22 -0400
Subject: [PATCH 03/28] Point dsn to sentry-android project

https://sentry-sdks.sentry.io/settings/projects/sentry-android/keys/
---
 .../sentry-samples-android/src/main/AndroidManifest.xml         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 370c5338883..fcfc98a6c00 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -76,7 +76,7 @@
         android:exported="false"/>
 
         <!--    NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard-->
-        <meta-data android:name="io.sentry.dsn" android:value="https://502f25099c204a2fbf4cb16edc5975d1@o447951.ingest.us.sentry.io/5428563" />
+        <meta-data android:name="io.sentry.dsn" android:value="https://1053864c67cc410aa1ffc9701bd6f93d@o447951.ingest.us.sentry.io/5428559" />
 
         <!--    how to enable Sentry's debug mode-->
         <meta-data android:name="io.sentry.debug" android:value="${sentryDebug}" />

From 71ed70edc35bfd892cda00e3cb7bfb9ea805c3d4 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Tue, 7 Oct 2025 13:59:41 -0400
Subject: [PATCH 04/28] Add HTTP Request Trigger to sentry-samples-android app

---
 .../src/main/AndroidManifest.xml              |   3 +
 .../sentry/samples/android/MainActivity.java  |   3 +
 .../android/TriggerHttpRequestActivity.java   | 270 ++++++++++++++++++
 .../src/main/res/layout/activity_main.xml     |   6 +
 .../layout/activity_trigger_http_request.xml  | 122 ++++++++
 .../src/main/res/values/strings.xml           |   2 +
 6 files changed, 406 insertions(+)
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
 create mode 100644 sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index fcfc98a6c00..ad681855840 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -75,6 +75,9 @@
       <activity android:name=".FrameDataForSpansActivity"
         android:exported="false"/>
 
+      <activity android:name=".TriggerHttpRequestActivity"
+        android:exported="false"/>
+
         <!--    NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard-->
         <meta-data android:name="io.sentry.dsn" android:value="https://1053864c67cc410aa1ffc9701bd6f93d@o447951.ingest.us.sentry.io/5428559" />
 
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.java
index 25907655f7f..5a62ed607fc 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.java
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.java
@@ -341,6 +341,9 @@ public void run() {
                   });
         });
 
+    binding.openHttpRequestActivity.setOnClickListener(
+        view -> startActivity(new Intent(this, TriggerHttpRequestActivity.class)));
+
     Sentry.logger().log(SentryLogLevel.INFO, "Creating content view");
     setContentView(binding.getRoot());
 
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
new file mode 100644
index 00000000000..14ed1d9d1dc
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
@@ -0,0 +1,270 @@
+package io.sentry.samples.android;
+
+import android.os.Bundle;
+import android.text.method.ScrollingMovementMethod;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+import android.widget.Toast;
+import androidx.appcompat.app.AppCompatActivity;
+import io.sentry.HttpStatusCodeRange;
+import io.sentry.Sentry;
+import io.sentry.SentryLevel;
+import io.sentry.okhttp.SentryOkHttpEventListener;
+import io.sentry.okhttp.SentryOkHttpInterceptor;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Locale;
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import org.json.JSONObject;
+
+public class TriggerHttpRequestActivity extends AppCompatActivity {
+
+    private EditText urlInput;
+    private TextView requestDisplay;
+    private TextView responseDisplay;
+    private ProgressBar loadingIndicator;
+    private Button getButton;
+    private Button postButton;
+    private Button clearButton;
+
+    private OkHttpClient okHttpClient;
+    private SimpleDateFormat dateFormat;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_trigger_http_request);
+
+        dateFormat = new SimpleDateFormat("HH:mm:ss.SSS", Locale.getDefault());
+
+        initializeViews();
+        setupOkHttpClient();
+        setupClickListeners();
+    }
+
+    private void initializeViews() {
+        urlInput = findViewById(R.id.url_input);
+        requestDisplay = findViewById(R.id.request_display);
+        responseDisplay = findViewById(R.id.response_display);
+        loadingIndicator = findViewById(R.id.loading_indicator);
+        getButton = findViewById(R.id.trigger_get_request);
+        postButton = findViewById(R.id.trigger_post_request);
+        clearButton = findViewById(R.id.clear_display);
+
+        requestDisplay.setMovementMethod(new ScrollingMovementMethod());
+        responseDisplay.setMovementMethod(new ScrollingMovementMethod());
+    }
+
+    private void setupOkHttpClient() {
+        // OkHttpClient with Sentry integration for monitoring HTTP requests
+        okHttpClient = new OkHttpClient.Builder()
+            .connectTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            .readTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            .writeTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            // performance monitoring
+//            .eventListener(new SentryOkHttpEventListener())
+            // breadcrumbs and failed request capture
+            .addInterceptor(new SentryOkHttpInterceptor())
+            .build();
+    }
+
+    private void setupClickListeners() {
+        getButton.setOnClickListener(v -> performGetRequest());
+        postButton.setOnClickListener(v -> performPostRequest());
+        clearButton.setOnClickListener(v -> clearDisplays());
+    }
+
+    private void performGetRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        Request request = new Request.Builder()
+            .url(url)
+            .get()
+            .addHeader("User-Agent", "Sentry-Sample-Android")
+            .addHeader("Accept", "application/json")
+            .build();
+
+        displayRequest("GET", request);
+        executeRequest(request);
+    }
+
+    private void performPostRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        try {
+            JSONObject json = new JSONObject();
+            json.put("message", "Hello from Sentry Android Sample");
+            json.put("timestamp", System.currentTimeMillis());
+            json.put("device", android.os.Build.MODEL);
+
+            RequestBody body = RequestBody.create(
+                json.toString(),
+                MediaType.get("application/json; charset=utf-8")
+            );
+
+            Request request = new Request.Builder()
+                .url(url)
+                .post(body)
+                .addHeader("User-Agent", "Sentry-Sample-Android")
+                .addHeader("Content-Type", "application/json")
+                .addHeader("Accept", "application/json")
+                .build();
+
+            displayRequest("POST", request, json.toString(2));
+            executeRequest(request);
+        } catch (Exception e) {
+            Sentry.captureException(e);
+            Toast.makeText(this, "Error creating request: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    private void executeRequest(Request request) {
+        showLoading(true);
+
+        okHttpClient.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                Sentry.captureException(e);
+                runOnUiThread(() -> {
+                    showLoading(false);
+                    displayResponse(
+                        "ERROR",
+                        null,
+                        "Request failed: " + e.getMessage(),
+                        0
+                    );
+                });
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                final long startTime = System.currentTimeMillis();
+                final int statusCode = response.code();
+                final String statusMessage = response.message();
+                ResponseBody responseBody = response.body();
+                String body = "";
+
+                try {
+                    if (responseBody != null) {
+                        body = responseBody.string();
+                    }
+                } catch (IOException e) {
+                    body = "Error reading response body: " + e.getMessage();
+                    Sentry.captureException(e);
+                }
+
+                final long responseTime = System.currentTimeMillis() - startTime;
+                final String finalBody = body;
+
+                runOnUiThread(() -> {
+                    showLoading(false);
+                    displayResponse(statusMessage, statusCode, finalBody, responseTime);
+                });
+
+                response.close();
+            }
+        });
+    }
+
+    private void displayRequest(String method, Request request) {
+        displayRequest(method, request, null);
+    }
+
+    private void displayRequest(String method, Request request, String body) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[").append(getCurrentTime()).append("]\n");
+        sb.append("━━━━━━━━━━━━━━━━━━━━━━━━\n");
+        sb.append("METHOD: ").append(method).append("\n");
+        sb.append("URL: ").append(request.url()).append("\n\n");
+        sb.append("HEADERS:\n");
+
+        for (int i = 0; i < request.headers().size(); i++) {
+            sb.append("  ").append(request.headers().name(i)).append(": ")
+              .append(request.headers().value(i)).append("\n");
+        }
+
+        if (body != null && !body.isEmpty()) {
+            sb.append("\nBODY:\n").append(body).append("\n");
+        }
+
+        sb.append("━━━━━━━━━━━━━━━━━━━━━━━━");
+
+        requestDisplay.setText(sb.toString());
+    }
+
+    private void displayResponse(String status, Integer code, String body, long responseTime) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[").append(getCurrentTime()).append("]\n");
+        sb.append("━━━━━━━━━━━━━━━━━━━━━━━━\n");
+
+        if (code != null) {
+            sb.append("STATUS: ").append(code).append(" ").append(status).append("\n");
+            sb.append("RESPONSE TIME: ").append(responseTime).append("ms\n\n");
+        } else {
+            sb.append("STATUS: ").append(status).append("\n\n");
+        }
+
+        if (body != null && !body.isEmpty()) {
+            try {
+                if (body.trim().startsWith("{") || body.trim().startsWith("[")) {
+                    JSONObject json = new JSONObject(body);
+                    sb.append("BODY (JSON):\n").append(json.toString(2));
+                } else {
+                    sb.append("BODY:\n").append(body);
+                }
+            } catch (Exception e) {
+                sb.append("BODY:\n").append(body);
+            }
+        }
+
+        sb.append("\n━━━━━━━━━━━━━━━━━━━━━━━━");
+
+        responseDisplay.setText(sb.toString());
+    }
+
+    private void clearDisplays() {
+        requestDisplay.setText("No request yet...");
+        responseDisplay.setText("No response yet...");
+    }
+
+    private String getUrl() {
+        String url = urlInput.getText().toString().trim();
+        if (url.isEmpty()) {
+            return "https://api.github.com/users/getsentry";
+        }
+        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+            url = "https://" + url;
+        }
+        return url;
+    }
+
+    private void showLoading(boolean show) {
+        loadingIndicator.setVisibility(show ? View.VISIBLE : View.GONE);
+        getButton.setEnabled(!show);
+        postButton.setEnabled(!show);
+    }
+
+    private String getCurrentTime() {
+        return dateFormat.format(new Date());
+    }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_main.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_main.xml
index 0083fae8f93..64e35b12748 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_main.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_main.xml
@@ -176,6 +176,12 @@
       android:layout_height="wrap_content"
       android:text="@string/check_for_update"/>
 
+    <Button
+      android:id="@+id/open_http_request_activity"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="@string/open_http_request_activity"/>
+
   </LinearLayout>
 
 </ScrollView>
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
new file mode 100644
index 00000000000..ee216d4ae47
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:fillViewport="true"
+  tools:context=".TriggerHttpRequestActivity">
+
+  <LinearLayout
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp">
+
+    <TextView
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="HTTP Request Debugger"
+      android:textSize="24sp"
+      android:textStyle="bold"
+      android:layout_marginBottom="16dp"/>
+
+    <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      android:layout_marginBottom="16dp">
+
+      <EditText
+        android:id="@+id/url_input"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:hint="Enter URL (or use default)"
+        android:text="https://api.github.com/users/getsentry"
+        android:inputType="textUri"/>
+
+    </LinearLayout>
+
+    <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      android:layout_marginBottom="16dp">
+
+      <Button
+        android:id="@+id/trigger_get_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="GET Request"
+        android:layout_marginEnd="8dp"/>
+
+      <Button
+        android:id="@+id/trigger_post_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="POST Request"
+        android:layout_marginStart="8dp"/>
+
+    </LinearLayout>
+
+    <Button
+      android:id="@+id/clear_display"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="Clear"
+      android:layout_marginBottom="16dp"/>
+
+    <TextView
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="REQUEST:"
+      android:textStyle="bold"
+      android:textSize="16sp"
+      android:layout_marginBottom="8dp"/>
+
+    <TextView
+      android:id="@+id/request_display"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:padding="12dp"
+      android:textSize="12sp"
+      android:textColor="@android:color/holo_blue_dark"
+      android:background="#F0F8FF"
+      android:fontFamily="monospace"
+      android:scrollbars="vertical"
+      android:text="No request yet..."
+      android:layout_marginBottom="16dp"/>
+
+    <TextView
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="RESPONSE:"
+      android:textStyle="bold"
+      android:textSize="16sp"
+      android:layout_marginBottom="8dp"/>
+
+    <TextView
+      android:id="@+id/response_display"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:padding="12dp"
+      android:textSize="12sp"
+      android:textColor="@android:color/holo_green_dark"
+      android:background="#F0FFF0"
+      android:fontFamily="monospace"
+      android:scrollbars="vertical"
+      android:text="No response yet..."
+      android:layout_marginBottom="16dp"/>
+
+    <ProgressBar
+      android:id="@+id/loading_indicator"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_gravity="center"
+      android:visibility="gone"/>
+
+  </LinearLayout>
+
+</ScrollView>
\ No newline at end of file
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 fe984bbff13..da326e9450d 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
@@ -50,4 +50,6 @@ Nulla interdum gravida augue, vel fringilla lorem bibendum vel. In hac habitasse
   <string name="profiling_no_dir_set">No profiling dir path set</string>
   <string name="profiling_start">Start Profiling</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_http_request_activity">Open Trigger HTTP Request Activity</string>
+  <string name="trigger_okhttp_request">Trigger OkHttp Request</string>
 </resources>

From f2ce22ec3c95b2e6606b64e27b4f100cee716215 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Thu, 9 Oct 2025 16:19:47 -0400
Subject: [PATCH 05/28] [replay] Make DefaultReplayBreadcrumbConverter the
 default BeforeBreadcrumbCallback to extract NetworkRequestData from Hint

-> NetworkRequestData is landing on DefaultReplayBreadcrumbConverter via Hint.get(replay:networkDetails)
---
 .../core/AndroidOptionsInitializer.java       |   6 +-
 .../DefaultReplayBreadcrumbConverter.kt       | 117 ++++++++++++++-
 .../sentry/okhttp/SentryOkHttpInterceptor.kt  | 136 +++++++++++++++++-
 3 files changed, 246 insertions(+), 13 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 70c76c72824..8ff3c3917d3 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
@@ -400,7 +400,11 @@ static void installDefaultIntegrations(
     if (isReplayAvailable) {
       final ReplayIntegration replay =
           new ReplayIntegration(context, CurrentDateProvider.getInstance());
-      replay.setBreadcrumbConverter(new DefaultReplayBreadcrumbConverter());
+      DefaultReplayBreadcrumbConverter replayBreadcrumbConverter = new DefaultReplayBreadcrumbConverter(options.getBeforeBreadcrumb());
+      options.setBeforeBreadcrumb(
+        replayBreadcrumbConverter
+      );
+      replay.setBreadcrumbConverter(replayBreadcrumbConverter);
       options.addIntegration(replay);
       options.setReplayController(replay);
     }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
index 058417ed2a1..97da4342a33 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
@@ -1,15 +1,22 @@
 package io.sentry.android.replay
 
+import android.util.Log
 import io.sentry.Breadcrumb
+import io.sentry.Hint
 import io.sentry.ReplayBreadcrumbConverter
 import io.sentry.SentryLevel
+import io.sentry.SentryOptions
+import io.sentry.SentryOptions.BeforeBreadcrumbCallback
 import io.sentry.SpanDataConvention
 import io.sentry.rrweb.RRWebBreadcrumbEvent
 import io.sentry.rrweb.RRWebEvent
 import io.sentry.rrweb.RRWebSpanEvent
+import io.sentry.util.network.NetworkRequestData
 import kotlin.LazyThreadSafetyMode.NONE
 
-public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
+public open class DefaultReplayBreadcrumbConverter(
+  private val userBeforeBreadcrumbCallback: BeforeBreadcrumbCallback? = null
+) : ReplayBreadcrumbConverter, SentryOptions.BeforeBreadcrumbCallback {
   internal companion object {
     private val snakecasePattern by lazy(NONE) { "_[a-z]".toRegex() }
     private val supportedNetworkData =
@@ -24,10 +31,11 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
   }
 
   private var lastConnectivityState: String? = null
+  private val httpBreadcrumbData = mutableMapOf<Breadcrumb, NetworkRequestData>()
 
   override fun convert(breadcrumb: Breadcrumb): RRWebEvent? {
     var breadcrumbMessage: String? = null
-    var breadcrumbCategory: String? = null
+    var breadcrumbCategory: String?
     var breadcrumbLevel: SentryLevel? = null
     val breadcrumbData = mutableMapOf<String, Any?>()
     when {
@@ -120,10 +128,62 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     }
   }
 
-  private fun Breadcrumb.isValidForRRWebSpan(): Boolean =
-    !(data["url"] as? String).isNullOrEmpty() &&
-      SpanDataConvention.HTTP_START_TIMESTAMP in data &&
-      SpanDataConvention.HTTP_END_TIMESTAMP in data
+  /**
+   * By default, ReplayIntegration provides its own BeforeBreadcrumbCallback,
+   * delegating to user-provided callback (if exists).
+   */
+  override fun execute(breadcrumb: Breadcrumb, hint: Hint): Breadcrumb? {
+    Log.d("SentryNetwork", "SentryNetwork: BeforeBreadcrumbCallback - Hint: $hint, Breadcrumb: $breadcrumb")
+    return userBeforeBreadcrumbCallback?.let {
+      it.execute(breadcrumb, hint)?.also { processedBreadcrumb ->
+        extractNetworkRequestDataFromHint(processedBreadcrumb, hint)?.let { networkData ->
+          httpBreadcrumbData[processedBreadcrumb] = networkData
+        }
+      }
+    } ?: run {
+      // No user callback - store hint and return original breadcrumb
+      extractNetworkRequestDataFromHint(breadcrumb, hint)?.let { networkData ->
+        httpBreadcrumbData[breadcrumb] = networkData
+      }
+      breadcrumb
+    }
+  }
+
+  private fun extractNetworkRequestDataFromHint(breadcrumb: Breadcrumb, breadcrumbHint: Hint): NetworkRequestData? {
+    if (breadcrumb.type != "http" && breadcrumb.category != "http") {
+      return null
+    }
+
+    // First try to get the structured network data from the hint
+    val networkDetails = breadcrumbHint.get("replay:networkDetails") as? NetworkRequestData
+    if (networkDetails != null) {
+      Log.d("SentryNetwork", "SentryNetwork: Found structured NetworkRequestData in hint: $networkDetails")
+      return networkDetails
+    }
+
+    Log.d("SentryNetwork", "SentryNetwork: No structured NetworkRequestData found on hint")
+    return null
+  }
+
+  private fun Breadcrumb.isValidForRRWebSpan(): Boolean {
+    val url = data["url"] as? String
+    val hasStartTimestamp = SpanDataConvention.HTTP_START_TIMESTAMP in data
+    val hasEndTimestamp = SpanDataConvention.HTTP_END_TIMESTAMP in data
+
+    val urlValid = !url.isNullOrEmpty()
+    val isValid = urlValid && hasStartTimestamp && hasEndTimestamp
+
+    val reasons = mutableListOf<String>()
+    if (!urlValid) reasons.add("missing or empty URL")
+    if (!hasStartTimestamp) reasons.add("missing start timestamp")
+    if (!hasEndTimestamp) reasons.add("missing end timestamp")
+
+    Log.d("SentryReplay", "Breadcrumb RRWeb span validation: ${if (isValid) "VALID" else "INVALID"}" +
+      if (!isValid) " (${reasons.joinToString(", ")})" else "" +
+      " - URL: ${url ?: "null"}, Category: ${category}")
+
+    return isValid
+  }
 
   private fun String.snakeToCamelCase(): String =
     replace(snakecasePattern) { it.value.last().toString().uppercase() }
@@ -132,6 +192,14 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     val breadcrumb = this
     val httpStartTimestamp = breadcrumb.data[SpanDataConvention.HTTP_START_TIMESTAMP]
     val httpEndTimestamp = breadcrumb.data[SpanDataConvention.HTTP_END_TIMESTAMP]
+
+    // Get the NetworkRequestData if available
+    val networkRequestData = httpBreadcrumbData[breadcrumb]
+
+    Log.d("SentryNetwork", "SentryNetwork: convert(breadcrumb=${breadcrumb.type}) httpBreadcrumbData map size: ${httpBreadcrumbData.size}, " +
+      "contains current breadcrumb: ${httpBreadcrumbData.containsKey(breadcrumb)}, " +
+      "network data for current: ${httpBreadcrumbData[breadcrumb]}")
+
     return RRWebSpanEvent().apply {
       timestamp = breadcrumb.timestamp.time
       op = "resource.http"
@@ -151,6 +219,41 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
         }
 
       val breadcrumbData = mutableMapOf<String, Any?>()
+
+      // Add data from NetworkRequestData if available
+      if (networkRequestData != null) {
+        networkRequestData.method?.let { breadcrumbData["method"] = it }
+        networkRequestData.statusCode?.let { breadcrumbData["statusCode"] = it }
+        networkRequestData.requestBodySize?.let { breadcrumbData["requestBodySize"] = it }
+        networkRequestData.responseBodySize?.let { breadcrumbData["responseBodySize"] = it }
+
+        // Add request and response data if available
+        networkRequestData.request?.let { request ->
+          val requestData = mutableMapOf<String, Any?>()
+          request.size?.let { requestData["size"] = it }
+          request.body?.let { requestData["body"] = it }
+          if (request.headers.isNotEmpty()) {
+            requestData["headers"] = request.headers
+          }
+          if (requestData.isNotEmpty()) {
+            breadcrumbData["request"] = requestData
+          }
+        }
+
+        networkRequestData.response?.let { response ->
+          val responseData = mutableMapOf<String, Any?>()
+          response.size?.let { responseData["size"] = it }
+          response.body?.let { responseData["body"] = it }
+          if (response.headers.isNotEmpty()) {
+            responseData["headers"] = response.headers
+          }
+          if (responseData.isNotEmpty()) {
+            breadcrumbData["response"] = responseData
+          }
+        }
+      }
+      // Original breadcrumb data processing
+      // TODO: Remove if superceded by more detailed data (above).
       for ((key, value) in breadcrumb.data) {
         if (key in supportedNetworkData) {
           breadcrumbData[
@@ -158,6 +261,8 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
           ] = value
         }
       }
+
+
       data = breadcrumbData
     }
   }
diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index be1ee1caf37..f51224e6d77 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -21,6 +21,8 @@ import io.sentry.util.PropagationTargetsUtils
 import io.sentry.util.SpanUtils
 import io.sentry.util.TracingUtils
 import io.sentry.util.UrlUtils
+import io.sentry.util.network.NetworkRequestData
+import io.sentry.util.network.ReplayNetworkRequestOrResponse
 import java.io.IOException
 import okhttp3.Interceptor
 import okhttp3.Request
@@ -172,18 +174,30 @@ public open class SentryOkHttpInterceptor(
     startTimestamp: Long,
   ) {
     val breadcrumb = Breadcrumb.http(request.url.toString(), request.method, code)
+
+    // Track request and response body sizes for the breadcrumb
+    var requestBodySize: Long? = null
+    var responseBodySize: Long? = null
+
     request.body?.contentLength().ifHasValidLength {
       breadcrumb.setData("http.request_content_length", it)
+      requestBodySize = it
     }
 
-    val hint = Hint().also { it.set(OKHTTP_REQUEST, request) }
-    response?.let {
-      it.body?.contentLength().ifHasValidLength { responseBodySize ->
-        breadcrumb.setData(SpanDataConvention.HTTP_RESPONSE_CONTENT_LENGTH_KEY, responseBodySize)
-      }
+    response?.body?.contentLength().ifHasValidLength {
+      breadcrumb.setData(SpanDataConvention.HTTP_RESPONSE_CONTENT_LENGTH_KEY, it)
+      responseBodySize = it
+    }
 
-      hint[OKHTTP_RESPONSE] = it
+    val hint = Hint().also {
+      // Set the structured network data for replay
+      val networkData = createNetworkRequestData(request, response, requestBodySize, responseBodySize)
+      it.set("replay:networkDetails", networkData)
+
+//      it.set(OKHTTP_REQUEST, request)
+//      response?.let { resp -> it[OKHTTP_RESPONSE] = resp }
     }
+
     // needs this as unix timestamp for rrweb
     breadcrumb.setData(SpanDataConvention.HTTP_START_TIMESTAMP, startTimestamp)
     breadcrumb.setData(
@@ -194,6 +208,116 @@ public open class SentryOkHttpInterceptor(
     scopes.addBreadcrumb(breadcrumb, hint)
   }
 
+  /**
+   * Extracts headers from OkHttp Headers object into a map
+   */
+  private fun okhttp3.Headers.toMap(): Map<String, String> {
+    val headers = mutableMapOf<String, String>()
+    for (name in names()) {
+      headers[name] = get(name) ?: ""
+    }
+    return headers
+  }
+
+  /**
+   * Extracts body metadata from OkHttp RequestBody or ResponseBody
+   * Note: We don't consume the actual body stream to avoid interfering with the request/response
+   */
+  private fun extractBodyMetadata(
+    contentLength: Long?,
+    contentType: okhttp3.MediaType?
+  ): Pair<Long?, Any?> {
+    val bodySize = contentLength?.takeIf { it >= 0 }
+    val bodyInfo = if (contentLength != null && contentLength != 0L) {
+      mapOf(
+        "contentType" to contentType?.toString(),
+        "hasBody" to true
+      )
+    } else null
+
+    return bodySize to bodyInfo
+  }
+
+  /**
+   * Creates a NetworkRequestData object from the request and response
+   */
+  private fun createNetworkRequestData(
+    request: Request,
+    response: Response?,
+    requestBodySize: Long?,
+    responseBodySize: Long?
+  ): NetworkRequestData {
+    // Log the incoming request details
+    println("SentryNetwork: Creating NetworkRequestData for: ${request.method} ${request.url}")
+    scopes.options.logger.log(
+      io.sentry.SentryLevel.INFO,
+      "SentryNetwork: Creating NetworkRequestData for: ${request.method} ${request.url}"
+    )
+
+    // Extract request data
+    val requestHeaders = request.headers.toMap()
+    val (reqBodySize, reqBodyInfo) = extractBodyMetadata(
+      request.body?.contentLength(),
+      request.body?.contentType()
+    )
+
+    scopes.options.logger.log(
+      io.sentry.SentryLevel.INFO,
+      "SentryNetwork: Request - Headers count: ${requestHeaders.size}, Body size: $reqBodySize, Body info: $reqBodyInfo"
+    )
+
+    val requestData = ReplayNetworkRequestOrResponse(
+      reqBodySize,
+      reqBodyInfo,
+      requestHeaders
+    )
+
+    // Extract response data if available
+    val responseData = response?.let {
+      val responseHeaders = it.headers.toMap()
+      val (respBodySize, respBodyInfo) = extractBodyMetadata(
+        it.body?.contentLength(),
+        it.body?.contentType()
+      )
+
+      scopes.options.logger.log(
+        io.sentry.SentryLevel.INFO,
+        "SentryNetwork: Response - Status: ${it.code}, Headers count: ${responseHeaders.size}, Body size: $respBodySize, Body info: $respBodyInfo"
+      )
+
+      ReplayNetworkRequestOrResponse(
+        respBodySize,
+        respBodyInfo,
+        responseHeaders
+      )
+    }
+
+    // Determine final body sizes (prefer the explicit sizes passed in)
+    val finalResponseBodySize = response?.let {
+      val (respBodySize, _) = extractBodyMetadata(
+        it.body?.contentLength(),
+        it.body?.contentType()
+      )
+      responseBodySize ?: respBodySize
+    }
+
+    val networkData = NetworkRequestData(
+      request.method,
+      response?.code,
+      requestBodySize ?: reqBodySize,
+      finalResponseBodySize,
+      requestData,
+      responseData
+    )
+
+    scopes.options.logger.log(
+      io.sentry.SentryLevel.INFO,
+      "SentryNetwork: Created NetworkRequestData: $networkData"
+    )
+
+    return networkData
+  }
+
   private fun finishSpan(
     span: ISpan?,
     request: Request,

From 201102af630c97794584a7bf5af058408a0c7699 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 13 Oct 2025 10:52:02 -0400
Subject: [PATCH 06/28] [replay] Add data classes for NetworkDetails

These get set on the breadcrumb Hint, and then hang around in DefaultReplayBreadcrumbConverter until the replay segment has been sent off

See
https://github.com/getsentry/sentry-javascript/blob/632f0b953d99050c11b0edafb9f80b5f3ba88045/packages/replay-internal/src/types/performance.ts#L133-L140
https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts#L12
---
 .../util/network/NetworkRequestData.java      | 69 +++++++++++++++++++
 .../ReplayNetworkRequestOrResponse.java       | 51 ++++++++++++++
 2 files changed, 120 insertions(+)
 create mode 100644 sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
 create mode 100644 sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java

diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java b/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
new file mode 100644
index 00000000000..50ecf07d645
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
@@ -0,0 +1,69 @@
+package io.sentry.util.network;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Data class for tracking network request and response information in replays.
+ * Used by various HTTP integrations (OkHttp, Apache HttpClient, etc.) to capture
+ * network data for replay functionality.
+ * see https://github.com/getsentry/sentry-javascript/blob/632f0b953d99050c11b0edafb9f80b5f3ba88045/packages/replay-internal/src/types/performance.ts#L133-L140
+ */
+public final class NetworkRequestData {
+  private final @Nullable String method;
+  private final @Nullable Integer statusCode;
+  private final @Nullable Long requestBodySize;
+  private final @Nullable Long responseBodySize;
+  private final @Nullable ReplayNetworkRequestOrResponse request;
+  private final @Nullable ReplayNetworkRequestOrResponse response;
+
+  public NetworkRequestData(
+      @Nullable String method,
+      @Nullable Integer statusCode,
+      @Nullable Long requestBodySize,
+      @Nullable Long responseBodySize,
+      @Nullable ReplayNetworkRequestOrResponse request,
+      @Nullable ReplayNetworkRequestOrResponse response) {
+    this.method = method;
+    this.statusCode = statusCode;
+    this.requestBodySize = requestBodySize;
+    this.responseBodySize = responseBodySize;
+    this.request = request;
+    this.response = response;
+  }
+
+  public @Nullable String getMethod() {
+    return method;
+  }
+
+  public @Nullable Integer getStatusCode() {
+    return statusCode;
+  }
+
+  public @Nullable Long getRequestBodySize() {
+    return requestBodySize;
+  }
+
+  public @Nullable Long getResponseBodySize() {
+    return responseBodySize;
+  }
+
+  public @Nullable ReplayNetworkRequestOrResponse getRequest() {
+    return request;
+  }
+
+  public @Nullable ReplayNetworkRequestOrResponse getResponse() {
+    return response;
+  }
+
+  @Override
+  public String toString() {
+    return "NetworkRequestData{" +
+        "method='" + method + '\'' +
+        ", statusCode=" + statusCode +
+        ", requestBodySize=" + requestBodySize +
+        ", responseBodySize=" + responseBodySize +
+        ", request=" + request +
+        ", response=" + response +
+        '}';
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java b/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
new file mode 100644
index 00000000000..05a4b56e0c9
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
@@ -0,0 +1,51 @@
+package io.sentry.util.network;
+
+import java.util.Collections;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Data class for tracking HTTP request or response information in replays.
+ * Captures essential information about the request/response without consuming
+ * the actual body stream.
+ */
+public final class ReplayNetworkRequestOrResponse {
+  private final @Nullable Long size;
+  private final @Nullable Object body; // Can be Map<*, *>, List<*>, or String
+  private final @NotNull Map<String, String> headers;
+
+  public ReplayNetworkRequestOrResponse(
+      @Nullable Long size,
+      @Nullable Object body,
+      @NotNull Map<String, String> headers) {
+    this.size = size;
+    this.body = body;
+    this.headers = headers != null ? headers : Collections.emptyMap();
+  }
+
+  public ReplayNetworkRequestOrResponse() {
+    this(null, null, Collections.emptyMap());
+  }
+
+  public @Nullable Long getSize() {
+    return size;
+  }
+
+  public @Nullable Object getBody() {
+    return body;
+  }
+
+  public @NotNull Map<String, String> getHeaders() {
+    return headers;
+  }
+
+  @Override
+  public String toString() {
+    return "ReplayNetworkRequestOrResponse{" +
+        "size=" + size +
+        ", body=" + body +
+        ", headers=" + headers +
+        '}';
+  }
+}
\ No newline at end of file

From 724ec421d6152755fd0ecb1f6cc5c25a12de55e2 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 13 Oct 2025 10:54:45 -0400
Subject: [PATCH 07/28] [DNL] Force dashboard to show request/response bodies

Manually set networkDetailHasUrls to pass this check
https://github.com/getsentry/sentry-javascript/blob/d1646c8a281dd8795c5a6a3b8e18f2e7069e7fa9/packages/replay-internal/src/util/handleRecordingEmit.ts#L134
https://github.com/getsentry/sentry/blob/master/static/app/views/replays/detail/network/details/getOutputType.tsx#L33
https://github.com/getsentry/sentry/blob/master/static/app/views/replays/detail/network/details/content.tsx#L55-L56
---
 sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java b/sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java
index f9a96074c1c..958d31a13a2 100644
--- a/sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java
+++ b/sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java
@@ -52,6 +52,7 @@ public RRWebOptionsEvent(final @NotNull SentryOptions options) {
     optionsPayload.put("quality", replayOptions.getQuality().serializedName());
     optionsPayload.put("maskedViewClasses", replayOptions.getMaskViewClasses());
     optionsPayload.put("unmaskedViewClasses", replayOptions.getUnmaskViewClasses());
+    optionsPayload.put("networkDetailHasUrls", true);
   }
 
   @NotNull

From 2d08e7b5f8b4b5e43cecd90981a6357c92092faf Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 13 Oct 2025 12:46:27 -0400
Subject: [PATCH 08/28] Move BeforeBreadcrumbCallback initialization to after
 user config

added some unit tests:
 ./gradlew :sentry-android-replay:testDebugUnitTest --tests="*DefaultReplayBreadcrumbConverterTest*"
---
 .../core/AndroidOptionsInitializer.java       |  15 +-
 .../DefaultReplayBreadcrumbConverter.kt       |  42 ++--
 .../DefaultReplayBreadcrumbConverterTest.kt   | 214 ++++++++++++++++++
 .../sentry/NoOpReplayBreadcrumbConverter.java |  10 +
 .../io/sentry/ReplayBreadcrumbConverter.java  |  11 +-
 5 files changed, 266 insertions(+), 26 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 8ff3c3917d3..a928d8ab7bc 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
@@ -19,6 +19,7 @@
 import io.sentry.NoOpSocketTagger;
 import io.sentry.NoOpTransactionProfiler;
 import io.sentry.NoopVersionDetector;
+import io.sentry.ReplayBreadcrumbConverter;
 import io.sentry.ScopeType;
 import io.sentry.SendFireAndForgetEnvelopeSender;
 import io.sentry.SendFireAndForgetOutboxSender;
@@ -247,6 +248,14 @@ static void initializeIntegrationsAndProcessors(
       options.setCompositePerformanceCollector(new DefaultCompositePerformanceCollector(options));
     }
 
+    if (options.getReplayController() != null) { // TODO: Triple-check this should be a null check
+      ReplayBreadcrumbConverter replayBreadcrumbConverter = options.getReplayController().getBreadcrumbConverter();
+      replayBreadcrumbConverter.setUserBeforeBreadcrumbCallback(options.getBeforeBreadcrumb());
+      options.setBeforeBreadcrumb(
+        replayBreadcrumbConverter
+      );
+    }
+
     // Check if the profiler was already instantiated in the app start.
     // We use the Android profiler, that uses a global start/stop api, so we need to preserve the
     // state of the profiler, and it's only possible retaining the instance.
@@ -400,11 +409,7 @@ static void installDefaultIntegrations(
     if (isReplayAvailable) {
       final ReplayIntegration replay =
           new ReplayIntegration(context, CurrentDateProvider.getInstance());
-      DefaultReplayBreadcrumbConverter replayBreadcrumbConverter = new DefaultReplayBreadcrumbConverter(options.getBeforeBreadcrumb());
-      options.setBeforeBreadcrumb(
-        replayBreadcrumbConverter
-      );
-      replay.setBreadcrumbConverter(replayBreadcrumbConverter);
+      replay.setBreadcrumbConverter(new DefaultReplayBreadcrumbConverter());
       options.addIntegration(replay);
       options.setReplayController(replay);
     }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
index 97da4342a33..c0c67a90fad 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
@@ -5,7 +5,6 @@ import io.sentry.Breadcrumb
 import io.sentry.Hint
 import io.sentry.ReplayBreadcrumbConverter
 import io.sentry.SentryLevel
-import io.sentry.SentryOptions
 import io.sentry.SentryOptions.BeforeBreadcrumbCallback
 import io.sentry.SpanDataConvention
 import io.sentry.rrweb.RRWebBreadcrumbEvent
@@ -14,9 +13,7 @@ import io.sentry.rrweb.RRWebSpanEvent
 import io.sentry.util.network.NetworkRequestData
 import kotlin.LazyThreadSafetyMode.NONE
 
-public open class DefaultReplayBreadcrumbConverter(
-  private val userBeforeBreadcrumbCallback: BeforeBreadcrumbCallback? = null
-) : ReplayBreadcrumbConverter, SentryOptions.BeforeBreadcrumbCallback {
+public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
   internal companion object {
     private val snakecasePattern by lazy(NONE) { "_[a-z]".toRegex() }
     private val supportedNetworkData =
@@ -32,7 +29,9 @@ public open class DefaultReplayBreadcrumbConverter(
 
   private var lastConnectivityState: String? = null
   private val httpBreadcrumbData = mutableMapOf<Breadcrumb, NetworkRequestData>()
+  private var userBeforeBreadcrumbCallback: BeforeBreadcrumbCallback? = null
 
+  // TODO: If user provided a new Breadcrumb object via their BeforeBreadcrumbCallback, is that reflected in the `Breadcrumb`s passed in here?
   override fun convert(breadcrumb: Breadcrumb): RRWebEvent? {
     var breadcrumbMessage: String? = null
     var breadcrumbCategory: String?
@@ -128,25 +127,29 @@ public open class DefaultReplayBreadcrumbConverter(
     }
   }
 
+  override fun setUserBeforeBreadcrumbCallback(beforeBreadcrumbCallback: BeforeBreadcrumbCallback?) {
+    this.userBeforeBreadcrumbCallback = beforeBreadcrumbCallback
+  }
+
   /**
-   * By default, ReplayIntegration provides its own BeforeBreadcrumbCallback,
-   * delegating to user-provided callback (if exists).
+   * Delegate to user-provided callback (if exists) to provide the final breadcrumb to process.
    */
   override fun execute(breadcrumb: Breadcrumb, hint: Hint): Breadcrumb? {
-    Log.d("SentryNetwork", "SentryNetwork: BeforeBreadcrumbCallback - Hint: $hint, Breadcrumb: $breadcrumb")
-    return userBeforeBreadcrumbCallback?.let {
-      it.execute(breadcrumb, hint)?.also { processedBreadcrumb ->
-        extractNetworkRequestDataFromHint(processedBreadcrumb, hint)?.let { networkData ->
-          httpBreadcrumbData[processedBreadcrumb] = networkData
-        }
-      }
-    } ?: run {
-      // No user callback - store hint and return original breadcrumb
-      extractNetworkRequestDataFromHint(breadcrumb, hint)?.let { networkData ->
-        httpBreadcrumbData[breadcrumb] = networkData
-      }
+    val callback = userBeforeBreadcrumbCallback
+    val result = if (callback != null) {
+      callback.execute(breadcrumb, hint)
+    } else {
       breadcrumb
     }
+
+    result?.let { finalBreadcrumb ->
+      extractNetworkRequestDataFromHint(finalBreadcrumb, hint)?.let { networkData ->
+        httpBreadcrumbData[finalBreadcrumb] = networkData
+      }
+    }
+
+    Log.d("SentryNetwork", "SentryNetwork: BeforeBreadcrumbCallback - Hint: $hint, Breadcrumb: $result")
+    return result
   }
 
   private fun extractNetworkRequestDataFromHint(breadcrumb: Breadcrumb, breadcrumbHint: Hint): NetworkRequestData? {
@@ -154,7 +157,6 @@ public open class DefaultReplayBreadcrumbConverter(
       return null
     }
 
-    // First try to get the structured network data from the hint
     val networkDetails = breadcrumbHint.get("replay:networkDetails") as? NetworkRequestData
     if (networkDetails != null) {
       Log.d("SentryNetwork", "SentryNetwork: Found structured NetworkRequestData in hint: $networkDetails")
@@ -252,7 +254,7 @@ public open class DefaultReplayBreadcrumbConverter(
           }
         }
       }
-      // Original breadcrumb data processing
+      // Original breadcrumb http data
       // TODO: Remove if superceded by more detailed data (above).
       for ((key, value) in breadcrumb.data) {
         if (key in supportedNetworkData) {
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
index a12ae043154..1aaf01de13c 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
@@ -1,14 +1,20 @@
 package io.sentry.android.replay
 
 import io.sentry.Breadcrumb
+import io.sentry.Hint
 import io.sentry.SentryLevel
+import io.sentry.SentryOptions
 import io.sentry.SpanDataConvention
 import io.sentry.rrweb.RRWebBreadcrumbEvent
 import io.sentry.rrweb.RRWebSpanEvent
+import io.sentry.util.network.NetworkRequestData
+import io.sentry.util.network.ReplayNetworkRequestOrResponse
 import java.util.Date
 import junit.framework.TestCase.assertEquals
 import kotlin.test.Test
+import kotlin.test.assertNotNull
 import kotlin.test.assertNull
+import kotlin.test.assertSame
 
 class DefaultReplayBreadcrumbConverterTest {
   class Fixture {
@@ -318,4 +324,212 @@ class DefaultReplayBreadcrumbConverterTest {
     assertEquals(SentryLevel.ERROR, rrwebEvent.level)
     assertEquals("shiet", rrwebEvent.data!!["stuff"])
   }
+
+  // BeforeBreadcrumbCallback delegation tests
+
+  @Test
+  fun `returned breadcrumb is not modified when no user BeforeBreadcrumbCallback is provided`() {
+    val converter = fixture.getSut()
+    val breadcrumb = Breadcrumb(Date()).apply {
+      message = "test message"
+      category = "test.category"
+    }
+    val hint = Hint()
+
+    converter.setUserBeforeBreadcrumbCallback(null)
+
+    val result = converter.execute(breadcrumb, hint)
+
+    assertSame(breadcrumb, result)
+  }
+
+  @Test
+  fun `returned breadcrumb is modified according to user provided BeforeBreadcrumbCallback`() {
+    val converter = fixture.getSut()
+    val originalBreadcrumb = Breadcrumb(Date()).apply {
+      message = "original message"
+      category = "original.category"
+    }
+    val userModifiedBreadcrumb = Breadcrumb(Date()).apply {
+      message = "modified message"
+      category = "modified.category"
+    }
+    val hint = Hint()
+
+    val userBeforeBreadcrumbCallback = SentryOptions.BeforeBreadcrumbCallback { _, _ -> userModifiedBreadcrumb }
+    converter.setUserBeforeBreadcrumbCallback(userBeforeBreadcrumbCallback)
+
+    val result = converter.execute(originalBreadcrumb, hint)
+
+    assertSame(userModifiedBreadcrumb, result)
+  }
+
+  @Test
+  fun `returns null when user BeforeBreadcrumbCallback returns null`() {
+    val converter = fixture.getSut()
+    val breadcrumb = Breadcrumb(Date()).apply {
+      message = "test message"
+      category = "test.category"
+    }
+    val hint = Hint()
+
+    val userCallback = SentryOptions.BeforeBreadcrumbCallback { _, _ -> null }
+    converter.setUserBeforeBreadcrumbCallback(userCallback)
+
+    val result = converter.execute(breadcrumb, hint)
+
+    assertNull(result)
+  }
+
+  @Test
+  fun `network data is extracted from hint for http breadcrumbs with user callback`() {
+    val converter = fixture.getSut()
+    val httpBreadcrumb = Breadcrumb(Date()).apply {
+      type = "http"
+      category = "http"
+      data["url"] = "https://example.com"
+    }
+
+    val networkData = NetworkRequestData(
+      "GET",
+      200,
+      100L,
+      500L,
+      ReplayNetworkRequestOrResponse(100L, null, mapOf("Content-Type" to "application/json")),
+      ReplayNetworkRequestOrResponse(500L, null, mapOf("Content-Type" to "application/json"))
+    )
+    val hint = Hint()
+    hint.set("replay:networkDetails", networkData)
+
+    val userCallback = SentryOptions.BeforeBreadcrumbCallback { b, _ -> b }
+    converter.setUserBeforeBreadcrumbCallback(userCallback)
+
+    val result = converter.execute(httpBreadcrumb, hint)
+
+    assertSame(httpBreadcrumb, result)
+    // Network data should be stored internally for later conversion
+  }
+
+  @Test
+  fun `network data is extracted from hint for http breadcrumbs without user callback`() {
+    val converter = fixture.getSut()
+    val httpBreadcrumb = Breadcrumb(Date()).apply {
+      type = "http"
+      category = "http"
+      data["url"] = "https://example.com"
+    }
+
+    val networkData = NetworkRequestData(
+      "POST",
+      201,
+      200L,
+      400L,
+      ReplayNetworkRequestOrResponse(200L, mapOf("body" to "request"), mapOf()),
+      ReplayNetworkRequestOrResponse(400L, mapOf("body" to "response"), mapOf())
+    )
+    val hint = Hint()
+    hint.set("replay:networkDetails", networkData)
+
+    converter.setUserBeforeBreadcrumbCallback(null)
+
+    val result = converter.execute(httpBreadcrumb, hint)
+
+    assertSame(httpBreadcrumb, result)
+  }
+
+  @Test
+  fun `setUserBeforeBreadcrumbCallback updates the callback`() {
+    val converter = fixture.getSut()
+    val breadcrumb = Breadcrumb(Date()).apply { message = "test" }
+    val hint = Hint()
+
+    // First callback modifies the message
+    val firstCallback = SentryOptions.BeforeBreadcrumbCallback { b, _ ->
+      b.message = "modified by first"
+      b
+    }
+    converter.setUserBeforeBreadcrumbCallback(firstCallback)
+    var result = converter.execute(breadcrumb, hint)
+    assertEquals("modified by first", result?.message)
+
+    // Second callback modifies differently
+    val secondCallback = SentryOptions.BeforeBreadcrumbCallback { b, _ ->
+      b.message = "modified by second"
+      b
+    }
+    converter.setUserBeforeBreadcrumbCallback(secondCallback)
+
+    breadcrumb.message = "test" // Reset
+    result = converter.execute(breadcrumb, hint)
+    assertEquals("modified by second", result?.message)
+  }
+
+  @Test
+  fun `user callback receives same breadcrumb and hint objects`() {
+    val converter = fixture.getSut()
+    val breadcrumb = Breadcrumb(Date()).apply { message = "test" }
+    val hint = Hint()
+
+    var capturedBreadcrumb: Breadcrumb? = null
+    var capturedHint: Hint? = null
+
+    val capturingCallback = SentryOptions.BeforeBreadcrumbCallback { b, h ->
+      capturedBreadcrumb = b
+      capturedHint = h
+      b
+    }
+    converter.setUserBeforeBreadcrumbCallback(capturingCallback)
+
+    converter.execute(breadcrumb, hint)
+
+    assertSame(breadcrumb, capturedBreadcrumb)
+    assertSame(hint, capturedHint)
+  }
+
+  @Test
+  fun `non-http breadcrumbs do not extract network data`() {
+    val converter = fixture.getSut()
+    val navigationBreadcrumb = Breadcrumb(Date()).apply {
+      type = "navigation"
+      category = "navigation"
+    }
+    val hint = Hint()
+    hint.set("replay:networkDetails", NetworkRequestData("GET", 200, null, null, null, null))
+
+    converter.setUserBeforeBreadcrumbCallback(null)
+
+    val result = converter.execute(navigationBreadcrumb, hint)
+
+    assertSame(navigationBreadcrumb, result)
+    // Network data extraction only happens for http breadcrumbs
+  }
+
+  @Test
+  fun `chained callbacks work correctly`() {
+    val converter = fixture.getSut()
+    val breadcrumb = Breadcrumb(Date()).apply { message = "original" }
+    val hint = Hint()
+
+    val firstCallback = SentryOptions.BeforeBreadcrumbCallback { b, h ->
+      b.message = "modified by first"
+      b
+    }
+
+    val secondCallback = SentryOptions.BeforeBreadcrumbCallback { b, h ->
+      // This simulates what happens when ReplayBreadcrumbConverter
+      // wraps a user's callback
+      val result = firstCallback.execute(b, h)
+      result?.let {
+        it.message = "${it.message} and second"
+        it
+      }
+    }
+
+    converter.setUserBeforeBreadcrumbCallback(secondCallback)
+
+    val result = converter.execute(breadcrumb, hint)
+
+    assertNotNull(result)
+    assertEquals("modified by first and second", result.message)
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/NoOpReplayBreadcrumbConverter.java b/sentry/src/main/java/io/sentry/NoOpReplayBreadcrumbConverter.java
index d71a57e440f..4d1d4ee886a 100644
--- a/sentry/src/main/java/io/sentry/NoOpReplayBreadcrumbConverter.java
+++ b/sentry/src/main/java/io/sentry/NoOpReplayBreadcrumbConverter.java
@@ -18,4 +18,14 @@ private NoOpReplayBreadcrumbConverter() {}
   public @Nullable RRWebEvent convert(final @NotNull Breadcrumb breadcrumb) {
     return null;
   }
+
+  @Override
+  public void setUserBeforeBreadcrumbCallback(
+      SentryOptions.@Nullable BeforeBreadcrumbCallback beforeBreadcrumbCallback) {}
+
+  @Override
+  public @Nullable Breadcrumb execute(
+      final @NotNull Breadcrumb breadcrumb, final @NotNull Hint hint) {
+    return breadcrumb;
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/ReplayBreadcrumbConverter.java b/sentry/src/main/java/io/sentry/ReplayBreadcrumbConverter.java
index dadd5d9b6fd..adada160cbe 100644
--- a/sentry/src/main/java/io/sentry/ReplayBreadcrumbConverter.java
+++ b/sentry/src/main/java/io/sentry/ReplayBreadcrumbConverter.java
@@ -5,8 +5,17 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+/**
+ * ReplayBreadcrumbConverter will always be the registered {@link
+ * io.sentry.SentryOptions.BeforeBreadcrumbCallback} for extending replays with data from breadcrumb
+ * {@link io.sentry.Hint}s. As such, implementations need to wrap and delegate to any user-provided
+ * BeforeBreadcrumbCallback {@link ReplayBreadcrumbConverter#setUserBeforeBreadcrumbCallback} .
+ */
 @ApiStatus.Internal
-public interface ReplayBreadcrumbConverter {
+public interface ReplayBreadcrumbConverter extends SentryOptions.BeforeBreadcrumbCallback {
   @Nullable
   RRWebEvent convert(@NotNull Breadcrumb breadcrumb);
+
+  void setUserBeforeBreadcrumbCallback(
+      @Nullable SentryOptions.BeforeBreadcrumbCallback beforeBreadcrumbCallback);
 }

From ebc5ff337f0305b62aac86bc4cf16ed2cb3fb0f9 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Wed, 15 Oct 2025 12:21:03 -0400
Subject: [PATCH 09/28] bugfix: Update Breadcrumb #hashcode to be consistent
 with #equals

Breadcrumb.java has several timestamp fields:
`timestamp: Date`, `timestampMs: Long`, `nanos: Long`

`hashcode` was relying solely on `timestamp`, which can be null depending on which constructor was used.

=> Change to use getTimestamp as 1. this is what equals does (consistency) 2. getTimestamp initialises timestamp if null.
---
 sentry/src/main/java/io/sentry/Breadcrumb.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sentry/src/main/java/io/sentry/Breadcrumb.java b/sentry/src/main/java/io/sentry/Breadcrumb.java
index d5bb66d33e1..d3b30b0222b 100644
--- a/sentry/src/main/java/io/sentry/Breadcrumb.java
+++ b/sentry/src/main/java/io/sentry/Breadcrumb.java
@@ -721,8 +721,9 @@ public boolean equals(Object o) {
   }
 
   @Override
+  @SuppressWarnings("JavaUtilDate")
   public int hashCode() {
-    return Objects.hash(timestamp, message, type, category, origin, level);
+    return Objects.hash(getTimestamp().getTime(), message, type, category, origin, level);
   }
 
   // region json

From 122a8a62a5d5230e8ff29cfce9d420f954597d12 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 13 Oct 2025 17:33:53 -0400
Subject: [PATCH 10/28] Initial NetworkDetails extraction logic

Entrypoint is NetworkDetailCaptureUtils (initializeForUrl) called from SentryOkHttpInterceptor
- common logic to handle checking sdk options.
- Accept data from http client via NetworkBodyExtractor, NetworkHeaderExtractor interfaces
that can be reused in future (if needed)

Placeholder impl for req/resp bodies.

From https://docs.sentry.io/platforms/javascript/session-replay/configuration/
- networkDetailAllowUrls, networkDetailDenyUrls,
- networkCaptureBodies
- networkRequestHeaders, networkResponseHeaders

These SDKOptions don't exist yet => impl acts as if they do, but have not been enabled.
---
 .../DefaultReplayBreadcrumbConverterTest.kt   |   5 +-
 .../sentry/okhttp/SentryOkHttpInterceptor.kt  | 213 ++++++++++--------
 .../io/sentry/util/network/NetworkBody.java   |  68 ++++++
 .../network/NetworkDetailCaptureUtils.java    | 149 ++++++++++++
 .../util/network/NetworkRequestData.java      |  68 ++++--
 .../ReplayNetworkRequestOrResponse.java       |  32 ++-
 6 files changed, 398 insertions(+), 137 deletions(-)
 create mode 100644 sentry/src/main/java/io/sentry/util/network/NetworkBody.java
 create mode 100644 sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java

diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
index 1aaf01de13c..f3f11b60005 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
@@ -7,6 +7,7 @@ import io.sentry.SentryOptions
 import io.sentry.SpanDataConvention
 import io.sentry.rrweb.RRWebBreadcrumbEvent
 import io.sentry.rrweb.RRWebSpanEvent
+import io.sentry.util.network.NetworkBody
 import io.sentry.util.network.NetworkRequestData
 import io.sentry.util.network.ReplayNetworkRequestOrResponse
 import java.util.Date
@@ -424,8 +425,8 @@ class DefaultReplayBreadcrumbConverterTest {
       201,
       200L,
       400L,
-      ReplayNetworkRequestOrResponse(200L, mapOf("body" to "request"), mapOf()),
-      ReplayNetworkRequestOrResponse(400L, mapOf("body" to "response"), mapOf())
+      ReplayNetworkRequestOrResponse(200L, NetworkBody.JsonObject(mapOf("body" to "request")), mapOf()),
+      ReplayNetworkRequestOrResponse(400L, NetworkBody.JsonObject(mapOf("body" to "response")), mapOf())
     )
     val hint = Hint()
     hint.set("replay:networkDetails", networkData)
diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index f51224e6d77..6cd3c50f50e 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -21,7 +21,8 @@ import io.sentry.util.PropagationTargetsUtils
 import io.sentry.util.SpanUtils
 import io.sentry.util.TracingUtils
 import io.sentry.util.UrlUtils
-import io.sentry.util.network.NetworkRequestData
+import io.sentry.util.network.NetworkBody
+import io.sentry.util.network.NetworkDetailCaptureUtils
 import io.sentry.util.network.ReplayNetworkRequestOrResponse
 import java.io.IOException
 import okhttp3.Interceptor
@@ -189,14 +190,46 @@ public open class SentryOkHttpInterceptor(
       responseBodySize = it
     }
 
-    val hint = Hint().also {
-      // Set the structured network data for replay
-      val networkData = createNetworkRequestData(request, response, requestBodySize, responseBodySize)
-      it.set("replay:networkDetails", networkData)
+    val hint =
+      Hint().also {
+        it.set(OKHTTP_REQUEST, request)
+        response?.let { resp -> it[OKHTTP_RESPONSE] = resp }
 
-//      it.set(OKHTTP_REQUEST, request)
-//      response?.let { resp -> it[OKHTTP_RESPONSE] = resp }
-    }
+        val networkDetailData =
+          NetworkDetailCaptureUtils.initializeForUrl(
+            request.url.toString(),
+            request.method,
+            null,
+            null
+          )
+
+        networkDetailData?.setRequestDetails(
+          NetworkDetailCaptureUtils.createRequest(
+            request,
+            requestBodySize,
+            false,
+            { req: Request -> req.extractRequestBody() },
+            emptyArray<String>(),
+            { req: Request -> req.headers.toMap() }
+          )
+        )
+
+        response?.let { response ->
+          networkDetailData?.setResponseDetails(
+            response.code,
+            NetworkDetailCaptureUtils.createResponse(
+              response,
+              responseBodySize,
+              false,
+              { resp: Response -> resp.extractOkHttpResponseBody() },
+              emptyArray<String>(),
+              { resp: Response -> resp.headers.toMap() }
+            )
+          )
+        }
+
+        it.set("replay:networkDetails", networkDetailData)
+      }
 
     // needs this as unix timestamp for rrweb
     breadcrumb.setData(SpanDataConvention.HTTP_START_TIMESTAMP, startTimestamp)
@@ -208,9 +241,7 @@ public open class SentryOkHttpInterceptor(
     scopes.addBreadcrumb(breadcrumb, hint)
   }
 
-  /**
-   * Extracts headers from OkHttp Headers object into a map
-   */
+  /** Extracts headers from OkHttp Headers object into a map */
   private fun okhttp3.Headers.toMap(): Map<String, String> {
     val headers = mutableMapOf<String, String>()
     for (name in names()) {
@@ -219,103 +250,86 @@ public open class SentryOkHttpInterceptor(
     return headers
   }
 
-  /**
-   * Extracts body metadata from OkHttp RequestBody or ResponseBody
-   * Note: We don't consume the actual body stream to avoid interfering with the request/response
-   */
-  private fun extractBodyMetadata(
-    contentLength: Long?,
-    contentType: okhttp3.MediaType?
-  ): Pair<Long?, Any?> {
-    val bodySize = contentLength?.takeIf { it >= 0 }
-    val bodyInfo = if (contentLength != null && contentLength != 0L) {
-      mapOf(
-        "contentType" to contentType?.toString(),
-        "hasBody" to true
-      )
-    } else null
-
-    return bodySize to bodyInfo
+  /** Extracts the body content from an OkHttp Request safely */
+  private fun Request.extractRequestBody(): NetworkBody? {
+    return body?.let {
+      try {
+        // Create a copy of the request to safely read the body without consuming the original
+        val requestCopy = newBuilder().build()
+        val buffer = okio.Buffer()
+        requestCopy.body?.writeTo(buffer)
+        val bodyString = buffer.readUtf8()
+
+        // Try to parse as JSON first, fall back to string
+        when {
+          bodyString.isEmpty() -> null
+          bodyString.trimStart().startsWith("{") -> {
+            // Attempt JSON object parsing (simplified)
+            NetworkBody.JsonObject(mapOf("raw" to bodyString)) // Placeholder for now
+          }
+          bodyString.trimStart().startsWith("[") -> {
+            // Attempt JSON array parsing (simplified)
+            NetworkBody.JsonArray(listOf(bodyString)) // Placeholder for now
+          }
+          else -> NetworkBody.StringBody(bodyString)
+        }
+      } catch (e: Exception) {
+        // If body reading fails (e.g., one-shot body), log and return null
+        scopes.options.logger.log(
+          io.sentry.SentryLevel.DEBUG,
+          "Failed to read request body safely: ${e.message}"
+        )
+        null
+      }
+    }
   }
 
-  /**
-   * Creates a NetworkRequestData object from the request and response
-   */
-  private fun createNetworkRequestData(
-    request: Request,
-    response: Response?,
-    requestBodySize: Long?,
-    responseBodySize: Long?
-  ): NetworkRequestData {
-    // Log the incoming request details
-    println("SentryNetwork: Creating NetworkRequestData for: ${request.method} ${request.url}")
-    scopes.options.logger.log(
-      io.sentry.SentryLevel.INFO,
-      "SentryNetwork: Creating NetworkRequestData for: ${request.method} ${request.url}"
-    )
-
-    // Extract request data
-    val requestHeaders = request.headers.toMap()
-    val (reqBodySize, reqBodyInfo) = extractBodyMetadata(
-      request.body?.contentLength(),
-      request.body?.contentType()
-    )
-
+  /** Extension function to create ReplayNetworkRequestOrResponse from OkHttp Response */
+  private fun Response.toReplayNetworkResponse(): ReplayNetworkRequestOrResponse {
     scopes.options.logger.log(
       io.sentry.SentryLevel.INFO,
-      "SentryNetwork: Request - Headers count: ${requestHeaders.size}, Body size: $reqBodySize, Body info: $reqBodyInfo"
+      "SentryNetwork: Creating ReplayNetworkResponse for status: $code",
     )
 
-    val requestData = ReplayNetworkRequestOrResponse(
-      reqBodySize,
-      reqBodyInfo,
-      requestHeaders
+    return NetworkDetailCaptureUtils.createResponse(
+      this,
+      body?.contentLength()?.takeIf { it >= 0 },
+      true,
+      { resp: Response -> resp.extractOkHttpResponseBody() },
+      emptyArray<String>(),
+      { resp: Response -> resp.headers.toMap() }
     )
+  }
 
-    // Extract response data if available
-    val responseData = response?.let {
-      val responseHeaders = it.headers.toMap()
-      val (respBodySize, respBodyInfo) = extractBodyMetadata(
-        it.body?.contentLength(),
-        it.body?.contentType()
-      )
-
-      scopes.options.logger.log(
-        io.sentry.SentryLevel.INFO,
-        "SentryNetwork: Response - Status: ${it.code}, Headers count: ${responseHeaders.size}, Body size: $respBodySize, Body info: $respBodyInfo"
-      )
-
-      ReplayNetworkRequestOrResponse(
-        respBodySize,
-        respBodyInfo,
-        responseHeaders
-      )
-    }
-
-    // Determine final body sizes (prefer the explicit sizes passed in)
-    val finalResponseBodySize = response?.let {
-      val (respBodySize, _) = extractBodyMetadata(
-        it.body?.contentLength(),
-        it.body?.contentType()
-      )
-      responseBodySize ?: respBodySize
+  /** Extracts the body content from an OkHttp Response safely */
+  private fun Response.extractOkHttpResponseBody(): NetworkBody? {
+    return body?.let {
+      try {
+        val peekBody = peekBody(Long.MAX_VALUE)
+        val bodyString = peekBody.string()
+
+        // Try to parse as JSON first, fall back to string
+        when {
+          bodyString.isEmpty() -> null
+          bodyString.trimStart().startsWith("{") -> {
+            // Attempt JSON object parsing (simplified)
+            NetworkBody.JsonObject(mapOf("raw" to bodyString)) // Placeholder for now
+          }
+          bodyString.trimStart().startsWith("[") -> {
+            // Attempt JSON array parsing (simplified)
+            NetworkBody.JsonArray(listOf(bodyString)) // Placeholder for now
+          }
+          else -> NetworkBody.StringBody(bodyString)
+        }
+      } catch (e: Exception) {
+        // If body reading fails, log and return null
+        scopes.options.logger.log(
+          io.sentry.SentryLevel.DEBUG,
+          "Failed to read response body safely: ${e.message}"
+        )
+        null
+      }
     }
-
-    val networkData = NetworkRequestData(
-      request.method,
-      response?.code,
-      requestBodySize ?: reqBodySize,
-      finalResponseBodySize,
-      requestData,
-      responseData
-    )
-
-    scopes.options.logger.log(
-      io.sentry.SentryLevel.INFO,
-      "SentryNetwork: Created NetworkRequestData: $networkData"
-    )
-
-    return networkData
   }
 
   private fun finishSpan(
@@ -375,6 +389,7 @@ public open class SentryOkHttpInterceptor(
     return false
   }
 
+
   /** The BeforeSpan callback */
   public fun interface BeforeSpanCallback {
     /**
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
new file mode 100644
index 00000000000..f3dbe53e2d7
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
@@ -0,0 +1,68 @@
+package io.sentry.util.network;
+
+import java.util.List;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents the body content of a network request or response. Can be one of: JsonObject,
+ * JsonArray, or String.
+ *
+ * <p> See https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts
+ */
+public interface NetworkBody {
+
+  /** Represents a JSON object body (key-value pairs) */
+  public static final class JsonObject implements NetworkBody {
+    private final @NotNull Map<String, Object> value;
+
+    public JsonObject(@NotNull Map<String, Object> value) {
+      this.value = value;
+    }
+
+    public @NotNull Map<String, Object> getValue() {
+      return value;
+    }
+
+    @Override
+    public String toString() {
+      return "JsonObject{" + value + '}';
+    }
+  }
+
+  /** Represents a JSON array body (ordered list) */
+  public static final class JsonArray implements NetworkBody {
+    private final @NotNull List<Object> value;
+
+    public JsonArray(@NotNull List<Object> value) {
+      this.value = value;
+    }
+
+    public @NotNull List<Object> getValue() {
+      return value;
+    }
+
+    @Override
+    public String toString() {
+      return "JsonArray{" + value + '}';
+    }
+  }
+
+  /** Represents a string body (text content) */
+  public static final class StringBody implements NetworkBody {
+    private final @NotNull String value;
+
+    public StringBody(@NotNull String value) {
+      this.value = value;
+    }
+
+    public @NotNull String getValue() {
+      return value;
+    }
+
+    @Override
+    public String toString() {
+      return "StringBody{" + value + '}';
+    }
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java b/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
new file mode 100644
index 00000000000..ed5373ab9ea
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
@@ -0,0 +1,149 @@
+package io.sentry.util.network;
+
+import io.sentry.SentryOptions;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Utility class for network capture operations shared across HTTP client integrations. Provides
+ * common logic for determining what network data to capture and filtering headers.
+ */
+public final class NetworkDetailCaptureUtils {
+
+  private NetworkDetailCaptureUtils() {}
+
+  /** Functional interface for extracting network body content from HTTP objects. */
+  public interface NetworkBodyExtractor<T> {
+    @Nullable
+    NetworkBody extract(@NotNull T httpObject);
+  }
+
+
+  /** Functional interface for extracting headers from HTTP objects. */
+  public interface NetworkHeaderExtractor<T> {
+    @NotNull
+    Map<String, String> extract(@NotNull T httpObject);
+  }
+
+  public static @Nullable NetworkRequestData initializeForUrl(
+      @NotNull String url,
+      @Nullable String method,
+      @Nullable String[] networkDetailAllowUrls,
+      @Nullable String[] networkDetailDenyUrls) {
+
+    if (!shouldCaptureUrl(url, networkDetailAllowUrls, networkDetailDenyUrls)) {
+      return null;
+    }
+
+    // Create instance with basic info, details will be added later
+    NetworkRequestData result = new NetworkRequestData(method, null, null, null, null, null);
+    return result;
+  }
+
+  /**
+   * Creates a ReplayNetworkRequestOrResponse for a request, extracting body and headers based on
+   * configuration.
+   */
+  public static <T> @NotNull ReplayNetworkRequestOrResponse createRequest(
+      @NotNull T httpObject,
+      @Nullable Long bodySize,
+      boolean networkCaptureBodies,
+      @NotNull NetworkBodyExtractor<T> bodyExtractor,
+      @NotNull String[] networkRequestHeaders,
+      @NotNull NetworkHeaderExtractor<T> headerExtractor) {
+
+    return createRequestOrResponseInternal(
+        httpObject, bodySize, networkCaptureBodies, bodyExtractor, networkRequestHeaders, headerExtractor);
+  }
+
+  public static <T> @NotNull ReplayNetworkRequestOrResponse createResponse(
+      @NotNull T httpObject,
+      @Nullable Long bodySize,
+      boolean networkCaptureBodies,
+      @NotNull NetworkBodyExtractor<T> bodyExtractor,
+      @NotNull String[] networkResponseHeaders,
+      @NotNull NetworkHeaderExtractor<T> headerExtractor) {
+
+    return createRequestOrResponseInternal(
+        httpObject, bodySize, networkCaptureBodies, bodyExtractor, networkResponseHeaders, headerExtractor);
+  }
+
+  /**
+   * Determines if detailed network data should be captured for the given URL.
+   * See https://docs.sentry.io/platforms/javascript/session-replay/configuration/
+   *
+   * @param url The URL to check
+   * @param networkDetailAllowUrls Array of regex patterns that allow capture (null means allow all)
+   * @param networkDetailDenyUrls Array of regex patterns that deny capture (null means deny none)
+   * @return true if the URL should be captured, false otherwise
+   */
+  private static boolean shouldCaptureUrl(
+      @NotNull String url,
+      @Nullable String[] networkDetailAllowUrls,
+      @Nullable String[] networkDetailDenyUrls) {
+
+    // If there are deny patterns and URL matches any, don't capture.
+    if (networkDetailDenyUrls != null) {
+      for (String pattern : networkDetailDenyUrls) {
+        if (pattern != null && url.matches(pattern)) {
+          return false;
+        }
+      }
+    }
+
+    // Only capture developer-provided urls.
+    if (networkDetailAllowUrls == null || networkDetailAllowUrls.length == 0) {
+      return false;
+    }
+
+    // If there are allow patterns, URL must match at least one
+    for (String pattern : networkDetailAllowUrls) {
+      if (pattern != null && url.matches(pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  private static @NotNull Map<String, String> getCaptureHeaders(
+      @Nullable Map<String, String> allHeaders, @NotNull String[] allowedHeaders) {
+
+    Map<String, String> capturedHeaders = new HashMap<>();
+
+    if (allHeaders == null) {
+      return capturedHeaders;
+    }
+
+    for (String header : allowedHeaders) {
+      String value = allHeaders.get(header);
+      if (value != null) {
+        capturedHeaders.put(header, value);
+      }
+    }
+
+    return capturedHeaders;
+  }
+
+  private static <T> @NotNull ReplayNetworkRequestOrResponse createRequestOrResponseInternal(
+      @NotNull T httpObject, @Nullable Long bodySize,
+      boolean networkCaptureBodies, @NotNull NetworkBodyExtractor<T> bodyExtractor,
+      @NotNull String[] allowedHeaders, @NotNull NetworkHeaderExtractor<T> headerExtractor) {
+
+    NetworkBody body = null;
+
+    if (networkCaptureBodies) {
+      body = bodyExtractor.extract(httpObject);
+    }
+
+    Map<String, String> headers = getCaptureHeaders(headerExtractor.extract(httpObject), allowedHeaders);
+
+    return new ReplayNetworkRequestOrResponse(bodySize, body, headers);
+  }
+}
+
+
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java b/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
index 50ecf07d645..0b2f6387ee0 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
@@ -1,22 +1,24 @@
 package io.sentry.util.network;
 
+import io.sentry.SentryOptions;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
- * Data class for tracking network request and response information in replays.
- * Used by various HTTP integrations (OkHttp, Apache HttpClient, etc.) to capture
- * network data for replay functionality.
- * see https://github.com/getsentry/sentry-javascript/blob/632f0b953d99050c11b0edafb9f80b5f3ba88045/packages/replay-internal/src/types/performance.ts#L133-L140
+ * Data class for tracking network request and response information in replays. Used by various HTTP
+ * integrations (OkHttp, Apache HttpClient, etc.) to capture network data for replay functionality.
+ * see
+ * https://github.com/getsentry/sentry-javascript/blob/632f0b953d99050c11b0edafb9f80b5f3ba88045/packages/replay-internal/src/types/performance.ts#L133-L140
  */
 public final class NetworkRequestData {
-  private final @Nullable String method;
-  private final @Nullable Integer statusCode;
-  private final @Nullable Long requestBodySize;
-  private final @Nullable Long responseBodySize;
-  private final @Nullable ReplayNetworkRequestOrResponse request;
-  private final @Nullable ReplayNetworkRequestOrResponse response;
+  private @Nullable String method;
+  private @Nullable Integer statusCode;
+  private @Nullable Long requestBodySize;
+  private @Nullable Long responseBodySize;
+  private @Nullable ReplayNetworkRequestOrResponse request;
+  private @Nullable ReplayNetworkRequestOrResponse response;
 
-  public NetworkRequestData(
+  NetworkRequestData(
       @Nullable String method,
       @Nullable Integer statusCode,
       @Nullable Long requestBodySize,
@@ -55,15 +57,43 @@ public NetworkRequestData(
     return response;
   }
 
+  /**
+   * Populates this instance with request details obtained via {@link NetworkDetailCaptureUtils#createRequest}
+   *
+   */
+  public void setRequestDetails(
+      @NotNull ReplayNetworkRequestOrResponse requestData) {
+    this.request = requestData;
+    this.requestBodySize = requestData.getSize();
+  }
+
+  /**
+   * Populates this instance with request details obtained via {@link NetworkDetailCaptureUtils#createResponse}
+   */
+  public void setResponseDetails(
+      int statusCode,
+      @NotNull ReplayNetworkRequestOrResponse responseData) {
+    this.statusCode = statusCode;
+    this.response = responseData;
+    this.responseBodySize = responseData.getSize();
+  }
+
   @Override
   public String toString() {
-    return "NetworkRequestData{" +
-        "method='" + method + '\'' +
-        ", statusCode=" + statusCode +
-        ", requestBodySize=" + requestBodySize +
-        ", responseBodySize=" + responseBodySize +
-        ", request=" + request +
-        ", response=" + response +
-        '}';
+    return "NetworkRequestData{"
+        + "method='"
+        + method
+        + '\''
+        + ", statusCode="
+        + statusCode
+        + ", requestBodySize="
+        + requestBodySize
+        + ", responseBodySize="
+        + responseBodySize
+        + ", request="
+        + request
+        + ", response="
+        + response
+        + '}';
   }
 }
diff --git a/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java b/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
index 05a4b56e0c9..c131f27abe0 100644
--- a/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
+++ b/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
@@ -1,38 +1,33 @@
 package io.sentry.util.network;
 
+import io.sentry.SentryOptions;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
  * Data class for tracking HTTP request or response information in replays.
- * Captures essential information about the request/response without consuming
- * the actual body stream.
+ * See https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts
  */
 public final class ReplayNetworkRequestOrResponse {
   private final @Nullable Long size;
-  private final @Nullable Object body; // Can be Map<*, *>, List<*>, or String
+  private final @Nullable NetworkBody body;
   private final @NotNull Map<String, String> headers;
 
   public ReplayNetworkRequestOrResponse(
-      @Nullable Long size,
-      @Nullable Object body,
-      @NotNull Map<String, String> headers) {
+      @Nullable Long size, @Nullable NetworkBody body, @NotNull Map<String, String> headers) {
     this.size = size;
     this.body = body;
     this.headers = headers != null ? headers : Collections.emptyMap();
   }
 
-  public ReplayNetworkRequestOrResponse() {
-    this(null, null, Collections.emptyMap());
-  }
-
   public @Nullable Long getSize() {
     return size;
   }
 
-  public @Nullable Object getBody() {
+  public @Nullable NetworkBody getBody() {
     return body;
   }
 
@@ -42,10 +37,13 @@ public ReplayNetworkRequestOrResponse() {
 
   @Override
   public String toString() {
-    return "ReplayNetworkRequestOrResponse{" +
-        "size=" + size +
-        ", body=" + body +
-        ", headers=" + headers +
-        '}';
+    return "ReplayNetworkRequestOrResponse{"
+        + "size="
+        + size
+        + ", body="
+        + body
+        + ", headers="
+        + headers
+        + '}';
   }
-}
\ No newline at end of file
+}

From 6964a535876425e8987a8e20e2de63d44e8fa6a9 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Thu, 23 Oct 2025 14:51:02 -0400
Subject: [PATCH 11/28] Add FAKE_OPTIONS for testing

to revert
---
 .../sentry/okhttp/SentryOkHttpInterceptor.kt  | 30 +++++++++++++------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index 6cd3c50f50e..9ea5789e3ee 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -56,6 +56,18 @@ public open class SentryOkHttpInterceptor(
       SentryIntegrationPackageStorage.getInstance()
         .addPackage("maven:io.sentry:sentry-okhttp", BuildConfig.VERSION_NAME)
     }
+
+    /**
+     * Fake options for testing network detail capture
+     * TODO: Remove before landing.
+     */
+    private val FAKE_OPTIONS = object {
+      val networkDetailAllowUrls: Array<String> = arrayOf(".*")
+      val networkDetailDenyUrls: Array<String>? = null
+      val networkCaptureBodies: Boolean = true
+      val networkRequestHeaders: Array<String> = arrayOf("User-Agent", "Accept", "sentry-trace", "Content-Type")
+      val networkResponseHeaders: Array<String> = arrayOf("User-Agent", "access-control-allow-origin", "x-ratelimit-resource")
+    }
   }
 
   public constructor() : this(ScopesAdapter.getInstance())
@@ -199,17 +211,17 @@ public open class SentryOkHttpInterceptor(
           NetworkDetailCaptureUtils.initializeForUrl(
             request.url.toString(),
             request.method,
-            null,
-            null
+            FAKE_OPTIONS.networkDetailAllowUrls,
+            FAKE_OPTIONS.networkDetailDenyUrls,
           )
 
         networkDetailData?.setRequestDetails(
           NetworkDetailCaptureUtils.createRequest(
             request,
             requestBodySize,
-            false,
+            FAKE_OPTIONS.networkCaptureBodies,
             { req: Request -> req.extractRequestBody() },
-            emptyArray<String>(),
+            FAKE_OPTIONS.networkRequestHeaders,
             { req: Request -> req.headers.toMap() }
           )
         )
@@ -220,9 +232,9 @@ public open class SentryOkHttpInterceptor(
             NetworkDetailCaptureUtils.createResponse(
               response,
               responseBodySize,
-              false,
-              { resp: Response -> resp.extractOkHttpResponseBody() },
-              emptyArray<String>(),
+              FAKE_OPTIONS.networkCaptureBodies,
+              { resp: Response -> resp.extractResponseBody() },
+              FAKE_OPTIONS.networkResponseHeaders,
               { resp: Response -> resp.headers.toMap() }
             )
           )
@@ -295,14 +307,14 @@ public open class SentryOkHttpInterceptor(
       this,
       body?.contentLength()?.takeIf { it >= 0 },
       true,
-      { resp: Response -> resp.extractOkHttpResponseBody() },
+      { resp: Response -> resp.extractResponseBody() },
       emptyArray<String>(),
       { resp: Response -> resp.headers.toMap() }
     )
   }
 
   /** Extracts the body content from an OkHttp Response safely */
-  private fun Response.extractOkHttpResponseBody(): NetworkBody? {
+  private fun Response.extractResponseBody(): NetworkBody? {
     return body?.let {
       try {
         val peekBody = peekBody(Long.MAX_VALUE)

From 25c42c7c3d0a2f63fc56e864e15cead466013ca3 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Thu, 23 Oct 2025 15:23:27 -0400
Subject: [PATCH 12/28] DefaultReplayBreadcrumbConverter properly manages
 NetworkRequestData entries

Removes entry when creating RRWebSpanEvent
Uses syncrhonized LinkedHashMap with impl to cap size of map (avoid
memory bloat)
---
 .../DefaultReplayBreadcrumbConverter.kt       | 45 ++++++++++++-------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
index c0c67a90fad..64208791cff 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
@@ -11,10 +11,12 @@ import io.sentry.rrweb.RRWebBreadcrumbEvent
 import io.sentry.rrweb.RRWebEvent
 import io.sentry.rrweb.RRWebSpanEvent
 import io.sentry.util.network.NetworkRequestData
+import java.util.Collections
 import kotlin.LazyThreadSafetyMode.NONE
 
 public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
   internal companion object {
+    private const val MAX_HTTP_NETWORK_DETAILS = 32
     private val snakecasePattern by lazy(NONE) { "_[a-z]".toRegex() }
     private val supportedNetworkData =
       HashSet<String>().apply {
@@ -28,7 +30,16 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
   }
 
   private var lastConnectivityState: String? = null
-  private val httpBreadcrumbData = mutableMapOf<Breadcrumb, NetworkRequestData>()
+  private val httpNetworkDetails =
+    Collections.synchronizedMap(
+      object : LinkedHashMap<Breadcrumb, NetworkRequestData>() {
+        override fun removeEldestEntry(
+          eldest: MutableMap.MutableEntry<Breadcrumb, NetworkRequestData>?
+        ): Boolean {
+          return size > MAX_HTTP_NETWORK_DETAILS
+        }
+      }
+    )
   private var userBeforeBreadcrumbCallback: BeforeBreadcrumbCallback? = null
 
   // TODO: If user provided a new Breadcrumb object via their BeforeBreadcrumbCallback, is that reflected in the `Breadcrumb`s passed in here?
@@ -144,7 +155,7 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
 
     result?.let { finalBreadcrumb ->
       extractNetworkRequestDataFromHint(finalBreadcrumb, hint)?.let { networkData ->
-        httpBreadcrumbData[finalBreadcrumb] = networkData
+        httpNetworkDetails[finalBreadcrumb] = networkData
       }
     }
 
@@ -195,12 +206,14 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     val httpStartTimestamp = breadcrumb.data[SpanDataConvention.HTTP_START_TIMESTAMP]
     val httpEndTimestamp = breadcrumb.data[SpanDataConvention.HTTP_END_TIMESTAMP]
 
-    // Get the NetworkRequestData if available
-    val networkRequestData = httpBreadcrumbData[breadcrumb]
+    // Get the NetworkRequestData if available and remove it from the map
+    val networkDetailData = httpNetworkDetails.remove(breadcrumb)
 
-    Log.d("SentryNetwork", "SentryNetwork: convert(breadcrumb=${breadcrumb.type}) httpBreadcrumbData map size: ${httpBreadcrumbData.size}, " +
-      "contains current breadcrumb: ${httpBreadcrumbData.containsKey(breadcrumb)}, " +
-      "network data for current: ${httpBreadcrumbData[breadcrumb]}")
+    Log.d(
+      "SentryNetwork",
+      "SentryNetwork: convert(breadcrumb=${breadcrumb.type}) httpNetworkDetails map size: ${httpNetworkDetails.size}, " +
+        "found network data for current breadcrumb: ${networkDetailData != null}",
+    )
 
     return RRWebSpanEvent().apply {
       timestamp = breadcrumb.timestamp.time
@@ -223,14 +236,13 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
       val breadcrumbData = mutableMapOf<String, Any?>()
 
       // Add data from NetworkRequestData if available
-      if (networkRequestData != null) {
-        networkRequestData.method?.let { breadcrumbData["method"] = it }
-        networkRequestData.statusCode?.let { breadcrumbData["statusCode"] = it }
-        networkRequestData.requestBodySize?.let { breadcrumbData["requestBodySize"] = it }
-        networkRequestData.responseBodySize?.let { breadcrumbData["responseBodySize"] = it }
-
-        // Add request and response data if available
-        networkRequestData.request?.let { request ->
+      networkDetailData?.let { networkData ->
+        networkData.method?.let { breadcrumbData["method"] = it }
+        networkData.statusCode?.let { breadcrumbData["statusCode"] = it }
+        networkData.requestBodySize?.let { breadcrumbData["requestBodySize"] = it }
+        networkData.responseBodySize?.let { breadcrumbData["responseBodySize"] = it }
+
+        networkData.request?.let { request ->
           val requestData = mutableMapOf<String, Any?>()
           request.size?.let { requestData["size"] = it }
           request.body?.let { requestData["body"] = it }
@@ -242,7 +254,7 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
           }
         }
 
-        networkRequestData.response?.let { response ->
+        networkData.response?.let { response ->
           val responseData = mutableMapOf<String, Any?>()
           response.size?.let { responseData["size"] = it }
           response.body?.let { responseData["body"] = it }
@@ -264,7 +276,6 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
         }
       }
 
-
       data = breadcrumbData
     }
   }

From 308072b58d7c802c3e5175f96ee4f32bb48e54e0 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Fri, 24 Oct 2025 15:31:02 -0400
Subject: [PATCH 13/28] Extract bodies of okhttp requests/responses

Replaces previous placeholder logic.
Now NetworkBodyParser uses io.sentry.JsonObjectReader
to extract body into JSONObject, JSONArray, with fallback to plain-text String (or nothing)
---
 .../sentry/okhttp/SentryOkHttpInterceptor.kt  | 228 ++++++++++--------
 .../java/io/sentry/SentryReplayOptions.java   |   7 +
 .../io/sentry/util/network/NetworkBody.java   | 181 ++++++++++++--
 .../util/network/NetworkBodyParser.java       | 178 ++++++++++++++
 4 files changed, 474 insertions(+), 120 deletions(-)
 create mode 100644 sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java

diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index 9ea5789e3ee..e1c24e4a13d 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -9,6 +9,7 @@ import io.sentry.ISpan
 import io.sentry.ScopesAdapter
 import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.SentryOptions.DEFAULT_PROPAGATION_TARGETS
+import io.sentry.SentryReplayOptions
 import io.sentry.SpanDataConvention
 import io.sentry.SpanStatus
 import io.sentry.TypeCheckHint.OKHTTP_REQUEST
@@ -22,11 +23,13 @@ import io.sentry.util.SpanUtils
 import io.sentry.util.TracingUtils
 import io.sentry.util.UrlUtils
 import io.sentry.util.network.NetworkBody
+import io.sentry.util.network.NetworkBodyParser
 import io.sentry.util.network.NetworkDetailCaptureUtils
-import io.sentry.util.network.ReplayNetworkRequestOrResponse
+import io.sentry.util.network.NetworkRequestData
 import java.io.IOException
 import okhttp3.Interceptor
 import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 
 /**
@@ -112,6 +115,13 @@ public open class SentryOkHttpInterceptor(
     var response: Response? = null
     var code: Int? = null
 
+    var networkDetailData = NetworkDetailCaptureUtils.initializeForUrl(
+      request.url.toString(),
+      request.method,
+      FAKE_OPTIONS.networkDetailAllowUrls,
+      FAKE_OPTIONS.networkDetailDenyUrls,
+    )
+
     try {
       val requestBuilder = request.newBuilder()
 
@@ -135,6 +145,40 @@ public open class SentryOkHttpInterceptor(
           }
       }
 
+      val requestContentLength = request.body?.contentLength()
+
+      networkDetailData?.setRequestDetails(
+        NetworkDetailCaptureUtils.createRequest(
+          request,
+          requestContentLength,
+          FAKE_OPTIONS.networkCaptureBodies,
+          { req ->
+            req.body?.let { originalBody ->
+              try {
+                val buffer = okio.Buffer()
+                originalBody.writeTo(buffer)
+                val bodyBytes = buffer.readByteArray()
+
+                // Create fresh RequestBody and update the request being built
+                val newRequestBody = bodyBytes.toRequestBody(originalBody.contentType())
+                requestBuilder.method(request.method, newRequestBody)
+
+                // Parse the buffered bytes into NetworkBody for capture
+                safeExtractRequestBody(bodyBytes, originalBody.contentType())
+              } catch (e: Exception) {
+                scopes.options.logger.log(
+                  io.sentry.SentryLevel.DEBUG,
+                  "Failed to buffer request body for network detail capture: ${e.message}",
+                )
+                null
+              }
+            }
+          },
+          FAKE_OPTIONS.networkRequestHeaders,
+          { req: Request -> req.headers.toMap() },
+        )
+      )
+
       request = requestBuilder.build()
       response = chain.proceed(request)
       code = response.code
@@ -168,11 +212,31 @@ public open class SentryOkHttpInterceptor(
       // this only works correctly if SentryOkHttpInterceptor is the last one in the chain
       okHttpEvent?.setRequest(request)
 
+      response?.let { response ->
+        networkDetailData?.setResponseDetails(
+          response.code,
+          NetworkDetailCaptureUtils.createResponse(
+            response,
+            response.body?.contentLength(),
+            FAKE_OPTIONS.networkCaptureBodies,
+            { resp: Response -> resp.extractResponseBody() },
+            FAKE_OPTIONS.networkResponseHeaders,
+            { resp: Response -> resp.headers.toMap() },
+          ),
+        )
+      }
+
       finishSpan(span, request, response, isFromEventListener, okHttpEvent)
 
       // The SentryOkHttpEventListener will send the breadcrumb itself if used for this call
       if (!isFromEventListener) {
-        sendBreadcrumb(request, code, response, startTimestamp)
+        sendBreadcrumb(
+          request,
+          code,
+          response,
+          startTimestamp,
+          networkDetailData,
+        )
       }
     }
   }
@@ -185,21 +249,17 @@ public open class SentryOkHttpInterceptor(
     code: Int?,
     response: Response?,
     startTimestamp: Long,
+    networkDetailData: NetworkRequestData?
   ) {
     val breadcrumb = Breadcrumb.http(request.url.toString(), request.method, code)
 
     // Track request and response body sizes for the breadcrumb
-    var requestBodySize: Long? = null
-    var responseBodySize: Long? = null
-
     request.body?.contentLength().ifHasValidLength {
       breadcrumb.setData("http.request_content_length", it)
-      requestBodySize = it
     }
 
     response?.body?.contentLength().ifHasValidLength {
       breadcrumb.setData(SpanDataConvention.HTTP_RESPONSE_CONTENT_LENGTH_KEY, it)
-      responseBodySize = it
     }
 
     val hint =
@@ -207,40 +267,9 @@ public open class SentryOkHttpInterceptor(
         it.set(OKHTTP_REQUEST, request)
         response?.let { resp -> it[OKHTTP_RESPONSE] = resp }
 
-        val networkDetailData =
-          NetworkDetailCaptureUtils.initializeForUrl(
-            request.url.toString(),
-            request.method,
-            FAKE_OPTIONS.networkDetailAllowUrls,
-            FAKE_OPTIONS.networkDetailDenyUrls,
-          )
-
-        networkDetailData?.setRequestDetails(
-          NetworkDetailCaptureUtils.createRequest(
-            request,
-            requestBodySize,
-            FAKE_OPTIONS.networkCaptureBodies,
-            { req: Request -> req.extractRequestBody() },
-            FAKE_OPTIONS.networkRequestHeaders,
-            { req: Request -> req.headers.toMap() }
-          )
-        )
-
-        response?.let { response ->
-          networkDetailData?.setResponseDetails(
-            response.code,
-            NetworkDetailCaptureUtils.createResponse(
-              response,
-              responseBodySize,
-              FAKE_OPTIONS.networkCaptureBodies,
-              { resp: Response -> resp.extractResponseBody() },
-              FAKE_OPTIONS.networkResponseHeaders,
-              { resp: Response -> resp.headers.toMap() }
-            )
-          )
+        if (networkDetailData != null) {
+          it.set("replay:networkDetails", networkDetailData)
         }
-
-        it.set("replay:networkDetails", networkDetailData)
       }
 
     // needs this as unix timestamp for rrweb
@@ -262,82 +291,72 @@ public open class SentryOkHttpInterceptor(
     return headers
   }
 
-  /** Extracts the body content from an OkHttp Request safely */
-  private fun Request.extractRequestBody(): NetworkBody? {
-    return body?.let {
-      try {
-        // Create a copy of the request to safely read the body without consuming the original
-        val requestCopy = newBuilder().build()
-        val buffer = okio.Buffer()
-        requestCopy.body?.writeTo(buffer)
-        val bodyString = buffer.readUtf8()
-
-        // Try to parse as JSON first, fall back to string
-        when {
-          bodyString.isEmpty() -> null
-          bodyString.trimStart().startsWith("{") -> {
-            // Attempt JSON object parsing (simplified)
-            NetworkBody.JsonObject(mapOf("raw" to bodyString)) // Placeholder for now
-          }
-          bodyString.trimStart().startsWith("[") -> {
-            // Attempt JSON array parsing (simplified)
-            NetworkBody.JsonArray(listOf(bodyString)) // Placeholder for now
-          }
-          else -> NetworkBody.StringBody(bodyString)
-        }
-      } catch (e: Exception) {
-        // If body reading fails (e.g., one-shot body), log and return null
-        scopes.options.logger.log(
-          io.sentry.SentryLevel.DEBUG,
-          "Failed to read request body safely: ${e.message}"
-        )
-        null
-      }
+  /**
+   * Extracts NetworkBody from already buffered request body data.
+   */
+  private fun safeExtractRequestBody(
+    bufferedBody: ByteArray?,
+    contentType: okhttp3.MediaType?,
+  ): NetworkBody? {
+    if (bufferedBody == null) {
+      return null
     }
-  }
 
-  /** Extension function to create ReplayNetworkRequestOrResponse from OkHttp Response */
-  private fun Response.toReplayNetworkResponse(): ReplayNetworkRequestOrResponse {
-    scopes.options.logger.log(
-      io.sentry.SentryLevel.INFO,
-      "SentryNetwork: Creating ReplayNetworkResponse for status: $code",
-    )
-
-    return NetworkDetailCaptureUtils.createResponse(
-      this,
-      body?.contentLength()?.takeIf { it >= 0 },
-      true,
-      { resp: Response -> resp.extractResponseBody() },
-      emptyArray<String>(),
-      { resp: Response -> resp.headers.toMap() }
-    )
+    try {
+      val contentTypeString = contentType?.toString()
+      val maxBodySize = SentryReplayOptions.MAX_NETWORK_BODY_SIZE
+      val charset = contentType?.charset(Charsets.UTF_8)?.name() ?: "UTF-8"
+
+      return NetworkBodyParser.fromBytes(
+        bufferedBody,
+        contentTypeString,
+        charset,
+        maxBodySize,
+        scopes.options,
+      )
+    } catch (e: Exception) {
+      scopes.options.logger.log(
+        io.sentry.SentryLevel.DEBUG,
+        "Failed to parse buffered request body: ${e.message}",
+      )
+      return null
+    }
   }
 
   /** Extracts the body content from an OkHttp Response safely */
   private fun Response.extractResponseBody(): NetworkBody? {
-    return body?.let {
+    return body?.let { responseBody ->
       try {
-        val peekBody = peekBody(Long.MAX_VALUE)
-        val bodyString = peekBody.string()
-
-        // Try to parse as JSON first, fall back to string
-        when {
-          bodyString.isEmpty() -> null
-          bodyString.trimStart().startsWith("{") -> {
-            // Attempt JSON object parsing (simplified)
-            NetworkBody.JsonObject(mapOf("raw" to bodyString)) // Placeholder for now
-          }
-          bodyString.trimStart().startsWith("[") -> {
-            // Attempt JSON array parsing (simplified)
-            NetworkBody.JsonArray(listOf(bodyString)) // Placeholder for now
-          }
-          else -> NetworkBody.StringBody(bodyString)
+        val contentType = responseBody.contentType()
+        val contentTypeString = contentType?.toString()
+        val maxBodySize = SentryReplayOptions.MAX_NETWORK_BODY_SIZE
+
+        val contentLength = responseBody.contentLength()
+        if (contentLength > maxBodySize * 2) {
+          scopes.options.logger.log(
+            io.sentry.SentryLevel.DEBUG,
+            "Response body too large: $contentLength bytes (max: $maxBodySize)",
+          )
+          return NetworkBody.fromString("[Response body too large: $contentLength bytes]")
         }
+
+        // Peek at the body (doesn't consume it)
+        val peekBody = peekBody(maxBodySize.toLong())
+        val bodyBytes = peekBody.bytes()
+
+        val charset = contentType?.charset(Charsets.UTF_8)?.name() ?: "UTF-8"
+        return NetworkBodyParser.fromBytes(
+          bodyBytes,
+          contentTypeString,
+          charset,
+          maxBodySize,
+          scopes.options,
+        )
       } catch (e: Exception) {
         // If body reading fails, log and return null
         scopes.options.logger.log(
           io.sentry.SentryLevel.DEBUG,
-          "Failed to read response body safely: ${e.message}"
+          "Failed to read response body safely: ${e.message}",
         )
         null
       }
@@ -401,7 +420,6 @@ public open class SentryOkHttpInterceptor(
     return false
   }
 
-
   /** The BeforeSpan callback */
   public fun interface BeforeSpanCallback {
     /**
diff --git a/sentry/src/main/java/io/sentry/SentryReplayOptions.java b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
index 3cddf4705ab..87abfda537f 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
@@ -20,6 +20,13 @@ public final class SentryReplayOptions {
   public static final String EXOPLAYER_STYLED_CLASS_NAME =
       "com.google.android.exoplayer2.ui.StyledPlayerView";
 
+  /**
+   * Maximum size in bytes for network request/response bodies to be captured in replays. Bodies
+   * larger than this will be truncated or replaced with a placeholder message. Default is 150KB
+   * (153600 bytes).
+   */
+  @ApiStatus.Internal public static final int MAX_NETWORK_BODY_SIZE = 150 * 1024;
+
   public enum SentryReplayQuality {
     /** Video Scale: 80% Bit Rate: 50.000 JPEG Compression: 10 */
     LOW(0.8f, 50_000, 10),
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
index f3dbe53e2d7..6fb6f56002d 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
@@ -3,66 +3,217 @@
 import java.util.List;
 import java.util.Map;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
- * Represents the body content of a network request or response. Can be one of: JsonObject,
- * JsonArray, or String.
+ * Represents the body content of a network request or response. Can be one of: JSON object, JSON
+ * array, or string.
  *
- * <p> See https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts
+ * <p>See
+ * https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts
  */
 public interface NetworkBody {
 
-  /** Represents a JSON object body (key-value pairs) */
-  public static final class JsonObject implements NetworkBody {
+  /**
+   * Creates a NetworkBody from a JSON object.
+   *
+   * @param value The map representing the JSON object
+   * @return A NetworkBody instance for the JSON object
+   */
+  static @NotNull NetworkBody fromJsonObject(@NotNull Map<String, Object> value) {
+    return new JsonObjectImpl(value);
+  }
+
+  /**
+   * Creates a NetworkBody from a JSON array.
+   *
+   * @param value The list representing the JSON array
+   * @return A NetworkBody instance for the JSON array
+   */
+  static @NotNull NetworkBody fromJsonArray(@NotNull List<Object> value) {
+    return new JsonArrayImpl(value);
+  }
+
+  /**
+   * Creates a NetworkBody from string content.
+   *
+   * @param value The string content
+   * @return A NetworkBody instance for the string
+   */
+  static @NotNull NetworkBody fromString(@NotNull String value) {
+    return new StringBodyImpl(value);
+  }
+
+  /**
+   * Gets the underlying value of this NetworkBody.
+   *
+   * @return The value as an Object (could be Map, List, or String)
+   */
+  @NotNull
+  Object getValue();
+
+  /**
+   * Checks if this NetworkBody represents a JSON object.
+   *
+   * @return true if this is a JSON object
+   */
+  default boolean isJsonObject() {
+    return getValue() instanceof Map;
+  }
+
+  /**
+   * Checks if this NetworkBody represents a JSON array.
+   *
+   * @return true if this is a JSON array
+   */
+  default boolean isJsonArray() {
+    return getValue() instanceof List;
+  }
+
+  /**
+   * Checks if this NetworkBody represents string content.
+   *
+   * @return true if this is a string
+   */
+  default boolean isString() {
+    return getValue() instanceof String;
+  }
+
+  /**
+   * Gets the value as a JSON object (Map).
+   *
+   * @return The Map if this is a JSON object, null otherwise
+   */
+  default @Nullable Map<String, Object> asJsonObject() {
+    Object value = getValue();
+    if (value instanceof Map) {
+      @SuppressWarnings("unchecked")
+      Map<String, Object> map = (Map<String, Object>) value;
+      return map;
+    }
+    return null;
+  }
+
+  /**
+   * Gets the value as a JSON array (List).
+   *
+   * @return The List if this is a JSON array, null otherwise
+   */
+  default @Nullable List<Object> asJsonArray() {
+    Object value = getValue();
+    if (value instanceof List) {
+      @SuppressWarnings("unchecked")
+      List<Object> list = (List<Object>) value;
+      return list;
+    }
+    return null;
+  }
+
+  /**
+   * Gets the value as a string.
+   *
+   * @return The String if this is string content, null otherwise
+   */
+  default @Nullable String asString() {
+    Object value = getValue();
+    return value instanceof String ? (String) value : null;
+  }
+
+  // Private implementation classes
+
+  /** Implementation for JSON object bodies */
+  final class JsonObjectImpl implements NetworkBody {
     private final @NotNull Map<String, Object> value;
 
-    public JsonObject(@NotNull Map<String, Object> value) {
+    JsonObjectImpl(@NotNull Map<String, Object> value) {
       this.value = value;
     }
 
+    @Override
     public @NotNull Map<String, Object> getValue() {
       return value;
     }
 
     @Override
     public String toString() {
-      return "JsonObject{" + value + '}';
+      return "NetworkBody.JsonObject{" + value + '}';
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) return true;
+      if (!(obj instanceof JsonObjectImpl)) return false;
+      JsonObjectImpl that = (JsonObjectImpl) obj;
+      return value.equals(that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return value.hashCode();
     }
   }
 
-  /** Represents a JSON array body (ordered list) */
-  public static final class JsonArray implements NetworkBody {
+  /** Implementation for JSON array bodies */
+  final class JsonArrayImpl implements NetworkBody {
     private final @NotNull List<Object> value;
 
-    public JsonArray(@NotNull List<Object> value) {
+    JsonArrayImpl(@NotNull List<Object> value) {
       this.value = value;
     }
 
+    @Override
     public @NotNull List<Object> getValue() {
       return value;
     }
 
     @Override
     public String toString() {
-      return "JsonArray{" + value + '}';
+      return "NetworkBody.JsonArray{" + value + '}';
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) return true;
+      if (!(obj instanceof JsonArrayImpl)) return false;
+      JsonArrayImpl that = (JsonArrayImpl) obj;
+      return value.equals(that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return value.hashCode();
     }
   }
 
-  /** Represents a string body (text content) */
-  public static final class StringBody implements NetworkBody {
+  /** Implementation for string bodies */
+  final class StringBodyImpl implements NetworkBody {
     private final @NotNull String value;
 
-    public StringBody(@NotNull String value) {
+    StringBodyImpl(@NotNull String value) {
       this.value = value;
     }
 
+    @Override
     public @NotNull String getValue() {
       return value;
     }
 
     @Override
     public String toString() {
-      return "StringBody{" + value + '}';
+      return "NetworkBody.StringBody{" + value + '}';
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) return true;
+      if (!(obj instanceof StringBodyImpl)) return false;
+      StringBodyImpl that = (StringBodyImpl) obj;
+      return value.equals(that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return value.hashCode();
     }
   }
 }
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java b/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
new file mode 100644
index 00000000000..9620aa4da75
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
@@ -0,0 +1,178 @@
+package io.sentry.util.network;
+
+import io.sentry.JsonObjectReader;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import java.io.StringReader;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/** Utility class for parsing and creating NetworkBody instances. */
+public final class NetworkBodyParser {
+
+  private NetworkBodyParser() {}
+
+  /**
+   * Creates a NetworkBody from raw bytes with content type information. This is useful for handling
+   * binary or unknown content types.
+   *
+   * @param bytes The raw bytes of the body
+   * @param contentType Optional content type hint to help with parsing
+   * @param charset Optional charset to use for text conversion (defaults to UTF-8)
+   * @param maxSizeBytes Maximum size to process
+   * @param logger Optional logger
+   * @return A NetworkBody or null if bytes are null/empty
+   */
+  public static @Nullable NetworkBody fromBytes(
+      @Nullable byte[] bytes,
+      @Nullable String contentType,
+      @Nullable String charset,
+      int maxSizeBytes,
+      @Nullable SentryOptions logger) {
+
+    if (bytes == null || bytes.length == 0) {
+      return null;
+    }
+
+    // Check binary content type
+    if (contentType != null && isBinaryContentType(contentType)) {
+      // For binary content, return a description instead of the actual content
+      return NetworkBody.fromString(
+          "[Binary data, " + bytes.length + " bytes, type: " + contentType + "]");
+    }
+
+    // Convert to string and parse
+    try {
+      String effectiveCharset = charset != null ? charset : "UTF-8";
+      String content = new String(bytes, effectiveCharset);
+      return parse(content, contentType, maxSizeBytes, logger);
+    } catch (UnsupportedEncodingException e) {
+      if (logger != null) {
+        logger.getLogger().log(SentryLevel.DEBUG, "Failed to decode bytes: " + e.getMessage());
+      }
+      return NetworkBody.fromString("[Failed to decode bytes, " + bytes.length + " bytes]");
+    }
+  }
+
+  private static @Nullable NetworkBody parse(
+      @Nullable String content,
+      @Nullable String contentType,
+      int maxSizeBytes,
+      @Nullable SentryOptions logger) {
+
+    if (content == null || content.isEmpty()) {
+      return null;
+    }
+
+    // Check size limit
+    if (content.getBytes(StandardCharsets.UTF_8).length > maxSizeBytes) {
+      if (logger != null) {
+        logger
+            .getLogger()
+            .log(SentryLevel.DEBUG, "Content exceeds max size limit of " + maxSizeBytes + " bytes");
+      }
+      // Return truncated string
+      int truncateAt = Math.min(content.length(), maxSizeBytes);
+      return NetworkBody.fromString(content.substring(0, truncateAt) + "...[truncated]");
+    }
+
+    // Handle based on content type hint if provided
+    if (contentType != null) {
+      String lowerContentType = contentType.toLowerCase();
+
+      if (lowerContentType.contains("application/x-www-form-urlencoded")) {
+        return parseFormUrlEncoded(content, logger);
+      }
+
+      if (lowerContentType.contains("xml")) {
+        // For XML, return as string (could be enhanced to parse XML structure)
+        return NetworkBody.fromString(content);
+      }
+    }
+
+    // Try to parse as JSON using the existing JsonObjectReader
+    String trimmed = content.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try (JsonObjectReader reader = new JsonObjectReader(new StringReader(trimmed))) {
+        Object parsed = reader.nextObjectOrNull();
+        if (parsed instanceof Map) {
+          @SuppressWarnings("unchecked")
+          Map<String, Object> map = (Map<String, Object>) parsed;
+          return NetworkBody.fromJsonObject(map);
+        } else if (parsed instanceof List) {
+          @SuppressWarnings("unchecked")
+          List<Object> list = (List<Object>) parsed;
+          return NetworkBody.fromJsonArray(list);
+        }
+      } catch (Exception e) {
+        if (logger != null) {
+          logger.getLogger().log(SentryLevel.DEBUG, "Failed to parse JSON: " + e.getMessage());
+        }
+      }
+    }
+
+    // Default to string representation
+    return NetworkBody.fromString(content);
+  }
+
+  /** Parses URL-encoded form data into a JsonObject NetworkBody. */
+  private static @Nullable NetworkBody parseFormUrlEncoded(
+      @NotNull String content, @Nullable SentryOptions logger) {
+    try {
+      Map<String, Object> params = new HashMap<>();
+      String[] pairs = content.split("&", -1);
+
+      for (String pair : pairs) {
+        int idx = pair.indexOf("=");
+        if (idx > 0) {
+          String key = URLDecoder.decode(pair.substring(0, idx), "UTF-8");
+          String value =
+              idx < pair.length() - 1 ? URLDecoder.decode(pair.substring(idx + 1), "UTF-8") : "";
+
+          // Handle multiple values for the same key
+          if (params.containsKey(key)) {
+            Object existing = params.get(key);
+            if (existing instanceof List) {
+              @SuppressWarnings("unchecked")
+              List<String> list = (List<String>) existing;
+              list.add(value);
+            } else {
+              List<String> list = new ArrayList<>();
+              list.add((String) existing);
+              list.add(value);
+              params.put(key, list);
+            }
+          } else {
+            params.put(key, value);
+          }
+        }
+      }
+
+      return NetworkBody.fromJsonObject(params);
+    } catch (UnsupportedEncodingException e) {
+      if (logger != null) {
+        logger.getLogger().log(SentryLevel.DEBUG, "Failed to parse form data: " + e.getMessage());
+      }
+      return null;
+    }
+  }
+
+  /** Checks if the content type is binary and shouldn't be converted to string. */
+  private static boolean isBinaryContentType(@NotNull String contentType) {
+    String lower = contentType.toLowerCase();
+    return lower.contains("image/")
+        || lower.contains("video/")
+        || lower.contains("audio/")
+        || lower.contains("application/octet-stream")
+        || lower.contains("application/pdf")
+        || lower.contains("application/zip")
+        || lower.contains("application/gzip");
+  }
+}

From 5836ef1c16f8dc0cfe78d7e36b90048e6faaabd3 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Fri, 24 Oct 2025 11:00:13 -0400
Subject: [PATCH 14/28] Check-in sentry-android-replay.api

---
 sentry-android-replay/api/sentry-android-replay.api | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sentry-android-replay/api/sentry-android-replay.api b/sentry-android-replay/api/sentry-android-replay.api
index 5d6df28f7b3..1cbff1e2a88 100644
--- a/sentry-android-replay/api/sentry-android-replay.api
+++ b/sentry-android-replay/api/sentry-android-replay.api
@@ -10,6 +10,8 @@ public class io/sentry/android/replay/DefaultReplayBreadcrumbConverter : io/sent
 	public static final field $stable I
 	public fun <init> ()V
 	public fun convert (Lio/sentry/Breadcrumb;)Lio/sentry/rrweb/RRWebEvent;
+	public fun execute (Lio/sentry/Breadcrumb;Lio/sentry/Hint;)Lio/sentry/Breadcrumb;
+	public fun setUserBeforeBreadcrumbCallback (Lio/sentry/SentryOptions$BeforeBreadcrumbCallback;)V
 }
 
 public final class io/sentry/android/replay/GeneratedVideo {

From d9f82548dbc30324a7a602b2da267ea45d2b1e85 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Thu, 23 Oct 2025 14:55:39 -0400
Subject: [PATCH 15/28] Cleanup

Linter / formatting / tests / comments
---
 .../DefaultReplayBreadcrumbConverter.kt       |  43 +++--
 .../DefaultReplayBreadcrumbConverterTest.kt   | 174 ++++++++++--------
 .../io/sentry/rrweb/RRWebOptionsEvent.java    |   1 -
 .../network/NetworkDetailCaptureUtils.java    |  42 +++--
 .../util/network/NetworkRequestData.java      |  18 +-
 .../ReplayNetworkRequestOrResponse.java       |   8 +-
 6 files changed, 160 insertions(+), 126 deletions(-)

diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
index 64208791cff..d2f746f828d 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
@@ -42,10 +42,9 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     )
   private var userBeforeBreadcrumbCallback: BeforeBreadcrumbCallback? = null
 
-  // TODO: If user provided a new Breadcrumb object via their BeforeBreadcrumbCallback, is that reflected in the `Breadcrumb`s passed in here?
   override fun convert(breadcrumb: Breadcrumb): RRWebEvent? {
     var breadcrumbMessage: String? = null
-    var breadcrumbCategory: String?
+    val breadcrumbCategory: String?
     var breadcrumbLevel: SentryLevel? = null
     val breadcrumbData = mutableMapOf<String, Any?>()
     when {
@@ -142,16 +141,15 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     this.userBeforeBreadcrumbCallback = beforeBreadcrumbCallback
   }
 
-  /**
-   * Delegate to user-provided callback (if exists) to provide the final breadcrumb to process.
-   */
+  /** Delegate to user-provided callback (if exists) to provide the final breadcrumb to process. */
   override fun execute(breadcrumb: Breadcrumb, hint: Hint): Breadcrumb? {
     val callback = userBeforeBreadcrumbCallback
-    val result = if (callback != null) {
-      callback.execute(breadcrumb, hint)
-    } else {
-      breadcrumb
-    }
+    val result =
+      if (callback != null) {
+        callback.execute(breadcrumb, hint)
+      } else {
+        breadcrumb
+      }
 
     result?.let { finalBreadcrumb ->
       extractNetworkRequestDataFromHint(finalBreadcrumb, hint)?.let { networkData ->
@@ -159,18 +157,27 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
       }
     }
 
-    Log.d("SentryNetwork", "SentryNetwork: BeforeBreadcrumbCallback - Hint: $hint, Breadcrumb: $result")
+    Log.d(
+      "SentryNetwork",
+      "SentryNetwork: BeforeBreadcrumbCallback - Hint: $hint, Breadcrumb: $result",
+    )
     return result
   }
 
-  private fun extractNetworkRequestDataFromHint(breadcrumb: Breadcrumb, breadcrumbHint: Hint): NetworkRequestData? {
+  private fun extractNetworkRequestDataFromHint(
+    breadcrumb: Breadcrumb,
+    breadcrumbHint: Hint,
+  ): NetworkRequestData? {
     if (breadcrumb.type != "http" && breadcrumb.category != "http") {
       return null
     }
 
     val networkDetails = breadcrumbHint.get("replay:networkDetails") as? NetworkRequestData
     if (networkDetails != null) {
-      Log.d("SentryNetwork", "SentryNetwork: Found structured NetworkRequestData in hint: $networkDetails")
+      Log.d(
+        "SentryNetwork",
+        "SentryNetwork: Found structured NetworkRequestData in hint: $networkDetails",
+      )
       return networkDetails
     }
 
@@ -191,9 +198,12 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     if (!hasStartTimestamp) reasons.add("missing start timestamp")
     if (!hasEndTimestamp) reasons.add("missing end timestamp")
 
-    Log.d("SentryReplay", "Breadcrumb RRWeb span validation: ${if (isValid) "VALID" else "INVALID"}" +
-      if (!isValid) " (${reasons.joinToString(", ")})" else "" +
-      " - URL: ${url ?: "null"}, Category: ${category}")
+    Log.d(
+      "SentryReplay",
+      "Breadcrumb RRWeb span validation: ${if (isValid) "VALID" else "INVALID"}" +
+        if (!isValid) " (${reasons.joinToString(", ")})"
+        else "" + " - URL: ${url ?: "null"}, Category: ${category}",
+    )
 
     return isValid
   }
@@ -267,7 +277,6 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
         }
       }
       // Original breadcrumb http data
-      // TODO: Remove if superceded by more detailed data (above).
       for ((key, value) in breadcrumb.data) {
         if (key in supportedNetworkData) {
           breadcrumbData[
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
index f3f11b60005..5336740724f 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
@@ -331,10 +331,11 @@ class DefaultReplayBreadcrumbConverterTest {
   @Test
   fun `returned breadcrumb is not modified when no user BeforeBreadcrumbCallback is provided`() {
     val converter = fixture.getSut()
-    val breadcrumb = Breadcrumb(Date()).apply {
-      message = "test message"
-      category = "test.category"
-    }
+    val breadcrumb =
+      Breadcrumb(Date()).apply {
+        message = "test message"
+        category = "test.category"
+      }
     val hint = Hint()
 
     converter.setUserBeforeBreadcrumbCallback(null)
@@ -347,17 +348,20 @@ class DefaultReplayBreadcrumbConverterTest {
   @Test
   fun `returned breadcrumb is modified according to user provided BeforeBreadcrumbCallback`() {
     val converter = fixture.getSut()
-    val originalBreadcrumb = Breadcrumb(Date()).apply {
-      message = "original message"
-      category = "original.category"
-    }
-    val userModifiedBreadcrumb = Breadcrumb(Date()).apply {
-      message = "modified message"
-      category = "modified.category"
-    }
+    val originalBreadcrumb =
+      Breadcrumb(Date()).apply {
+        message = "original message"
+        category = "original.category"
+      }
+    val userModifiedBreadcrumb =
+      Breadcrumb(Date()).apply {
+        message = "modified message"
+        category = "modified.category"
+      }
     val hint = Hint()
 
-    val userBeforeBreadcrumbCallback = SentryOptions.BeforeBreadcrumbCallback { _, _ -> userModifiedBreadcrumb }
+    val userBeforeBreadcrumbCallback =
+      SentryOptions.BeforeBreadcrumbCallback { _, _ -> userModifiedBreadcrumb }
     converter.setUserBeforeBreadcrumbCallback(userBeforeBreadcrumbCallback)
 
     val result = converter.execute(originalBreadcrumb, hint)
@@ -368,10 +372,11 @@ class DefaultReplayBreadcrumbConverterTest {
   @Test
   fun `returns null when user BeforeBreadcrumbCallback returns null`() {
     val converter = fixture.getSut()
-    val breadcrumb = Breadcrumb(Date()).apply {
-      message = "test message"
-      category = "test.category"
-    }
+    val breadcrumb =
+      Breadcrumb(Date()).apply {
+        message = "test message"
+        category = "test.category"
+      }
     val hint = Hint()
 
     val userCallback = SentryOptions.BeforeBreadcrumbCallback { _, _ -> null }
@@ -385,20 +390,22 @@ class DefaultReplayBreadcrumbConverterTest {
   @Test
   fun `network data is extracted from hint for http breadcrumbs with user callback`() {
     val converter = fixture.getSut()
-    val httpBreadcrumb = Breadcrumb(Date()).apply {
-      type = "http"
-      category = "http"
-      data["url"] = "https://example.com"
-    }
-
-    val networkData = NetworkRequestData(
-      "GET",
-      200,
-      100L,
-      500L,
-      ReplayNetworkRequestOrResponse(100L, null, mapOf("Content-Type" to "application/json")),
-      ReplayNetworkRequestOrResponse(500L, null, mapOf("Content-Type" to "application/json"))
-    )
+    val httpBreadcrumb =
+      Breadcrumb(Date()).apply {
+        type = "http"
+        category = "http"
+        data["url"] = "https://example.com"
+      }
+
+    val networkData =
+      NetworkRequestData(
+        "GET",
+        200,
+        100L,
+        500L,
+        ReplayNetworkRequestOrResponse(100L, null, mapOf("Content-Type" to "application/json")),
+        ReplayNetworkRequestOrResponse(500L, null, mapOf("Content-Type" to "application/json")),
+      )
     val hint = Hint()
     hint.set("replay:networkDetails", networkData)
 
@@ -408,26 +415,35 @@ class DefaultReplayBreadcrumbConverterTest {
     val result = converter.execute(httpBreadcrumb, hint)
 
     assertSame(httpBreadcrumb, result)
-    // Network data should be stored internally for later conversion
   }
 
   @Test
   fun `network data is extracted from hint for http breadcrumbs without user callback`() {
     val converter = fixture.getSut()
-    val httpBreadcrumb = Breadcrumb(Date()).apply {
-      type = "http"
-      category = "http"
-      data["url"] = "https://example.com"
-    }
-
-    val networkData = NetworkRequestData(
-      "POST",
-      201,
-      200L,
-      400L,
-      ReplayNetworkRequestOrResponse(200L, NetworkBody.JsonObject(mapOf("body" to "request")), mapOf()),
-      ReplayNetworkRequestOrResponse(400L, NetworkBody.JsonObject(mapOf("body" to "response")), mapOf())
-    )
+    val httpBreadcrumb =
+      Breadcrumb(Date()).apply {
+        type = "http"
+        category = "http"
+        data["url"] = "https://example.com"
+      }
+
+    val networkData =
+      NetworkRequestData(
+        "POST",
+        201,
+        200L,
+        400L,
+        ReplayNetworkRequestOrResponse(
+          200L,
+          NetworkBody.fromJsonObject(mapOf("body" to "request")),
+          mapOf(),
+        ),
+        ReplayNetworkRequestOrResponse(
+          400L,
+          NetworkBody.fromJsonObject(mapOf("body" to "response")),
+          mapOf(),
+        ),
+      )
     val hint = Hint()
     hint.set("replay:networkDetails", networkData)
 
@@ -445,19 +461,21 @@ class DefaultReplayBreadcrumbConverterTest {
     val hint = Hint()
 
     // First callback modifies the message
-    val firstCallback = SentryOptions.BeforeBreadcrumbCallback { b, _ ->
-      b.message = "modified by first"
-      b
-    }
+    val firstCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, _ ->
+        b.message = "modified by first"
+        b
+      }
     converter.setUserBeforeBreadcrumbCallback(firstCallback)
     var result = converter.execute(breadcrumb, hint)
     assertEquals("modified by first", result?.message)
 
     // Second callback modifies differently
-    val secondCallback = SentryOptions.BeforeBreadcrumbCallback { b, _ ->
-      b.message = "modified by second"
-      b
-    }
+    val secondCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, _ ->
+        b.message = "modified by second"
+        b
+      }
     converter.setUserBeforeBreadcrumbCallback(secondCallback)
 
     breadcrumb.message = "test" // Reset
@@ -474,11 +492,12 @@ class DefaultReplayBreadcrumbConverterTest {
     var capturedBreadcrumb: Breadcrumb? = null
     var capturedHint: Hint? = null
 
-    val capturingCallback = SentryOptions.BeforeBreadcrumbCallback { b, h ->
-      capturedBreadcrumb = b
-      capturedHint = h
-      b
-    }
+    val capturingCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, h ->
+        capturedBreadcrumb = b
+        capturedHint = h
+        b
+      }
     converter.setUserBeforeBreadcrumbCallback(capturingCallback)
 
     converter.execute(breadcrumb, hint)
@@ -490,10 +509,11 @@ class DefaultReplayBreadcrumbConverterTest {
   @Test
   fun `non-http breadcrumbs do not extract network data`() {
     val converter = fixture.getSut()
-    val navigationBreadcrumb = Breadcrumb(Date()).apply {
-      type = "navigation"
-      category = "navigation"
-    }
+    val navigationBreadcrumb =
+      Breadcrumb(Date()).apply {
+        type = "navigation"
+        category = "navigation"
+      }
     val hint = Hint()
     hint.set("replay:networkDetails", NetworkRequestData("GET", 200, null, null, null, null))
 
@@ -511,20 +531,22 @@ class DefaultReplayBreadcrumbConverterTest {
     val breadcrumb = Breadcrumb(Date()).apply { message = "original" }
     val hint = Hint()
 
-    val firstCallback = SentryOptions.BeforeBreadcrumbCallback { b, h ->
-      b.message = "modified by first"
-      b
-    }
-
-    val secondCallback = SentryOptions.BeforeBreadcrumbCallback { b, h ->
-      // This simulates what happens when ReplayBreadcrumbConverter
-      // wraps a user's callback
-      val result = firstCallback.execute(b, h)
-      result?.let {
-        it.message = "${it.message} and second"
-        it
+    val firstCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, h ->
+        b.message = "modified by first"
+        b
+      }
+
+    val secondCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, h ->
+        // This simulates what happens when ReplayBreadcrumbConverter
+        // wraps a user's callback
+        val result = firstCallback.execute(b, h)
+        result?.let {
+          it.message = "${it.message} and second"
+          it
+        }
       }
-    }
 
     converter.setUserBeforeBreadcrumbCallback(secondCallback)
 
diff --git a/sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java b/sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java
index 958d31a13a2..f9a96074c1c 100644
--- a/sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java
+++ b/sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java
@@ -52,7 +52,6 @@ public RRWebOptionsEvent(final @NotNull SentryOptions options) {
     optionsPayload.put("quality", replayOptions.getQuality().serializedName());
     optionsPayload.put("maskedViewClasses", replayOptions.getMaskViewClasses());
     optionsPayload.put("unmaskedViewClasses", replayOptions.getUnmaskViewClasses());
-    optionsPayload.put("networkDetailHasUrls", true);
   }
 
   @NotNull
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java b/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
index ed5373ab9ea..065fa34309d 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
@@ -1,10 +1,7 @@
 package io.sentry.util.network;
 
-import io.sentry.SentryOptions;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
-import java.util.Set;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -22,7 +19,6 @@ public interface NetworkBodyExtractor<T> {
     NetworkBody extract(@NotNull T httpObject);
   }
 
-
   /** Functional interface for extracting headers from HTTP objects. */
   public interface NetworkHeaderExtractor<T> {
     @NotNull
@@ -39,9 +35,7 @@ public interface NetworkHeaderExtractor<T> {
       return null;
     }
 
-    // Create instance with basic info, details will be added later
-    NetworkRequestData result = new NetworkRequestData(method, null, null, null, null, null);
-    return result;
+    return new NetworkRequestData(method, null, null, null, null, null);
   }
 
   /**
@@ -57,7 +51,12 @@ public interface NetworkHeaderExtractor<T> {
       @NotNull NetworkHeaderExtractor<T> headerExtractor) {
 
     return createRequestOrResponseInternal(
-        httpObject, bodySize, networkCaptureBodies, bodyExtractor, networkRequestHeaders, headerExtractor);
+        httpObject,
+        bodySize,
+        networkCaptureBodies,
+        bodyExtractor,
+        networkRequestHeaders,
+        headerExtractor);
   }
 
   public static <T> @NotNull ReplayNetworkRequestOrResponse createResponse(
@@ -69,12 +68,17 @@ public interface NetworkHeaderExtractor<T> {
       @NotNull NetworkHeaderExtractor<T> headerExtractor) {
 
     return createRequestOrResponseInternal(
-        httpObject, bodySize, networkCaptureBodies, bodyExtractor, networkResponseHeaders, headerExtractor);
+        httpObject,
+        bodySize,
+        networkCaptureBodies,
+        bodyExtractor,
+        networkResponseHeaders,
+        headerExtractor);
   }
 
   /**
-   * Determines if detailed network data should be captured for the given URL.
-   * See https://docs.sentry.io/platforms/javascript/session-replay/configuration/
+   * Determines if detailed network data should be captured for the given URL. See
+   * <a href="https://docs.sentry.io/platforms/javascript/session-replay/configuration/">docs.sentry.io</a>
    *
    * @param url The URL to check
    * @param networkDetailAllowUrls Array of regex patterns that allow capture (null means allow all)
@@ -96,7 +100,7 @@ private static boolean shouldCaptureUrl(
     }
 
     // Only capture developer-provided urls.
-    if (networkDetailAllowUrls == null || networkDetailAllowUrls.length == 0) {
+    if (networkDetailAllowUrls == null) {
       return false;
     }
 
@@ -130,9 +134,12 @@ private static boolean shouldCaptureUrl(
   }
 
   private static <T> @NotNull ReplayNetworkRequestOrResponse createRequestOrResponseInternal(
-      @NotNull T httpObject, @Nullable Long bodySize,
-      boolean networkCaptureBodies, @NotNull NetworkBodyExtractor<T> bodyExtractor,
-      @NotNull String[] allowedHeaders, @NotNull NetworkHeaderExtractor<T> headerExtractor) {
+      @NotNull T httpObject,
+      @Nullable Long bodySize,
+      boolean networkCaptureBodies,
+      @NotNull NetworkBodyExtractor<T> bodyExtractor,
+      @NotNull String[] allowedHeaders,
+      @NotNull NetworkHeaderExtractor<T> headerExtractor) {
 
     NetworkBody body = null;
 
@@ -140,10 +147,9 @@ private static boolean shouldCaptureUrl(
       body = bodyExtractor.extract(httpObject);
     }
 
-    Map<String, String> headers = getCaptureHeaders(headerExtractor.extract(httpObject), allowedHeaders);
+    Map<String, String> headers =
+        getCaptureHeaders(headerExtractor.extract(httpObject), allowedHeaders);
 
     return new ReplayNetworkRequestOrResponse(bodySize, body, headers);
   }
 }
-
-
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java b/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
index 0b2f6387ee0..397cb402147 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
@@ -1,8 +1,8 @@
 package io.sentry.util.network;
 
-import io.sentry.SentryOptions;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.VisibleForTesting;
 
 /**
  * Data class for tracking network request and response information in replays. Used by various HTTP
@@ -18,7 +18,8 @@ public final class NetworkRequestData {
   private @Nullable ReplayNetworkRequestOrResponse request;
   private @Nullable ReplayNetworkRequestOrResponse response;
 
-  NetworkRequestData(
+  @VisibleForTesting
+  public NetworkRequestData(
       @Nullable String method,
       @Nullable Integer statusCode,
       @Nullable Long requestBodySize,
@@ -58,21 +59,20 @@ public final class NetworkRequestData {
   }
 
   /**
-   * Populates this instance with request details obtained via {@link NetworkDetailCaptureUtils#createRequest}
-   *
+   * Populates this instance with request details obtained via {@link
+   * NetworkDetailCaptureUtils#createRequest}
    */
-  public void setRequestDetails(
-      @NotNull ReplayNetworkRequestOrResponse requestData) {
+  public void setRequestDetails(@NotNull ReplayNetworkRequestOrResponse requestData) {
     this.request = requestData;
     this.requestBodySize = requestData.getSize();
   }
 
   /**
-   * Populates this instance with request details obtained via {@link NetworkDetailCaptureUtils#createResponse}
+   * Populates this instance with request details obtained via {@link
+   * NetworkDetailCaptureUtils#createResponse}
    */
   public void setResponseDetails(
-      int statusCode,
-      @NotNull ReplayNetworkRequestOrResponse responseData) {
+      int statusCode, @NotNull ReplayNetworkRequestOrResponse responseData) {
     this.statusCode = statusCode;
     this.response = responseData;
     this.responseBodySize = responseData.getSize();
diff --git a/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java b/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
index c131f27abe0..0c99481f145 100644
--- a/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
+++ b/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
@@ -1,15 +1,13 @@
 package io.sentry.util.network;
 
-import io.sentry.SentryOptions;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Map;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
- * Data class for tracking HTTP request or response information in replays.
- * See https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts
+ * Data class for tracking HTTP request or response information in replays. See
+ * <a href="https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts">JS SDK types</a>
  */
 public final class ReplayNetworkRequestOrResponse {
   private final @Nullable Long size;
@@ -20,7 +18,7 @@ public ReplayNetworkRequestOrResponse(
       @Nullable Long size, @Nullable NetworkBody body, @NotNull Map<String, String> headers) {
     this.size = size;
     this.body = body;
-    this.headers = headers != null ? headers : Collections.emptyMap();
+    this.headers = headers;
   }
 
   public @Nullable Long getSize() {

From 6b6f3fe5662d594754d78fbadafb6db964ea3741 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 14:46:17 -0400
Subject: [PATCH 16/28] Linter

---
 .../java/io/sentry/okhttp/SentryOkHttpInterceptor.kt   | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index e1c24e4a13d..3beb3d04e43 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -115,7 +115,7 @@ public open class SentryOkHttpInterceptor(
     var response: Response? = null
     var code: Int? = null
 
-    var networkDetailData = NetworkDetailCaptureUtils.initializeForUrl(
+    val networkDetailData = NetworkDetailCaptureUtils.initializeForUrl(
       request.url.toString(),
       request.method,
       FAKE_OPTIONS.networkDetailAllowUrls,
@@ -212,12 +212,12 @@ public open class SentryOkHttpInterceptor(
       // this only works correctly if SentryOkHttpInterceptor is the last one in the chain
       okHttpEvent?.setRequest(request)
 
-      response?.let { response ->
+      response?.let {
         networkDetailData?.setResponseDetails(
-          response.code,
+          it.code,
           NetworkDetailCaptureUtils.createResponse(
-            response,
-            response.body?.contentLength(),
+            it,
+            it.body?.contentLength(),
             FAKE_OPTIONS.networkCaptureBodies,
             { resp: Response -> resp.extractResponseBody() },
             FAKE_OPTIONS.networkResponseHeaders,

From cadc5290f2aa473df3b39b67902c2840b4d3f977 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 15:48:35 -0400
Subject: [PATCH 17/28] Linter and clean-up unused code

---
 .../io/sentry/util/network/NetworkBody.java   | 108 +-----------------
 1 file changed, 1 insertion(+), 107 deletions(-)

diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
index 6fb6f56002d..dc60e55ed3c 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
@@ -10,7 +10,7 @@
  * array, or string.
  *
  * <p>See
- * https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts
+ * <a href="https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts">Javascript types</a>
  */
 public interface NetworkBody {
 
@@ -52,73 +52,6 @@ public interface NetworkBody {
   @NotNull
   Object getValue();
 
-  /**
-   * Checks if this NetworkBody represents a JSON object.
-   *
-   * @return true if this is a JSON object
-   */
-  default boolean isJsonObject() {
-    return getValue() instanceof Map;
-  }
-
-  /**
-   * Checks if this NetworkBody represents a JSON array.
-   *
-   * @return true if this is a JSON array
-   */
-  default boolean isJsonArray() {
-    return getValue() instanceof List;
-  }
-
-  /**
-   * Checks if this NetworkBody represents string content.
-   *
-   * @return true if this is a string
-   */
-  default boolean isString() {
-    return getValue() instanceof String;
-  }
-
-  /**
-   * Gets the value as a JSON object (Map).
-   *
-   * @return The Map if this is a JSON object, null otherwise
-   */
-  default @Nullable Map<String, Object> asJsonObject() {
-    Object value = getValue();
-    if (value instanceof Map) {
-      @SuppressWarnings("unchecked")
-      Map<String, Object> map = (Map<String, Object>) value;
-      return map;
-    }
-    return null;
-  }
-
-  /**
-   * Gets the value as a JSON array (List).
-   *
-   * @return The List if this is a JSON array, null otherwise
-   */
-  default @Nullable List<Object> asJsonArray() {
-    Object value = getValue();
-    if (value instanceof List) {
-      @SuppressWarnings("unchecked")
-      List<Object> list = (List<Object>) value;
-      return list;
-    }
-    return null;
-  }
-
-  /**
-   * Gets the value as a string.
-   *
-   * @return The String if this is string content, null otherwise
-   */
-  default @Nullable String asString() {
-    Object value = getValue();
-    return value instanceof String ? (String) value : null;
-  }
-
   // Private implementation classes
 
   /** Implementation for JSON object bodies */
@@ -138,19 +71,6 @@ final class JsonObjectImpl implements NetworkBody {
     public String toString() {
       return "NetworkBody.JsonObject{" + value + '}';
     }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (this == obj) return true;
-      if (!(obj instanceof JsonObjectImpl)) return false;
-      JsonObjectImpl that = (JsonObjectImpl) obj;
-      return value.equals(that.value);
-    }
-
-    @Override
-    public int hashCode() {
-      return value.hashCode();
-    }
   }
 
   /** Implementation for JSON array bodies */
@@ -170,19 +90,6 @@ final class JsonArrayImpl implements NetworkBody {
     public String toString() {
       return "NetworkBody.JsonArray{" + value + '}';
     }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (this == obj) return true;
-      if (!(obj instanceof JsonArrayImpl)) return false;
-      JsonArrayImpl that = (JsonArrayImpl) obj;
-      return value.equals(that.value);
-    }
-
-    @Override
-    public int hashCode() {
-      return value.hashCode();
-    }
   }
 
   /** Implementation for string bodies */
@@ -202,18 +109,5 @@ final class StringBodyImpl implements NetworkBody {
     public String toString() {
       return "NetworkBody.StringBody{" + value + '}';
     }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (this == obj) return true;
-      if (!(obj instanceof StringBodyImpl)) return false;
-      StringBodyImpl that = (StringBodyImpl) obj;
-      return value.equals(that.value);
-    }
-
-    @Override
-    public int hashCode() {
-      return value.hashCode();
-    }
   }
 }

From 465b6e592fe971d0f6a903ce779a7cfc73dd1fae Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 15:50:01 -0400
Subject: [PATCH 18/28] Add additional http request types to sentry-samples app
 for testing

One-shot bodies
Form bodies
plain text bodies
binary bodies
---
 .../android/TriggerHttpRequestActivity.java   | 229 +++++++++++++++++-
 .../layout/activity_trigger_http_request.xml  |  56 ++++-
 2 files changed, 280 insertions(+), 5 deletions(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
index 14ed1d9d1dc..2648f01cc16 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
@@ -14,7 +14,9 @@
 import io.sentry.SentryLevel;
 import io.sentry.okhttp.SentryOkHttpEventListener;
 import io.sentry.okhttp.SentryOkHttpInterceptor;
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.text.SimpleDateFormat;
 import java.util.Arrays;
 import java.util.Date;
@@ -37,6 +39,10 @@ public class TriggerHttpRequestActivity extends AppCompatActivity {
     private ProgressBar loadingIndicator;
     private Button getButton;
     private Button postButton;
+    private Button formButton;
+    private Button binaryButton;
+    private Button stringButton;
+    private Button oneShotButton;
     private Button clearButton;
 
     private OkHttpClient okHttpClient;
@@ -61,6 +67,10 @@ private void initializeViews() {
         loadingIndicator = findViewById(R.id.loading_indicator);
         getButton = findViewById(R.id.trigger_get_request);
         postButton = findViewById(R.id.trigger_post_request);
+        formButton = findViewById(R.id.trigger_form_request);
+        binaryButton = findViewById(R.id.trigger_binary_request);
+        stringButton = findViewById(R.id.trigger_string_request);
+        oneShotButton = findViewById(R.id.trigger_oneshot_request);
         clearButton = findViewById(R.id.clear_display);
 
         requestDisplay.setMovementMethod(new ScrollingMovementMethod());
@@ -82,7 +92,11 @@ private void setupOkHttpClient() {
 
     private void setupClickListeners() {
         getButton.setOnClickListener(v -> performGetRequest());
-        postButton.setOnClickListener(v -> performPostRequest());
+        postButton.setOnClickListener(v -> performJsonRequest());
+        formButton.setOnClickListener(v -> performFormUrlencodedRequest());
+        binaryButton.setOnClickListener(v -> performOctetStreamRequest());
+        stringButton.setOnClickListener(v -> performTextPlainRequest());
+        oneShotButton.setOnClickListener(v -> performOneShotJsonRequest());
         clearButton.setOnClickListener(v -> clearDisplays());
     }
 
@@ -104,7 +118,7 @@ private void performGetRequest() {
         executeRequest(request);
     }
 
-    private void performPostRequest() {
+    private void performJsonRequest() {
         String url = getUrl();
         if (url.isEmpty()) {
             Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
@@ -113,6 +127,8 @@ private void performPostRequest() {
 
         try {
             JSONObject json = new JSONObject();
+            json.put("request_type", "POST_JSON");
+            json.put("button_clicked", "POST JSON");
             json.put("message", "Hello from Sentry Android Sample");
             json.put("timestamp", System.currentTimeMillis());
             json.put("device", android.os.Build.MODEL);
@@ -128,6 +144,7 @@ private void performPostRequest() {
                 .addHeader("User-Agent", "Sentry-Sample-Android")
                 .addHeader("Content-Type", "application/json")
                 .addHeader("Accept", "application/json")
+                .addHeader("X-Request-Type", "POST_JSON")
                 .build();
 
             displayRequest("POST", request, json.toString(2));
@@ -262,6 +279,214 @@ private void showLoading(boolean show) {
         loadingIndicator.setVisibility(show ? View.VISIBLE : View.GONE);
         getButton.setEnabled(!show);
         postButton.setEnabled(!show);
+        formButton.setEnabled(!show);
+        binaryButton.setEnabled(!show);
+        stringButton.setEnabled(!show);
+        oneShotButton.setEnabled(!show);
+    }
+
+    private void performFormUrlencodedRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        try {
+            // Create URL-encoded form data
+            String formData = "request_type=POST_FORM_URLENCODED&" +
+                             "button_clicked=POST%20Form&" +
+                             "username=sentry_android_user&" +
+                             "email=test@example.com&" +
+                             "message=Hello%20from%20Android%20Sample%20Form%20Request&" +
+                             "timestamp=" + System.currentTimeMillis() + "&" +
+                             "device=" + android.os.Build.MODEL.replace(" ", "%20");
+
+            RequestBody body = RequestBody.create(
+                formData,
+                MediaType.get("application/x-www-form-urlencoded")
+            );
+
+            Request request = new Request.Builder()
+                .url(url)
+                .post(body)
+                .addHeader("User-Agent", "Sentry-Sample-Android")
+                .addHeader("Content-Type", "application/x-www-form-urlencoded")
+                .addHeader("X-Request-Type", "POST_FORM_URLENCODED")
+                .build();
+
+            displayRequest("POST", request, formData);
+            executeRequest(request);
+        } catch (Exception e) {
+            Sentry.captureException(e);
+            Toast.makeText(this, "Error creating form request: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    private void performOctetStreamRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        try {
+            // Add request type to URL as query parameter for binary requests
+            String separator = url.contains("?") ? "&" : "?";
+            String urlWithType = url + separator + "request_type=POST_BINARY&button=POST_Binary";
+
+            // Create binary data (simulate a small file upload)
+            byte[] binaryData = new byte[1024]; // 1KB of binary data
+            for (int i = 0; i < binaryData.length; i++) {
+                binaryData[i] = (byte) (i % 256);
+            }
+
+            RequestBody body = RequestBody.create(
+                binaryData,
+                MediaType.get("application/octet-stream")
+            );
+
+            Request request = new Request.Builder()
+                .url(urlWithType)
+                .post(body)
+                .addHeader("User-Agent", "Sentry-Sample-Android")
+                .addHeader("Content-Type", "application/octet-stream")
+                .addHeader("Content-Length", String.valueOf(binaryData.length))
+                .addHeader("X-Request-Type", "POST_BINARY")
+                .build();
+
+            String displayBody = "[Binary data: " + binaryData.length + " bytes]\n" +
+                               "Request type in URL: POST_BINARY\n" +
+                               "Sample bytes: " + Arrays.toString(Arrays.copyOf(binaryData, Math.min(10, binaryData.length)));
+
+            displayRequest("POST", request, displayBody);
+            executeRequest(request);
+        } catch (Exception e) {
+            Sentry.captureException(e);
+            Toast.makeText(this, "Error creating binary request: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    private void performTextPlainRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        try {
+            // Create plain text string data with request type identifier
+            String textData = "REQUEST_TYPE: POST_STRING\n" +
+                            "BUTTON_CLICKED: POST String\n" +
+                            "Hello from Sentry Android Sample!\n" +
+                            "This is a plain text request body.\n" +
+                            "Timestamp: " + new Date().toString() + "\n" +
+                            "Device: " + android.os.Build.MODEL + "\n" +
+                            "SDK Version: " + android.os.Build.VERSION.SDK_INT + "\n" +
+                            "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+
+            RequestBody body = RequestBody.create(
+                textData,
+                MediaType.get("text/plain; charset=utf-8")
+            );
+
+            Request request = new Request.Builder()
+                .url(url)
+                .post(body)
+                .addHeader("User-Agent", "Sentry-Sample-Android")
+                .addHeader("Content-Type", "text/plain; charset=utf-8")
+                .addHeader("X-Request-Type", "POST_STRING")
+                .build();
+
+            displayRequest("POST", request, textData);
+            executeRequest(request);
+        } catch (Exception e) {
+            Sentry.captureException(e);
+            Toast.makeText(this, "Error creating string request: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    private void performOneShotJsonRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        try {
+            // Add request type to URL as query parameter for one-shot requests  
+            String separator = url.contains("?") ? "&" : "?";
+            String urlWithType = url + separator + "request_type=POST_ONE_SHOT&button=POST_OneShotBody";
+
+            // Create JSON data for one-shot request body
+            JSONObject json = new JSONObject();
+            json.put("request_type", "POST_ONE_SHOT");
+            json.put("button_clicked", "POST One-Shot");
+            json.put("message", "This is a ONE-SHOT REQUEST BODY - can only be read once!");
+            json.put("timestamp", System.currentTimeMillis());
+            json.put("device", android.os.Build.MODEL);
+            json.put("warning", "Reading this body multiple times will cause IOException");
+
+            String jsonString = json.toString();
+            byte[] bodyBytes = jsonString.getBytes("UTF-8");
+
+            // Create a TRUE one-shot request body that will fail if read multiple times
+            RequestBody oneShotBody = new RequestBody() {
+                private InputStream inputStream = new ByteArrayInputStream(bodyBytes);
+                private boolean hasBeenRead = false;
+
+                @Override
+                public MediaType contentType() {
+                    return MediaType.get("application/json; charset=utf-8");
+                }
+
+                @Override
+                public long contentLength() {
+                    return bodyBytes.length;
+                }
+
+                @Override
+                public void writeTo(okio.BufferedSink sink) throws IOException {
+                    if (hasBeenRead) {
+                        throw new IOException("One-shot body has already been read! This would happen in real scenarios with FileInputStream or other non-repeatable streams.");
+                    }
+                    
+                    hasBeenRead = true;
+                    
+                    try {
+                        byte[] buffer = new byte[8192];
+                        int bytesRead;
+                        while ((bytesRead = inputStream.read(buffer)) != -1) {
+                            sink.write(buffer, 0, bytesRead);
+                        }
+                    } finally {
+                        inputStream.close();
+                    }
+                }
+            };
+
+            Request request = new Request.Builder()
+                .url(urlWithType)
+                .post(oneShotBody)
+                .addHeader("User-Agent", "Sentry-Sample-Android")
+                .addHeader("Content-Type", "application/json; charset=utf-8")
+                .addHeader("X-Request-Type", "POST_ONE_SHOT")
+                .addHeader("X-Body-Type", "ONE_SHOT_STREAM")
+                .build();
+
+            String displayBody = "[ONE-SHOT REQUEST BODY]\n" +
+                               "Type: InputStream-based RequestBody\n" +
+                               "Size: " + bodyBytes.length + " bytes\n" +
+                               "Content: " + json.toString(2) + "\n" +
+                               "\nWARNING: This body can only be read once!\n" +
+                               "If interceptors try to read it multiple times, it will fail.";
+
+            displayRequest("POST", request, displayBody);
+            executeRequest(request);
+        } catch (Exception e) {
+            Sentry.captureException(e);
+            Toast.makeText(this, "Error creating one-shot request: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        }
     }
 
     private String getCurrentTime() {
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
index ee216d4ae47..48d0fb32a48 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
@@ -49,15 +49,65 @@
         android:layout_height="wrap_content"
         android:layout_weight="1"
         android:text="GET Request"
-        android:layout_marginEnd="8dp"/>
+        android:layout_marginEnd="4dp"/>
 
       <Button
         android:id="@+id/trigger_post_request"
         android:layout_width="0dp"
         android:layout_height="wrap_content"
         android:layout_weight="1"
-        android:text="POST Request"
-        android:layout_marginStart="8dp"/>
+        android:text="POST JSON"
+        android:layout_marginStart="4dp"
+        android:layout_marginEnd="4dp"/>
+
+    </LinearLayout>
+
+    <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      android:layout_marginBottom="16dp">
+
+      <Button
+        android:id="@+id/trigger_form_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="POST Form"
+        android:layout_marginEnd="4dp"/>
+
+      <Button
+        android:id="@+id/trigger_binary_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="POST Binary"
+        android:layout_marginStart="4dp"
+        android:layout_marginEnd="4dp"/>
+
+      <Button
+        android:id="@+id/trigger_string_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="POST String"
+        android:layout_marginStart="4dp"/>
+
+    </LinearLayout>
+
+    <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      android:layout_marginBottom="16dp">
+
+      <Button
+        android:id="@+id/trigger_oneshot_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="POST One-Shot"
+        android:layout_marginEnd="4dp"/>
 
     </LinearLayout>
 

From 6ab8e03cf07a03e039ee29fbe9edf83efbd2c8bc Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 16:12:31 -0400
Subject: [PATCH 19/28] Cleaning up logging

---
 .../DefaultReplayBreadcrumbConverter.kt       | 46 ++-----------------
 .../sentry/okhttp/SentryOkHttpInterceptor.kt  |  7 +--
 .../io/sentry/util/network/NetworkBody.java   |  1 -
 3 files changed, 4 insertions(+), 50 deletions(-)

diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
index d2f746f828d..24bfcb91389 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
@@ -1,6 +1,5 @@
 package io.sentry.android.replay
 
-import android.util.Log
 import io.sentry.Breadcrumb
 import io.sentry.Hint
 import io.sentry.ReplayBreadcrumbConverter
@@ -157,10 +156,6 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
       }
     }
 
-    Log.d(
-      "SentryNetwork",
-      "SentryNetwork: BeforeBreadcrumbCallback - Hint: $hint, Breadcrumb: $result",
-    )
     return result
   }
 
@@ -174,39 +169,12 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
 
     val networkDetails = breadcrumbHint.get("replay:networkDetails") as? NetworkRequestData
     if (networkDetails != null) {
-      Log.d(
-        "SentryNetwork",
-        "SentryNetwork: Found structured NetworkRequestData in hint: $networkDetails",
-      )
       return networkDetails
     }
-
-    Log.d("SentryNetwork", "SentryNetwork: No structured NetworkRequestData found on hint")
     return null
   }
 
-  private fun Breadcrumb.isValidForRRWebSpan(): Boolean {
-    val url = data["url"] as? String
-    val hasStartTimestamp = SpanDataConvention.HTTP_START_TIMESTAMP in data
-    val hasEndTimestamp = SpanDataConvention.HTTP_END_TIMESTAMP in data
-
-    val urlValid = !url.isNullOrEmpty()
-    val isValid = urlValid && hasStartTimestamp && hasEndTimestamp
-
-    val reasons = mutableListOf<String>()
-    if (!urlValid) reasons.add("missing or empty URL")
-    if (!hasStartTimestamp) reasons.add("missing start timestamp")
-    if (!hasEndTimestamp) reasons.add("missing end timestamp")
-
-    Log.d(
-      "SentryReplay",
-      "Breadcrumb RRWeb span validation: ${if (isValid) "VALID" else "INVALID"}" +
-        if (!isValid) " (${reasons.joinToString(", ")})"
-        else "" + " - URL: ${url ?: "null"}, Category: ${category}",
-    )
-
-    return isValid
-  }
+  private fun Breadcrumb.isValidForRRWebSpan(): Boolean = !(data["url"] as? String).isNullOrEmpty() && SpanDataConvention.HTTP_START_TIMESTAMP in data && SpanDataConvention.HTTP_END_TIMESTAMP in data
 
   private fun String.snakeToCamelCase(): String =
     replace(snakecasePattern) { it.value.last().toString().uppercase() }
@@ -216,15 +184,6 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     val httpStartTimestamp = breadcrumb.data[SpanDataConvention.HTTP_START_TIMESTAMP]
     val httpEndTimestamp = breadcrumb.data[SpanDataConvention.HTTP_END_TIMESTAMP]
 
-    // Get the NetworkRequestData if available and remove it from the map
-    val networkDetailData = httpNetworkDetails.remove(breadcrumb)
-
-    Log.d(
-      "SentryNetwork",
-      "SentryNetwork: convert(breadcrumb=${breadcrumb.type}) httpNetworkDetails map size: ${httpNetworkDetails.size}, " +
-        "found network data for current breadcrumb: ${networkDetailData != null}",
-    )
-
     return RRWebSpanEvent().apply {
       timestamp = breadcrumb.timestamp.time
       op = "resource.http"
@@ -245,7 +204,8 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
 
       val breadcrumbData = mutableMapOf<String, Any?>()
 
-      // Add data from NetworkRequestData if available
+      val networkDetailData = httpNetworkDetails.remove(breadcrumb)
+      // Add Network Details data when available
       networkDetailData?.let { networkData ->
         networkData.method?.let { breadcrumbData["method"] = it }
         networkData.statusCode?.let { breadcrumbData["statusCode"] = it }
diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index 3beb3d04e43..91f82d85a61 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -333,10 +333,6 @@ public open class SentryOkHttpInterceptor(
 
         val contentLength = responseBody.contentLength()
         if (contentLength > maxBodySize * 2) {
-          scopes.options.logger.log(
-            io.sentry.SentryLevel.DEBUG,
-            "Response body too large: $contentLength bytes (max: $maxBodySize)",
-          )
           return NetworkBody.fromString("[Response body too large: $contentLength bytes]")
         }
 
@@ -353,10 +349,9 @@ public open class SentryOkHttpInterceptor(
           scopes.options,
         )
       } catch (e: Exception) {
-        // If body reading fails, log and return null
         scopes.options.logger.log(
           io.sentry.SentryLevel.DEBUG,
-          "Failed to read response body safely: ${e.message}",
+          "Failed to read http response body for Network Details: ${e.message}",
         )
         null
       }
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
index dc60e55ed3c..625ec95fa5e 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
@@ -3,7 +3,6 @@
 import java.util.List;
 import java.util.Map;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * Represents the body content of a network request or response. Can be one of: JSON object, JSON

From d3f1a2457b2de69737c25c210322daaad20448db Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 16:16:20 -0400
Subject: [PATCH 20/28] Formatting

---
 .../DefaultReplayBreadcrumbConverter.kt       | 165 ++++++++++--------
 1 file changed, 92 insertions(+), 73 deletions(-)

diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
index 24bfcb91389..450d55e9f79 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
@@ -14,31 +14,33 @@ import java.util.Collections
 import kotlin.LazyThreadSafetyMode.NONE
 
 public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
+
   internal companion object {
     private const val MAX_HTTP_NETWORK_DETAILS = 32
     private val snakecasePattern by lazy(NONE) { "_[a-z]".toRegex() }
-    private val supportedNetworkData =
-      HashSet<String>().apply {
-        add("status_code")
-        add("method")
-        add("response_content_length")
-        add("request_content_length")
-        add("http.response_content_length")
-        add("http.request_content_length")
-      }
+    
+    private val supportedNetworkData = HashSet<String>().apply {
+      add("status_code")
+      add("method")
+      add("response_content_length")
+      add("request_content_length")
+      add("http.response_content_length")
+      add("http.request_content_length")
+    }
   }
 
   private var lastConnectivityState: String? = null
-  private val httpNetworkDetails =
-    Collections.synchronizedMap(
-      object : LinkedHashMap<Breadcrumb, NetworkRequestData>() {
-        override fun removeEldestEntry(
-          eldest: MutableMap.MutableEntry<Breadcrumb, NetworkRequestData>?
-        ): Boolean {
-          return size > MAX_HTTP_NETWORK_DETAILS
-        }
+  
+  private val httpNetworkDetails = Collections.synchronizedMap(
+    object : LinkedHashMap<Breadcrumb, NetworkRequestData>() {
+      override fun removeEldestEntry(
+        eldest: MutableMap.MutableEntry<Breadcrumb, NetworkRequestData>?
+      ): Boolean {
+        return size > MAX_HTTP_NETWORK_DETAILS
       }
-    )
+    }
+  )
+  
   private var userBeforeBreadcrumbCallback: BeforeBreadcrumbCallback? = null
 
   override fun convert(breadcrumb: Breadcrumb): RRWebEvent? {
@@ -46,9 +48,14 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     val breadcrumbCategory: String?
     var breadcrumbLevel: SentryLevel? = null
     val breadcrumbData = mutableMapOf<String, Any?>()
+    
     when {
       breadcrumb.category == "http" -> {
-        return if (breadcrumb.isValidForRRWebSpan()) breadcrumb.toRRWebSpanEvent() else null
+        return if (breadcrumb.isValidForRRWebSpan()) {
+          breadcrumb.toRRWebSpanEvent()
+        } else {
+          null
+        }
       }
 
       breadcrumb.type == "navigation" && breadcrumb.category == "app.lifecycle" -> {
@@ -58,6 +65,7 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
       breadcrumb.type == "navigation" && breadcrumb.category == "device.orientation" -> {
         breadcrumbCategory = breadcrumb.category!!
         val position = breadcrumb.data["position"]
+        
         if (position == "landscape" || position == "portrait") {
           breadcrumbData["position"] = position
         } else {
@@ -67,42 +75,42 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
 
       breadcrumb.type == "navigation" -> {
         breadcrumbCategory = "navigation"
-        breadcrumbData["to"] =
-          when {
-            breadcrumb.data["state"] == "resumed" ->
-              (breadcrumb.data["screen"] as? String)?.substringAfterLast('.')
-            "to" in breadcrumb.data -> breadcrumb.data["to"] as? String
-            else -> null
-          } ?: return null
+        breadcrumbData["to"] = when {
+          breadcrumb.data["state"] == "resumed" -> {
+            (breadcrumb.data["screen"] as? String)?.substringAfterLast('.')
+          }
+          "to" in breadcrumb.data -> breadcrumb.data["to"] as? String
+          else -> null
+        } ?: return null
       }
 
       breadcrumb.category == "ui.click" -> {
         breadcrumbCategory = "ui.tap"
-        breadcrumbMessage =
-          (breadcrumb.data["view.id"]
+        breadcrumbMessage = (
+          breadcrumb.data["view.id"]
             ?: breadcrumb.data["view.tag"]
-            ?: breadcrumb.data["view.class"])
-            as? String ?: return null
+            ?: breadcrumb.data["view.class"]
+        ) as? String ?: return null
+        
         breadcrumbData.putAll(breadcrumb.data)
       }
 
       breadcrumb.type == "system" && breadcrumb.category == "network.event" -> {
         breadcrumbCategory = "device.connectivity"
-        breadcrumbData["state"] =
-          when {
-            breadcrumb.data["action"] == "NETWORK_LOST" -> "offline"
-            "network_type" in breadcrumb.data ->
-              if (!(breadcrumb.data["network_type"] as? String).isNullOrEmpty()) {
-                breadcrumb.data["network_type"]
-              } else {
-                return null
-              }
-
-            else -> return null
+        breadcrumbData["state"] = when {
+          breadcrumb.data["action"] == "NETWORK_LOST" -> "offline"
+          "network_type" in breadcrumb.data -> {
+            if (!(breadcrumb.data["network_type"] as? String).isNullOrEmpty()) {
+              breadcrumb.data["network_type"]
+            } else {
+              return null
+            }
           }
+          else -> return null
+        }
 
         if (lastConnectivityState == breadcrumbData["state"]) {
-          // debounce same state
+          // Debounce same state
           return null
         }
 
@@ -111,7 +119,9 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
 
       breadcrumb.data["action"] == "BATTERY_CHANGED" -> {
         breadcrumbCategory = "device.battery"
-        breadcrumbData.putAll(breadcrumb.data.filterKeys { it == "level" || it == "charging" })
+        breadcrumbData.putAll(
+          breadcrumb.data.filterKeys { it == "level" || it == "charging" }
+        )
       }
 
       else -> {
@@ -121,6 +131,7 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
         breadcrumbData.putAll(breadcrumb.data)
       }
     }
+    
     return if (!breadcrumbCategory.isNullOrEmpty()) {
       RRWebBreadcrumbEvent().apply {
         timestamp = breadcrumb.timestamp.time
@@ -143,12 +154,11 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
   /** Delegate to user-provided callback (if exists) to provide the final breadcrumb to process. */
   override fun execute(breadcrumb: Breadcrumb, hint: Hint): Breadcrumb? {
     val callback = userBeforeBreadcrumbCallback
-    val result =
-      if (callback != null) {
-        callback.execute(breadcrumb, hint)
-      } else {
-        breadcrumb
-      }
+    val result = if (callback != null) {
+      callback.execute(breadcrumb, hint)
+    } else {
+      breadcrumb
+    }
 
     result?.let { finalBreadcrumb ->
       extractNetworkRequestDataFromHint(finalBreadcrumb, hint)?.let { networkData ->
@@ -167,17 +177,18 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
       return null
     }
 
-    val networkDetails = breadcrumbHint.get("replay:networkDetails") as? NetworkRequestData
-    if (networkDetails != null) {
-      return networkDetails
-    }
-    return null
+    return breadcrumbHint.get("replay:networkDetails") as? NetworkRequestData
   }
 
-  private fun Breadcrumb.isValidForRRWebSpan(): Boolean = !(data["url"] as? String).isNullOrEmpty() && SpanDataConvention.HTTP_START_TIMESTAMP in data && SpanDataConvention.HTTP_END_TIMESTAMP in data
+  private fun Breadcrumb.isValidForRRWebSpan(): Boolean {
+    return !(data["url"] as? String).isNullOrEmpty() &&
+      SpanDataConvention.HTTP_START_TIMESTAMP in data &&
+      SpanDataConvention.HTTP_END_TIMESTAMP in data
+  }
 
-  private fun String.snakeToCamelCase(): String =
-    replace(snakecasePattern) { it.value.last().toString().uppercase() }
+  private fun String.snakeToCamelCase(): String {
+    return replace(snakecasePattern) { it.value.last().toString().uppercase() }
+  }
 
   private fun Breadcrumb.toRRWebSpanEvent(): RRWebSpanEvent {
     val breadcrumb = this
@@ -188,23 +199,24 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
       timestamp = breadcrumb.timestamp.time
       op = "resource.http"
       description = breadcrumb.data["url"] as String
-      // can be double if it was serialized to disk
-      startTimestamp =
-        if (httpStartTimestamp is Double) {
-          httpStartTimestamp / 1000.0
-        } else {
-          (httpStartTimestamp as Long) / 1000.0
-        }
-      endTimestamp =
-        if (httpEndTimestamp is Double) {
-          httpEndTimestamp / 1000.0
-        } else {
-          (httpEndTimestamp as Long) / 1000.0
-        }
+      
+      // Can be double if it was serialized to disk
+      startTimestamp = if (httpStartTimestamp is Double) {
+        httpStartTimestamp / 1000.0
+      } else {
+        (httpStartTimestamp as Long) / 1000.0
+      }
+      
+      endTimestamp = if (httpEndTimestamp is Double) {
+        httpEndTimestamp / 1000.0
+      } else {
+        (httpEndTimestamp as Long) / 1000.0
+      }
 
       val breadcrumbData = mutableMapOf<String, Any?>()
 
       val networkDetailData = httpNetworkDetails.remove(breadcrumb)
+      
       // Add Network Details data when available
       networkDetailData?.let { networkData ->
         networkData.method?.let { breadcrumbData["method"] = it }
@@ -216,9 +228,11 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
           val requestData = mutableMapOf<String, Any?>()
           request.size?.let { requestData["size"] = it }
           request.body?.let { requestData["body"] = it }
+          
           if (request.headers.isNotEmpty()) {
             requestData["headers"] = request.headers
           }
+          
           if (requestData.isNotEmpty()) {
             breadcrumbData["request"] = requestData
           }
@@ -228,20 +242,25 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
           val responseData = mutableMapOf<String, Any?>()
           response.size?.let { responseData["size"] = it }
           response.body?.let { responseData["body"] = it }
+          
           if (response.headers.isNotEmpty()) {
             responseData["headers"] = response.headers
           }
+          
           if (responseData.isNotEmpty()) {
             breadcrumbData["response"] = responseData
           }
         }
       }
+      
       // Original breadcrumb http data
       for ((key, value) in breadcrumb.data) {
         if (key in supportedNetworkData) {
-          breadcrumbData[
-            key.replace("content_length", "body_size").substringAfter(".").snakeToCamelCase(),
-          ] = value
+          val formattedKey = key
+            .replace("content_length", "body_size")
+            .substringAfter(".")
+            .snakeToCamelCase()
+          breadcrumbData[formattedKey] = value
         }
       }
 

From 9eba521022c6c7bc20ba0ce36d7a6281268124c2 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 16:17:02 -0400
Subject: [PATCH 21/28] Add body too large http request types to sentry-samples
 app

---
 .../android/TriggerHttpRequestActivity.java   | 127 ++++++++++++++++++
 .../layout/activity_trigger_http_request.xml  |  24 ++++
 2 files changed, 151 insertions(+)

diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
index 2648f01cc16..c23a23deb76 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
@@ -43,6 +43,8 @@ public class TriggerHttpRequestActivity extends AppCompatActivity {
     private Button binaryButton;
     private Button stringButton;
     private Button oneShotButton;
+    private Button largeTextButton;
+    private Button largeBinaryButton;
     private Button clearButton;
 
     private OkHttpClient okHttpClient;
@@ -71,6 +73,8 @@ private void initializeViews() {
         binaryButton = findViewById(R.id.trigger_binary_request);
         stringButton = findViewById(R.id.trigger_string_request);
         oneShotButton = findViewById(R.id.trigger_oneshot_request);
+        largeTextButton = findViewById(R.id.trigger_large_text_request);
+        largeBinaryButton = findViewById(R.id.trigger_large_binary_request);
         clearButton = findViewById(R.id.clear_display);
 
         requestDisplay.setMovementMethod(new ScrollingMovementMethod());
@@ -97,6 +101,8 @@ private void setupClickListeners() {
         binaryButton.setOnClickListener(v -> performOctetStreamRequest());
         stringButton.setOnClickListener(v -> performTextPlainRequest());
         oneShotButton.setOnClickListener(v -> performOneShotJsonRequest());
+        largeTextButton.setOnClickListener(v -> performLargeTextPlainRequest());
+        largeBinaryButton.setOnClickListener(v -> performLargeOctetStreamRequest());
         clearButton.setOnClickListener(v -> clearDisplays());
     }
 
@@ -283,6 +289,8 @@ private void showLoading(boolean show) {
         binaryButton.setEnabled(!show);
         stringButton.setEnabled(!show);
         oneShotButton.setEnabled(!show);
+        largeTextButton.setEnabled(!show);
+        largeBinaryButton.setEnabled(!show);
     }
 
     private void performFormUrlencodedRequest() {
@@ -489,6 +497,125 @@ public void writeTo(okio.BufferedSink sink) throws IOException {
         }
     }
 
+    private void performLargeTextPlainRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        try {
+            // Add request type to URL for identification
+            String separator = url.contains("?") ? "&" : "?";
+            String urlWithType = url + separator + "request_type=POST_LARGE_TEXT&button=POST_LargeText";
+
+            // Create large text data that exceeds MAX_NETWORK_BODY_SIZE (150KB)
+            // Target size: 200KB (204,800 bytes)
+            int targetSize = 200 * 1024; // 200KB
+            StringBuilder largeText = new StringBuilder();
+            
+            largeText.append("REQUEST_TYPE: POST_LARGE_TEXT\n");
+            largeText.append("BUTTON_CLICKED: POST Large Text\n");
+            largeText.append("SIZE_TARGET: ").append(targetSize).append(" bytes (exceeds 150KB limit)\n");
+            largeText.append("TIMESTAMP: ").append(new Date()).append("\n");
+            largeText.append("DEVICE: ").append(android.os.Build.MODEL).append("\n");
+            largeText.append("WARNING: This body size exceeds MAX_NETWORK_BODY_SIZE!\n\n");
+
+            // Fill with repeated content to reach target size
+            String filler = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ";
+            
+            int currentSize = largeText.length();
+            while (currentSize < targetSize) {
+                largeText.append("FILLER_LINE_").append(currentSize / filler.length()).append(": ").append(filler);
+                currentSize = largeText.length();
+            }
+
+            String textData = largeText.toString();
+            
+            RequestBody body = RequestBody.create(
+                textData,
+                MediaType.get("text/plain; charset=utf-8")
+            );
+
+            Request request = new Request.Builder()
+                .url(urlWithType)
+                .post(body)
+                .addHeader("User-Agent", "Sentry-Sample-Android")
+                .addHeader("Content-Type", "text/plain; charset=utf-8")
+                .addHeader("X-Request-Type", "POST_LARGE_TEXT")
+                .addHeader("X-Body-Size", String.valueOf(textData.length()))
+                .build();
+
+            String displayBody = "[LARGE TEXT REQUEST BODY]\n" +
+                               "Type: text/plain\n" +
+                               "Size: " + textData.length() + " bytes (" + (textData.length() / 1024) + "KB)\n" +
+                               "Limit: 153,600 bytes (150KB)\n" +
+                               "Status: " + (textData.length() > 153600 ? "EXCEEDS LIMIT" : "Within limit") + "\n" +
+                               "Preview: " + textData.substring(0, Math.min(200, textData.length())) + "...";
+
+            displayRequest("POST", request, displayBody);
+            executeRequest(request);
+        } catch (Exception e) {
+            Sentry.captureException(e);
+            Toast.makeText(this, "Error creating large text request: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    private void performLargeOctetStreamRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        try {
+            // Add request type to URL for identification (binary bodies are ignored)
+            String separator = url.contains("?") ? "&" : "?";
+            String urlWithType = url + separator + "request_type=POST_LARGE_BINARY&button=POST_LargeBinary";
+
+            // Create large binary data that exceeds MAX_NETWORK_BODY_SIZE (150KB)
+            // Target size: 256KB (262,144 bytes)
+            int targetSize = 256 * 1024; // 256KB
+            byte[] binaryData = new byte[targetSize];
+            
+            // Fill with a pattern for easier identification
+            for (int i = 0; i < binaryData.length; i++) {
+                // Create a pattern: alternating bytes with position info
+                binaryData[i] = (byte) ((i % 256) ^ ((i / 256) % 256));
+            }
+
+            RequestBody body = RequestBody.create(
+                binaryData,
+                MediaType.get("application/octet-stream")
+            );
+
+            Request request = new Request.Builder()
+                .url(urlWithType)
+                .post(body)
+                .addHeader("User-Agent", "Sentry-Sample-Android")
+                .addHeader("Content-Type", "application/octet-stream")
+                .addHeader("Content-Length", String.valueOf(binaryData.length))
+                .addHeader("X-Request-Type", "POST_LARGE_BINARY")
+                .addHeader("X-Body-Size", String.valueOf(binaryData.length))
+                .build();
+
+            String displayBody = "[LARGE BINARY REQUEST BODY]\n" +
+                               "Type: application/octet-stream\n" +
+                               "Size: " + binaryData.length + " bytes (" + (binaryData.length / 1024) + "KB)\n" +
+                               "Limit: 153,600 bytes (150KB)\n" +
+                               "Status: " + (binaryData.length > 153600 ? "EXCEEDS LIMIT" : "Within limit") + "\n" +
+                               "Pattern: Alternating bytes with position info\n" +
+                               "Sample bytes: " + Arrays.toString(Arrays.copyOf(binaryData, Math.min(16, binaryData.length))) + "\n" +
+                               "Request type in URL: POST_LARGE_BINARY";
+
+            displayRequest("POST", request, displayBody);
+            executeRequest(request);
+        } catch (Exception e) {
+            Sentry.captureException(e);
+            Toast.makeText(this, "Error creating large binary request: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        }
+    }
+
     private String getCurrentTime() {
         return dateFormat.format(new Date());
     }
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
index 48d0fb32a48..40c8626831a 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
@@ -111,6 +111,30 @@
 
     </LinearLayout>
 
+    <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      android:layout_marginBottom="16dp">
+
+      <Button
+        android:id="@+id/trigger_large_text_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="POST Large Text"
+        android:layout_marginEnd="4dp"/>
+
+      <Button
+        android:id="@+id/trigger_large_binary_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="POST Large Binary"
+        android:layout_marginStart="4dp"/>
+
+    </LinearLayout>
+
     <Button
       android:id="@+id/clear_display"
       android:layout_width="wrap_content"

From 8deffe90e08b9c073875353085c3001f86f3b8a7 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 16:58:00 -0400
Subject: [PATCH 22/28] Properly handle content bodies that are too large

based on cursor[bot] feedback -
https://github.com/getsentry/sentry-java/pull/4796/files#r2466871208
---
 .../util/network/NetworkBodyParser.java       | 51 +++++++++++++------
 1 file changed, 36 insertions(+), 15 deletions(-)

diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java b/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
index 9620aa4da75..c566390254d 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
@@ -6,7 +6,6 @@
 import java.io.StringReader;
 import java.io.UnsupportedEncodingException;
 import java.net.URLDecoder;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -48,11 +47,21 @@ private NetworkBodyParser() {}
           "[Binary data, " + bytes.length + " bytes, type: " + contentType + "]");
     }
 
+    // Check size limit and truncate if necessary
+    if (bytes.length > maxSizeBytes) {
+      if (logger != null) {
+        logger
+            .getLogger()
+            .log(SentryLevel.DEBUG, "Content exceeds max size limit of " + maxSizeBytes + " bytes");
+      }
+      return createTruncatedNetworkBody(bytes, maxSizeBytes, charset);
+    }
+
     // Convert to string and parse
     try {
       String effectiveCharset = charset != null ? charset : "UTF-8";
       String content = new String(bytes, effectiveCharset);
-      return parse(content, contentType, maxSizeBytes, logger);
+      return parse(content, contentType, logger);
     } catch (UnsupportedEncodingException e) {
       if (logger != null) {
         logger.getLogger().log(SentryLevel.DEBUG, "Failed to decode bytes: " + e.getMessage());
@@ -64,25 +73,12 @@ private NetworkBodyParser() {}
   private static @Nullable NetworkBody parse(
       @Nullable String content,
       @Nullable String contentType,
-      int maxSizeBytes,
       @Nullable SentryOptions logger) {
 
     if (content == null || content.isEmpty()) {
       return null;
     }
 
-    // Check size limit
-    if (content.getBytes(StandardCharsets.UTF_8).length > maxSizeBytes) {
-      if (logger != null) {
-        logger
-            .getLogger()
-            .log(SentryLevel.DEBUG, "Content exceeds max size limit of " + maxSizeBytes + " bytes");
-      }
-      // Return truncated string
-      int truncateAt = Math.min(content.length(), maxSizeBytes);
-      return NetworkBody.fromString(content.substring(0, truncateAt) + "...[truncated]");
-    }
-
     // Handle based on content type hint if provided
     if (contentType != null) {
       String lowerContentType = contentType.toLowerCase();
@@ -164,6 +160,31 @@ private NetworkBodyParser() {}
     }
   }
 
+  /** Creates a truncated NetworkBody from oversized bytes with proper UTF-8 character handling. */
+  private static @NotNull NetworkBody createTruncatedNetworkBody(
+      @NotNull byte[] bytes, int maxSizeBytes, @Nullable String charset) {
+    byte[] truncatedBytes = new byte[maxSizeBytes];
+    System.arraycopy(bytes, 0, truncatedBytes, 0, maxSizeBytes);
+
+    try {
+      String effectiveCharset = charset != null ? charset : "UTF-8";
+      String content = new String(truncatedBytes, effectiveCharset);
+
+      // Find the last complete character by checking for replacement character
+      int lastValidIndex = content.length();
+      while (lastValidIndex > 0 && content.charAt(lastValidIndex - 1) == '\uFFFD') {
+        lastValidIndex--;
+      }
+      if (lastValidIndex < content.length()) {
+        content = content.substring(0, lastValidIndex);
+      }
+      content += "...[truncated]";
+      return NetworkBody.fromString(content);
+    } catch (UnsupportedEncodingException e) {
+      return NetworkBody.fromString("[Failed to decode truncated bytes, " + bytes.length + " bytes]");
+    }
+  }
+
   /** Checks if the content type is binary and shouldn't be converted to string. */
   private static boolean isBinaryContentType(@NotNull String contentType) {
     String lower = contentType.toLowerCase();

From 669c8a30e0aebba074f47da7ff9338e35541d992 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 16:45:17 -0400
Subject: [PATCH 23/28] Cleanup DefaultReplayBreadcrumbConverterTest

Removes unuseful test
---
 .../DefaultReplayBreadcrumbConverterTest.kt   | 33 +------------------
 1 file changed, 1 insertion(+), 32 deletions(-)

diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
index 5336740724f..b2ae3a7eb33 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
@@ -507,7 +507,7 @@ class DefaultReplayBreadcrumbConverterTest {
   }
 
   @Test
-  fun `non-http breadcrumbs do not extract network data`() {
+  fun `non-http breadcrumbs are unaltered by network detail data extraction`() {
     val converter = fixture.getSut()
     val navigationBreadcrumb =
       Breadcrumb(Date()).apply {
@@ -524,35 +524,4 @@ class DefaultReplayBreadcrumbConverterTest {
     assertSame(navigationBreadcrumb, result)
     // Network data extraction only happens for http breadcrumbs
   }
-
-  @Test
-  fun `chained callbacks work correctly`() {
-    val converter = fixture.getSut()
-    val breadcrumb = Breadcrumb(Date()).apply { message = "original" }
-    val hint = Hint()
-
-    val firstCallback =
-      SentryOptions.BeforeBreadcrumbCallback { b, h ->
-        b.message = "modified by first"
-        b
-      }
-
-    val secondCallback =
-      SentryOptions.BeforeBreadcrumbCallback { b, h ->
-        // This simulates what happens when ReplayBreadcrumbConverter
-        // wraps a user's callback
-        val result = firstCallback.execute(b, h)
-        result?.let {
-          it.message = "${it.message} and second"
-          it
-        }
-      }
-
-    converter.setUserBeforeBreadcrumbCallback(secondCallback)
-
-    val result = converter.execute(breadcrumb, hint)
-
-    assertNotNull(result)
-    assertEquals("modified by first and second", result.message)
-  }
 }

From 8b29cdda9ff5c7b9e2f0e23efc5fc9de7560b6bb Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 16:55:16 -0400
Subject: [PATCH 24/28] Address cursor[bot] nullpointer dereference comment

 https://github.com/getsentry/sentry-java/pull/4796/files#r2462011291

 Entirely removed any null checks - reading through the code everything is annotated @NonNull, and in the case where a NoOpReplayController could be initialised (believe this is unexpected as ReplayIntegration is always enabled) the NoOpBreadcrumbConverter implements BeforeBreadcrumbCallback and simply no-ops => nothing to crash
---
 .../android/core/AndroidOptionsInitializer.java     | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 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 a928d8ab7bc..bb5cc67bd72 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
@@ -248,13 +248,12 @@ static void initializeIntegrationsAndProcessors(
       options.setCompositePerformanceCollector(new DefaultCompositePerformanceCollector(options));
     }
 
-    if (options.getReplayController() != null) { // TODO: Triple-check this should be a null check
-      ReplayBreadcrumbConverter replayBreadcrumbConverter = options.getReplayController().getBreadcrumbConverter();
-      replayBreadcrumbConverter.setUserBeforeBreadcrumbCallback(options.getBeforeBreadcrumb());
-      options.setBeforeBreadcrumb(
-        replayBreadcrumbConverter
-      );
-    }
+    ReplayBreadcrumbConverter replayBreadcrumbConverter = options.getReplayController().getBreadcrumbConverter();
+    replayBreadcrumbConverter.setUserBeforeBreadcrumbCallback(options.getBeforeBreadcrumb());
+    options.setBeforeBreadcrumb(
+      replayBreadcrumbConverter
+    );
+
 
     // Check if the profiler was already instantiated in the app start.
     // We use the Android profiler, that uses a global start/stop api, so we need to preserve the

From 4bc5b7714d03e978017a75d5ebc1bd81d4d46c89 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 17:10:10 -0400
Subject: [PATCH 25/28] Disable Network Detail extraction

Initialize the values in FAKE_OPTIONS so that implementation acts as if dev never turned it on.

Leaves in the FAKE_OPTIONS variable to be easy to update reference to real `options` later on.
---
 .../java/io/sentry/okhttp/SentryOkHttpInterceptor.kt  | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index 91f82d85a61..e12e819f893 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -62,14 +62,13 @@ public open class SentryOkHttpInterceptor(
 
     /**
      * Fake options for testing network detail capture
-     * TODO: Remove before landing.
      */
     private val FAKE_OPTIONS = object {
-      val networkDetailAllowUrls: Array<String> = arrayOf(".*")
-      val networkDetailDenyUrls: Array<String>? = null
-      val networkCaptureBodies: Boolean = true
-      val networkRequestHeaders: Array<String> = arrayOf("User-Agent", "Accept", "sentry-trace", "Content-Type")
-      val networkResponseHeaders: Array<String> = arrayOf("User-Agent", "access-control-allow-origin", "x-ratelimit-resource")
+      val networkDetailAllowUrls: Array<String> = emptyArray()
+      val networkDetailDenyUrls: Array<String> = emptyArray()
+      val networkCaptureBodies: Boolean = false
+      val networkRequestHeaders: Array<String> = emptyArray()
+      val networkResponseHeaders: Array<String> = emptyArray()
     }
   }
 

From 177ae0c0bec489589e07ecc35c15d719e1366a8d Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 17:19:09 -0400
Subject: [PATCH 26/28] Revert "Point dsn to sentry-android project"

This reverts commit 5397e9dc8498f603a0e0bb9971f1e887aacbae01.
---
 .../sentry-samples-android/src/main/AndroidManifest.xml         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index ad681855840..013dd964c27 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -79,7 +79,7 @@
         android:exported="false"/>
 
         <!--    NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard-->
-        <meta-data android:name="io.sentry.dsn" android:value="https://1053864c67cc410aa1ffc9701bd6f93d@o447951.ingest.us.sentry.io/5428559" />
+        <meta-data android:name="io.sentry.dsn" android:value="https://502f25099c204a2fbf4cb16edc5975d1@o447951.ingest.us.sentry.io/5428563" />
 
         <!--    how to enable Sentry's debug mode-->
         <meta-data android:name="io.sentry.debug" android:value="${sentryDebug}" />

From a204a40d06665851caa91d5865b97a74a4111301 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 17:19:29 -0400
Subject: [PATCH 27/28] Revert "Enable replay verbose logging"

This reverts commit ca280403304595d7783e35cfd302228b8f25c8e3.
---
 .../sentry-samples-android/src/main/AndroidManifest.xml         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 013dd964c27..459950f890a 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -85,7 +85,7 @@
         <meta-data android:name="io.sentry.debug" android:value="${sentryDebug}" />
 
         <!--    how to disable verbose logging of the session replay feature-->
-        <meta-data android:name="io.sentry.session-replay.debug" android:value="true" />
+        <meta-data android:name="io.sentry.session-replay.debug" android:value="false" />
 
         <!--    how to set a custom debug level-->
         <!--    <meta-data android:name="io.sentry.debug.level" android:value="info" />-->

From 6629e944e295c8b68a1f19cfc9525da9c2de0034 Mon Sep 17 00:00:00 2001
From: Matthew Williams <43.matthew@gmail.com>
Date: Mon, 27 Oct 2025 17:19:49 -0400
Subject: [PATCH 28/28] Revert "Update dsn for testing"

This reverts commit b8555e2ab79dfe63af37fba249eee710ccacf31f.
---
 .../sentry-samples-android/src/main/AndroidManifest.xml         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 459950f890a..4653617c68d 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -79,7 +79,7 @@
         android:exported="false"/>
 
         <!--    NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard-->
-        <meta-data android:name="io.sentry.dsn" android:value="https://502f25099c204a2fbf4cb16edc5975d1@o447951.ingest.us.sentry.io/5428563" />
+        <meta-data android:name="io.sentry.dsn" android:value="https://1053864c67cc410aa1ffc9701bd6f93d@o447951.ingest.us.sentry.io/5428559" />
 
         <!--    how to enable Sentry's debug mode-->
         <meta-data android:name="io.sentry.debug" android:value="${sentryDebug}" />