Merge pull request #3076 from DataDog/yl/profiling/support-multi-request

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,44 @@ class PerfettoProfilerTest {
         verifyNoInteractions(mockProfilerCallback)
     }
 
+    @Test
+    fun `M not have the same stop signal W start&stop multiple times`() {
+        inOrder(mockService) {
+            // When
+            // First request
+            testedProfiler.start(mockContext, setOf(fakeInstanceName))
+            val stopSignalCaptor = argumentCaptor<CancellationSignal>()
+            testedProfiler.stop(fakeInstanceName)
+
+            verify(mockService).requestProfiling(
+                eq(ProfilingManager.PROFILING_TYPE_STACK_SAMPLING),
+                any<Bundle>(),
+                any<String>(),
+                stopSignalCaptor.capture(),
+                any(),
+                callbackCaptor.capture()
+            )
+            // Then
+            val successResult = mock<ProfilingResult> {
+                on { errorCode } doReturn ProfilingResult.ERROR_NONE
+                on { resultFilePath } doReturn fakePath
+            }
+            callbackCaptor.firstValue.accept(successResult)
+
+            // Second request
+            testedProfiler.start(mockContext, setOf(fakeInstanceName))
+            verify(mockService).requestProfiling(
+                eq(ProfilingManager.PROFILING_TYPE_STACK_SAMPLING),
+                any<Bundle>(),
+                any<String>(),
+                stopSignalCaptor.capture(),
+                any(),
+                callbackCaptor.capture()
+            )
+            assertThat(stopSignalCaptor.firstValue).isNotSameAs(stopSignalCaptor.secondValue)
+        }
+    }
+
     private class StubTimeProvider : TimeProvider {
         var startTime: Long = 0L
         var endTime: Long = 0L