Use case-insensitive comparision when extracting headers

Run tests
./gradlew :sentry:test --tests="*NetworkDetailCaptureUtilsTest*"

Author: 43jay

sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java

@@ -1,9 +1,12 @@
 package io.sentry.util.network;
 
-import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.VisibleForTesting;
 
 /**
  * Utility class for network capture operations shared across HTTP client integrations. Provides
@@ -115,19 +118,24 @@ private static boolean shouldCaptureUrl(
     return false;
   }
 
-  private static @NotNull Map<String, String> getCaptureHeaders(
+  @VisibleForTesting
+  static @NotNull Map<String, String> getCaptureHeaders(
       @Nullable final Map<String, String> allHeaders, @NotNull final String[] allowedHeaders) {
 
-    Map<String, String> capturedHeaders = new HashMap<>();
-
-    if (allHeaders == null) {
+    final Map<String, String> capturedHeaders = new LinkedHashMap<>();
+    if (allHeaders == null || allowedHeaders.length == 0) {
       return capturedHeaders;
     }
 
+    // Convert to lowercase for case-insensitive matching
+    Set<String> normalizedAllowed = new HashSet<>();
     for (String header : allowedHeaders) {
-      String value = allHeaders.get(header);
-      if (value != null) {
-        capturedHeaders.put(header, value);
+      normalizedAllowed.add(header.toLowerCase());
+    }
+
+    for (Map.Entry<String, String> entry : allHeaders.entrySet()) {
+      if (normalizedAllowed.contains(entry.getKey().toLowerCase())) {
+        capturedHeaders.put(entry.getKey(), entry.getValue());
       }
     }
 

sentry/src/test/java/io/sentry/util/network/NetworkDetailCaptureUtilsTest.kt

@@ -0,0 +1,81 @@
+package io.sentry.util.network
+
+import java.util.LinkedHashMap
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import org.junit.Test
+
+class NetworkDetailCaptureUtilsTest {
+
+  @Test
+  fun `getCaptureHeaders should match headers case-insensitively`() {
+    // Setup: allHeaders with mixed case keys
+    val allHeaders =
+      LinkedHashMap<String, String>().apply {
+        put("Content-Type", "application/json")
+        put("Authorization", "Bearer token123")
+        put("X-Custom-Header", "custom-value")
+        put("accept", "application/json")
+      }
+
+    // Test: allowedHeaders with different casing
+    val allowedHeaders = arrayOf("content-type", "AUTHORIZATION", "x-custom-header", "ACCEPT")
+
+    val result = NetworkDetailCaptureUtils.getCaptureHeaders(allHeaders, allowedHeaders)
+
+    // All headers should be matched despite case differences
+    assertEquals(4, result.size)
+
+    // Original casing should be preserved in output
+    assertEquals("application/json", result["Content-Type"])
+    assertEquals("Bearer token123", result["Authorization"])
+    assertEquals("custom-value", result["X-Custom-Header"])
+    assertEquals("application/json", result["accept"])
+
+    // Verify keys maintain original casing from allHeaders
+    assertTrue(result.containsKey("Content-Type"))
+    assertTrue(result.containsKey("Authorization"))
+    assertTrue(result.containsKey("X-Custom-Header"))
+    assertTrue(result.containsKey("accept"))
+  }
+
+  @Test
+  fun `getCaptureHeaders should handle null allHeaders`() {
+    val allowedHeaders = arrayOf("content-type")
+
+    val result = NetworkDetailCaptureUtils.getCaptureHeaders(null, allowedHeaders)
+
+    assertTrue(result.isEmpty())
+  }
+
+  @Test
+  fun `getCaptureHeaders should handle empty allowedHeaders`() {
+    val allHeaders = mapOf("Content-Type" to "application/json")
+    val allowedHeaders = arrayOf<String>()
+
+    val result = NetworkDetailCaptureUtils.getCaptureHeaders(allHeaders, allowedHeaders)
+
+    assertTrue(result.isEmpty())
+  }
+
+  @Test
+  fun `getCaptureHeaders should only capture allowed headers`() {
+    val allHeaders =
+      mapOf(
+        "Content-Type" to "application/json",
+        "Authorization" to "Bearer token123",
+        "X-Unwanted-Header" to "should-not-appear",
+      )
+
+    val allowedHeaders = arrayOf("content-type", "authorization")
+
+    val result = NetworkDetailCaptureUtils.getCaptureHeaders(allHeaders, allowedHeaders)
+
+    assertEquals(2, result.size)
+    assertEquals("application/json", result["Content-Type"])
+    assertEquals("Bearer token123", result["Authorization"])
+
+    // Unwanted header should not be present
+    assertTrue(!result.containsKey("X-Unwanted-Header"))
+  }
+}