Updated ANR data model from span to log event (#1101)

* updated ANR data from span to log event

* update readme

* restore comment in test case

* remove whitespace

* spotless apply

Author: tonzhan2

demo-app/README.md

@@ -41,7 +41,7 @@ The OpenTelemetry Android Demo App currently supports the following features:
 
 * ANR Detection
   - Automatically detects and reports ANRs in the app.
-  - ANR events are captured as spans with detailed stack traces, providing insights into the exact operations that caused the ANR.
+  - ANR events are captured as log record events with detailed stack traces, providing insights into the exact operations that caused the ANR.
   - The span includes key attributes such as `screen.name`, `session.id`, and network information to assist in diagnosing the issue.
   - In order to crash the demo app, try to add to cart exactly 9 National Park Foundation Explorascopes (first product on the product list) and click "Yes, I'm sure." on the alert pop-up.
 

instrumentation/anr/README.md

@@ -18,9 +18,9 @@ This instrumentation produces the following telemetry:
 
 ### ANR
 
-* Type: Span
+* Type: Event
 * Name: `ANR`
-* Description: This zero-duration span is created when this instrumentation detects an ANR.
+* Description: This log event is created when this instrumentation detects an ANR.
 * Status: `ERROR` (always)
 * Attributes:
   * `exception.stacktrace`: A string representation of the call stack of the main thread at the time of the ANR.

instrumentation/anr/build.gradle.kts

@@ -26,4 +26,6 @@ dependencies {
     implementation(libs.opentelemetry.semconv)
     implementation(libs.opentelemetry.sdk)
     implementation(libs.opentelemetry.instrumentation.api)
+    implementation(libs.opentelemetry.semconv.incubating)
+    implementation(libs.opentelemetry.sdk.extension.incubator)
 }

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

@@ -9,9 +9,8 @@
 import android.os.Looper;
 import io.opentelemetry.android.internal.services.applifecycle.AppLifecycle;
 import io.opentelemetry.api.OpenTelemetry;
-import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.api.logs.Logger;
 import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor;
-import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter;
 import java.util.List;
 import java.util.concurrent.ScheduledExecutorService;
 
@@ -44,25 +43,14 @@ public final class AnrDetector {
      */
     public void start() {
         Handler uiHandler = new Handler(mainLooper);
+        Logger anrLogger = openTelemetry.getLogsBridge().get("io.opentelemetry.anr");
         AnrWatcher anrWatcher =
-                new AnrWatcher(uiHandler, mainLooper.getThread(), buildAnrInstrumenter());
+                new AnrWatcher(uiHandler, mainLooper.getThread(), anrLogger, additionalExtractors);
 
         AnrDetectorToggler listener = new AnrDetectorToggler(anrWatcher, scheduler);
         // call it manually the first time to enable the ANR detection
         listener.onApplicationForegrounded();
 
         appLifecycle.registerListener(listener);
     }
-
-    private Instrumenter<StackTraceElement[], Void> buildAnrInstrumenter() {
-        return Instrumenter.<StackTraceElement[], Void>builder(
-                        openTelemetry, "io.opentelemetry.anr", stackTrace -> "ANR")
-                // it's always an error
-                .setSpanStatusExtractor(
-                        (spanStatusBuilder, stackTrace, unused, error) ->
-                                spanStatusBuilder.setStatus(StatusCode.ERROR))
-                .addAttributesExtractor(new StackTraceFormatter())
-                .addAttributesExtractors(additionalExtractors)
-                .buildInstrumenter();
-    }
 }

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

@@ -6,8 +6,14 @@
 package io.opentelemetry.android.instrumentation.anr
 
 import android.os.Handler
+import io.opentelemetry.api.common.Attributes
+import io.opentelemetry.api.incubator.logs.ExtendedLogRecordBuilder
+import io.opentelemetry.api.logs.Logger
 import io.opentelemetry.context.Context
-import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter
+import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor
+import io.opentelemetry.semconv.ExceptionAttributes.EXCEPTION_STACKTRACE
+import io.opentelemetry.semconv.incubating.ThreadIncubatingAttributes.THREAD_ID
+import io.opentelemetry.semconv.incubating.ThreadIncubatingAttributes.THREAD_NAME
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeUnit.SECONDS
@@ -25,13 +31,23 @@ internal val DEFAULT_POLL_DURATION_NS = SECONDS.toNanos(1)
 internal class AnrWatcher(
     private val uiHandler: Handler,
     private val mainThread: Thread,
-    private val instrumenter: Instrumenter<Array<StackTraceElement>, Void>,
+    private val anrLogger: Logger,
+    private val additionalExtractors: List<AttributesExtractor<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)
+    constructor(uiHandler: Handler, mainThread: Thread, anrLogger: Logger) :
+        this(uiHandler, mainThread, anrLogger, emptyList(), DEFAULT_POLL_DURATION_NS)
+
+    // A constructor that can be called from Java
+    constructor(
+        uiHandler: Handler,
+        mainThread: Thread,
+        anrLogger: Logger,
+        additionalExtractors: List<AttributesExtractor<Array<StackTraceElement>, Void>>,
+    ) :
+        this(uiHandler, mainThread, anrLogger, additionalExtractors, DEFAULT_POLL_DURATION_NS)
 
     override fun run() {
         val response = CountDownLatch(1)
@@ -51,14 +67,36 @@ internal class AnrWatcher(
         }
         if (anrCounter.incrementAndGet() >= 5) {
             val stackTrace = mainThread.stackTrace
-            recordAnr(stackTrace)
+            emitAnrEvent(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)
+    private fun emitAnrEvent(stackTrace: Array<StackTraceElement>) {
+        val attributesBuilder =
+            Attributes
+                .builder()
+                .put(THREAD_ID, mainThread.id)
+                .put(THREAD_NAME, mainThread.name)
+                .put(EXCEPTION_STACKTRACE, stackTraceToString(stackTrace))
+
+        for (extractor in additionalExtractors) {
+            extractor.onStart(attributesBuilder, Context.current(), stackTrace)
+        }
+
+        val eventBuilder = anrLogger.logRecordBuilder() as ExtendedLogRecordBuilder
+        eventBuilder
+            .setEventName("device.anr")
+            .setAllAttributes(attributesBuilder.build())
+            .emit()
+    }
+
+    private fun stackTraceToString(stackTrace: Array<StackTraceElement>): String {
+        val stackTraceString = StringBuilder()
+        for (stackTraceElement in stackTrace) {
+            stackTraceString.append(stackTraceElement).append("\n")
+        }
+        return stackTraceString.toString()
     }
 }

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

@@ -10,41 +10,52 @@ 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.api.common.Attributes
+import io.opentelemetry.api.incubator.logs.ExtendedLogRecordBuilder
+import io.opentelemetry.api.logs.Logger
 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()
+    companion object {
+        @JvmField
+        @RegisterExtension
+        val testing = OpenTelemetryExtension.create()
+    }
 
     private lateinit var handler: Handler
     private lateinit var mainThread: Thread
-    private lateinit var instrumenter: Instrumenter<Array<StackTraceElement>, Void>
+    private lateinit var logger: Logger
+    private lateinit var logRecordBuilder: ExtendedLogRecordBuilder
 
     @Before
     fun setup() {
         handler = mockk()
-        mainThread = mockk()
-        instrumenter = mockk()
+        mainThread = Thread.currentThread()
+        logger = mockk()
+        logRecordBuilder = mockk(relaxed = true)
+
+        every { logger.logRecordBuilder() } returns logRecordBuilder
+        every { logRecordBuilder.setEventName(any()) } returns logRecordBuilder
+        every { logRecordBuilder.setAllAttributes(any<Attributes>()) } returns logRecordBuilder
+        every { logRecordBuilder.emit() } returns Unit
     }
 
     @Test
     fun mainThreadDisappearing() {
-        val anrWatcher = AnrWatcher(handler, mainThread, instrumenter)
+        val anrWatcher = AnrWatcher(handler, mainThread, logger)
         for (i in 0..4) {
             every { handler.post(any()) } returns false
             anrWatcher.run()
         }
-        verify { instrumenter wasNot Called }
+        verify { logger wasNot Called }
     }
 
     @Test
     fun noAnr() {
-        val anrWatcher = AnrWatcher(handler, mainThread, instrumenter)
+        val anrWatcher = AnrWatcher(handler, mainThread, logger)
         for (i in 0..4) {
             every { handler.post(any()) } answers {
                 val callback = it.invocation.args[0] as Runnable
@@ -54,12 +65,12 @@ class AnrWatcherTest {
 
             anrWatcher.run()
         }
-        verify { instrumenter wasNot Called }
+        verify { logger wasNot Called }
     }
 
     @Test
     fun noAnr_temporaryPause() {
-        val anrWatcher = AnrWatcher(handler, mainThread, instrumenter)
+        val anrWatcher = AnrWatcher(handler, mainThread, logger)
         for (i in 0..4) {
             val index = i
             every { handler.post(any()) } answers {
@@ -72,33 +83,34 @@ class AnrWatcherTest {
             }
             anrWatcher.run()
         }
-        verify { instrumenter wasNot Called }
+        verify { logger 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)
+        val anrWatcher = AnrWatcher(handler, mainThread, logger, emptyList(), 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()) }
+        verify(exactly = 1) { logger.logRecordBuilder() }
+        verify(exactly = 1) { logRecordBuilder.setEventName("device.anr") }
+        verify(exactly = 1) { logRecordBuilder.setAllAttributes(any<Attributes>()) }
+        verify(exactly = 1) { logRecordBuilder.emit() }
+
         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()) }
+        verify(exactly = 1) { logger.logRecordBuilder() }
+        verify(exactly = 1) { logRecordBuilder.emit() }
 
         anrWatcher.run()
 
-        verify(exactly = 2) { instrumenter.start(any(), refEq(stackTrace)) }
-        verify(exactly = 2) { instrumenter.end(any(), refEq(stackTrace), isNull(), isNull()) }
+        verify(exactly = 2) { logger.logRecordBuilder() }
+        verify(exactly = 2) { logRecordBuilder.setEventName("device.anr") }
+        verify(exactly = 2) { logRecordBuilder.setAllAttributes(any<Attributes>()) }
+        verify(exactly = 2) { logRecordBuilder.emit() }
     }
 }