perf(core): SDK Overhead Reduction (#5499)

* collection: SDK Overhead Reduction

* perf(core): Skip java.specification.version lookup on Android

Android is never Java 9+, so the System.getProperty +
Double.valueOf parse in the Platform static initializer is
unnecessary overhead on the Android cold-start path.
Short-circuit to isJavaNinePlus=false when isAndroid is true.

* perf(android): Replace reflective OptionsContainer with direct subclass

Replace OptionsContainer.create(SentryAndroidOptions.class) which uses
getDeclaredConstructor().newInstance() with a direct
SentryAndroidOptionsContainer subclass that returns
new SentryAndroidOptions() without reflection.

Make OptionsContainer non-final (@OPEN) with a protected no-arg
constructor so Android can subclass it.

* collection: SDK Overhead reduction for JVM

* perf(core): Short-circuit combined scope breadcrumbs

Avoid allocating and sorting a merged breadcrumb queue when only one component scope has breadcrumbs. This keeps the full merge path for multi-scope breadcrumbs and returns the default write scope queue when all scopes are empty.

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

* perf(core): Reduce envelope writer buffer size

Use an explicit 512-character BufferedWriter buffer for envelope item and envelope serialization. This avoids allocating the oversized default char buffer for each short-lived serialization writer while preserving the existing OutputStreamWriter-based encoding path.

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

* changelog

* perf(core): Remove redundant event map copies

Avoid creating temporary maps when applying scope and options tags or scope extras. The event setters already copy these maps, so this preserves snapshot semantics while reducing allocation overhead.

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

* changelog

* changelog

* perf(core): Short-circuit combined scope collections

Avoid allocating merged collection copies when only one combined scope contains values. This extends the breadcrumbs optimization to tags, attributes, extras, and attachments while preserving merge behavior when multiple scopes contribute data.

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

* changelog

* perf(android): Use TimeZone.getDefault for device timezone

Avoid constructing a Calendar only to read the default device timezone. The locale passed to Calendar does not affect the timezone value, so TimeZone.getDefault returns the same value with less work during device context collection.

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

* perf(core): Replace Calendar with Date in DateUtils

Avoid constructing Calendar instances when DateUtils only needs the current epoch millis or a Date for an existing millis value. Date stores epoch millis without timezone state, so the returned values are unchanged while avoiding unnecessary Calendar allocation and field computation.

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

* perf(core): Reduce JsonWriter stack allocation

Shrink the vendored JsonWriter nesting stack from 32 entries to 8 entries. The stack still grows on demand for deeply nested payloads, while common SDK serialization avoids the larger initial array allocation.

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

* perf(core): Lazily allocate Breadcrumb data

Avoid allocating a ConcurrentHashMap for breadcrumbs that never set data. Initialize the data map on first write while preserving concurrent writes with double-checked locking.

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

* perf(core): Reduce context serialization allocations

Use sorted key arrays when serializing contexts to avoid allocating an ArrayList for each serialization. This preserves deterministic key ordering while keeping the snapshot representation smaller.

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

* perf(core): Lazily allocate reflection serializer state

Defer creation of the reflection serializer visiting set until reflection serialization is actually needed. Normal SDK payload serialization uses explicit serializers, so this avoids an unused HashSet allocation for each writer.

* perf(core): Lazily create reflection JSON serializer

Defer creation of JsonReflectionObjectSerializer until unknown-object reflection serialization is needed. Normal SDK payloads use explicit serializers, so this avoids allocating unused reflection serializer state for each writer.

* fix(android): Preserve locale timezone extension

Keep the Calendar-based timezone path for Android 13+ locales that carry a Unicode tz extension. This preserves the existing device timezone behavior while keeping the direct default timezone fast path for normal locales.

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

* perf(core): Replace ISO8601 timestamp handling

Replace the Calendar-backed vendored ISO8601 formatting and parsing path with a small Sentry-specific utility that works directly from epoch milliseconds.

This avoids formatter and parser allocations on timestamp-heavy serialization paths while keeping the existing DateUtils API as the facade.

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

* ref(core): Move ISO8601 utility to vendor package

Move the Sentry ISO8601 helper under the vendor package and mark it as internal API so the adapted public-domain date conversion code is isolated from core SDK classes.

Update attribution metadata to reflect the public-domain dedication source.

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

* perf(core): Avoid cloning Date getters

* fix(core): Preserve ISO8601 utility compatibility

Match edge-case behavior from the previous vendored ISO8601 utility for date-only timestamps, trailing characters after Z, and Gregorian cutover dates.

* fix(core): Preserve mutable breadcrumb data access

Initialize the lazy breadcrumb data map when callers request the full map. This keeps getData() mutable for existing callers while preserving lazy allocation for breadcrumbs that only serialize or read individual values.

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

* docs(android): Explain timezone Calendar fallback

Document why Android 13+ locales with Unicode timezone extensions keep using Calendar while normal locales use the default timezone directly for performance.

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

* fix(core): Avoid KeySetView in context serialization

Use ConcurrentHashMap.keys() when creating sorted context key snapshots so the serialization path stays compatible with Android API 21. Keep the array snapshot optimization without relying on KeySetView, which AnimalSniffer rejects for the SDK's minSdk.

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

* test(core): Add breadcrumb timestamp serialization coverage

Cover that breadcrumbs backed by timestamp milliseconds serialize the same timestamp as breadcrumbs backed by Date for the same instant.

* fix(core): Parse date-only timestamps with timezones

Preserve ISO8601 parser compatibility for date-only values that include a timezone suffix. Keep modern date-only timezone parsing on the fast path and add parity coverage against the previous parser.

* docs(core): Add timezone changelog entry

* docs(core): Add DateUtils changelog entry

* docs(core): Add JsonWriter changelog entry

* docs(core): Add breadcrumb changelog entry

* docs(core): Add contexts changelog entry

* docs(core): Add reflection state changelog entry

* docs(core): Add reflection serializer changelog entry

* docs(core): Add ISO8601 handling changelog entry

* docs(core): Add Date getter changelog entries

* changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: adinauer

CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## Unreleased
+
+### Behavioral Changes
+
+- Collections returned by scope (e.g. `getBreadcrumbs`, `getTags`, `getAttachments`) are shared state and should not be mutated. ([#5541](https://github.com/getsentry/sentry-java/pull/5541))
+  - Previously, when going through `CombinedScopeView`, we were returning a copy where mutations didn't show up in the underlying scopes.
+  - This has now changed in order to reduce SDK overhead.
+- `Date` objects returned by SDK data model getters are shared state and should not be mutated. ([#5603](https://github.com/getsentry/sentry-java/pull/5603))
+  - Previously, these getters returned defensive copies for some date fields.
+  - This has now changed in order to reduce SDK overhead.
+
+### Performance
+
+- Reduce writer buffer size from 8192 to 512 ([#5544](https://github.com/getsentry/sentry-java/pull/5544))
+- Remove redundant event map copies ([#5536](https://github.com/getsentry/sentry-java/pull/5536))
+- Optimize combined scope by adding an early return if only one scope has data ([#5541](https://github.com/getsentry/sentry-java/pull/5541))
+- Reduce model access overhead by avoiding defensive `Date` copies in SDK data model getters. ([#5603](https://github.com/getsentry/sentry-java/pull/5603))
+- Reduce timestamp parsing and formatting overhead with Sentry-specific ISO-8601 handling. ([#5602](https://github.com/getsentry/sentry-java/pull/5602))
+- Reduce JSON serialization overhead by creating the reflection serializer only when unknown-object fallback serialization is needed. ([#5601](https://github.com/getsentry/sentry-java/pull/5601))
+- Reduce JSON serialization overhead by allocating reflection cycle-tracking state only when reflection serialization is used. ([#5600](https://github.com/getsentry/sentry-java/pull/5600))
+- Reduce context serialization overhead by sorting key snapshots with arrays instead of temporary lists. ([#5599](https://github.com/getsentry/sentry-java/pull/5599))
+- Reduce breadcrumb allocation overhead by creating the `Breadcrumb` data map only when data is added. ([#5598](https://github.com/getsentry/sentry-java/pull/5598))
+- Reduce JSON serialization overhead by lowering the initial `JsonWriter` nesting stack size while preserving on-demand growth. ([#5591](https://github.com/getsentry/sentry-java/pull/5591))
+- Reduce timestamp helper overhead by replacing unnecessary `Calendar` usage in `DateUtils` with direct `Date` creation. ([#5589](https://github.com/getsentry/sentry-java/pull/5589))
+- Reduce Android startup overhead by using the default timezone directly on older devices or when no timezone info is available in the locale. ([#5587](https://github.com/getsentry/sentry-java/pull/5587))
+
 ## 8.45.0
 
 ### Features

THIRD_PARTY_NOTICES.md

@@ -62,6 +62,22 @@ limitations under the License.
 
 ---
 
+## Howard Hinnant — Date Algorithms (Public Domain)
+
+**Source:** https://howardhinnant.github.io/date_algorithms.html<br>
+**License:** Public Domain<br>
+**Copyright:** None; public domain dedication by Howard Hinnant
+
+### Scope
+
+The Sentry Java SDK includes adapted civil date conversion algorithms from Howard Hinnant's date algorithms for UTC ISO 8601 timestamp parsing and formatting. The code resides in `io.sentry.vendor.SentryIso8601Utils`.
+
+```
+Consider these donated to the public domain.
+```
+
+---
+
 ## Android Open Source Project — Base64 (Apache 2.0)
 
 **Source:** https://cs.android.com/android/platform/superproject/main/+/main:frameworks/base/core/java/android/util/Base64.java<br>

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

@@ -257,14 +257,19 @@ private void setDeviceIO(
   @SuppressWarnings("NewApi")
   @NotNull
   private TimeZone getTimeZone() {
-    if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.N) {
+    // Only use the costly Calendar API on Android 13+ (API Level 33+) when the locale contains a
+    // Unicode timezone extension (for example "en-US-u-tz-usnyc"), because Calendar honors that
+    // extension. For all other cases, use the process default timezone directly for performance.
+    if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.TIRAMISU) {
       LocaleList locales = context.getResources().getConfiguration().getLocales();
       if (!locales.isEmpty()) {
         Locale locale = locales.get(0);
-        return Calendar.getInstance(locale).getTimeZone();
+        if (locale.getUnicodeLocaleType("tz") != null) {
+          return Calendar.getInstance(locale).getTimeZone();
+        }
       }
     }
-    return Calendar.getInstance().getTimeZone();
+    return TimeZone.getDefault();
   }
 
   @SuppressWarnings("JdkObsolete")

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

@@ -9,7 +9,6 @@
 import io.sentry.IScopes;
 import io.sentry.ISentryLifecycleToken;
 import io.sentry.Integration;
-import io.sentry.OptionsContainer;
 import io.sentry.Sentry;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
@@ -98,7 +97,7 @@ public static void init(
       @NotNull Sentry.OptionsConfiguration<SentryAndroidOptions> configuration) {
     try (final @NotNull ISentryLifecycleToken ignored = staticLock.acquire()) {
       Sentry.init(
-          OptionsContainer.create(SentryAndroidOptions.class),
+          new SentryAndroidOptionsContainer(),
           options -> {
             final io.sentry.util.LoadClass classLoader = new io.sentry.util.LoadClass();
             final boolean isTimberUpstreamAvailable =

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

@@ -0,0 +1,16 @@
+package io.sentry.android.core;
+
+import io.sentry.OptionsContainer;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Direct OptionsContainer for SentryAndroidOptions that avoids reflective
+ * getDeclaredConstructor().newInstance() on the Android startup path.
+ */
+final class SentryAndroidOptionsContainer extends OptionsContainer<SentryAndroidOptions> {
+
+  @Override
+  public @NotNull SentryAndroidOptions createInstance() {
+    return new SentryAndroidOptions();
+  }
+}

sentry-android-core/src/test/java/io/sentry/android/core/DeviceInfoUtilTest.kt

@@ -2,16 +2,22 @@ package io.sentry.android.core
 
 import android.content.Context
 import android.content.Intent
+import android.content.res.Configuration
 import android.os.BatteryManager
+import android.os.Build
+import android.os.LocaleList
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.android.core.internal.util.CpuInfoUtils
+import java.util.Locale
+import java.util.TimeZone
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
 
 @RunWith(AndroidJUnit4::class)
 class DeviceInfoUtilTest {
@@ -47,6 +53,32 @@ class DeviceInfoUtilTest {
     assertNotNull(deviceInfo.memorySize)
   }
 
+  @Test
+  fun `sets default timezone`() {
+    val deviceInfoUtil = DeviceInfoUtil.getInstance(context, SentryAndroidOptions())
+    val deviceInfo = deviceInfoUtil.collectDeviceInformation(false, false)
+
+    assertEquals(TimeZone.getDefault(), deviceInfo.timezone)
+  }
+
+  @Test
+  @Config(sdk = [Build.VERSION_CODES.TIRAMISU])
+  fun `preserves timezone from locale unicode extension`() {
+    val defaultTimeZone = TimeZone.getDefault()
+    try {
+      TimeZone.setDefault(TimeZone.getTimeZone("UTC"))
+      val configuration = Configuration(context.resources.configuration)
+      configuration.setLocales(LocaleList(Locale.forLanguageTag("en-US-u-tz-usnyc")))
+      val localizedContext = context.createConfigurationContext(configuration)
+      val deviceInfoUtil = DeviceInfoUtil(localizedContext, SentryAndroidOptions())
+      val deviceInfo = deviceInfoUtil.collectDeviceInformation(false, false)
+
+      assertEquals("America/New_York", deviceInfo.timezone?.id)
+    } finally {
+      TimeZone.setDefault(defaultTimeZone)
+    }
+  }
+
   @Test
   fun `does include cpu data`() {
     CpuInfoUtils.getInstance().setCpuMaxFrequencies(listOf(1024))

sentry/api/sentry.api

@@ -1312,7 +1312,6 @@ public final class io/sentry/JsonObjectReader : io/sentry/ObjectReader {
 
 public final class io/sentry/JsonObjectSerializer {
 	public static final field OBJECT_PLACEHOLDER Ljava/lang/String;
-	public final field jsonReflectionObjectSerializer Lio/sentry/JsonReflectionObjectSerializer;
 	public fun <init> (I)V
 	public fun serialize (Lio/sentry/ObjectWriter;Lio/sentry/ILogger;Ljava/lang/Object;)V
 }
@@ -2067,7 +2066,8 @@ public abstract interface class io/sentry/ObjectWriter {
 	public abstract fun value (Z)Lio/sentry/ObjectWriter;
 }
 
-public final class io/sentry/OptionsContainer {
+public class io/sentry/OptionsContainer {
+	protected fun <init> ()V
 	public static fun create (Ljava/lang/Class;)Lio/sentry/OptionsContainer;
 	public fun createInstance ()Ljava/lang/Object;
 }
@@ -7618,6 +7618,7 @@ public final class io/sentry/util/CollectionUtils {
 	public static fun newHashMap (Ljava/util/Map;)Ljava/util/Map;
 	public static fun reverseListIterator (Ljava/util/concurrent/CopyOnWriteArrayList;)Ljava/util/ListIterator;
 	public static fun size (Ljava/lang/Iterable;)I
+	public static fun toSortedStringArray (Ljava/util/Enumeration;I)[Ljava/lang/String;
 }
 
 public abstract interface class io/sentry/util/CollectionUtils$Mapper {
@@ -8075,6 +8076,11 @@ public class io/sentry/vendor/Base64 {
 	public static fun encodeToString ([BIII)Ljava/lang/String;
 }
 
+public final class io/sentry/vendor/SentryIso8601Utils {
+	public static fun formatTimestamp (J)Ljava/lang/String;
+	public static fun parseTimestamp (Ljava/lang/String;)J
+}
+
 public class io/sentry/vendor/gson/internal/bind/util/ISO8601Utils {
 	public static final field TIMEZONE_UTC Ljava/util/TimeZone;
 	public fun <init> ()V

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

@@ -34,8 +34,10 @@ public final class Breadcrumb implements JsonUnknown, JsonSerializable, Comparab
   /** The type of breadcrumb. */
   private @Nullable String type;
 
+  private static final @NotNull Map<String, @NotNull Object> EMPTY_DATA = Collections.emptyMap();
+
   /** Data associated with this breadcrumb. */
-  private @NotNull Map<String, @NotNull Object> data = new ConcurrentHashMap<>();
+  private volatile @NotNull Map<String, @NotNull Object> data = EMPTY_DATA;
 
   /** Dotted strings that indicate what the crumb is or where it comes from. */
   private @Nullable String category;
@@ -78,9 +80,11 @@ public Breadcrumb(final long timestamp) {
     this.type = breadcrumb.type;
     this.category = breadcrumb.category;
     this.origin = breadcrumb.origin;
-    final Map<String, Object> dataClone = CollectionUtils.newConcurrentHashMap(breadcrumb.data);
-    if (dataClone != null) {
-      this.data = dataClone;
+    if (!breadcrumb.data.isEmpty()) {
+      final Map<String, Object> dataClone = CollectionUtils.newConcurrentHashMap(breadcrumb.data);
+      if (dataClone != null) {
+        this.data = dataClone;
+      }
     }
     this.unknown = CollectionUtils.newConcurrentHashMap(breadcrumb.unknown);
     this.level = breadcrumb.level;
@@ -100,7 +104,7 @@ public static Breadcrumb fromMap(
     @NotNull Date timestamp = DateUtils.getCurrentDateTime();
     String message = null;
     String type = null;
-    @NotNull Map<String, Object> data = new ConcurrentHashMap<>();
+    Map<String, Object> data = null;
     String category = null;
     String origin = null;
     SentryLevel level = null;
@@ -129,6 +133,9 @@ public static Breadcrumb fromMap(
           if (untypedData != null) {
             for (Map.Entry<Object, Object> dataEntry : untypedData.entrySet()) {
               if (dataEntry.getKey() instanceof String && dataEntry.getValue() != null) {
+                if (data == null) {
+                  data = new ConcurrentHashMap<>();
+                }
                 data.put((String) dataEntry.getKey(), dataEntry.getValue());
               } else {
                 options
@@ -166,7 +173,9 @@ public static Breadcrumb fromMap(
     final Breadcrumb breadcrumb = new Breadcrumb(timestamp);
     breadcrumb.message = message;
     breadcrumb.type = type;
-    breadcrumb.data = data;
+    if (data != null) {
+      breadcrumb.data = data;
+    }
     breadcrumb.category = category;
     breadcrumb.origin = origin;
     breadcrumb.level = level;
@@ -494,7 +503,7 @@ public static Breadcrumb fromMap(
       breadcrumb.setData("view.tag", viewTag);
     }
     for (final Map.Entry<String, Object> entry : additionalData.entrySet()) {
-      breadcrumb.getData().put(entry.getKey(), entry.getValue());
+      breadcrumb.setData(entry.getKey(), entry.getValue());
     }
     breadcrumb.setLevel(SentryLevel.INFO);
     return breadcrumb;
@@ -553,9 +562,9 @@ public Breadcrumb(@Nullable String message) {
   @SuppressWarnings("JavaUtilDate")
   public @NotNull Date getTimestamp() {
     if (timestamp != null) {
-      return (Date) timestamp.clone();
+      return timestamp;
     } else if (timestampMs != null) {
-      // we memoize it here into timestamp to avoid instantiating Calendar again and again
+      // we memoize it here into timestamp to avoid creating a Date again and again
       timestamp = DateUtils.getDateTime(timestampMs);
       return timestamp;
     }
@@ -598,6 +607,20 @@ public void setType(@Nullable String type) {
     this.type = type;
   }
 
+  private @NotNull Map<String, @NotNull Object> getOrCreateData() {
+    Map<String, @NotNull Object> currentData = data;
+    if (currentData == EMPTY_DATA) {
+      synchronized (this) {
+        currentData = data;
+        if (currentData == EMPTY_DATA) {
+          currentData = new ConcurrentHashMap<>();
+          data = currentData;
+        }
+      }
+    }
+    return currentData;
+  }
+
   /**
    * Returns the data map
    *
@@ -606,7 +629,7 @@ public void setType(@Nullable String type) {
   @ApiStatus.Internal
   @NotNull
   public Map<String, Object> getData() {
-    return data;
+    return getOrCreateData();
   }
 
   /**
@@ -636,7 +659,7 @@ public void setData(@Nullable String key, @Nullable Object value) {
     if (value == null) {
       removeData(key);
     } else {
-      data.put(key, value);
+      getOrCreateData().put(key, value);
     }
   }
 
@@ -649,7 +672,10 @@ public void removeData(@Nullable String key) {
     if (key == null) {
       return;
     }
-    data.remove(key);
+    final Map<String, @NotNull Object> currentData = data;
+    if (currentData != EMPTY_DATA) {
+      currentData.remove(key);
+    }
   }
 
   /**
@@ -823,7 +849,12 @@ public static final class JsonKeys {
   public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger logger)
       throws IOException {
     writer.beginObject();
-    writer.name(JsonKeys.TIMESTAMP).value(logger, getTimestamp());
+    writer
+        .name(JsonKeys.TIMESTAMP)
+        .value(
+            timestampMs != null
+                ? DateUtils.getTimestampFromMillis(timestampMs)
+                : DateUtils.getTimestamp(getTimestamp()));
     if (message != null) {
       writer.name(JsonKeys.MESSAGE).value(message);
     }
@@ -859,7 +890,7 @@ public static final class Deserializer implements JsonDeserializer<Breadcrumb> {
       @NotNull Date timestamp = DateUtils.getCurrentDateTime();
       String message = null;
       String type = null;
-      @NotNull Map<String, Object> data = new ConcurrentHashMap<>();
+      Map<String, Object> data = null;
       String category = null;
       String origin = null;
       SentryLevel level = null;
@@ -884,7 +915,7 @@ public static final class Deserializer implements JsonDeserializer<Breadcrumb> {
             Map<String, Object> deserializedData =
                 CollectionUtils.newConcurrentHashMap(
                     (Map<String, Object>) reader.nextObjectOrNull());
-            if (deserializedData != null) {
+            if (deserializedData != null && !deserializedData.isEmpty()) {
               data = deserializedData;
             }
             break;
@@ -913,7 +944,9 @@ public static final class Deserializer implements JsonDeserializer<Breadcrumb> {
       Breadcrumb breadcrumb = new Breadcrumb(timestamp);
       breadcrumb.message = message;
       breadcrumb.type = type;
-      breadcrumb.data = data;
+      if (data != null) {
+        breadcrumb.data = data;
+      }
       breadcrumb.category = category;
       breadcrumb.origin = origin;
       breadcrumb.level = level;