ref(core): Keep the creation tick on deserialized breadcrumbs

Always fill the tick and let the timestamp comparison carry the fix, so
ordering no longer depends on every caller using a stable sort.

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

Author: runningcode

sentry/src/main/java/io/sentry/Breadcrumb.java

@@ -26,14 +26,7 @@ public final class Breadcrumb implements JsonUnknown, JsonSerializable, Comparab
   /** A timestamp representing when the breadcrumb occurred as java.util.Date. */
   private @Nullable Date timestamp;
 
-  /**
-   * The tick this breadcrumb was created at, used to order breadcrumbs that share a timestamp.
-   *
-   * <p>Null for a breadcrumb rebuilt from a serialized one. A tick is a reading of a counter whose
-   * origin is this process run, so a tick from an earlier run is a number from an unrelated origin
-   * rather than a position in this run's order.
-   */
-  private final @Nullable Long creationTick;
+  private final @NotNull Long nanos;
 
   /** If a message is provided, its rendered as text and the whitespace is preserved. */
   private @Nullable String message;
@@ -66,33 +59,23 @@ public final class Breadcrumb implements JsonUnknown, JsonSerializable, Comparab
    *
    * @param timestamp the timestamp
    */
-  public Breadcrumb(final @NotNull Date timestamp) {
-    this(timestamp, System.nanoTime());
-  }
-
   @SuppressWarnings("JavaUtilDate")
-  private Breadcrumb(final @NotNull Date timestamp, final @Nullable Long creationTick) {
-    this.creationTick = creationTick;
+  public Breadcrumb(final @NotNull Date timestamp) {
+    this.nanos = System.nanoTime();
     this.timestamp = timestamp;
     this.timestampMs = null;
   }
 
-  /**
-   * A breadcrumb rebuilt from a serialized one — read back from disk, or handed over by a hybrid
-   * SDK. It carries the timestamp it was serialized with and no creation tick.
-   */
-  static @NotNull Breadcrumb deserialized(final @NotNull Date timestamp) {
-    return new Breadcrumb(timestamp, null);
-  }
-
   public Breadcrumb(final long timestamp) {
-    this.creationTick = System.nanoTime();
+    this.nanos = System.nanoTime();
     this.timestampMs = timestamp;
     this.timestamp = null;
   }
 
   Breadcrumb(final @NotNull Breadcrumb breadcrumb) {
-    this.creationTick = breadcrumb.creationTick;
+    // A clone stands in for the breadcrumb it was copied from, so it inherits its tie-breaker
+    // instead of taking a fresh one and sorting after everything recorded since.
+    this.nanos = breadcrumb.nanos;
     this.timestamp = breadcrumb.timestamp;
     this.timestampMs = breadcrumb.timestampMs;
     this.message = breadcrumb.message;
@@ -189,7 +172,7 @@ public static Breadcrumb fromMap(
       }
     }
 
-    final Breadcrumb breadcrumb = Breadcrumb.deserialized(timestamp);
+    final Breadcrumb breadcrumb = new Breadcrumb(timestamp);
     breadcrumb.message = message;
     breadcrumb.type = type;
     if (data != null) {
@@ -850,21 +833,14 @@ public void setUnknown(@Nullable Map<String, Object> unknown) {
 
   @Override
   @SuppressWarnings("JavaUtilDate")
-  public int compareTo(final @NotNull Breadcrumb o) {
+  public int compareTo(@NotNull Breadcrumb o) {
     final int byTimestamp = getTimestamp().compareTo(o.getTimestamp());
     if (byTimestamp != 0) {
       return byTimestamp;
     }
     // Timestamps are millisecond-granular, so breadcrumbs recorded in the same millisecond tie.
-    // Creation ticks break the tie in the order they were actually recorded.
-    if (creationTick == null) {
-      // Deserialized, so from an earlier process run than anything holding a tick.
-      return o.creationTick == null ? 0 : -1;
-    }
-    if (o.creationTick == null) {
-      return 1;
-    }
-    return creationTick.compareTo(o.creationTick);
+    // nanos is only meaningful within a process run, which is all a tie-breaker has to cover.
+    return nanos.compareTo(o.nanos);
   }
 
   public static final class JsonKeys {
@@ -973,7 +949,7 @@ public static final class Deserializer implements JsonDeserializer<Breadcrumb> {
         }
       }
 
-      Breadcrumb breadcrumb = Breadcrumb.deserialized(timestamp);
+      Breadcrumb breadcrumb = new Breadcrumb(timestamp);
       breadcrumb.message = message;
       breadcrumb.type = type;
       if (data != null) {

sentry/src/test/java/io/sentry/BreadcrumbTest.kt

@@ -1,6 +1,7 @@
 package io.sentry
 
 import com.google.common.truth.Truth.assertThat
+import java.io.StringReader
 import java.util.Date
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.Executors
@@ -395,6 +396,20 @@ class BreadcrumbTest {
     assertThat(sorted).containsExactly("restored", "live").inOrder()
   }
 
+  @Test
+  fun `a breadcrumb read back from JSON is ordered by its own timestamp, not by when it was parsed`() {
+    val live = Breadcrumb(Date(1_600_000_000_000)).apply { message = "live" }
+    val json =
+      """{"timestamp":"${DateUtils.getTimestamp(Date(1_500_000_000_000))}","message":"restored"}"""
+    val restored =
+      Breadcrumb.Deserializer()
+        .deserialize(JsonObjectReader(StringReader(json)), NoOpLogger.getInstance())
+
+    val sorted = listOf(live, restored).sorted().map { it.message }
+
+    assertThat(sorted).containsExactly("restored", "live").inOrder()
+  }
+
   @Test
   fun `cloning a breadcrumb keeps its position among breadcrumbs sharing its timestamp`() {
     val timestamp = Date(1_600_000_000_000)