Rebuild profiling request for every profiling start

Author: ambushwork

features/dd-sdk-android-profiling/src/main/java/com/datadog/android/profiling/internal/perfetto/PerfettoProfiler.kt

@@ -11,6 +11,7 @@ import android.os.Build
 import android.os.CancellationSignal
 import android.os.ProfilingResult
 import androidx.annotation.RequiresApi
+import androidx.core.os.ProfilingRequest
 import androidx.core.os.StackSamplingRequestBuilder
 import androidx.core.os.requestProfiling
 import com.datadog.android.api.InternalLogger
@@ -38,10 +39,7 @@ internal class PerfettoProfiler(
     private val profilingExecutor: ExecutorService = Executors.newSingleThreadExecutor()
 ) : Profiler {
 
-    private val requestBuilder: StackSamplingRequestBuilder
-
-    private val stopSignal = CancellationSignal()
-
+    private var stopSignal: CancellationSignal? = null
     private val resultCallback: Consumer<ProfilingResult>
 
     // This flag represents which instance of this class is working for.
@@ -55,12 +53,6 @@ internal class PerfettoProfiler(
     private val callbackMap: MutableMap<String, ProfilerCallback> = ConcurrentHashMap()
 
     init {
-        requestBuilder = StackSamplingRequestBuilder()
-            .setCancellationSignal(stopSignal)
-            .setTag(PROFILING_TAG_APPLICATION_LAUNCH)
-            .setSamplingFrequencyHz(PROFILING_SAMPLING_RATE)
-            .setBufferSizeKb(BUFFER_SIZE_KB)
-            .setDurationMs(PROFILING_MAX_DURATION_MS)
 
         resultCallback = Consumer<ProfilingResult> { result ->
             val endTime = timeProvider.getDeviceTimestamp()
@@ -80,6 +72,19 @@ internal class PerfettoProfiler(
         }
     }
 
+    private fun buildStackSamplingRequest(): ProfilingRequest {
+        return CancellationSignal().let {
+            this.stopSignal = it
+            StackSamplingRequestBuilder()
+                .setCancellationSignal(it)
+                .setTag(PROFILING_TAG_APPLICATION_LAUNCH)
+                .setSamplingFrequencyHz(PROFILING_SAMPLING_RATE)
+                .setBufferSizeKb(BUFFER_SIZE_KB)
+                .setDurationMs(PROFILING_MAX_DURATION_MS)
+                .build()
+        }
+    }
+
     private fun notifyAllCallbacks(result: PerfettoResult) {
         callbackMap.filter { runningInstances.get().contains(it.key) }.forEach { callback ->
             callback.value.onSuccess(result)
@@ -92,13 +97,19 @@ internal class PerfettoProfiler(
         if (runningInstances.compareAndSet(emptySet(), sdkInstanceNames)) {
             sendProfilingStartTelemetry()
             profilingStartTime = timeProvider.getDeviceTimestamp()
-            requestProfiling(appContext, requestBuilder.build(), profilingExecutor, resultCallback)
+            requestProfiling(
+                appContext,
+                buildStackSamplingRequest(),
+                profilingExecutor,
+                resultCallback
+            )
         }
     }
 
     override fun stop(sdkInstanceName: String) {
         if (runningInstances.get().contains(sdkInstanceName)) {
-            stopSignal.cancel()
+            stopSignal?.cancel()
+            stopSignal = null
         }
     }
 

features/dd-sdk-android-profiling/src/test/kotlin/com/datadog/android/profiling/internal/PerfettoProfilerTest.kt

@@ -30,6 +30,7 @@ import org.mockito.kotlin.any
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.eq
+import org.mockito.kotlin.inOrder
 import org.mockito.kotlin.isNull
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
@@ -395,6 +396,49 @@ class PerfettoProfilerTest {
         verifyNoInteractions(mockProfilerCallback)
     }
 
+    @Test
+    fun `M not have the same stop signal W start&stop multiple times`() {
+        val inOrder = inOrder(mockService)
+
+        // When
+        // First request
+        testedProfiler.start(mockContext, setOf(fakeInstanceName))
+        val firstStopSignalCaptor = argumentCaptor<CancellationSignal>()
+        testedProfiler.stop(fakeInstanceName)
+
+        // Then
+        inOrder.verify(mockService).requestProfiling(
+            eq(ProfilingManager.PROFILING_TYPE_STACK_SAMPLING),
+            any<Bundle>(),
+            any<String>(),
+            firstStopSignalCaptor.capture(),
+            any(),
+            callbackCaptor.capture()
+        )
+
+        val successResult = mock<ProfilingResult> {
+            on { errorCode } doReturn ProfilingResult.ERROR_NONE
+            on { resultFilePath } doReturn fakePath
+        }
+        callbackCaptor.firstValue.accept(successResult)
+        val captor = argumentCaptor<PerfettoResult>()
+        verify(mockProfilerCallback).onSuccess(captor.capture())
+
+        // Second request
+        val secondStopSignalCaptor = argumentCaptor<CancellationSignal>()
+        testedProfiler.start(mockContext, setOf(fakeInstanceName))
+        inOrder.verify(mockService).requestProfiling(
+            eq(ProfilingManager.PROFILING_TYPE_STACK_SAMPLING),
+            any<Bundle>(),
+            any<String>(),
+            secondStopSignalCaptor.capture(),
+            any(),
+            callbackCaptor.capture()
+        )
+
+        assertThat(firstStopSignalCaptor.firstValue).isNotSameAs(secondStopSignalCaptor.firstValue)
+    }
+
     private class StubTimeProvider : TimeProvider {
         var startTime: Long = 0L
         var endTime: Long = 0L