ref: follow Session rename in InternalSentrySdk

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: buenaflor

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

@@ -225,11 +225,12 @@ public static SentryId captureEnvelope(
    * treat {@code handled=false} as a crash that ends the session. Instead it:
    *
    * <ul>
-   *   <li>marks the current session as pending-unhandled and increments the error count
+   *   <li>flags the current session with a non-terminating unhandled error and increments the error
+   *       count
    *   <li>keeps session status {@code Ok} and the same session id on the scope
    *   <li>does not attach a session update item to this envelope
    *   <li>does not start a new session
-   *   <li>persists the current session so pending-unhandled survives process death
+   *   <li>persists the current session so the flag survives process death
    * </ul>
    *
    * <p>The session is finalized later by normal lifecycle ({@code endSession} / background /
@@ -254,31 +255,31 @@ public static SentryId captureEnvelopeNonTerminating(final @NotNull byte[] envel
 
     try {
       final @NotNull ISerializer serializer = options.getSerializer();
-      boolean markPendingUnhandled = false;
+      boolean hasUnhandled = false;
       boolean addErrorsCount = false;
       for (SentryEnvelopeItem item : envelope.getItems()) {
         final SentryEvent event = item.getEvent(serializer);
         if (event != null) {
           if (event.getUnhandledException() != null) {
-            markPendingUnhandled = true;
+            hasUnhandled = true;
             addErrorsCount = true;
           } else if (event.isErrored()) {
             addErrorsCount = true;
           }
         }
       }
 
-      if (markPendingUnhandled || addErrorsCount) {
-        final boolean pending = markPendingUnhandled;
+      if (hasUnhandled || addErrorsCount) {
+        final boolean unhandled = hasUnhandled;
         final boolean addErrors = addErrorsCount;
         scopes.configureScope(
             scope -> {
               scope.withSession(
                   session -> {
                     if (session != null) {
                       final boolean updated =
-                          pending
-                              ? session.markPendingUnhandled()
+                          unhandled
+                              ? session.recordNonTerminatingUnhandledError()
                               : session.update(null, null, addErrors, null);
                       if (updated && options.getEnvelopeDiskCache() instanceof EnvelopeCache) {
                         ((EnvelopeCache) options.getEnvelopeDiskCache())

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

@@ -470,7 +470,7 @@ class InternalSentrySdkTest {
   }
 
   @Test
-  fun `captureEnvelopeNonTerminating keeps the session Ok and marks it pending unhandled`() {
+  fun `captureEnvelopeNonTerminating keeps the session Ok and flags the unhandled error`() {
     val fixture = Fixture()
     fixture.init(context)
 
@@ -488,19 +488,19 @@ class InternalSentrySdkTest {
     assertThat(capturedEnvelopeItems).hasSize(1)
     assertThat(capturedEnvelopeItems[0].header.type).isEqualTo(SentryItemType.Event)
 
-    // and the session stays alive on the scope, same id, marked pending unhandled
+    // and the session stays alive on the scope, same id, flagged with the unhandled error
     val scopeSession = AtomicReference<Session>()
     Sentry.configureScope { scope -> scopeSession.set(scope.session) }
     assertThat(scopeSession.get().status).isEqualTo(Session.State.Ok)
-    assertThat(scopeSession.get().isPendingUnhandled).isTrue()
+    assertThat(scopeSession.get().hasNonTerminatingUnhandledError()).isTrue()
     assertThat(scopeSession.get().sessionId).isEqualTo(originalSid.get())
 
     // and it is persisted so pending survives process death
     val sessionFile = EnvelopeCache.getCurrentSessionFile(fixture.options.cacheDirPath!!)
     val persistedSession =
       fixture.options.serializer.deserialize(sessionFile.reader(), Session::class.java)!!
     assertThat(persistedSession.status).isEqualTo(Session.State.Ok)
-    assertThat(persistedSession.isPendingUnhandled).isTrue()
+    assertThat(persistedSession.hasNonTerminatingUnhandledError()).isTrue()
     assertThat(persistedSession.sessionId).isEqualTo(originalSid.get())
   }
 
@@ -544,7 +544,7 @@ class InternalSentrySdkTest {
     val pendingSession = AtomicReference<Session>()
     Sentry.configureScope { scope -> pendingSession.set(scope.session) }
     val oldSid = pendingSession.get().sessionId
-    assertThat(pendingSession.get().isPendingUnhandled).isTrue()
+    assertThat(pendingSession.get().hasNonTerminatingUnhandledError()).isTrue()
     fixture.capturedEnvelopes.clear()
 
     // when a subsequent hard crash is captured through the existing terminating API
@@ -562,14 +562,14 @@ class InternalSentrySdkTest {
         Session::class.java,
       )!!
     assertThat(crashedSession.status).isEqualTo(Session.State.Crashed)
-    assertThat(crashedSession.isPendingUnhandled).isFalse()
+    assertThat(crashedSession.hasNonTerminatingUnhandledError()).isFalse()
     assertThat(crashedSession.sessionId).isEqualTo(oldSid)
 
     // and a new Ok session with a different id is active
     val activeSession = AtomicReference<Session>()
     Sentry.configureScope { scope -> activeSession.set(scope.session) }
     assertThat(activeSession.get().status).isEqualTo(Session.State.Ok)
-    assertThat(activeSession.get().isPendingUnhandled).isFalse()
+    assertThat(activeSession.get().hasNonTerminatingUnhandledError()).isFalse()
     assertThat(activeSession.get().sessionId).isNotEqualTo(oldSid)
   }