perf(core): Drop per-instance lock from SentryId and SpanId (JAVA-589)

SentryId and SpanId stored their string value behind a
LazyEvaluator<String>, which allocates an AutoClosableReentrantLock
(a ReentrantLock with its internal Sync) plus a capturing lambda on
every instance. Since one SentryId is created per event/transaction
and one SpanId per span, this per-instance lock machinery is far
heavier than the single String it guards, and the eager string-arg
constructors gained no laziness at all.

Replace the LazyEvaluator with a plain volatile String guarded by a
double-checked synchronized(this) block. Eager constructors now assign
the value directly; the no-arg and UUID constructors still defer
UUID-string generation. Synchronization is retained because UUID
generation is non-idempotent and two racing threads must not produce
different ids.

Follow-up to the SDK Overhead Reduction work (#5499).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: runningcode

sentry/src/main/java/io/sentry/SpanId.java

@@ -2,50 +2,61 @@
 
 import static io.sentry.util.StringUtils.PROPER_NIL_UUID;
 
-import io.sentry.util.LazyEvaluator;
 import java.io.IOException;
 import java.util.Objects;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 public final class SpanId implements JsonSerializable {
   public static final SpanId EMPTY_ID =
       new SpanId(PROPER_NIL_UUID.replace("-", "").substring(0, 16));
 
-  private final @NotNull LazyEvaluator<String> lazyValue;
+  private volatile @Nullable String value;
 
   public SpanId(final @NotNull String value) {
-    Objects.requireNonNull(value, "value is required");
-    this.lazyValue = new LazyEvaluator<>(() -> value);
+    this.value = Objects.requireNonNull(value, "value is required");
   }
 
-  public SpanId() {
-    this.lazyValue = new LazyEvaluator<>(SentryUUID::generateSpanId);
+  public SpanId() {}
+
+  private @NotNull String getValue() {
+    String result = value;
+    if (result == null) {
+      synchronized (this) {
+        result = value;
+        if (result == null) {
+          result = SentryUUID.generateSpanId();
+          value = result;
+        }
+      }
+    }
+    return result;
   }
 
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     SpanId spanId = (SpanId) o;
-    return lazyValue.getValue().equals(spanId.lazyValue.getValue());
+    return getValue().equals(spanId.getValue());
   }
 
   @Override
   public int hashCode() {
-    return lazyValue.getValue().hashCode();
+    return getValue().hashCode();
   }
 
   @Override
   public String toString() {
-    return lazyValue.getValue();
+    return getValue();
   }
 
   // JsonElementSerializer
 
   @Override
   public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger logger)
       throws IOException {
-    writer.value(lazyValue.getValue());
+    writer.value(getValue());
   }
 
   // JsonElementDeserializer

sentry/src/main/java/io/sentry/protocol/SentryId.java

@@ -6,7 +6,6 @@
 import io.sentry.ObjectReader;
 import io.sentry.ObjectWriter;
 import io.sentry.SentryUUID;
-import io.sentry.util.LazyEvaluator;
 import io.sentry.util.StringUtils;
 import io.sentry.util.UUIDStringUtils;
 import java.io.IOException;
@@ -19,19 +18,15 @@ public final class SentryId implements JsonSerializable {
   public static final SentryId EMPTY_ID =
       new SentryId(StringUtils.PROPER_NIL_UUID.replace("-", ""));
 
-  private final @NotNull LazyEvaluator<String> lazyStringValue;
+  private volatile @Nullable String value;
+  private final @Nullable UUID uuid;
 
   public SentryId() {
     this((UUID) null);
   }
 
   public SentryId(@Nullable UUID uuid) {
-    if (uuid != null) {
-      this.lazyStringValue =
-          new LazyEvaluator<>(() -> normalize(UUIDStringUtils.toSentryIdString(uuid)));
-    } else {
-      this.lazyStringValue = new LazyEvaluator<>(SentryUUID::generateSentryId);
-    }
+    this.uuid = uuid;
   }
 
   public SentryId(final @NotNull String sentryIdString) {
@@ -42,29 +37,43 @@ public SentryId(final @NotNull String sentryIdString) {
               + "or 36 characters long (completed UUID). Received: "
               + sentryIdString);
     }
-    if (normalized.length() == 36) {
-      this.lazyStringValue = new LazyEvaluator<>(() -> normalize(normalized));
-    } else {
-      this.lazyStringValue = new LazyEvaluator<>(() -> normalized);
+    this.uuid = null;
+    this.value = normalized.length() == 36 ? normalized.replace("-", "") : normalized;
+  }
+
+  private @NotNull String getValue() {
+    String result = value;
+    if (result == null) {
+      synchronized (this) {
+        result = value;
+        if (result == null) {
+          result =
+              uuid != null
+                  ? normalize(UUIDStringUtils.toSentryIdString(uuid))
+                  : SentryUUID.generateSentryId();
+          value = result;
+        }
+      }
     }
+    return result;
   }
 
   @Override
   public String toString() {
-    return lazyStringValue.getValue();
+    return getValue();
   }
 
   @Override
   public boolean equals(final @Nullable Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     SentryId sentryId = (SentryId) o;
-    return lazyStringValue.getValue().equals(sentryId.lazyStringValue.getValue());
+    return getValue().equals(sentryId.getValue());
   }
 
   @Override
   public int hashCode() {
-    return lazyStringValue.getValue().hashCode();
+    return getValue().hashCode();
   }
 
   private @NotNull String normalize(@NotNull String uuidString) {