automatic breadcrumbs for app, activity and sessions lifecycles and system events

build.gradle.kts

@@ -66,6 +66,7 @@ spotless {
         target("**/*.java")
         removeUnusedImports()
         googleJavaFormat()
+        paddedCell()
     }
 
     kotlin {

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

@@ -0,0 +1,105 @@
+package io.sentry.android.core;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import io.sentry.core.Breadcrumb;
+import io.sentry.core.IHub;
+import io.sentry.core.Integration;
+import io.sentry.core.SentryLevel;
+import io.sentry.core.SentryOptions;
+import io.sentry.core.util.Objects;
+import java.io.Closeable;
+import java.io.IOException;
+import org.jetbrains.annotations.NotNull;
+
+public final class ActivityBreadcrumbsIntegration
+    implements Integration, Closeable, Application.ActivityLifecycleCallbacks {
+
+  private final @NotNull Application application;
+  private @Nullable IHub hub;
+  private @Nullable SentryAndroidOptions options;
+
+  public ActivityBreadcrumbsIntegration(final @NotNull Application application) {
+    this.application = Objects.requireNonNull(application, "Application is required");
+  }
+
+  @Override
+  public void register(final @NotNull IHub hub, final @NotNull SentryOptions options) {
+    this.options =
+        Objects.requireNonNull(
+            (options instanceof SentryAndroidOptions) ? (SentryAndroidOptions) options : null,
+            "SentryAndroidOptions is required");
+
+    this.hub = Objects.requireNonNull(hub, "Hub is required");
+
+    this.options
+        .getLogger()
+        .log(
+            SentryLevel.DEBUG,
+            "ActivityBreadcrumbsIntegration enabled: %s",
+            this.options.isEnableActivityLifecycleBreadcrumbs());
+
+    if (this.options.isEnableActivityLifecycleBreadcrumbs()) {
+      application.registerActivityLifecycleCallbacks(this);
+      options.getLogger().log(SentryLevel.DEBUG, "ActivityBreadcrumbsIntegration installed.");
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    application.unregisterActivityLifecycleCallbacks(this);
+
+    if (options != null) {
+      options.getLogger().log(SentryLevel.DEBUG, "ActivityBreadcrumbsIntegration removed.");
+    }
+  }
+
+  private void addBreadcrumb(final @NonNull Activity activity, final @NotNull String state) {
+    if (hub != null) {
+      final Breadcrumb breadcrumb = new Breadcrumb();
+      breadcrumb.setType("navigation");
+      breadcrumb.setData("state", state);
+      breadcrumb.setData("screen", activity.getClass().getSimpleName());
+      breadcrumb.setCategory("ui.lifecycle");
+      hub.addBreadcrumb(breadcrumb);
+    }
+  }
+
+  @Override
+  public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
+    addBreadcrumb(activity, "created");
+  }
+
+  @Override
+  public void onActivityStarted(@NonNull Activity activity) {
+    addBreadcrumb(activity, "started");
+  }
+
+  @Override
+  public void onActivityResumed(@NonNull Activity activity) {
+    addBreadcrumb(activity, "resumed");
+  }
+
+  @Override
+  public void onActivityPaused(@NonNull Activity activity) {
+    addBreadcrumb(activity, "paused");
+  }
+
+  @Override
+  public void onActivityStopped(@NonNull Activity activity) {
+    addBreadcrumb(activity, "stopped");
+  }
+
+  @Override
+  public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {
+    addBreadcrumb(activity, "saveInstanceState");
+  }
+
+  @Override
+  public void onActivityDestroyed(@NonNull Activity activity) {
+    addBreadcrumb(activity, "destroyed");
+  }
+}

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

@@ -1,5 +1,6 @@
 package io.sentry.android.core;
 
+import android.app.Application;
 import android.content.Context;
 import android.content.pm.PackageInfo;
 import io.sentry.core.EnvelopeReader;
@@ -63,6 +64,22 @@ static void init(
 
     final IEnvelopeReader envelopeReader = new EnvelopeReader();
 
+    installDefaultIntegrations(context, options, envelopeReader);
+
+    readDefaultOptionValues(options, context);
+
+    options.addEventProcessor(new DefaultAndroidEventProcessor(context, options));
+
+    options.setSerializer(new AndroidSerializer(options.getLogger(), envelopeReader));
+
+    options.setTransportGate(new AndroidTransportGate(context, options.getLogger()));
+  }
+
+  private static void installDefaultIntegrations(
+      final @NotNull Context context,
+      final @NotNull SentryOptions options,
+      final @NotNull IEnvelopeReader envelopeReader) {
+
     // Integrations are registered in the same order. NDK before adding Watch outbox,
     // because sentry-native move files around and we don't want to watch that.
     options.addIntegration(new NdkIntegration());
@@ -95,15 +112,20 @@ static void init(
             }));
 
     options.addIntegration(new AnrIntegration());
