feat: minimal tombstone integration

gradle/libs.versions.toml

@@ -41,6 +41,7 @@ spotless = "7.0.4"
 gummyBears = "0.12.0"
 camerax = "1.3.0"
 openfeature = "1.18.2"
+protobuf = "4.33.1"
 
 [plugins]
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
@@ -60,6 +61,7 @@ spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }
 detekt = { id = "io.gitlab.arturbosch.detekt", version = "1.23.8" }
 jacoco-android = { id = "com.mxalbert.gradle.jacoco-android", version = "0.2.0" }
 kover = { id = "org.jetbrains.kotlinx.kover", version = "0.7.3" }
+protobuf = { id = "com.google.protobuf", version = "0.9.5" }
 vanniktech-maven-publish = { id = "com.vanniktech.maven.publish", version = "0.30.0" }
 springboot2 = { id = "org.springframework.boot", version.ref = "springboot2" }
 springboot3 = { id = "org.springframework.boot", version.ref = "springboot3" }
@@ -138,6 +140,8 @@ otel-javaagent-extension-api = { module = "io.opentelemetry.javaagent:openteleme
 otel-semconv = { module = "io.opentelemetry.semconv:opentelemetry-semconv", version.ref = "otelSemanticConventions" }
 otel-semconv-incubating = { module = "io.opentelemetry.semconv:opentelemetry-semconv-incubating", version.ref = "otelSemanticConventionsAlpha" }
 p6spy = { module = "p6spy:p6spy", version = "3.9.1" }
+protobuf-javalite = { module = "com.google.protobuf:protobuf-javalite", version.ref = "protobuf"}
+protoc = { module = "com.google.protobuf:protoc", version.ref = "protobuf" }
 quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }

sentry-android-core/build.gradle.kts

