[RUM-8654] Slow frames collection support

dd-sdk-android-internal/api/apiSurface

@@ -1,3 +1,9 @@
+class com.datadog.android.internal.collections.EvictingQueue<T> : java.util.Queue<T>
+  constructor(Int = Int.MAX_VALUE)
+  override val size: Int
+  override fun add(T): Boolean
+  override fun offer(T): Boolean
+  override fun addAll(Collection<T>): Boolean
 interface com.datadog.android.internal.profiler.BenchmarkProfiler
   fun getTracer(String): BenchmarkTracer
 interface com.datadog.android.internal.profiler.BenchmarkSpan

dd-sdk-android-internal/api/dd-sdk-android-internal.api

@@ -1,3 +1,27 @@
+public final class com/datadog/android/internal/collections/EvictingQueue : java/util/Queue {
+	public fun <init> (I)V
+	public synthetic fun <init> (IILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun add (Ljava/lang/Object;)Z
+	public fun addAll (Ljava/util/Collection;)Z
+	public fun clear ()V
+	public fun contains (Ljava/lang/Object;)Z
+	public fun containsAll (Ljava/util/Collection;)Z
+	public fun element ()Ljava/lang/Object;
+	public fun getSize ()I
+	public fun isEmpty ()Z
+	public fun iterator ()Ljava/util/Iterator;
+	public fun offer (Ljava/lang/Object;)Z
+	public fun peek ()Ljava/lang/Object;
+	public fun poll ()Ljava/lang/Object;
+	public fun remove ()Ljava/lang/Object;
+	public fun remove (Ljava/lang/Object;)Z
+	public fun removeAll (Ljava/util/Collection;)Z
+	public fun retainAll (Ljava/util/Collection;)Z
+	public final fun size ()I
+	public fun toArray ()[Ljava/lang/Object;
+	public fun toArray ([Ljava/lang/Object;)[Ljava/lang/Object;
+}
+
 public abstract interface class com/datadog/android/internal/profiler/BenchmarkProfiler {
 	public abstract fun getTracer (Ljava/lang/String;)Lcom/datadog/android/internal/profiler/BenchmarkTracer;
 }

dd-sdk-android-internal/src/main/java/com/datadog/android/internal/collections/EvictingQueue.kt

@@ -0,0 +1,111 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+package com.datadog.android.internal.collections
+
+import java.util.LinkedList
+import java.util.Queue
+import kotlin.math.max
+
+/**
+ * A bounded queue that automatically evicts the oldest elements when new elements are added beyond its maximum capacity.
+ *
+ * This implementation delegates all [Queue] operations to an underlying [LinkedList]. It provides a FIFO (first-in, first-out)
+ * behavior with a fixed maximum size. When new elements are added and the queue is at capacity, the oldest element is evicted.
+ *
+ * @param T the type of elements held in this queue.
+ * @param maxSize the maximum number of elements the queue can hold. Must be greater than or equal to 0.
+ *                The default value is [Int.MAX_VALUE], which effectively means there is no practical bound.
+ * @param delegate the underlying [LinkedList] that stores the elements and to which all [Queue] operations are delegated.
+ */
+class EvictingQueue<T> private constructor(
+    maxSize: Int,
+    private val delegate: LinkedList<T>
+) : Queue<T> by delegate {
+
+    /**
+     * Secondary constructor that initializes the [EvictingQueue] with the given [maxSize].
+     *
+     * @param maxSize the maximum number of elements the queue can hold.
+     */
+    constructor(maxSize: Int = Int.MAX_VALUE) : this(maxSize, LinkedList())
+
+    override val size: Int
+        get() = delegate.size
+    private val maxSize: Int = max(0, maxSize)
+
+    /**
+     * Adds the specified [element] to the end of this queue.
+     *
+     * If the queue has reached its maximum capacity, the first (oldest) element is evicted (removed)
+     * before the new element is added.
+     *
+     * This queue should never throw [IllegalStateException] due to capacity restriction of the [delegate] because it
+     * uses [java.util.Queue.offer] to insert elements.
+     *
+     * @param element the element to be added.
+     *
+     * @return `true` if this collection changed as a result of the call (as specified by [java.util.Collection.add])
+     */
+    override fun add(element: T): Boolean {
+        return this.offer(element)
+    }
+
+    /**
+     * Adds the specified [element] to the end of this queue.
+     *
+     * If the queue has reached its maximum capacity, the first (oldest) element is evicted (removed)
+     * before the new element is added.
+     *
+     * @param element the element to be added.
+     *
+     * @return `true` if this collection changed as a result of the call
+     */
+    override fun offer(element: T): Boolean {
+        if (maxSize == 0) return false
+        if (size >= maxSize) {
+            delegate.poll()
+        }
+
+        @Suppress("UnsafeThirdPartyFunctionCall") // can't have NPE here
+        return delegate.offer(element)
+    }
+
+    /**
+     * Adds all of the elements in the specified [elements] collection to the end of this queue.
+     *
+     * If the number of elements in [elements] is greater than or equal to [maxSize], the queue is cleared first,
+     * and only the last [maxSize] elements from [elements] are added.
+     *
+     * Otherwise, if adding [elements] would exceed the maximum capacity, the required number of oldest elements
+     * are evicted from the front of the queue to make room.
+     *
+     * @param elements the collection of elements to be added.
+     * @return `true` if the queue changed as a result of the call.
+     */
+    override fun addAll(elements: Collection<T>): Boolean {
+        return when {
+            maxSize == 0 -> false
+
+            elements.size >= maxSize -> {
+                clear()
+                for ((index, element) in elements.withIndex()) {
+                    if (index < elements.size - maxSize) continue
+                    delegate.add(element)
+                }
+                true
+            }
+
+            else -> {
+                val spaceLeft = maxSize - size
+                for (index in 0 until elements.size - spaceLeft) {
+                    delegate.poll()
+                }
+
+                delegate.addAll(elements)
+            }
+        }
+    }
+}

dd-sdk-android-internal/src/test/java/com/datadog/internal/collections/EvictingQueueTest.kt

@@ -0,0 +1,170 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+package com.datadog.internal.collections
+
+import com.datadog.android.internal.collections.EvictingQueue
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+
+internal class EvictingQueueTest {
+
+    @Test
+    fun `M shrink items W add {more than max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        repeat(5) { queue.add(it) }
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(2, 3, 4))
+    }
+
+    @Test
+    fun `M shrink items W offer {more than max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        repeat(5) { queue.offer(it) }
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(2, 3, 4))
+    }
+
+    @Test
+    fun `M not shrink items W add {less than max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        repeat(2) { queue.add(it) }
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(0, 1))
+    }
+
+    @Test
+    fun `M not shrink items W offer {less than max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        repeat(2) { queue.offer(it) }
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(0, 1))
+    }
+
+    @Test
+    fun `M not shrink items W addAll {less than max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        queue.addAll(listOf(1, 2))
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(1, 2))
+    }
+
+    @Test
+    fun `M not shrink items W addAll {equal max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        queue.addAll(listOf(1, 2))
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(1, 2))
+    }
+
+    @Test
+    fun `M shrink items W addAll {more than max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        queue.addAll(listOf(1, 2, 3, 4))
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(2, 3, 4))
+    }
+
+    @Test
+    fun `M shrink items W addAll {more than max, less than max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        queue.addAll(listOf(1, 2, 3, 4))
+        queue.addAll(listOf(5, 6))
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(4, 5, 6))
+    }
+
+    @Test
+    fun `M shrink items W addAll {more than max, more than max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        queue.addAll(listOf(1, 2, 3, 4))
+        queue.addAll(listOf(5, 6, 7, 8))
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(6, 7, 8))
+    }
+
+    @Test
+    fun `M shrink items W addAll {equal max, equal max}`() {
+        // Given
+        val queue = EvictingQueue<Int>(3)
+
+        // When
+        queue.addAll(listOf(1, 2, 3))
+        queue.addAll(listOf(4, 5, 6))
+
+        // Then
+        assertThat(queue.toList()).isEqualTo(listOf(4, 5, 6))
+    }
+
+    @Test
+    fun `M create empty queue W maxSize le 0`() {
+        // When
+        val queue = EvictingQueue<Int>(-1)
+
+        // Then
+        assertThat(queue.size).isEqualTo(0)
+    }
+
+    @Test
+    fun `M not change 0-sized queue W add`() {
+        // Given
+        val queue = EvictingQueue<Int>(0)
+
+        // When
+        assertDoesNotThrow { queue.add(1) }
+
+        // Then
+        assertThat(queue.size).isEqualTo(0)
+    }
+
+    @Test
+    fun `M not change 0-sized queue W offer`() {
+        // Given
+        val queue = EvictingQueue<Int>(0)
+
+        // When
+        assertDoesNotThrow { queue.offer(1) }
+
+        // Then
+        assertThat(queue.size).isEqualTo(0)
+    }
+}

detekt_custom.yml

@@ -633,6 +633,7 @@ datadog:
       - "java.util.ArrayList.forEach(kotlin.Function1)"
       - "java.util.HashSet.add(kotlin.String)"
       - "java.util.HashSet.clear()"
+      - "java.util.LinkedList.add(kotlin.Any?)"
       - "java.util.HashSet.remove(kotlin.String)"
       - "java.util.LinkedList.add(android.view.View)"
       - "java.util.LinkedList.add(com.datadog.android.privacy.TrackingConsentProviderCallback)"
@@ -644,6 +645,7 @@ datadog:
       - "java.util.LinkedList.add(com.datadog.android.sessionreplay.recorder.Node)"
       - "java.util.LinkedList.add(kotlin.Pair)"
       - "java.util.LinkedList.addAll(kotlin.collections.Collection)"
+      - "java.util.LinkedList.addAll(kotlin.Int, kotlin.collections.Collection)"
       - "java.util.LinkedList.addFirst(android.view.View?)"
       - "java.util.LinkedList.clear()"
       - "java.util.LinkedList.constructor()"
@@ -656,6 +658,8 @@ datadog:
       - "java.util.LinkedList.remove(com.datadog.android.privacy.TrackingConsentProviderCallback)"
       - "java.util.LinkedHashMap.remove(kotlin.String)"
       - "java.util.Queue.clear()"
+      - "java.util.Queue.lastOrNull()"
+      - "java.util.Queue.map(kotlin.Function1)"
       - "java.util.Stack.constructor()"
       - "java.util.Stack.isNotEmpty()"
       - "java.util.Stack.pop()"
@@ -972,6 +976,7 @@ datadog:
       - "kotlin.collections.MutableList.add(com.datadog.android.core.internal.persistence.tlvformat.TLVBlock)"
       - "kotlin.collections.MutableList.add(com.datadog.android.plugin.DatadogPlugin)"
       - "kotlin.collections.MutableList.add(com.datadog.android.rum.internal.domain.scope.RumScope)"
+      - "kotlin.collections.MutableList.add(com.datadog.android.rum.internal.vitals.FrameStateListener)"
       - "kotlin.collections.MutableList.add(com.datadog.android.rum.model.ActionEvent.Type)"
       - "kotlin.collections.MutableList.add(com.datadog.android.sessionreplay.compose.internal.data.Parameter)"
       - "kotlin.collections.MutableList.add(com.datadog.android.sessionreplay.compose.internal.utils.BackgroundInfo)"
@@ -1298,6 +1303,7 @@ datadog:
       - "kotlin.Throwable.fillInStackTrace()"
       - "kotlin.Throwable.stackTraceToString()"
       - "kotlin.UnsupportedOperationException()"
+      - "kotlin.UnsupportedOperationException(kotlin.String?)"
       - "kotlin.comparisons.maxOf(kotlin.Float, kotlin.Float)"
       - "kotlin.comparisons.minOf(kotlin.Float, kotlin.Float)"
       - "kotlin.ranges.IntRange.map(kotlin.Function1)"