RUMS-5318 Fix race condition in lastFatalAnrSent

Use lazy initialization to prevent concurrent duplicate reads

  ## Problem
  Multiple threads could concurrently read `lastFatalAnrSent` as null before
  any writes occurred, causing duplicate ANR reports to be sent. The property
  was implemented as a getter that read from disk on every access, allowing
  race conditions where multiple threads would all see null and attempt to
  report the same ANR.

  ## Solution
  Changed `lastFatalAnrSent` from a property getter to a lazy-initialized
  property. This ensures the file is read exactly once in a thread-safe manner,
  and the value is cached in memory for all subsequent accesses.

Author: cgcote

dd-sdk-android-core/src/main/kotlin/com/datadog/android/core/internal/CoreFeature.kt

@@ -235,15 +235,18 @@ internal class CoreFeature(
         )
     }
 
-    internal val lastFatalAnrSent: Long?
-        get() {
-            val file = File(storageDir, LAST_FATAL_ANR_SENT_FILE_NAME)
-            return if (file.existsSafe(internalLogger)) {
-                file.readTextSafe(Charsets.UTF_8, internalLogger)?.toLongOrNull()
-            } else {
-                null
-            }
+    // FIX for RUMS-5318: Cache timestamp in memory to prevent race condition
+    // Previously this was a property getter that read from disk every time,
+    // allowing multiple concurrent threads to pass the duplicate check before
+    // any writes occurred. Now it's lazily initialized once.
+    internal val lastFatalAnrSent: Long? by lazy {
+        val file = File(storageDir, LAST_FATAL_ANR_SENT_FILE_NAME)
+        if (file.existsSafe(internalLogger)) {
+            file.readTextSafe(Charsets.UTF_8, internalLogger)?.toLongOrNull()
+        } else {
+            null
         }
+    }
 
     fun initialize(
         appContext: Context,

dd-sdk-android-core/src/test/kotlin/com/datadog/android/core/internal/CoreFeatureTest.kt

@@ -1093,6 +1093,53 @@ internal class CoreFeatureTest {
         assertThat(lastFatalAnrSent).isNull()
     }
 
+    @Test
+    fun `M cache value consistently W lastFatalAnrSent { concurrent access race condition }`(
+        @TempDir tempDir: File
+    ) {
+        // Given - RUMS-5318: This test verifies the fix for the race condition where
+        // multiple threads could read lastFatalAnrSent before any writes occurred.
+        // The fix uses lazy initialization to ensure the value is read and cached once.
+        // This test verifies that the property returns a consistent reference.
+        val expectedTimestamp = 1234567890L
+        testedFeature.storageDir = tempDir
+        File(tempDir, CoreFeature.LAST_FATAL_ANR_SENT_FILE_NAME)
+            .writeText(expectedTimestamp.toString())
+
+        val threadCount = 10
+        val results = mutableListOf<Long?>()
+        val threads = mutableListOf<Thread>()
+        val latch = java.util.concurrent.CountDownLatch(1)
+
+        // When - Multiple threads access lastFatalAnrSent simultaneously
+        repeat(threadCount) {
+            val thread = Thread {
+                latch.await()
+                val value = testedFeature.lastFatalAnrSent
+                synchronized(results) {
+                    results.add(value)
+                }
+            }
+            threads.add(thread)
+            thread.start()
+        }
+
+        // Release all threads at once to maximize contention
+        latch.countDown()
+        threads.forEach { it.join(5000) }
+
+        // Then - With lazy initialization, all threads read the same cached value.
+        // The key difference is that with 'by lazy', the value is computed once and cached,
+        // whereas with a getter, the file could be read multiple times.
+        assertThat(results).hasSize(threadCount)
+        assertThat(results).allMatch { it == expectedTimestamp }
+
+        // Verify lazy caching: reading again returns the exact same reference
+        val firstRead = testedFeature.lastFatalAnrSent
+        val secondRead = testedFeature.lastFatalAnrSent
+        assertThat(firstRead).isSameAs(secondRead)
+    }
+
     @Test
     fun `M delete last fatal ANR sent W deleteLastFatalAnrSent`(
         @TempDir tempDir: File,