feat: Add request_duration measurement for proxy detection

Measure HTTP round-trip time of the first (IPv6) request and send it
with the second (IPv4) request. This matches the browser device.js
behavior and helps with proxy detection.

Changes:
- Add requestDuration field to DeviceData (Float?, milliseconds)
- Measure time in sendWithDualRequest() around IPv6 request
- Pass duration to IPv4 request via DeviceData.copy()
- Add tests for dual-request behavior and request_duration field

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: oschwald

device-sdk/src/main/java/com/maxmind/device/model/DeviceData.kt

@@ -44,4 +44,7 @@ public data class DeviceData(
     val deviceTime: Long = System.currentTimeMillis(),
     @SerialName("webview_user_agent")
     val webViewUserAgent: String? = null,
+    // Request timing for proxy detection (set by DeviceApiClient on IPv4 request)
+    @SerialName("request_duration")
+    val requestDuration: Float? = null,
 )

device-sdk/src/main/java/com/maxmind/device/network/DeviceApiClient.kt

@@ -88,22 +88,28 @@ internal class DeviceApiClient(
      * Sends device data using the dual-request flow (IPv6 first, then IPv4 if needed).
      */
     private suspend fun sendWithDualRequest(deviceData: DeviceData): Result<ServerResponse> {
-        // First, try IPv6
+        // First, try IPv6 - measure duration for proxy detection
         val ipv6Url = "https://${SdkConfig.DEFAULT_IPV6_HOST}${SdkConfig.ENDPOINT_PATH}"
+        val startTime = System.currentTimeMillis()
         val ipv6Result = sendToUrl(deviceData, ipv6Url)
+        val requestDurationMs = System.currentTimeMillis() - startTime
 
         if (ipv6Result.isFailure) {
             return ipv6Result
         }
 
         val ipv6Response = ipv6Result.getOrNull()!!
 
-        // If we got an IPv6 response, also send to IPv4 to capture that IP
+        // If we got an IPv6 response, also send to IPv4 with the request duration
         if (ipv6Response.ipVersion == IPV6) {
             val ipv4Url = "https://${SdkConfig.DEFAULT_IPV4_HOST}${SdkConfig.ENDPOINT_PATH}"
+            val dataWithDuration =
+                deviceData.copy(
+                    requestDuration = requestDurationMs.toFloat(),
+                )
             // Send to IPv4 but don't fail the overall operation if it fails
             // The stored_id from IPv6 is already valid
-            sendToUrl(deviceData, ipv4Url)
+            sendToUrl(dataWithDuration, ipv4Url)
         }
 
         // Return the IPv6 response (which has the stored_id)

device-sdk/src/test/java/com/maxmind/device/network/DeviceApiClientTest.kt

@@ -19,6 +19,7 @@ import io.ktor.http.headersOf
 import io.ktor.serialization.kotlinx.json.json
 import kotlinx.coroutines.test.runTest
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.float
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
 import org.junit.jupiter.api.Assertions.assertEquals
@@ -328,6 +329,99 @@ internal class DeviceApiClientTest {
             client.close()
         }
 
+    // ========== Dual Request / Request Duration Tests ==========
+
+    @Test
+    internal fun `dual request includes request_duration only on second request`() =
+        runTest {
+            val capturedRequests = mutableListOf<Pair<String, String>>()
+            var requestCount = 0
+
+            val mockEngine =
+                MockEngine { request ->
+                    requestCount++
+                    capturedRequests.add(request.url.toString() to (request.body as TextContent).text)
+                    respond(
+                        content =
+                            if (requestCount == 1) {
+                                """{"stored_id":"test","ip_version":6}"""
+                            } else {
+                                """{"stored_id":"test"}"""
+                            },
+                        status = HttpStatusCode.OK,
+                        headers = headersOf(HttpHeaders.ContentType, "application/json"),
+                    )
+                }
+            val client = createTestClientWithDefaultServers(mockEngine)
+
+            client.sendDeviceData(testDeviceData)
+
+            assertEquals(2, capturedRequests.size)
+
+            // First request (IPv6) should NOT have request_duration
+            val firstRequestJson = json.parseToJsonElement(capturedRequests[0].second).jsonObject
+            assertNull(firstRequestJson["request_duration"])
+
+            // Second request (IPv4) SHOULD have request_duration
+            val secondRequestJson = json.parseToJsonElement(capturedRequests[1].second).jsonObject
+            assertNotNull(secondRequestJson["request_duration"])
+            assertTrue(secondRequestJson["request_duration"]!!.jsonPrimitive.float >= 0)
+            client.close()
+        }
+
+    @Test
+    internal fun `dual request sends to correct IPv6 and IPv4 endpoints`() =
+        runTest {
+            val capturedUrls = mutableListOf<String>()
+            var requestCount = 0
+
+            val mockEngine =
+                MockEngine { request ->
+                    requestCount++
+                    capturedUrls.add(request.url.toString())
+                    respond(
+                        content =
+                            if (requestCount == 1) {
+                                """{"stored_id":"test","ip_version":6}"""
+                            } else {
+                                """{"stored_id":"test"}"""
+                            },
+                        status = HttpStatusCode.OK,
+                        headers = headersOf(HttpHeaders.ContentType, "application/json"),
+                    )
+                }
+            val client = createTestClientWithDefaultServers(mockEngine)
+
+            client.sendDeviceData(testDeviceData)
+
+            assertEquals(2, capturedUrls.size)
+            assertTrue(capturedUrls[0].contains("d-ipv6.mmapiws.com"))
+            assertTrue(capturedUrls[1].contains("d-ipv4.mmapiws.com"))
+            client.close()
+        }
+
+    @Test
+    internal fun `dual request skips IPv4 when ip_version is not 6`() =
+        runTest {
+            var requestCount = 0
+
+            val mockEngine =
+                MockEngine { _ ->
+                    requestCount++
+                    respond(
+                        content = """{"stored_id":"test","ip_version":4}""",
+                        status = HttpStatusCode.OK,
+                        headers = headersOf(HttpHeaders.ContentType, "application/json"),
+                    )
+                }
+            val client = createTestClientWithDefaultServers(mockEngine)
+
+            client.sendDeviceData(testDeviceData)
+
+            assertEquals(1, requestCount)
+            client.close()
+        }
+
     // ========== Helper Functions ==========
 
     private fun createTestClient(
@@ -354,4 +448,27 @@ internal class DeviceApiClientTest {
                 .build()
         return DeviceApiClient(config, httpClient)
     }
+
+    private fun createTestClientWithDefaultServers(
+        mockEngine: MockEngine,
+        accountID: Int = 99999,
+    ): DeviceApiClient {
+        val httpClient =
+            HttpClient(mockEngine) {
+                install(ContentNegotiation) {
+                    json(
+                        Json {
+                            prettyPrint = true
+                            isLenient = true
+                            ignoreUnknownKeys = true
+                        },
+                    )
+                }
+            }
+        val config =
+            SdkConfig
+                .Builder(accountID)
+                .build()
+        return DeviceApiClient(config, httpClient)
+    }
 }