ref: move init flag (#542)

sentry-core/src/main/java/io/sentry/core/Session.java

@@ -4,6 +4,7 @@
 import java.util.Date;
 import java.util.UUID;
 import java.util.concurrent.atomic.AtomicInteger;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -142,6 +143,12 @@ public Session(
     return init;
   }
 
+  /** Used for migrating the init flag when an session is gonna be deleted. */
+  @ApiStatus.Internal
+  public void setInitAsTrue() {
+    this.init = true;
+  }
+
   public int errorCount() {
     return errorCount.get();
   }

sentry-core/src/main/java/io/sentry/core/cache/CacheStrategy.java

@@ -3,13 +3,35 @@
 import static io.sentry.core.SentryLevel.ERROR;
 
 import io.sentry.core.ISerializer;
+import io.sentry.core.SentryEnvelope;
+import io.sentry.core.SentryEnvelopeItem;
+import io.sentry.core.SentryItemType;
 import io.sentry.core.SentryLevel;
 import io.sentry.core.SentryOptions;
+import io.sentry.core.Session;
 import io.sentry.core.util.Objects;
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
 import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
 import java.nio.charset.Charset;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 abstract class CacheStrategy {
 
@@ -79,10 +101,15 @@ protected void rotateCacheIfNeeded(final @NotNull File[] files) {
 
       sortFilesOldestToNewest(files);
 
+      final File[] notDeletedFiles = Arrays.copyOfRange(files, totalToBeDeleted, length);
+
       // delete files from the top of the Array as its sorted by the oldest to the newest
       for (int i = 0; i < totalToBeDeleted; i++) {
         final File file = files[i];
-        // sanity check if the file actually exists.
+
+        // move init flag if necessary
+        moveInitFlagIfNecessary(file, notDeletedFiles);
+
         if (!file.delete()) {
           options
               .getLogger()
@@ -91,4 +118,189 @@ protected void rotateCacheIfNeeded(final @NotNull File[] files) {
       }
     }
   }
+
+  private void moveInitFlagIfNecessary(
+      final @NotNull File currentFile, final @NotNull File[] notDeletedFiles) {
+    final SentryEnvelope currentEnvelope = readEnvelope(currentFile);
+
+    if (!isValidEnvelope(currentEnvelope)) {
+      return;
+    }
+
+    final Session currentSession = getFirstSession(currentEnvelope);
+
+    if (!isValidSession(currentSession)) {
+      return;
+    }
+
+    // nothing to do if its not true
+    final Boolean currentSessionInit = currentSession.getInit();
+    if (currentSessionInit == null || !currentSessionInit) {
+      return;
+    }
+
+    // we need to move the init flag
+    for (final File notDeletedFile : notDeletedFiles) {
+      final SentryEnvelope envelope = readEnvelope(notDeletedFile);
+
+      if (!isValidEnvelope(envelope)) {
+        continue;
+      }
+
+      SentryEnvelopeItem newSessionItem = null;
+      final Iterator<SentryEnvelopeItem> itemsIterator = envelope.getItems().iterator();
+
+      while (itemsIterator.hasNext()) {
+        final SentryEnvelopeItem envelopeItem = itemsIterator.next();
+
+        if (!isSessionType(envelopeItem)) {
+          continue;
+        }
+
+        final Session session = readSession(envelopeItem);
+
+        if (!isValidSession(session)) {
+          continue;
+        }
+
+        final Boolean init = session.getInit();
+        if (init != null && init) {
+          options
+              .getLogger()
+              .log(ERROR, "Session %s has 2 times the init flag.", currentSession.getSessionId());
+          return;
+        }
+
+        if (currentSession.getSessionId().equals(session.getSessionId())) {
+          session.setInitAsTrue();
+          try {
+            newSessionItem = SentryEnvelopeItem.fromSession(serializer, session);
+            // remove item from envelope items so we can replace with the new one that has the
+            // init flag true
+            itemsIterator.remove();
+          } catch (IOException e) {
+            options
+                .getLogger()
+                .log(
+                    ERROR,
+                    e,
+                    "Failed to create new envelope item for the session %s",
+                    currentSession.getSessionId());
+          }
+
+          break;
+        }
+      }
+
+      if (newSessionItem != null) {
+        final SentryEnvelope newEnvelope = buildNewEnvelope(envelope, newSessionItem);
+
+        long notDeletedFileTimestamp = notDeletedFile.lastModified();
+        if (!notDeletedFile.delete()) {
+          options
+              .getLogger()
+              .log(
+                  SentryLevel.WARNING,
+                  "File can't be deleted: %s",
+                  notDeletedFile.getAbsolutePath());
+        }
+
+        saveNewEnvelope(newEnvelope, notDeletedFile, notDeletedFileTimestamp);
+        break;
+      }
+    }
+  }
+
+  private @Nullable SentryEnvelope readEnvelope(final @NotNull File file) {
+    try (final InputStream inputStream = new BufferedInputStream(new FileInputStream(file))) {
+      return serializer.deserializeEnvelope(inputStream);
+    } catch (IOException e) {
+      options.getLogger().log(ERROR, "Failed to deserialize the envelope.", e);
+    }
+
+    return null;
+  }
+
+  private @Nullable Session getFirstSession(final @NotNull SentryEnvelope envelope) {
+    for (final SentryEnvelopeItem item : envelope.getItems()) {
+      if (!isSessionType(item)) {
+        continue;
+      }
+
+      // we are assuming that there's only 1 session per envelope for now
+      return readSession(item);
+    }
+    return null;
+  }
+
+  private boolean isValidSession(final @Nullable Session session) {
+    if (session == null) {
+      return false;
+    }
+
+    if (!session.getStatus().equals(Session.State.Ok)) {
+      return false;
+    }
+
+    final UUID sessionId = session.getSessionId();
+
+    if (sessionId == null) {
+      return false;
+    }
+    return true;
+  }
+
+  private boolean isSessionType(final @Nullable SentryEnvelopeItem item) {
+    if (item == null) {
+      return false;
+    }
+
+    return item.getHeader().getType().equals(SentryItemType.Session);
+  }
+
+  private @Nullable Session readSession(final @NotNull SentryEnvelopeItem item) {
+    try (final Reader reader =
+        new BufferedReader(
+            new InputStreamReader(new ByteArrayInputStream(item.getData()), UTF_8))) {
+      return serializer.deserializeSession(reader);
+    } catch (Exception e) {
+      options.getLogger().log(ERROR, "Failed to deserialize the session.", e);
+    }
+    return null;
+  }
+
+  private void saveNewEnvelope(
+      final @NotNull SentryEnvelope envelope, final @NotNull File file, final long timestamp) {
+    try (final OutputStream outputStream = new FileOutputStream(file);
+        final Writer writer = new BufferedWriter(new OutputStreamWriter(outputStream, UTF_8))) {
+      serializer.serialize(envelope, writer);
+      // we need to set the same timestamp so the sorting from oldest to newest wont break.
+      file.setLastModified(timestamp);
+    } catch (Exception e) {
+      options.getLogger().log(ERROR, "Failed to serialize the new envelope to the disk.", e);
+    }
+  }
+
+  private @NotNull SentryEnvelope buildNewEnvelope(
+      final @NotNull SentryEnvelope envelope, final @NotNull SentryEnvelopeItem sessionItem) {
+    final List<SentryEnvelopeItem> newEnvelopeItems = new ArrayList<>();
+
+    for (final SentryEnvelopeItem newEnvelopeItem : envelope.getItems()) {
+      newEnvelopeItems.add(newEnvelopeItem);
+    }
+    newEnvelopeItems.add(sessionItem);
+
+    return new SentryEnvelope(envelope.getHeader(), newEnvelopeItems);
+  }
+
+  private boolean isValidEnvelope(final @Nullable SentryEnvelope envelope) {
+    if (envelope == null) {
+      return false;
+    }
+
+    if (!envelope.getItems().iterator().hasNext()) {
+      return false;
+    }
+    return true;
+  }
 }

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

@@ -132,7 +132,10 @@ public void store(final @NotNull SentryEnvelope envelope, final @Nullable Object
       }
       updateCurrentSession(currentSessionFile, envelope);
     }
-    // TODO: problem we need to update the current session file
+
+    // TODO: probably we need to update the current session file for session updates to because of
+    // hardcrash events
+
     final File envelopeFile = getEnvelopeFile(envelope);
     if (envelopeFile.exists()) {
       options