-    options.addIntegration(new SessionTrackingIntegration());
-
-    readDefaultOptionValues(options, context);
-
-    options.addEventProcessor(new DefaultAndroidEventProcessor(context, options));
-
-    options.setSerializer(new AndroidSerializer(options.getLogger(), envelopeReader));
-
-    options.setTransportGate(new AndroidTransportGate(context, options.getLogger()));
+    options.addIntegration(new AppLifecycleIntegration());
+    if (context instanceof Application) { // just a guard check, it should be an Application
+      options.addIntegration(new ActivityBreadcrumbsIntegration((Application) context));
+    } else {
+      options
+          .getLogger()
+          .log(
+              SentryLevel.WARNING,
+              "ActivityBreadcrumbsIntegration needs an Application class to be installed.");
+    }
+    options.addIntegration(new AppComponentsBreadcrumbsIntegration(context));
+    options.addIntegration(new SystemEventsBreadcrumbsIntegration(context));
+    options.addIntegration(new TempSensorBreadcrumbsIntegration(context));
+    options.addIntegration(new PhoneStateBreadcrumbsIntegration(context));
   }
 
   /**

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

@@ -0,0 +1,94 @@
+package io.sentry.android.core;
+
+import android.content.ComponentCallbacks;
+import android.content.Context;
+import android.content.res.Configuration;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import io.sentry.android.core.util.DeviceOrientations;
+import io.sentry.core.Breadcrumb;
+import io.sentry.core.IHub;
+import io.sentry.core.Integration;
+import io.sentry.core.SentryLevel;
+import io.sentry.core.SentryOptions;
+import io.sentry.core.protocol.Device;
+import io.sentry.core.util.Objects;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Locale;
+import org.jetbrains.annotations.NotNull;
+
+public final class AppComponentsBreadcrumbsIntegration
+    implements Integration, Closeable, ComponentCallbacks {
+
+  private final @NotNull Context context;
+  private @Nullable IHub hub;
+  private @Nullable SentryAndroidOptions options;
+
+  public AppComponentsBreadcrumbsIntegration(final @NotNull Context context) {
+    this.context = Objects.requireNonNull(context, "Context is required");
+  }
+
+  @Override
+  public void register(final @NotNull IHub hub, final @NotNull SentryOptions options) {
+    this.hub = Objects.requireNonNull(hub, "Hub is required");
+    this.options =
+        Objects.requireNonNull(
+            (options instanceof SentryAndroidOptions) ? (SentryAndroidOptions) options : null,
+            "SentryAndroidOptions is required");
+
+    this.options
+        .getLogger()
+        .log(
+            SentryLevel.DEBUG,
+            "AppComponentsBreadcrumbsIntegration enabled: %s",
+            this.options.isEnableAppComponentBreadcrumbs());
+
+    if (this.options.isEnableAppComponentBreadcrumbs()) {
+      context.registerComponentCallbacks(this);
+      options.getLogger().log(SentryLevel.DEBUG, "AppComponentsBreadcrumbsIntegration installed.");
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    context.unregisterComponentCallbacks(this);
+
+    if (options != null) {
+      options.getLogger().log(SentryLevel.DEBUG, "AppComponentsBreadcrumbsIntegration removed.");
+    }
+  }
+
+  @SuppressWarnings("deprecation")
+  @Override
+  public void onConfigurationChanged(@NonNull Configuration newConfig) {
+    if (hub != null) {
+      final Device.DeviceOrientation deviceOrientation =
+          DeviceOrientations.getOrientation(context.getResources().getConfiguration().orientation);
+
+      String orientation;
+      if (deviceOrientation != null) {
+        orientation = deviceOrientation.name().toLowerCase(Locale.ROOT);
+      } else {
+        orientation = "undefined";
+      }
+
+      final Breadcrumb breadcrumb = new Breadcrumb();
+      breadcrumb.setType("navigation");
+      breadcrumb.setCategory("device.orientation");
+      breadcrumb.setData("position", orientation);
+      hub.addBreadcrumb(breadcrumb);
+    }
+  }
+
+  @Override
+  public void onLowMemory() {
+    if (hub != null) {
+      final Breadcrumb breadcrumb = new Breadcrumb();
+      breadcrumb.setType("info");
+      breadcrumb.setCategory("device.memory");
+      breadcrumb.setLevel(SentryLevel.WARNING);
+      hub.addBreadcrumb(breadcrumb);
+    }
+  }
+}

sentry-android-core/src/main/java/io/sentry/android/core/SessionTrackingIntegration.java → sentry-android-core/src/main/java/io/sentry/android/core/AppLifecycleIntegration.java

@@ -12,32 +12,47 @@
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 
-public final class SessionTrackingIntegration implements Integration, Closeable {
+public final class AppLifecycleIntegration implements Integration, Closeable {
 
   @TestOnly @Nullable LifecycleWatcher watcher;
 
-  private @Nullable SentryOptions options;
+  private @Nullable SentryAndroidOptions options;
 
   @Override
   public void register(final @NotNull IHub hub, final @NotNull SentryOptions options) {
-    this.options = Objects.requireNonNull(options, "SentryOptions is required");
     Objects.requireNonNull(hub, "Hub is required");
+    this.options =
+        Objects.requireNonNull(
+            (options instanceof SentryAndroidOptions) ? (SentryAndroidOptions) options : null,
+            "SentryAndroidOptions is required");
 
-    options
+    this.options
         .getLogger()
         .log(
             SentryLevel.DEBUG,
-            "SessionTrackingIntegration enabled: %s",
-            options.isEnableSessionTracking());
+            "enableSessionTracking enabled: %s",
+            this.options.isEnableSessionTracking());
 
-    if (options.isEnableSessionTracking()) {
+    this.options
+        .getLogger()
+        .log(
+            SentryLevel.DEBUG,
+            "enableAppLifecycleBreadcrumbs enabled: %s",
+            this.options.isEnableAppLifecycleBreadcrumbs());
+
+    if (this.options.isEnableSessionTracking() || this.options.isEnableAppLifecycleBreadcrumbs()) {
       try {
         Class.forName("androidx.lifecycle.DefaultLifecycleObserver");
         Class.forName("androidx.lifecycle.ProcessLifecycleOwner");
-        watcher = new LifecycleWatcher(hub, options.getSessionTrackingIntervalMillis());
+        watcher =
+            new LifecycleWatcher(
+                hub,
+                this.options.getSessionTrackingIntervalMillis(),
+                options.isEnableSessionTracking(),
+                this.options.isEnableAppLifecycleBreadcrumbs());
         ProcessLifecycleOwner.get().getLifecycle().addObserver(watcher);
 
-        options.getLogger().log(SentryLevel.DEBUG, "SessionTrackingIntegration installed.");
+        options.getLogger().log(SentryLevel.DEBUG, "AppLifecycleIntegration installed.");
       } catch (ClassNotFoundException e) {
         options
             .getLogger()
@@ -55,7 +70,7 @@ public void close() throws IOException {
       ProcessLifecycleOwner.get().getLifecycle().removeObserver(watcher);
       watcher = null;
       if (options != null) {
-        options.getLogger().log(SentryLevel.DEBUG, "SessionTrackingIntegration removed.");
+        options.getLogger().log(SentryLevel.DEBUG, "AppLifecycleIntegration removed.");
       }
     }
   }