@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.jacoco.android)
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
+  alias(libs.plugins.protobuf)
 }
 
 android {
@@ -83,6 +84,7 @@ dependencies {
   implementation(libs.androidx.lifecycle.common.java8)
   implementation(libs.androidx.lifecycle.process)
   implementation(libs.androidx.core)
+  implementation(libs.protobuf.javalite)
 
   errorprone(libs.errorprone.core)
   errorprone(libs.nopen.checker)
@@ -109,3 +111,18 @@ dependencies {
   testRuntimeOnly(libs.androidx.fragment.ktx)
   testRuntimeOnly(libs.timber)
 }
+
+protobuf {
+  protoc {
+    artifact = libs.protoc.get().toString()
+  }
+  generateProtoTasks {
+    all().forEach { task ->
+      task.builtins {
+        create("java") {
+          option("lite")
+        }
+      }
+    }
+  }
+}

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

@@ -5,6 +5,7 @@
 import android.app.Application;
 import android.content.Context;
 import android.content.pm.PackageInfo;
+import android.os.Build;
 import io.sentry.CompositePerformanceCollector;
 import io.sentry.DeduplicateMultithreadedEventProcessor;
 import io.sentry.DefaultCompositePerformanceCollector;
@@ -372,6 +373,10 @@ static void installDefaultIntegrations(
     final Class<?> sentryNdkClass = loadClass.loadClass(SENTRY_NDK_CLASS_NAME, options.getLogger());
     options.addIntegration(new NdkIntegration(sentryNdkClass));
 
+    if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.R) {
+      options.addIntegration(new TombstoneIntegration(context));
+    }
+
     // this integration uses android.os.FileObserver, we can't move to sentry
     // before creating a pure java impl.
     options.addIntegration(EnvelopeFileObserverIntegration.getOutboxFileObserver());

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

@@ -227,6 +227,8 @@ public interface BeforeCaptureCallback {
 
   private @Nullable SentryFrameMetricsCollector frameMetricsCollector;
 
+  private boolean tombstonesEnabled = false;
+
   public SentryAndroidOptions() {
     setSentryClientName(BuildConfig.SENTRY_ANDROID_SDK_NAME + "/" + BuildConfig.VERSION_NAME);
     setSdkVersion(createSdkVersion());
@@ -300,6 +302,26 @@ public void setAnrReportInDebug(boolean anrReportInDebug) {
     this.anrReportInDebug = anrReportInDebug;
   }
 
+  /**
+   * Sets Tombstone reporting (ApplicationExitInfo.REASON_CRASH_NATIVE) to enabled or disabled.
+   *
+   * @param tombstonesEnabled true for enabled and false for disabled
+   */
+  @ApiStatus.Internal
+  public void setTombstonesEnabled(boolean tombstonesEnabled) {
+    this.tombstonesEnabled = tombstonesEnabled;
+  }
+
+  /**
+   * Checks if Tombstone reporting (ApplicationExitInfo.REASON_CRASH_NATIVE) is enabled or disabled Default is disabled
+   *
+   * @return true if enabled or false otherwise
+   */
+  @ApiStatus.Internal
+  public boolean isTombstonesEnabled() {
+    return tombstonesEnabled;
+  }
+
   public boolean isEnableActivityLifecycleBreadcrumbs() {
     return enableActivityLifecycleBreadcrumbs;
   }

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

@@ -0,0 +1,197 @@
+package io.sentry.android.core;
+
+import static io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion;
+
+import android.app.ActivityManager;
+import android.app.ApplicationExitInfo;
+import android.content.Context;
+import android.os.Build;
+
+import androidx.annotation.RequiresApi;
+
+import io.sentry.DateUtils;
+import io.sentry.IScopes;
+import io.sentry.Integration;
+import io.sentry.SentryEvent;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import io.sentry.android.core.internal.tombstone.TombstoneParser;
+import io.sentry.cache.EnvelopeCache;
+import io.sentry.cache.IEnvelopeCache;
+import io.sentry.transport.CurrentDateProvider;
+import io.sentry.transport.ICurrentDateProvider;
+import io.sentry.util.Objects;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class TombstoneIntegration implements Integration, Closeable {
+  static final long NINETY_DAYS_THRESHOLD = TimeUnit.DAYS.toMillis(91);
+
+  private final @NotNull Context context;
+  private final @NotNull ICurrentDateProvider dateProvider;
+  private @Nullable SentryAndroidOptions options;
+
+  public TombstoneIntegration(final @NotNull Context context) {
+    // using CurrentDateProvider instead of AndroidCurrentDateProvider as AppExitInfo uses
+    // System.currentTimeMillis
+    this(context, CurrentDateProvider.getInstance());
+  }
+
+  TombstoneIntegration(
+    final @NotNull Context context, final @NotNull ICurrentDateProvider dateProvider) {
+    this.context = ContextUtils.getApplicationContext(context);
+    this.dateProvider = dateProvider;
+  }
+
+  @Override
+  public void register(@NotNull IScopes scopes, @NotNull SentryOptions options) {
+    this.options =
+      Objects.requireNonNull(
+        (options instanceof SentryAndroidOptions) ? (SentryAndroidOptions) options : null,
+        "SentryAndroidOptions is required");
+
+    this.options
+      .getLogger()
+      .log(SentryLevel.DEBUG, "TombstoneIntegration enabled: %s", this.options.isTombstonesEnabled());
+
+    if (this.options.isTombstonesEnabled()) {
+      if (this.options.getCacheDirPath() == null) {
+        this.options
+          .getLogger()
+          .log(SentryLevel.INFO, "Cache dir is not set, unable to process Tombstones");
+        return;
+      }
+
+      try {
+        options
+          .getExecutorService()
+          .submit(
+            new TombstoneProcessor(
+              context, scopes, this.options, dateProvider));
+      } catch (Throwable e) {
+        options.getLogger().log(SentryLevel.DEBUG, "Failed to start TombstoneProcessor.", e);
+      }
+      options.getLogger().log(SentryLevel.DEBUG, "TombstoneIntegration installed.");
+      addIntegrationToSdkVersion("Tombstone");
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    if (options != null) {
+      options.getLogger().log(SentryLevel.DEBUG, "TombstoneIntegration removed.");
+    }
+  }
+
+  public static class TombstoneProcessor implements Runnable {
+
+    @NotNull
+    private final Context context;
+    @NotNull
+    private final IScopes scopes;
+    @NotNull
+    private final SentryAndroidOptions options;
+    private final long threshold;
+
+    public TombstoneProcessor(
+      @NotNull Context context,
+      @NotNull IScopes scopes,
+      @NotNull SentryAndroidOptions options,
+      @NotNull ICurrentDateProvider dateProvider) {
+      this.context = context;
+      this.scopes = scopes;
+      this.options = options;
+
+      this.threshold = dateProvider.getCurrentTimeMillis() - NINETY_DAYS_THRESHOLD;
+    }
+
+    @Override
+    @RequiresApi(api = Build.VERSION_CODES.R)
+    public void run() {
+      final ActivityManager activityManager =
+        (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+
+      final List<ApplicationExitInfo> applicationExitInfoList;
+      applicationExitInfoList = activityManager.getHistoricalProcessExitReasons(null, 0, 0);
+
+      if (applicationExitInfoList.isEmpty()) {
+        options.getLogger().log(SentryLevel.DEBUG, "No records in historical exit reasons.");
+        return;
+      }
+
+      final IEnvelopeCache cache = options.getEnvelopeDiskCache();
+      if (cache instanceof EnvelopeCache) {
+        if (options.isEnableAutoSessionTracking()
+          && !((EnvelopeCache) cache).waitPreviousSessionFlush()) {
+          options
+            .getLogger()
+            .log(
+              SentryLevel.WARNING,
+              "Timed out waiting to flush previous session to its own file.");
+
+          // if we timed out waiting here, we can already flush the latch, because the timeout is
+          // big
+          // enough to wait for it only once and we don't have to wait again in
+          // PreviousSessionFinalizer
+          ((EnvelopeCache) cache).flushPreviousSession();
+        }
+      }
+
+      // making a deep copy as we're modifying the list
+      final List<ApplicationExitInfo> exitInfos = new ArrayList<>(applicationExitInfoList);
+
+      // search for the latest Tombstone to report it separately as we're gonna enrich it. The
+      // latest
+      // Tombstone will be first in the list, as it's filled last-to-first in order of appearance
+      ApplicationExitInfo latestTombstone = null;
+      for (ApplicationExitInfo applicationExitInfo : exitInfos) {
+        if (applicationExitInfo.getReason() == ApplicationExitInfo.REASON_CRASH_NATIVE) {
+          latestTombstone = applicationExitInfo;
+          // remove it, so it's not reported twice
+          // TODO: if we fail after this, we effectively lost the ApplicationExitInfo (maybe only remove after we reported it)
+          exitInfos.remove(applicationExitInfo);
+          break;
+        }
+      }
+
+      if (latestTombstone == null) {
+        options
+          .getLogger()
+          .log(
+            SentryLevel.DEBUG,
+            "No Tombstones have been found in the historical exit reasons list.");
+        return;
+      }
+
+      if (latestTombstone.getTimestamp() < threshold) {
+        options
+          .getLogger()
+          .log(SentryLevel.DEBUG, "Latest Tombstones happened too long ago, returning early.");
+        return;
+      }
+
+      reportAsSentryEvent(latestTombstone);
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.R)
+    private void reportAsSentryEvent(ApplicationExitInfo exitInfo) {
+      SentryEvent event;
+      try {
+        TombstoneParser parser = new TombstoneParser(exitInfo.getTraceInputStream());
+        event = parser.parse();
+        event.setTimestamp(DateUtils.getDateTime(exitInfo.getTimestamp()));
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+
+      scopes.captureEvent(event);
+    }
+  }
+}