Speed up AnrWatcherTest and migrate to kotlin (#877)

* Rename .java to .kt

* migrate to kotlin

* remove old java test

* overload timeout to speed up test

* fix test

Author: breedx-splk

instrumentation/anr/src/main/java/io/opentelemetry/android/instrumentation/anr/AnrWatcher.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.android.instrumentation.anr
+
+import android.os.Handler
+import io.opentelemetry.context.Context
+import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeUnit.SECONDS
+import java.util.concurrent.atomic.AtomicInteger
+
+internal val DEFAULT_POLL_DURATION_NS = SECONDS.toNanos(1)
+
+/**
+ * Class that watches the ui thread for ANRs by posting
+ * Runnables to the main thread. If 5 consecutive responses
+ * time out, then an ANR is detected.
+ *
+ * @param pollDurationNs - exists for testing
+ */
+internal class AnrWatcher(
+    private val uiHandler: Handler,
+    private val mainThread: Thread,
+    private val instrumenter: Instrumenter<Array<StackTraceElement>, Void>,
+    private val pollDurationNs: Long = DEFAULT_POLL_DURATION_NS,
+) : Runnable {
+    private val anrCounter = AtomicInteger()
+
+    constructor(uiHandler: Handler, mainThread: Thread, instrumenter: Instrumenter<Array<StackTraceElement>, Void>) :
+        this(uiHandler, mainThread, instrumenter, DEFAULT_POLL_DURATION_NS)
+
+    override fun run() {
+        val response = CountDownLatch(1)
+        if (!uiHandler.post { response.countDown() }) {
+            // the main thread is probably shutting down. ignore and return.
+            return
+        }
+        val success: Boolean
+        try {
+            success = response.await(pollDurationNs, TimeUnit.NANOSECONDS)
+        } catch (e: InterruptedException) {
+            return
+        }
+        if (success) {
+            anrCounter.set(0)
+            return
+        }
+        if (anrCounter.incrementAndGet() >= 5) {
+            val stackTrace = mainThread.stackTrace
+            recordAnr(stackTrace)
+            // only report once per 5s.
+            anrCounter.set(0)
+        }
+    }
+
+    private fun recordAnr(stackTrace: Array<StackTraceElement>) {
+        val context = instrumenter.start(Context.current(), stackTrace)
+        instrumenter.end(context, stackTrace, null, null)
+    }
+}

instrumentation/anr/src/main/java/io/opentelemetry/android/instrumentation/anr/AnrWatcher.kt

@@ -10,6 +10,7 @@
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import android.os.Looper;
 import io.opentelemetry.android.internal.services.applifecycle.AppLifecycle;
@@ -32,6 +33,7 @@ class AnrDetectorTest {
 
     @Test
     void shouldInstallInstrumentation() {
+        when(mainLooper.getThread()).thenReturn(new Thread());
         OpenTelemetry openTelemetry = OpenTelemetrySdk.builder().build();
 
         AnrDetector anrDetector =

instrumentation/anr/src/test/java/io/opentelemetry/android/instrumentation/anr/AnrDetectorTest.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.android.instrumentation.anr
+
+import android.os.Handler
+import io.mockk.Called
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter
+import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension
+import org.junit.Before
+import org.junit.Test
+import org.junit.jupiter.api.extension.RegisterExtension
+
+class AnrWatcherTest {
+    @JvmField
+    @RegisterExtension
+    val testing = OpenTelemetryExtension.create()
+
+    private lateinit var handler: Handler
+    private lateinit var mainThread: Thread
+    private lateinit var instrumenter: Instrumenter<Array<StackTraceElement>, Void>
+
+    @Before
+    fun setup() {
+        handler = mockk()
+        mainThread = mockk()
+        instrumenter = mockk()
+    }
+
+    @Test
+    fun mainThreadDisappearing() {
+        val anrWatcher = AnrWatcher(handler, mainThread, instrumenter)
+        for (i in 0..4) {
+            every { handler.post(any()) } returns false
+            anrWatcher.run()
+        }
+        verify { instrumenter wasNot Called }
+    }
+
+    @Test
+    fun noAnr() {
+        val anrWatcher = AnrWatcher(handler, mainThread, instrumenter)
+        for (i in 0..4) {
+            every { handler.post(any()) } answers {
+                val callback = it.invocation.args[0] as Runnable
+                callback.run()
+                true
+            }
+
+            anrWatcher.run()
+        }
+        verify { instrumenter wasNot Called }
+    }
+
+    @Test
+    fun noAnr_temporaryPause() {
+        val anrWatcher = AnrWatcher(handler, mainThread, instrumenter)
+        for (i in 0..4) {
+            val index = i
+            every { handler.post(any()) } answers {
+                val callback = it.invocation.args[0] as Runnable
+                // have it fail once
+                if (index != 3) {
+                    callback.run()
+                }
+                true
+            }
+            anrWatcher.run()
+        }
+        verify { instrumenter wasNot Called }
+    }
+
+    @Test
+    fun anr_detected() {
+        val stackTrace: Array<StackTraceElement> = arrayOf()
+        every { instrumenter.start(any(), any()) } returns mockk()
+        every { instrumenter.end(any(), any(), any(), any()) } returns mockk()
+        every { mainThread.stackTrace } returns stackTrace
+
+        val anrWatcher = AnrWatcher(handler, mainThread, instrumenter, 1)
+        every { handler.post(any()) } returns true
+        for (i in 0..4) {
+            anrWatcher.run()
+        }
+        verify(exactly = 1) { instrumenter.start(any(), refEq(stackTrace)) }
+        verify(exactly = 1) { instrumenter.end(any(), refEq(stackTrace), isNull(), isNull()) }
+        for (i in 0..3) {
+            anrWatcher.run()
+        }
+        // Still just the 1 time
+        verify(exactly = 1) { instrumenter.start(any(), refEq(stackTrace)) }
+        verify(exactly = 1) { instrumenter.end(any(), refEq(stackTrace), isNull(), isNull()) }
+
+        anrWatcher.run()
+
+        verify(exactly = 2) { instrumenter.start(any(), refEq(stackTrace)) }
+        verify(exactly = 2) { instrumenter.end(any(), refEq(stackTrace), isNull(), isNull()) }
+    }
+}