fix(flags): dedupe exposures by latest assignment

Author: leoromanovsky

features/dd-sdk-android-flags/src/main/kotlin/com/datadog/android/flags/internal/ExposureEventsProcessor.kt

@@ -18,49 +18,51 @@ internal class ExposureEventsProcessor(private val writer: RecordWriter, private
 
     private data class CacheKey(
         val targetingKey: String,
-        val flagName: String,
+        val flagName: String
+    )
+
+    private data class CacheValue(
         val allocationKey: String,
         val variationKey: String
     )
 
     @Suppress("UnsafeThirdPartyFunctionCall") // maxSize > 0
-    private val exposuresSentCache = object : LruCache<CacheKey, Boolean>(MAX_CACHE_SIZE_BYTES) {
-        override fun sizeOf(key: CacheKey, value: Boolean): Int {
+    private val exposuresSentCache = object : LruCache<CacheKey, CacheValue>(MAX_CACHE_SIZE_BYTES) {
+        override fun sizeOf(key: CacheKey, value: CacheValue): Int {
             // Calculate approximate memory footprint of the cache entry
             // String overhead: ~40 bytes + (2 bytes per character for UTF-16)
-            // Object overhead for CacheKey: ~16 bytes
-            // Boolean: ~1 byte
+            // Object overhead for CacheKey and CacheValue: ~16 bytes each
             val keySize = OBJECT_OVERHEAD +
                 (STRING_OVERHEAD + key.targetingKey.length * CHAR_SIZE) +
-                (STRING_OVERHEAD + key.flagName.length * CHAR_SIZE) +
-                (STRING_OVERHEAD + key.allocationKey.length * CHAR_SIZE) +
-                (STRING_OVERHEAD + key.variationKey.length * CHAR_SIZE)
-            val valueSize = BOOLEAN_SIZE
+                (STRING_OVERHEAD + key.flagName.length * CHAR_SIZE)
+            val valueSize = OBJECT_OVERHEAD +
+                (STRING_OVERHEAD + value.allocationKey.length * CHAR_SIZE) +
+                (STRING_OVERHEAD + value.variationKey.length * CHAR_SIZE)
             return keySize + valueSize
         }
     }
 
     override fun processEvent(flagName: String, context: EvaluationContext, data: UnparsedFlag) {
         val cacheKey = CacheKey(
             targetingKey = context.targetingKey,
-            flagName = flagName,
+            flagName = flagName
+        )
+        val cacheValue = CacheValue(
             allocationKey = data.allocationKey,
             variationKey = data.variationKey
         )
 
-        // Atomically check and mark to prevent duplicate writes
-        // Only write to cache on first access to avoid refreshing LRU position
-        val isFirstTime = synchronized(exposuresSentCache) {
-            val alreadySent = exposuresSentCache[cacheKey]
-            if (alreadySent == null) {
-                exposuresSentCache.put(cacheKey, true)
+        val shouldWrite = synchronized(exposuresSentCache) {
+            val lastSentValue = exposuresSentCache[cacheKey]
+            if (lastSentValue != cacheValue) {
+                exposuresSentCache.put(cacheKey, cacheValue)
                 true
             } else {
                 false
             }
         }
 
-        if (isFirstTime) {
+        if (shouldWrite) {
             val event = buildExposureEvent(flagName, context, data)
             writeExposureEvent(event)
         }
@@ -87,13 +89,14 @@ internal class ExposureEventsProcessor(private val writer: RecordWriter, private
     }
 
     companion object {
-        // Maximum cache size in bytes (4MB)
+        // Maximum cache size in bytes (4MB). The expected high-water mark is
+        // two subjects with 2,500 flags each, which is about 2.8-3.8MB when
+        // identifiers average 200-300 combined characters per cache entry.
         private const val MAX_CACHE_SIZE_BYTES = 4 * 1024 * 1024 // 4MB
 
         // Memory overhead constants for size calculation
         private const val OBJECT_OVERHEAD = 16 // bytes for object header
         private const val STRING_OVERHEAD = 40 // bytes for String object overhead
         private const val CHAR_SIZE = 2 // bytes per character (UTF-16)
-        private const val BOOLEAN_SIZE = 1 // byte
     }
 }

features/dd-sdk-android-flags/src/test/kotlin/com/datadog/android/flags/internal/ExposureEventsProcessorTest.kt

@@ -118,6 +118,39 @@ internal class ExposureEventsProcessorTest {
         verify(mockRecordWriter).write(any())
     }
 
+    @Test
+    fun `M process exposure again W processEvent() { assignment cycles back }`() {
+        // Given
+        val fakeContext = EvaluationContext(targetingKey = fakeTargetingKey)
+        val flagA = fakeFlag.copy(
+            allocationKey = "allocation-a",
+            variationKey = "variation-a"
+        )
+        val flagB = fakeFlag.copy(
+            allocationKey = "allocation-b",
+            variationKey = "variation-b"
+        )
+
+        // When
+        testedProcessor.processEvent(fakeFlagName, fakeContext, flagA)
+        testedProcessor.processEvent(fakeFlagName, fakeContext, flagB)
+        testedProcessor.processEvent(fakeFlagName, fakeContext, flagA)
+
+        // Then
+        val eventCaptor = argumentCaptor<ExposureEvent>()
+        verify(mockRecordWriter, times(3)).write(eventCaptor.capture())
+        assertThat(eventCaptor.allValues.map { it.allocation.key }).containsExactly(
+            "allocation-a",
+            "allocation-b",
+            "allocation-a"
+        )
+        assertThat(eventCaptor.allValues.map { it.variant.key }).containsExactly(
+            "variation-a",
+            "variation-b",
+            "variation-a"
+        )
+    }
+
     @Test
     fun `M process different exposures W processEvent() { different flag names }`(forge: Forge) {
         // Given
@@ -397,10 +430,10 @@ internal class ExposureEventsProcessorTest {
         testedProcessor.processEvent("flag1", context2, flag1) // Different context
         testedProcessor.processEvent("flag2", context1, flag1) // Different flag name
         testedProcessor.processEvent("flag1", context1, flag2) // Different flag data
-        testedProcessor.processEvent("flag1", context1, flag1) // Duplicate again
+        testedProcessor.processEvent("flag1", context1, flag1) // Assignment changed back
 
         // Then
-        verify(mockRecordWriter, times(4)).write(any())
+        verify(mockRecordWriter, times(5)).write(any())
     }
 
     // endregion