adapt tryEndPreviousSession() in EnvelopeCache to NativeCrashExit hint

Author: supervacuus

sentry/src/main/java/io/sentry/cache/EnvelopeCache.java

@@ -20,6 +20,7 @@
 import io.sentry.Session;
 import io.sentry.UncaughtExceptionHandlerIntegration;
 import io.sentry.hints.AbnormalExit;
+import io.sentry.hints.NativeCrashExit;
 import io.sentry.hints.SessionEnd;
 import io.sentry.hints.SessionStart;
 import io.sentry.transport.NoOpEnvelopeCache;
@@ -119,10 +120,10 @@ private boolean storeInternal(final @NotNull SentryEnvelope envelope, final @Not
       }
     }
 
-    if (HintUtils.hasType(hint, AbnormalExit.class)) {
+    if (HintUtils.hasType(hint, AbnormalExit.class)
+        || HintUtils.hasType(hint, NativeCrashExit.class)) {
       tryEndPreviousSession(hint);
     }
-    // TODO: adapt       tryEndPreviousSession(hint); to CrashExit.class
 
     if (HintUtils.hasType(hint, SessionStart.class)) {
       movePreviousSession(currentSessionFile, previousSessionFile);
@@ -202,20 +203,20 @@ private boolean storeInternal(final @NotNull SentryEnvelope envelope, final @Not
   @SuppressWarnings("JavaUtilDate")
   private void tryEndPreviousSession(final @NotNull Hint hint) {
     final Object sdkHint = HintUtils.getSentrySdkHint(hint);
-    if (sdkHint instanceof AbnormalExit) {
-      final File previousSessionFile = getPreviousSessionFile(directory.getAbsolutePath());
+    final File previousSessionFile = getPreviousSessionFile(directory.getAbsolutePath());
 
-      if (previousSessionFile.exists()) {
-        options.getLogger().log(WARNING, "Previous session is not ended, we'd need to end it.");
+    if (previousSessionFile.exists()) {
+      options.getLogger().log(WARNING, "Previous session is not ended, we'd need to end it.");
 
-        try (final Reader reader =
-            new BufferedReader(
-                new InputStreamReader(new FileInputStream(previousSessionFile), UTF_8))) {
-          final Session session = serializer.getValue().deserialize(reader, Session.class);
-          if (session != null) {
+      try (final Reader reader =
+          new BufferedReader(
+              new InputStreamReader(new FileInputStream(previousSessionFile), UTF_8))) {
+        final Session session = serializer.getValue().deserialize(reader, Session.class);
+        if (session != null) {
+          Date timestamp = null;
+          if (sdkHint instanceof AbnormalExit) {
             final AbnormalExit abnormalHint = (AbnormalExit) sdkHint;
             final @Nullable Long abnormalExitTimestamp = abnormalHint.timestamp();
-            Date timestamp = null;
 
             if (abnormalExitTimestamp != null) {
               timestamp = DateUtils.getDateTime(abnormalExitTimestamp);
@@ -233,17 +234,33 @@ private void tryEndPreviousSession(final @NotNull Hint hint) {
 
             final String abnormalMechanism = abnormalHint.mechanism();
             session.update(Session.State.Abnormal, null, true, abnormalMechanism);
-            // we have to use the actual timestamp of the Abnormal Exit here to mark the session
-            // as finished at the time it happened
-            session.end(timestamp);
-            writeSessionToDisk(previousSessionFile, session);
+          } else if (sdkHint instanceof NativeCrashExit) {
+            final NativeCrashExit nativeCrashHint = (NativeCrashExit) sdkHint;
+            final @NotNull Long nativeCrashExitTimestamp = nativeCrashHint.timestamp();
+
+            timestamp = DateUtils.getDateTime(nativeCrashExitTimestamp);
+            // sanity check if the native crash exit actually happened when the session was alive
+            final Date sessionStart = session.getStarted();
+            if (sessionStart == null || timestamp.before(sessionStart)) {
+              options
+                  .getLogger()
+                  .log(
+                      WARNING,
+                      "Native crash exit happened before previous session start, not ending the session.");
+              return;
+            }
+            session.update(Session.State.Crashed, null, true, null);
           }
-        } catch (Throwable e) {
-          options.getLogger().log(SentryLevel.ERROR, "Error processing previous session.", e);
+          // we have to use the actual timestamp of the Abnormal or Crash Exit here to mark the
+          // session as finished at the time it happened
+          session.end(timestamp);
+          writeSessionToDisk(previousSessionFile, session);
         }
-      } else {
-        options.getLogger().log(DEBUG, "No previous session file to end.");
+      } catch (Throwable e) {
+        options.getLogger().log(SentryLevel.ERROR, "Error processing previous session.", e);
       }
+    } else {
+      options.getLogger().log(DEBUG, "No previous session file to end.");
     }
   }
 

sentry/src/test/java/io/sentry/cache/EnvelopeCacheTest.kt

@@ -17,6 +17,7 @@ import io.sentry.UncaughtExceptionHandlerIntegration.UncaughtExceptionHint
 import io.sentry.cache.EnvelopeCache.PREFIX_CURRENT_SESSION_FILE
 import io.sentry.cache.EnvelopeCache.SUFFIX_SESSION_FILE
 import io.sentry.hints.AbnormalExit
+import io.sentry.hints.NativeCrashExit
 import io.sentry.hints.SessionEndHint
 import io.sentry.hints.SessionStartHint
 import io.sentry.protocol.SentryId
@@ -347,6 +348,53 @@ class EnvelopeCacheTest {
     assertEquals(null, updatedSession.abnormalMechanism)
   }
 
+  @Test
+  fun `NativeCrashExit hint marks previous session as crashed with crash timestamp`() {
+    val cache = fixture.getSUT()
+
+    val previousSessionFile = EnvelopeCache.getPreviousSessionFile(fixture.options.cacheDirPath!!)
+    val session = createSession()
+    fixture.options.serializer.serialize(session, previousSessionFile.bufferedWriter())
+
+    val nativeCrashTimestamp = session.started!!.time + TimeUnit.HOURS.toMillis(3)
+    val envelope = SentryEnvelope.from(fixture.options.serializer, SentryEvent(), null)
+    val nativeCrashHint = NativeCrashExit { nativeCrashTimestamp }
+    val hints = HintUtils.createWithTypeCheckHint(nativeCrashHint)
+    cache.storeEnvelope(envelope, hints)
+
+    val updatedSession =
+      fixture.options.serializer.deserialize(
+        previousSessionFile.bufferedReader(),
+        Session::class.java,
+      )
+    assertEquals(State.Crashed, updatedSession!!.status)
+    assertEquals(nativeCrashTimestamp, updatedSession.timestamp!!.time)
+  }
+
+  @Test
+  fun `when NativeCrashExit happened before previous session start, does not mark as crashed`() {
+    val cache = fixture.getSUT()
+
+    val previousSessionFile = EnvelopeCache.getPreviousSessionFile(fixture.options.cacheDirPath!!)
+    val session = createSession()
+    val nativeCrashTimestamp = session.started!!.time - TimeUnit.HOURS.toMillis(3)
+    fixture.options.serializer.serialize(session, previousSessionFile.bufferedWriter())
+
+    val envelope = SentryEnvelope.from(fixture.options.serializer, SentryEvent(), null)
+    val nativeCrashHint = NativeCrashExit { nativeCrashTimestamp }
+    val hints = HintUtils.createWithTypeCheckHint(nativeCrashHint)
+    cache.storeEnvelope(envelope, hints)
+
+    val updatedSession =
+      fixture.options.serializer.deserialize(
+        previousSessionFile.bufferedReader(),
+        Session::class.java,
+      )
+    assertEquals(Ok, updatedSession!!.status)
+    assertTrue(nativeCrashTimestamp < updatedSession.started!!.time)
+    assertTrue(nativeCrashTimestamp < updatedSession.timestamp!!.time)
+  }
+
   @Test
   fun `failing to store returns false`() {
     val serializer = mock<ISerializer>()