ref(time): Read the epoch directly instead of through SentryDateProvider (JAVA-572)

DateProviderEpochClock took its instant from options.getDateProvider(),
which meant allocating a SentryDate per call to read one long out of it --
and on Android that allocation also takes a System.nanoTime() reading that
an EpochClock never looks at, because a Timing measures on the
elapsed-real-time clock instead. The indirection bought compatibility with
a tick nothing here consumes.

SystemEpochClock reads the epoch itself, picking precision the way
SentryAutoDateProvider does: Instant.now() on JVM 9+, currentTimeMillis()
otherwise. Android is always the latter -- Instant is millisecond-granular
there whether or not the build desugars it. InstantEpochNanos is a class of
its own so the java.time reference is loaded only where it is used, the
same reason SentryInstantDate is kept separate.

The values are identical on every platform; the dependency is what changes.
setDateProvider no longer reaches the epoch clock, so tests override
getEpochClock() on SentryOptions, as SentryAndroidOptions already does for
getElapsedRealtimeClock().

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

Author: runningcode

sentry/api/sentry.api

@@ -7621,6 +7621,12 @@ public final class io/sentry/time/Stopwatch {
 	public static fun started (Lio/sentry/time/Ticker;)Lio/sentry/time/Stopwatch;
 }
 
+public final class io/sentry/time/SystemEpochClock : io/sentry/time/EpochClock {
+	public fun <init> (Lio/sentry/time/ElapsedRealtimeClock;)V
+	public fun now ()Lio/sentry/time/Timestamp;
+	public fun start ()Lio/sentry/time/Timing;
+}
+
 public abstract interface class io/sentry/time/Ticker {
 	public abstract fun tickNanos ()J
 }

sentry/src/main/java/io/sentry/DateProviderEpochClock.java

@@ -24,6 +24,7 @@
 import io.sentry.time.ElapsedRealtimeClock;
 import io.sentry.time.EpochClock;
 import io.sentry.time.JavaElapsedRealtimeClock;
+import io.sentry.time.SystemEpochClock;
 import io.sentry.transport.ITransport;
 import io.sentry.transport.ITransportGate;
 import io.sentry.transport.NoOpEnvelopeCache;
@@ -529,7 +530,7 @@ public class SentryOptions {
       new LazyEvaluator<>(() -> new SentryAutoDateProvider());
 
   private final @NotNull LazyEvaluator<EpochClock> epochClock =
-      new LazyEvaluator<>(() -> new DateProviderEpochClock(this));
+      new LazyEvaluator<>(() -> new SystemEpochClock(getElapsedRealtimeClock()));
 
   private final @NotNull List<IPerformanceCollector> performanceCollectors = new ArrayList<>();
 
@@ -3069,8 +3070,9 @@ public void setDateProvider(final @NotNull SentryDateProvider dateProvider) {
    * Returns the wall clock, for stamping an instant that will be serialized or for starting
    * something whose duration will be reported.
    *
-   * <p>Backed by {@link #getDateProvider()}, so a provider set through {@link #setDateProvider} is
-   * honoured here too.
+   * <p>Independent of {@link #getDateProvider()}: the epoch values are the same, but an {@link
+   * io.sentry.time.Timing} measures on {@link #getElapsedRealtimeClock()} rather than on the {@link
+   * System#nanoTime()} tick a {@link SentryNanotimeDate} carries.
    */
   @ApiStatus.Internal
   public @NotNull EpochClock getEpochClock() {

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

@@ -0,0 +1,25 @@
+package io.sentry.time;
+
+import io.sentry.DateUtils;
+import java.time.Instant;
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * Reads the epoch from {@link Instant}.
+ *
+ * <p>A class of its own so that the reference to {@code java.time} is loaded only where {@link
+ * SystemEpochClock} decided to use it. Android's minSdk is below the API 26 that introduced {@code
+ * Instant}.
+ */
+@ApiStatus.Internal
+@SuppressWarnings("NewApi")
+final class InstantEpochNanos {
+
+  private InstantEpochNanos() {}
+
+  static long read() {
+    final Instant now = Instant.now();
+    // No long overflow until year 2262
+    return DateUtils.secondsToNanos(now.getEpochSecond()) + now.getNano();
+  }
+}

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

@@ -0,0 +1,44 @@
+package io.sentry.time;
+
+import io.sentry.DateUtils;
+import io.sentry.util.Platform;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * The {@link EpochClock} backed by the system wall clock.
+ *
+ * <p>{@link #now()} reads the epoch at the best precision the platform offers: {@link
+ * java.time.Instant} where it is sub-millisecond, and {@link System#currentTimeMillis()} everywhere
+ * else. Android is always the latter — {@code Instant} is millisecond-granular there whether or not
+ * the build desugars it, see https://github.com/getsentry/sentry-java/pull/2451.
+ *
+ * <p>Millisecond anchors are not the precision loss they look like, because nothing here measures
+ * with them. A {@link Timing} reports its duration from a {@link Stopwatch}, so the nanosecond
+ * precision that matters comes off the monotonic clock and only the anchor is coarse.
+ */
+@ApiStatus.Internal
+public final class SystemEpochClock implements EpochClock {
+
+  private static final boolean INSTANT_IS_SUB_MILLISECOND =
+      Platform.isJvm() && Platform.isJavaNinePlus();
+
+  private final @NotNull ElapsedRealtimeClock clock;
+
+  public SystemEpochClock(final @NotNull ElapsedRealtimeClock clock) {
+    this.clock = clock;
+  }
+
+  @Override
+  public @NotNull Timestamp now() {
+    return Timestamp.ofEpochNanos(
+        INSTANT_IS_SUB_MILLISECOND
+            ? InstantEpochNanos.read()
+            : DateUtils.millisToNanos(System.currentTimeMillis()));
+  }
+
+  @Override
+  public @NotNull Timing start() {
+    return Timing.started(now(), clock);
+  }
+}

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

@@ -0,0 +1,34 @@
+package io.sentry.time
+
+import com.google.common.truth.Truth.assertThat
+import java.util.concurrent.TimeUnit.MILLISECONDS
+import kotlin.test.Test
+
+class SystemEpochClockTest {
+  @Test
+  fun `now reads the system wall clock`() {
+    val clock = SystemEpochClock(TestTicker())
+    val before = MILLISECONDS.toNanos(System.currentTimeMillis())
+    val now = clock.now().epochNanos()
+    val after = MILLISECONDS.toNanos(System.currentTimeMillis())
+
+    // the bounds are millisecond-truncated, so now() may sit up to a millisecond past `after`
+    assertThat(now).isAtLeast(before)
+    assertThat(now).isAtMost(after + MILLISECONDS.toNanos(1))
+  }
+
+  @Test
+  fun `start anchors on the wall clock and measures on the supplied clock`() {
+    val ticker = TestTicker()
+    val clock = SystemEpochClock(ticker)
+    val before = MILLISECONDS.toNanos(System.currentTimeMillis())
+
+    val timing = clock.start()
+    ticker.advance(120, MILLISECONDS)
+
+    assertThat(timing.start().epochNanos()).isAtLeast(before)
+    assertThat(timing.durationNanos()).isEqualTo(MILLISECONDS.toNanos(120))
+    assertThat(timing.end().epochNanos())
+      .isEqualTo(timing.start().epochNanos() + MILLISECONDS.toNanos(120))
+  }
+}