fix(android): Backfill pre-init ANR and native crash metadata (#5762)

* fix(android): Backfill exit options when app is unchanged

Use current options when persisted values are missing and the app has not been updated since the exit. Avoid attributing historical crashes to a newer app version.

* changelog

* fix(android): Backfill app context for historical exits

Populate app version and build for historical ANR and native crash events when the current package metadata is safe to use.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Limit historical app metadata backfill

Backfill only app version and build for historical exits. Avoid attaching current localized app names, identifiers, or split APK state to older events.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Reject unknown exit timestamps

Do not use current SDK options when an exit timestamp is unavailable because an intervening app update cannot be ruled out.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Validate persisted options cache generation

Persist the app update timestamp after writing the options snapshot. Trust cached release, environment, and dist only when the marker identifies the current app installation, preserving launch-specific values without leaking stale metadata across app updates.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Validate launch-specific cached options

Apply the app-generation marker when selecting option tags and the replay-on-error sample rate. Preserve values from the crashed launch within one app version while rejecting stale values after an update.

Co-Authored-By: Codex <noreply@openai.com>

* docs(android): Explain options cache marker ordering

Document why the generation observer uses its release callback only after the options cache has been fully persisted.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Validate exit option cache sources

Reject option caches created after an exit and keep immutable build metadata aligned with the event's app generation. This prevents intermediate releases and stale ProGuard or SDK metadata from being attached to historical exits.

Co-Authored-By: Codex <noreply@openai.com>

* style(android): Annotate nullable app context

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* docs(android): Explain options cache generation observer

Clarify why the observer is ordered after option persistence and update the changelog to describe the generation-aware behavior.

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* docs(android): Add cache generation example

Document the same-build, account-specific options scenario that requires preferring a matching persisted snapshot.

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* ref(android): Reuse cache utilities for generation marker

Expose cache serialization helpers as internal API and use them for the Android options cache generation marker.

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* docs(android): Explain exit option selection

Document how launch options, build metadata, and cache generations are selected for application exit events.

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* docs: Move changelog entry to Unreleased

Keep PR #5762 out of the already released 8.49.0 section.

Co-Authored-By: Codex <noreply@openai.com>

---------

Co-authored-by: Codex <noreply@openai.com>

Author: romtsn

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Backfill release, environment, distribution, tags, and app version/build—and use the matching replay-on-error sample rate—for `ApplicationExitInfo` ANR and native crash events captured before SDK initialization, without reusing options cached by a later app update ([#5762](https://github.com/getsentry/sentry-java/pull/5762))
+
 ## 8.49.0
 
 ### Features

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

@@ -182,6 +182,11 @@ static void initializeIntegrationsAndProcessors(
     if (options.getCacheDirPath() != null) {
       options.addScopeObserver(new PersistingScopeObserver(options));
       options.addOptionsObserver(new PersistingOptionsObserver(options));
+      final PackageInfo packageInfo = ContextUtils.getPackageInfo(context, buildInfoProvider);
+      if (packageInfo != null && packageInfo.lastUpdateTime > 0) {
+        options.addOptionsObserver(
+            new PersistingOptionsCacheGenerationObserver(options, packageInfo.lastUpdateTime));
+      }
     }
 
     options.addEventProcessor(new DeduplicateMultithreadedEventProcessor(options));

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

@@ -51,6 +51,7 @@
 import io.sentry.exception.ExceptionMechanismException;
 import io.sentry.hints.AbnormalExit;
 import io.sentry.hints.Backfillable;
+import io.sentry.hints.NativeCrashExit;
 import io.sentry.protocol.App;
 import io.sentry.protocol.Contexts;
 import io.sentry.protocol.DebugImage;
@@ -161,7 +162,13 @@ public ApplicationExitInfoEventProcessor(
     mergeOS(event);
     setDevice(event);
 
+    final OptionsSource optionsSource = getOptionsSource(backfillable);
+
     if (!backfillable.shouldEnrich()) {
+      setRelease(event, optionsSource);
+      setEnvironment(event, optionsSource);
+      setDist(event, optionsSource);
+      setAppVersionAndBuild(event);
       options
           .getLogger()
           .log(
@@ -170,9 +177,9 @@ public ApplicationExitInfoEventProcessor(
       return event;
     }
 
-    backfillScope(event);
+    backfillScope(event, optionsSource);
 
-    backfillOptions(event);
+    backfillOptions(event, optionsSource);
 
     setStaticValues(event);
 
@@ -184,7 +191,8 @@ public ApplicationExitInfoEventProcessor(
   }
 
   // region scope persisted values
-  private void backfillScope(final @NotNull SentryEvent event) {
+  private void backfillScope(
+      final @NotNull SentryEvent event, final @NotNull OptionsSource optionsSource) {
     setRequest(event);
     setUser(event);
     setScopeTags(event);
@@ -195,19 +203,25 @@ private void backfillScope(final @NotNull SentryEvent event) {
     setFingerprints(event);
     setLevel(event);
     setTrace(event);
-    setReplayId(event);
+    setReplayId(event, optionsSource);
   }
 
-  private boolean sampleReplay(final @NotNull SentryEvent event) {
+  private boolean sampleReplay(
+      final @NotNull SentryEvent event, final @NotNull OptionsSource optionsSource) {
+    final @Nullable Double currentSampleRate = options.getSessionReplay().getOnErrorSampleRate();
     final @Nullable String replayErrorSampleRate =
-        PersistingOptionsObserver.read(options, REPLAY_ERROR_SAMPLE_RATE_FILENAME, String.class);
+        getLaunchOption(
+            REPLAY_ERROR_SAMPLE_RATE_FILENAME,
+            String.class,
+            currentSampleRate == null ? null : currentSampleRate.toString(),
+            optionsSource);
 
     if (replayErrorSampleRate == null) {
       return false;
     }
 
     try {
-      // we have to sample here with the old sample rate, because it may change between app launches
+      // Sample with the rate from the relevant launch because it may change between launches.
       final double replayErrorSampleRateDouble = Double.parseDouble(replayErrorSampleRate);
       if (replayErrorSampleRateDouble < SentryRandom.current().nextDouble()) {
         options
@@ -226,15 +240,16 @@ private boolean sampleReplay(final @NotNull SentryEvent event) {
     return true;
   }
 
-  private void setReplayId(final @NotNull SentryEvent event) {
+  private void setReplayId(
+      final @NotNull SentryEvent event, final @NotNull OptionsSource optionsSource) {
     @Nullable String persistedReplayId = readFromDisk(options, REPLAY_FILENAME, String.class);
     @Nullable String cacheDirPath = options.getCacheDirPath();
     if (cacheDirPath == null) {
       return;
     }
     final @NotNull File replayFolder = new File(cacheDirPath, "replay_" + persistedReplayId);
     if (!replayFolder.exists()) {
-      if (!sampleReplay(event)) {
+      if (!sampleReplay(event, optionsSource)) {
         return;
       }
       // if the replay folder does not exist (e.g. running in buffer mode), we need to find the
@@ -393,14 +408,15 @@ private void setRequest(final @NotNull SentryBaseEvent event) {
   // endregion
 
   // region options persisted values
-  private void backfillOptions(final @NotNull SentryEvent event) {
-    setRelease(event);
-    setEnvironment(event);
-    setDist(event);
-    setDebugMeta(event);
-    setSdk(event);
+  private void backfillOptions(
+      final @NotNull SentryEvent event, final @NotNull OptionsSource optionsSource) {
+    setRelease(event, optionsSource);
+    setEnvironment(event, optionsSource);
+    setDist(event, optionsSource);
+    setDebugMeta(event, optionsSource);
+    setSdk(event, optionsSource);
     setApp(event);
-    setOptionsTags(event);
+    setOptionsTags(event, optionsSource);
   }
 
   private void setApp(final @NotNull SentryBaseEvent event) {
@@ -415,25 +431,6 @@ private void setApp(final @NotNull SentryBaseEvent event) {
       app.setAppIdentifier(packageInfo.packageName);
     }
 
-    // backfill versionName and versionCode from the persisted release string
-    final String release =
-        event.getRelease() != null
-            ? event.getRelease()
-            : PersistingOptionsObserver.read(options, RELEASE_FILENAME, String.class);
-    if (release != null) {
-      try {
-        final String versionName =
-            release.substring(release.indexOf('@') + 1, release.indexOf('+'));
-        final String versionCode = release.substring(release.indexOf('+') + 1);
-        app.setAppVersion(versionName);
-        app.setAppBuild(versionCode);
-      } catch (Throwable e) {
-        options
-            .getLogger()
-            .log(SentryLevel.WARNING, "Failed to parse release from scope cache: %s", release);
-      }
-    }
-
     try {
       final ContextUtils.SplitApksInfo splitApksInfo =
           DeviceInfoUtil.getInstance(context, options).getSplitApksInfo();
@@ -448,25 +445,50 @@ private void setApp(final @NotNull SentryBaseEvent event) {
     }
 
     event.getContexts().setApp(app);
+    setAppVersionAndBuild(event);
+  }
+
+  private void setAppVersionAndBuild(final @NotNull SentryBaseEvent event) {
+    final String release = event.getRelease();
+    if (release != null) {
+      try {
+        @Nullable App app = event.getContexts().getApp();
+        if (app == null) {
+          app = new App();
+        }
+        final String versionName =
+            release.substring(release.indexOf('@') + 1, release.indexOf('+'));
+        final String versionCode = release.substring(release.indexOf('+') + 1);
+        app.setAppVersion(versionName);
+        app.setAppBuild(versionCode);
+        event.getContexts().setApp(app);
+      } catch (Throwable e) {
+        options
+            .getLogger()
+            .log(SentryLevel.WARNING, "Failed to parse release from scope cache: %s", release);
+      }
+    }
   }
 
-  private void setRelease(final @NotNull SentryBaseEvent event) {
+  private void setRelease(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     if (event.getRelease() == null) {
-      final String release =
-          PersistingOptionsObserver.read(options, RELEASE_FILENAME, String.class);
-      event.setRelease(release);
+      event.setRelease(
+          getLaunchOption(RELEASE_FILENAME, String.class, options.getRelease(), optionsSource));
     }
   }
 
-  private void setEnvironment(final @NotNull SentryBaseEvent event) {
+  private void setEnvironment(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     if (event.getEnvironment() == null) {
-      final String environment =
-          PersistingOptionsObserver.read(options, ENVIRONMENT_FILENAME, String.class);
-      event.setEnvironment(environment != null ? environment : options.getEnvironment());
+      event.setEnvironment(
+          getLaunchOption(
+              ENVIRONMENT_FILENAME, String.class, options.getEnvironment(), optionsSource));
     }
   }
 
-  private void setDebugMeta(final @NotNull SentryBaseEvent event) {
+  private void setDebugMeta(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     DebugMeta debugMeta = event.getDebugMeta();
 
     if (debugMeta == null) {
@@ -478,7 +500,8 @@ private void setDebugMeta(final @NotNull SentryBaseEvent event) {
     List<DebugImage> images = debugMeta.getImages();
     if (images != null) {
       final String proguardUuid =
-          PersistingOptionsObserver.read(options, PROGUARD_UUID_FILENAME, String.class);
+          getBuildOption(
+              PROGUARD_UUID_FILENAME, String.class, options.getProguardUuid(), optionsSource);
 
       if (proguardUuid != null) {
         final DebugImage debugImage = new DebugImage();
@@ -490,15 +513,14 @@ private void setDebugMeta(final @NotNull SentryBaseEvent event) {
     }
   }
 
-  private void setDist(final @NotNull SentryBaseEvent event) {
+  private void setDist(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     if (event.getDist() == null) {
-      final String dist = PersistingOptionsObserver.read(options, DIST_FILENAME, String.class);
-      event.setDist(dist);
+      event.setDist(getLaunchOption(DIST_FILENAME, String.class, options.getDist(), optionsSource));
     }
-    // if there's no user-set dist, fall back to versionCode from the persisted release string
+    // if there's no user-set dist, fall back to versionCode from the release string
     if (event.getDist() == null) {
-      final String release =
-          PersistingOptionsObserver.read(options, RELEASE_FILENAME, String.class);
+      final String release = event.getRelease();
       if (release != null) {
         try {
           final String versionCode = release.substring(release.indexOf('+') + 1);
@@ -512,20 +534,101 @@ private void setDist(final @NotNull SentryBaseEvent event) {
     }
   }
 
-  private void setSdk(final @NotNull SentryBaseEvent event) {
+  /**
+   * Resolves an option that may change between launches of the same build, such as environment or
+   * tags. A matching persisted value is preferred; the current value is used only when the source
+   * identifies the current app generation or permits a fallback for a missing persisted value.
+   */
+  private <T> @Nullable T getLaunchOption(
+      final @NotNull String fileName,
+      final @NotNull Class<T> clazz,
+      final @Nullable T currentValue,
+      final @NotNull OptionsSource optionsSource) {
+    if (optionsSource == OptionsSource.CURRENT) {
+      return currentValue;
+    } else if (optionsSource == OptionsSource.NONE) {
+      return null;
+    }
+
+    final T persistedValue = PersistingOptionsObserver.read(options, fileName, clazz);
+    return persistedValue != null || optionsSource == OptionsSource.PERSISTED
+        ? persistedValue
+        : currentValue;
+  }
+
+  /**
+   * Resolves metadata that cannot change between launches of the same build, such as the ProGuard
+   * UUID or SDK version. Current metadata is used for exits from the current app generation, while
+   * persisted metadata is reserved for historical exits.
+   */
+  private <T> @Nullable T getBuildOption(
+      final @NotNull String fileName,
+      final @NotNull Class<T> clazz,
+      final @Nullable T currentValue,
+      final @NotNull OptionsSource optionsSource) {
+    if (optionsSource == OptionsSource.CURRENT
+        || optionsSource == OptionsSource.PERSISTED_WITH_CURRENT_FALLBACK) {
+      return currentValue;
+    } else if (optionsSource == OptionsSource.NONE) {
+      return null;
+    }
+    return PersistingOptionsObserver.read(options, fileName, clazz);
+  }
+
+  /**
+   * Chooses the options snapshot that can safely describe an exit by comparing its timestamp with
+   * the current app update time and the persisted cache generation. A markerless legacy cache is
+   * accepted for compatibility; {@link OptionsSource#NONE} is returned when neither current nor
+   * persisted options can be matched to the exit.
+   */
+  private @NotNull OptionsSource getOptionsSource(final @NotNull Backfillable hint) {
+    final @Nullable Long timestamp;
+    if (hint instanceof AbnormalExit) {
+      timestamp = ((AbnormalExit) hint).timestamp();
+    } else if (hint instanceof NativeCrashExit) {
+      timestamp = ((NativeCrashExit) hint).timestamp();
+    } else {
+      timestamp = null;
+    }
+    final Long cachedLastUpdateTime = PersistingOptionsCacheGenerationObserver.read(options);
+    final PackageInfo packageInfo = ContextUtils.getPackageInfo(context, buildInfoProvider);
+    final long currentLastUpdateTime = packageInfo == null ? 0 : packageInfo.lastUpdateTime;
+
+    if (timestamp != null && currentLastUpdateTime > 0 && currentLastUpdateTime <= timestamp) {
+      return cachedLastUpdateTime != null && cachedLastUpdateTime == currentLastUpdateTime
+          ? OptionsSource.PERSISTED_WITH_CURRENT_FALLBACK
+          : OptionsSource.CURRENT;
+    }
+    if (cachedLastUpdateTime == null) {
+      return OptionsSource.PERSISTED;
+    }
+    // A cache generation created after the exit cannot describe that exit.
+    if (timestamp != null && cachedLastUpdateTime > 0 && cachedLastUpdateTime <= timestamp) {
+      return OptionsSource.PERSISTED;
+    }
+    return OptionsSource.NONE;
+  }
+
+  private void setSdk(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     if (event.getSdk() == null) {
       final SdkVersion sdkVersion =
-          PersistingOptionsObserver.read(options, SDK_VERSION_FILENAME, SdkVersion.class);
+          getBuildOption(
+              SDK_VERSION_FILENAME, SdkVersion.class, options.getSdkVersion(), optionsSource);
       event.setSdk(sdkVersion);
     }
   }
 
   @SuppressWarnings("unchecked")
-  private void setOptionsTags(final @NotNull SentryBaseEvent event) {
+  private void setOptionsTags(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     final Map<String, String> tags =
         (Map<String, String>)
-            PersistingOptionsObserver.read(
-                options, PersistingOptionsObserver.TAGS_FILENAME, Map.class);
+            getLaunchOption(
+                PersistingOptionsObserver.TAGS_FILENAME,
+                Map.class,
+                options.getTags(),
+                optionsSource);
     if (tags == null) {
       return;
     }
@@ -542,6 +645,13 @@ private void setOptionsTags(final @NotNull SentryBaseEvent event) {
 
   // endregion
 
+  private enum OptionsSource {
+    CURRENT,
+    PERSISTED,
+    PERSISTED_WITH_CURRENT_FALLBACK,
+    NONE
+  }
+
   @Override
   public @Nullable Long getOrder() {
     return 12000L;