ref(time): Supply the ANR ticker through MonotonicTickerProvider (JAVA-579)

Both ANR detectors resolved AndroidMonotonicTicker.getInstance() themselves,
so each call site named the concrete Android ticker and neither could be
pointed at another one. SentryAndroidOptions already knows which ticker the
platform wants, but it is final, so a test cannot override the getter.

Add a one-method MonotonicTickerProvider that SentryOptions implements.
ANRWatchDog gains a static factory that reads its timeout, debug behavior,
logger and ticker off options, replacing the telescoping convenience
constructor. AnrProfilingIntegration installs the ticker in register(),
which drops the two constructors it had grown and leaves the public no-arg
constructor and sentry-android-core.api unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: runningcode

sentry-android-core/src/main/java/io/sentry/android/core/ANRWatchDog.java

@@ -32,19 +32,19 @@
 import android.os.Debug;
 import io.sentry.ILogger;
 import io.sentry.SentryLevel;
-import io.sentry.android.core.internal.time.AndroidMonotonicTicker;
 import io.sentry.time.Deadline;
 import io.sentry.time.MonotonicTicker;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.TestOnly;
 
 /** A watchdog timer thread that detects when the UI thread has frozen. */
 @SuppressWarnings("UnusedReturnValue")
 final class ANRWatchDog extends Thread {
 
+  private static final long DEFAULT_POLLING_INTERVAL_MS = 500;
+
   private final boolean reportInDebug;
   private final ANRListener anrListener;
   private final MainLooperHandler uiHandler;
@@ -66,24 +66,22 @@ final class ANRWatchDog extends Thread {
   @SuppressWarnings("UnnecessaryLambda")
   private final Runnable ticker;
 
-  ANRWatchDog(
-      long timeoutIntervalMillis,
-      boolean reportInDebug,
-      @NotNull ANRListener listener,
-      @NotNull ILogger logger,
+  /** Reads the timeout, the debug behavior, the logger and the ticker off {@code options}. */
+  static @NotNull ANRWatchDog create(
+      final @NotNull SentryAndroidOptions options,
+      final @NotNull ANRListener listener,
       final @NotNull Context context) {
-    this(
-        AndroidMonotonicTicker.getInstance(),
-        timeoutIntervalMillis,
-        500,
-        reportInDebug,
+    return new ANRWatchDog(
+        options.getMonotonicTicker(),
+        options.getAnrTimeoutIntervalMillis(),
+        DEFAULT_POLLING_INTERVAL_MS,
+        options.isAnrReportInDebug(),
         listener,
-        logger,
+        options.getLogger(),
         new MainLooperHandler(),
         context);
   }
 
-  @TestOnly
   ANRWatchDog(
       @NotNull final MonotonicTicker monotonicTicker,
       long timeoutIntervalMillis,

sentry-android-core/src/main/java/io/sentry/android/core/AnrIntegration.java

@@ -95,12 +95,7 @@ private void startAnrWatchdog(
                 options.getAnrTimeoutIntervalMillis());
 
         anrWatchDog =
-            new ANRWatchDog(
-                options.getAnrTimeoutIntervalMillis(),
-                options.isAnrReportInDebug(),
-                error -> reportANR(scopes, options, error),
-                options.getLogger(),
-                context);
+            ANRWatchDog.create(options, error -> reportANR(scopes, options, error), context);
         anrWatchDog.start();
 
         options.getLogger().log(SentryLevel.DEBUG, "AnrIntegration installed.");

sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfilingIntegration.java

@@ -13,8 +13,9 @@
 import io.sentry.SentryOptions;
 import io.sentry.android.core.AppState;
 import io.sentry.android.core.SentryAndroidOptions;
-import io.sentry.android.core.internal.time.AndroidMonotonicTicker;
+import io.sentry.time.JavaMonotonicTicker;
 import io.sentry.time.MonotonicTicker;
+import io.sentry.time.MonotonicTickerProvider;
 import io.sentry.time.Stopwatch;
 import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.Objects;
@@ -46,8 +47,11 @@ public class AnrProfilingIntegration
   static final int MAX_NUM_STACKS = (int) (10_000 / POLLING_INTERVAL_MS);
 
   private final AtomicBoolean enabled = new AtomicBoolean(true);
-  private final @NotNull MonotonicTicker ticker;
-  private final @NotNull Runnable updater;
+  private volatile @NotNull MonotonicTicker ticker = JavaMonotonicTicker.getInstance();
+
+  @SuppressWarnings("UnnecessaryLambda")
+  private final @NotNull Runnable updater = () -> lastMainThreadExecutionNanos = ticker.tickNanos();
+
   private final @NotNull AutoClosableReentrantLock lifecycleLock = new AutoClosableReentrantLock();
   private final @NotNull AutoClosableReentrantLock profileManagerLock =
       new AutoClosableReentrantLock();
@@ -64,15 +68,16 @@ public class AnrProfilingIntegration
   private volatile @Nullable Handler mainHandler;
   private volatile @Nullable Thread mainThread;
 
-  public AnrProfilingIntegration() {
-    this(AndroidMonotonicTicker.getInstance());
-  }
-
-  @TestOnly
-  AnrProfilingIntegration(final @NotNull MonotonicTicker ticker) {
-    this.ticker = ticker;
+  /**
+   * Installs the ticker to measure main-thread stalls with. Also resets the last-execution reading,
+   * so a stall is never measured against a tick from a different ticker.
+   *
+   * <p>Package-private so a test can install a fake ticker after {@link #register}, which {@code
+   * SentryAndroidOptions} cannot supply.
+   */
+  void installTickerFrom(final @NotNull MonotonicTickerProvider provider) {
+    this.ticker = provider.getMonotonicTicker();
     this.lastMainThreadExecutionNanos = ticker.tickNanos();
-    this.updater = () -> lastMainThreadExecutionNanos = ticker.tickNanos();
   }
 
   @Override
@@ -82,6 +87,7 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
             (options instanceof SentryAndroidOptions) ? (SentryAndroidOptions) options : null,
             "SentryAndroidOptions is required");
     this.logger = options.getLogger();
+    installTickerFrom(options);
 
     if (this.options.isAnrProfilingEnabled()) {
       if (this.options.getCacheDirPath() == null) {

sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt

@@ -174,8 +174,9 @@ class AnrProfilingIntegrationTest {
         anrProfilingSampleRate = 1.0
       }
 
-    val integration = AnrProfilingIntegration(ticker)
+    val integration = AnrProfilingIntegration()
     integration.register(mockScopes, androidOptions)
+    integration.installTickerFrom { ticker }
     // Drive the state machine synchronously to avoid racing the background polling thread.
 
     ticker.advance(900, MILLISECONDS)
@@ -209,8 +210,9 @@ class AnrProfilingIntegrationTest {
         anrProfilingSampleRate = 1.0
       }
 
-    val integration = AnrProfilingIntegration(ticker)
+    val integration = AnrProfilingIntegration()
     integration.register(mockScopes, androidOptions)
+    integration.installTickerFrom { ticker }
     integration.onBackground()
 
     ticker.advance(19_000, MILLISECONDS)
@@ -275,8 +277,9 @@ class AnrProfilingIntegrationTest {
         anrProfilingSampleRate = 0.0
       }
 
-    val integration = AnrProfilingIntegration(ticker)
+    val integration = AnrProfilingIntegration()
     integration.register(mockScopes, androidOptions)
+    integration.installTickerFrom { ticker }
     integration.onForeground()
 
     // Transition to suspicious

sentry/api/sentry.api

@@ -3654,7 +3654,7 @@ public final class io/sentry/SentryOpenTelemetryMode : java/lang/Enum {
 	public static fun values ()[Lio/sentry/SentryOpenTelemetryMode;
 }
 
-public class io/sentry/SentryOptions : io/sentry/transport/RateLimiterConfig {
+public class io/sentry/SentryOptions : io/sentry/time/MonotonicTickerProvider, io/sentry/transport/RateLimiterConfig {
 	public static final field DEFAULT_PROPAGATION_TARGETS Ljava/lang/String;
 	public static final field MAX_EVENT_SIZE_BYTES J
 	protected final field lock Lio/sentry/util/AutoClosableReentrantLock;
@@ -7626,6 +7626,10 @@ public abstract interface class io/sentry/time/MonotonicTicker {
 	public abstract fun tickNanos ()J
 }
 
+public abstract interface class io/sentry/time/MonotonicTickerProvider {
+	public abstract fun getMonotonicTicker ()Lio/sentry/time/MonotonicTicker;
+}
+
 public final class io/sentry/time/Stopwatch {
 	public fun elapsed (Ljava/util/concurrent/TimeUnit;)J
 	public fun elapsedNanos ()J

sentry/src/main/java/io/sentry/SentryOptions.java

@@ -24,6 +24,7 @@
 import io.sentry.time.EpochClock;
 import io.sentry.time.JavaMonotonicTicker;
 import io.sentry.time.MonotonicTicker;
+import io.sentry.time.MonotonicTickerProvider;
 import io.sentry.time.SystemEpochClock;
 import io.sentry.transport.ITransport;
 import io.sentry.transport.ITransportGate;
@@ -59,7 +60,7 @@
 
 /** Sentry SDK options */
 @Open
-public class SentryOptions implements RateLimiterConfig {
+public class SentryOptions implements RateLimiterConfig, MonotonicTickerProvider {
 
   @ApiStatus.Internal public static final @NotNull String DEFAULT_PROPAGATION_TARGETS = ".*";
 
@@ -3088,6 +3089,7 @@ public void setDateProvider(final @NotNull SentryDateProvider dateProvider) {
    * which this module cannot reference. On the JVM there is no suspend state to account for.
    */
   @ApiStatus.Internal
+  @Override
   public @NotNull MonotonicTicker getMonotonicTicker() {
     return JavaMonotonicTicker.getInstance();
   }

sentry/src/main/java/io/sentry/time/MonotonicTickerProvider.java

@@ -0,0 +1,18 @@
+package io.sentry.time;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Supplies the {@link MonotonicTicker} to measure elapsed time with.
+ *
+ * <p>{@code SentryOptions} implements this, and the Android module overrides it with a ticker the
+ * core module cannot reference. Depending on this interface rather than on the options class keeps
+ * the concrete ticker out of call sites, and lets a test supply its own without subclassing the
+ * final {@code SentryAndroidOptions}.
+ */
+@ApiStatus.Internal
+public interface MonotonicTickerProvider {
+  @NotNull
+  MonotonicTicker getMonotonicTicker();
+}