change generator logic, per @adutra

Author: adnanhemani

runtime/service/src/main/java/org/apache/polaris/service/tracing/RequestIdGenerator.java

@@ -22,32 +22,35 @@
 import com.google.common.annotations.VisibleForTesting;
 import jakarta.enterprise.context.ApplicationScoped;
 import java.util.UUID;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
 
 @ApplicationScoped
 public class RequestIdGenerator {
-  private volatile String baseDefaultUuid = UUID.randomUUID().toString();
-  static final AtomicLong COUNTER = new AtomicLong();
   static final Long COUNTER_SOFT_MAX = Long.MAX_VALUE / 2;
 
-  public String generateRequestId() {
-    long currentCounter = COUNTER.incrementAndGet();
-    String requestId = baseDefaultUuid + "_" + currentCounter;
-    if (currentCounter >= COUNTER_SOFT_MAX) {
-      synchronized (this) {
-        if (COUNTER.get() >= COUNTER_SOFT_MAX) {
-          // If we get anywhere close to danger of overflowing Long (which, theoretically,
-          // would be extremely unlikely) rotate the UUID and start again.
-          baseDefaultUuid = UUID.randomUUID().toString();
-          COUNTER.set(0);
-        }
-      }
+  record State(String uuid, long counter) {
+
+    State() {
+      this(UUID.randomUUID().toString(), 1);
+    }
+
+    String requestId() {
+      return String.format("%s_%019d", uuid, counter);
+    }
+
+    State increment() {
+      return counter >= COUNTER_SOFT_MAX ? new State() : new State(uuid, counter + 1);
     }
-    return requestId;
+  }
+
+  final AtomicReference<State> state = new AtomicReference<>(new State());
+
+  public String generateRequestId() {
+    return state.getAndUpdate(State::increment).requestId();
   }
 
   @VisibleForTesting
   public void setCounter(long counter) {
-    COUNTER.set(counter);
+    state.set(new State(state.get().uuid, counter));
   }
 }

runtime/service/src/test/java/org/apache/polaris/service/tracing/RequestIdGeneratorTest.java

@@ -43,7 +43,8 @@ void testGenerateRequestId_ReturnsValidFormat() {
 
     assertThat(requestId).isNotNull();
     assertThat(requestId).matches(this::isValidRequestIdFormat);
-    assertThat(requestId).contains("_1"); // First call should increment counter to 1
+    // First call should increment counter to 1
+    assertThat(extractCounterFromRequestId(requestId)).isEqualTo(1);
   }
 
   @Test
@@ -62,22 +63,22 @@ void testGenerateRequestId_ReturnsUniqueIds() {
 
   @Test
   void testCounterIncrementsSequentially() {
-    requestIdGenerator.setCounter(0);
+    //    requestIdGenerator.setCounter(0);
 
     String firstId = requestIdGenerator.generateRequestId();
     String secondId = requestIdGenerator.generateRequestId();
     String thirdId = requestIdGenerator.generateRequestId();
 
-    assertThat(firstId).endsWith("_1");
-    assertThat(secondId).endsWith("_2");
-    assertThat(thirdId).endsWith("_3");
+    assertThat(extractCounterFromRequestId(firstId)).isEqualTo(1);
+    assertThat(extractCounterFromRequestId(secondId)).isEqualTo(2);
+    assertThat(extractCounterFromRequestId(thirdId)).isEqualTo(3);
   }
 
   @Test
   void testCounterRotationAtSoftMax() {
     // Set counter close to soft max
     long softMax = RequestIdGenerator.COUNTER_SOFT_MAX;
-    requestIdGenerator.setCounter(softMax - 1);
+    requestIdGenerator.setCounter(softMax);
 
     String beforeRotation = requestIdGenerator.generateRequestId();
     String afterRotation = requestIdGenerator.generateRequestId();
@@ -87,9 +88,9 @@ void testCounterRotationAtSoftMax() {
     String afterUuidPart = afterRotation.substring(0, afterRotation.lastIndexOf('_'));
     assertNotEquals(beforeUuidPart, afterUuidPart);
 
-    // After rotation, counter should be reset and UUID should be different
-    assertThat(beforeRotation).endsWith("_" + softMax);
-    assertThat(afterRotation).endsWith("_1"); // Counter reset to 1 (after increment from 0)
+    assertThat(extractCounterFromRequestId(beforeRotation)).isEqualTo(softMax);
+    // Counter reset to 1 (after increment from 0)
+    assertThat(extractCounterFromRequestId(afterRotation)).isEqualTo(1);
   }
 
   @Test
@@ -98,7 +99,8 @@ void testSetCounterChangesNextGeneratedId() {
 
     String requestId = requestIdGenerator.generateRequestId();
 
-    assertThat(requestId).endsWith("_101"); // Should increment from set value
+    // Should increment from set value
+    assertThat(extractCounterFromRequestId(requestId)).isEqualTo(100);
   }
 
   private boolean isValidRequestIdFormat(String str) {
@@ -113,4 +115,8 @@ private boolean isValidRequestIdFormat(String str) {
       return false;
     }
   }
+
+  private long extractCounterFromRequestId(String requestId) {
+    return Long.parseLong(requestId.split("_")[1]);
+  }
 }