From 6d03de35a4950065f3db7d0101a67a1a8a88b0eb Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Fri, 20 Nov 2026 09:55:41 +0100 Subject: [PATCH] feat(anr): Add ThreadHangSignal --- .../api/sentry-android-core.api | 9 + .../android/core/hang/HangRecorder.java | 1 + .../android/core/hang/ThreadHangSignal.java | 110 +++++++++ .../android/core/hang/HangRecorderTest.kt | 44 ++++ .../android/core/hang/ThreadHangSignalTest.kt | 223 ++++++++++++++++++ 5 files changed, 387 insertions(+) create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/hang/ThreadHangSignal.java create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/hang/ThreadHangSignalTest.kt diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api index fe6b644b33..5db38fadc3 100644 --- a/sentry-android-core/api/sentry-android-core.api +++ b/sentry-android-core/api/sentry-android-core.api @@ -841,6 +841,7 @@ public final class io/sentry/android/core/hang/HangRecorder : io/sentry/android/ public static final field DEFAULT_EXECUTOR_FACTORY Lio/sentry/android/core/hang/HangRecorder$ExecutorFactory; public static final field DEFAULT_MAX_RECORDING_TIME_MS J public static final field DEFAULT_POLLING_INTERVAL_MS J + public static final field DEFAULT_SUSPICIOUS_THRESHOLD_MS J public fun (Lio/sentry/SentryOptions;Lio/sentry/android/core/AppStateProvider;Lio/sentry/time/MonotonicTicker;Lio/sentry/time/EpochClock;JJLio/sentry/android/core/hang/HangRecorder$ExecutorFactory;Lio/sentry/android/core/hang/HangRecorder$SignalFactory;Ljava/util/List;)V public fun addTickListener (Lio/sentry/android/core/hang/Metronome$TickListener;)V public fun close ()V @@ -890,6 +891,14 @@ public abstract interface class io/sentry/android/core/hang/Metronome$TickListen public abstract fun onMetronomeTick (J)V } +public final class io/sentry/android/core/hang/ThreadHangSignal : io/sentry/android/core/hang/HangSignal, io/sentry/android/core/hang/Metronome$TickListener { + public fun (Lio/sentry/android/core/hang/Metronome;Lio/sentry/time/MonotonicTicker;Lio/sentry/IDebugManager;Lio/sentry/android/core/hang/ThreadPoster;J)V + public fun close ()V + public fun onMetronomeTick (J)V + public fun start (Lio/sentry/android/core/hang/HangSignalListener;)V + public fun stop ()V +} + public abstract interface class io/sentry/android/core/hang/ThreadPoster { public abstract fun post (Ljava/lang/Runnable;)V public abstract fun remove (Ljava/lang/Runnable;)V diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/hang/HangRecorder.java b/sentry-android-core/src/main/java/io/sentry/android/core/hang/HangRecorder.java index b8f96cbff2..ddf442abd1 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/hang/HangRecorder.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/hang/HangRecorder.java @@ -44,6 +44,7 @@ public final class HangRecorder implements Metronome, Closeable, AppState.AppSta public static final long DEFAULT_POLLING_INTERVAL_MS = 66; public static final long DEFAULT_MAX_RECORDING_TIME_MS = 8_000; + public static final long DEFAULT_SUSPICIOUS_THRESHOLD_MS = 300; /** * Creates the executor of the recorder thread. It must run one task at a time on one thread, in diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/hang/ThreadHangSignal.java b/sentry-android-core/src/main/java/io/sentry/android/core/hang/ThreadHangSignal.java new file mode 100644 index 0000000000..168a5e9960 --- /dev/null +++ b/sentry-android-core/src/main/java/io/sentry/android/core/hang/ThreadHangSignal.java @@ -0,0 +1,110 @@ +package io.sentry.android.core.hang; + +import io.sentry.IDebugManager; +import io.sentry.time.MonotonicTicker; +import java.util.concurrent.TimeUnit; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * Reports {@link HangSignal.State#SUSPICIOUS} when a probe posted to the watched thread did not run + * for more than the suspicious threshold, and {@link HangSignal.State#IDLE} when it ran. The + * watched thread is the thread that the {@link ThreadPoster} posts to. + * + *

Only the probe runs on the watched thread. Everything else runs on the thread that calls the + * ticks of the {@link Metronome}. + */ +@ApiStatus.Internal +public final class ThreadHangSignal implements HangSignal, Metronome.TickListener { + + private final @NotNull Metronome metronome; + private final @NotNull MonotonicTicker ticker; + private final @NotNull IDebugManager debugManager; + private final @NotNull ThreadPoster poster; + private final long suspiciousThresholdMs; + + private volatile long probeRunMs; + + private final @NotNull Runnable probe = () -> probeRunMs = nowMs(); + + private @Nullable HangSignalListener listener; + private long probeFloorMs; + private boolean suspicious; + private long suspiciousSinceMs; + + public ThreadHangSignal( + final @NotNull Metronome metronome, + final @NotNull MonotonicTicker ticker, + final @NotNull IDebugManager debugManager, + final @NotNull ThreadPoster poster, + final long suspiciousThresholdMs) { + this.metronome = metronome; + this.ticker = ticker; + this.debugManager = debugManager; + this.poster = poster; + this.suspiciousThresholdMs = suspiciousThresholdMs; + } + + @Override + public void start(final @NotNull HangSignalListener listener) { + this.listener = listener; + suspicious = false; + // The probe may not have run since the last stop, so its time would read as a hang. + probeFloorMs = nowMs(); + metronome.addTickListener(this); + } + + @Override + public void stop() { + metronome.removeTickListener(this); + poster.remove(probe); + listener = null; + suspicious = false; + } + + @Override + public void close() { + stop(); + } + + @Override + public void onMetronomeTick(final long nowMs) { + check(nowMs); + poster.remove(probe); + poster.post(probe); + } + + private void check(final long nowMs) { + final @Nullable HangSignalListener currentListener = listener; + if (currentListener == null) { + return; + } + + // A breakpoint is not a hang. + if (debugManager.isDebuggerConnected()) { + probeFloorMs = nowMs; + if (suspicious) { + suspicious = false; + currentListener.onSignalCanceled(this); + } + return; + } + + final long lastProbeMs = Math.max(probeRunMs, probeFloorMs); + if (suspicious) { + if (lastProbeMs > suspiciousSinceMs) { + suspicious = false; + currentListener.onSignalChanged(this, State.IDLE, nowMs - lastProbeMs); + } + } else if (nowMs - lastProbeMs > suspiciousThresholdMs) { + suspicious = true; + suspiciousSinceMs = lastProbeMs; + currentListener.onSignalChanged(this, State.SUSPICIOUS, nowMs - lastProbeMs); + } + } + + private long nowMs() { + return TimeUnit.NANOSECONDS.toMillis(ticker.tickNanos()); + } +} diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/hang/HangRecorderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/hang/HangRecorderTest.kt index 23ddbab5ad..c43f309408 100644 --- a/sentry-android-core/src/test/java/io/sentry/android/core/hang/HangRecorderTest.kt +++ b/sentry-android-core/src/test/java/io/sentry/android/core/hang/HangRecorderTest.kt @@ -12,8 +12,10 @@ import io.sentry.android.core.hang.HangRecorder.DEFAULT_POLLING_INTERVAL_MS import io.sentry.test.DeferredExecutorService import io.sentry.test.NonOverridableNoOpSentryExecutorService import io.sentry.time.EpochClock +import io.sentry.time.JavaMonotonicTicker import io.sentry.time.TestMonotonicTicker import io.sentry.time.Timestamp +import java.util.concurrent.CountDownLatch import java.util.concurrent.TimeUnit import java.util.concurrent.TimeUnit.HOURS import java.util.concurrent.TimeUnit.MILLISECONDS @@ -665,6 +667,48 @@ class HangRecorderTest { assertThat(collector.calls).containsExactly("close") } + @Test + fun `recorder on the default executor posts the probe of a thread signal`() { + val posted = CountDownLatch(1) + val poster = + object : ThreadPoster { + override fun post(runnable: Runnable) = posted.countDown() + + override fun remove(runnable: Runnable) = Unit + } + appStateProvider.foreground() + val created = + HangRecorder( + options, + appStateProvider, + JavaMonotonicTicker.getInstance(), + epochClock, + DEFAULT_POLLING_INTERVAL_MS, + DEFAULT_MAX_RECORDING_TIME_MS, + HangRecorder.DEFAULT_EXECUTOR_FACTORY, + { metronome -> + listOf( + ThreadHangSignal( + metronome, + JavaMonotonicTicker.getInstance(), + { false }, + poster, + HangRecorder.DEFAULT_SUSPICIOUS_THRESHOLD_MS, + ), + ) + }, + emptyList(), + ) + + created.subscribe(listener) + + try { + assertThat(posted.await(10, TimeUnit.SECONDS)).isTrue() + } finally { + created.close() + } + } + private class FakeAppStateProvider : AppStateProvider { val listeners = mutableListOf() private var inBackground: Boolean? = null diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/hang/ThreadHangSignalTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/hang/ThreadHangSignalTest.kt new file mode 100644 index 0000000000..7b0c55d29c --- /dev/null +++ b/sentry-android-core/src/test/java/io/sentry/android/core/hang/ThreadHangSignalTest.kt @@ -0,0 +1,223 @@ +package io.sentry.android.core.hang + +import com.google.common.truth.Truth.assertThat +import io.sentry.IDebugManager +import io.sentry.time.TestMonotonicTicker +import java.util.concurrent.TimeUnit.HOURS +import java.util.concurrent.TimeUnit.MILLISECONDS +import java.util.concurrent.TimeUnit.NANOSECONDS +import kotlin.test.BeforeTest +import kotlin.test.Test + +class ThreadHangSignalTest { + + private class FakeMetronome : Metronome { + val listeners = mutableListOf() + + override fun addTickListener(listener: Metronome.TickListener) { + listeners.add(listener) + } + + override fun removeTickListener(listener: Metronome.TickListener) { + listeners.remove(listener) + } + + fun tick(nowMs: Long) = listeners.toList().forEach { it.onMetronomeTick(nowMs) } + } + + private class FakePoster : ThreadPoster { + val calls = mutableListOf() + var pending: Runnable? = null + + override fun post(runnable: Runnable) { + calls.add("post") + pending = runnable + } + + override fun remove(runnable: Runnable) { + calls.add("remove") + if (pending === runnable) { + pending = null + } + } + + fun runProbe() { + pending?.run() + pending = null + } + } + + private inner class RecordingListener : HangSignalListener { + val changes = mutableListOf>() + var canceled = 0 + + override fun onSignalChanged(signal: HangSignal, state: HangSignal.State, durationMs: Long) { + changes.add(state to nowMs - durationMs) + } + + override fun onSignalCanceled(signal: HangSignal) { + canceled++ + } + } + + private lateinit var ticker: TestMonotonicTicker + private lateinit var metronome: FakeMetronome + private lateinit var poster: FakePoster + private lateinit var listener: RecordingListener + private var debuggerConnected = false + private lateinit var signal: ThreadHangSignal + + private val nowMs: Long + get() = NANOSECONDS.toMillis(ticker.tickNanos()) + + @BeforeTest + fun setUp() { + ticker = TestMonotonicTicker(HOURS.toNanos(30)) + metronome = FakeMetronome() + poster = FakePoster() + listener = RecordingListener() + signal = createSignal(HangRecorder.DEFAULT_SUSPICIOUS_THRESHOLD_MS) + signal.start(listener) + } + + private fun createSignal(suspiciousThresholdMs: Long) = + ThreadHangSignal( + metronome, + ticker, + IDebugManager { debuggerConnected }, + poster, + suspiciousThresholdMs, + ) + + private fun advance(ms: Long) { + ticker.advance(ms, MILLISECONDS) + } + + private fun advanceAndTick(ms: Long) { + advance(ms) + metronome.tick(nowMs) + } + + @Test + fun `delay above 300ms sends suspicious with the duration since the last probe run`() { + val start = nowMs + advanceAndTick(66) + poster.runProbe() + val probeRun = nowMs + advanceAndTick(HangRecorder.DEFAULT_SUSPICIOUS_THRESHOLD_MS + 1) + + assertThat(listener.changes).containsExactly(HangSignal.State.SUSPICIOUS to probeRun) + assertThat(probeRun).isEqualTo(start + 66) + } + + @Test + fun `suspicious threshold comes from the constructor`() { + signal.stop() + signal = createSignal(1_000) + signal.start(listener) + + advanceAndTick(1_000) + assertThat(listener.changes).isEmpty() + + advanceAndTick(1) + assertThat(listener.changes.map { it.first }).containsExactly(HangSignal.State.SUSPICIOUS) + } + + @Test + fun `probe run after suspicious sends idle with the duration since the probe run`() { + advanceAndTick(400) + advance(500) + poster.runProbe() + val probeRun = nowMs + advanceAndTick(66) + + assertThat(listener.changes.map { it.first }) + .containsExactly(HangSignal.State.SUSPICIOUS, HangSignal.State.IDLE) + .inOrder() + assertThat(listener.changes.last().second).isEqualTo(probeRun) + } + + @Test + fun `suspicious is not sent again until idle`() { + advanceAndTick(400) + advanceAndTick(66) + advanceAndTick(66) + + assertThat(listener.changes).hasSize(1) + } + + @Test + fun `delay below 300ms sends nothing`() { + advanceAndTick(66) + poster.runProbe() + advanceAndTick(HangRecorder.DEFAULT_SUSPICIOUS_THRESHOLD_MS) + + assertThat(listener.changes).isEmpty() + assertThat(listener.canceled).isEqualTo(0) + } + + @Test + fun `start resets probe time after a long stop`() { + signal.stop() + ticker.advance(10_000, MILLISECONDS) + signal.start(listener) + advanceAndTick(66) + + assertThat(listener.changes).isEmpty() + } + + @Test + fun `stop removes the tick listener`() { + signal.stop() + + assertThat(metronome.listeners).isEmpty() + } + + @Test + fun `close removes the tick listener and the pending probe`() { + advanceAndTick(66) + + signal.close() + + assertThat(metronome.listeners).isEmpty() + assertThat(poster.pending).isNull() + } + + @Test + fun `debugger connected while suspicious cancels`() { + advanceAndTick(400) + debuggerConnected = true + advanceAndTick(66) + + assertThat(listener.changes.map { it.first }).containsExactly(HangSignal.State.SUSPICIOUS) + assertThat(listener.canceled).isEqualTo(1) + } + + @Test + fun `debugger connected sends no state`() { + debuggerConnected = true + advanceAndTick(5_000) + advanceAndTick(5_000) + + assertThat(listener.changes).isEmpty() + assertThat(listener.canceled).isEqualTo(0) + } + + @Test + fun `time at a breakpoint does not count after the debugger detaches`() { + debuggerConnected = true + advanceAndTick(5_000) + debuggerConnected = false + advanceAndTick(66) + + assertThat(listener.changes).isEmpty() + } + + @Test + fun `each tick removes the pending probe before posting`() { + advanceAndTick(66) + advanceAndTick(66) + + assertThat(poster.calls).containsExactly("remove", "post", "remove", "post").inOrder() + } +}