Merge branch 'main' into feat/improve-sentry-trace-header-validation

Author: alexander-alderman-webb

CHANGELOG.md

@@ -5,13 +5,25 @@
 ### Improvements
 
 - Session Replay: Use main thread looper to schedule replay capture ([#4542](https://github.com/getsentry/sentry-java/pull/4542))
+- Use single `LifecycleObserver` and multi-cast it to the integrations interested in lifecycle states ([#4567](https://github.com/getsentry/sentry-java/pull/4567))
+- Prewarm `SentryExecutorService` for better performance at runtime ([#4606](https://github.com/getsentry/sentry-java/pull/4606))
 
 ### Fixes
 
 - Cache network capabilities and status to reduce IPC calls ([#4560](https://github.com/getsentry/sentry-java/pull/4560))
 - Deduplicate battery breadcrumbs ([#4561](https://github.com/getsentry/sentry-java/pull/4561))
 - Remove unused method in ManifestMetadataReader ([#4585](https://github.com/getsentry/sentry-java/pull/4585))
 - Have single `NetworkCallback` registered at a time to reduce IPC calls ([#4562](https://github.com/getsentry/sentry-java/pull/4562))
+- Do not register for SystemEvents and NetworkCallbacks immediately when launched with non-foreground importance ([#4579](https://github.com/getsentry/sentry-java/pull/4579))
+- Limit ProGuard keep rules for native methods within `sentry-android-ndk` to the `io.sentry.**` namespace. ([#4427](https://github.com/getsentry/sentry-java/pull/4427))
+  - If you relied on the Sentry SDK to keep native method names for JNI compatibility within your namespace, please review your ProGuard rules and ensure the configuration still works. Especially when you're not consuming any of the default Android proguard rules (`proguard-android.txt` or `proguard-android-optimize.txt`) the following config should be present:
+  ```
+  -keepclasseswithmembernames class * {
+    native <methods>;
+  }
+  ```
+- Fix abstract method error in `SentrySupportSQLiteDatabase` ([#4597](https://github.com/getsentry/sentry-java/pull/4597))
+- Ensure frame metrics listeners are registered/unregistered on the main thread ([#4582](https://github.com/getsentry/sentry-java/pull/4582))
 
 ## 8.18.0
 

gradle/libs.versions.toml

@@ -79,7 +79,7 @@ androidx-lifecycle-common-java8 = { module = "androidx.lifecycle:lifecycle-commo
 androidx-lifecycle-process = { module = "androidx.lifecycle:lifecycle-process", version.ref = "androidxLifecycle" }
 androidx-navigation-runtime = { module = "androidx.navigation:navigation-runtime", version.ref = "androidxNavigation" }
 androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "androidxNavigation" }
-androidx-sqlite = { module = "androidx.sqlite:sqlite", version = "2.3.1" }
+androidx-sqlite = { module = "androidx.sqlite:sqlite", version = "2.5.2" }
 androidx-recyclerview = { module = "androidx.recyclerview:recyclerview", version = "1.2.1" }
 coil-compose = { module = "io.coil-kt:coil-compose", version = "2.6.0" }
 commons-compress = {module = "org.apache.commons:commons-compress", version = "1.25.0"}

sentry-android-core/api/sentry-android-core.api

@@ -166,9 +166,28 @@ public final class io/sentry/android/core/AppLifecycleIntegration : io/sentry/In
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
-public final class io/sentry/android/core/AppState {
+public final class io/sentry/android/core/AppState : java/io/Closeable {
+	public fun addAppStateListener (Lio/sentry/android/core/AppState$AppStateListener;)V
+	public fun close ()V
 	public static fun getInstance ()Lio/sentry/android/core/AppState;
+	public fun getLifecycleObserver ()Lio/sentry/android/core/AppState$LifecycleObserver;
 	public fun isInBackground ()Ljava/lang/Boolean;
+	public fun registerLifecycleObserver (Lio/sentry/SentryOptions;)V
+	public fun removeAppStateListener (Lio/sentry/android/core/AppState$AppStateListener;)V
+	public fun resetInstance ()V
+	public fun unregisterLifecycleObserver ()V
+}
+
+public abstract interface class io/sentry/android/core/AppState$AppStateListener {
+	public abstract fun onBackground ()V
+	public abstract fun onForeground ()V
+}
+
+public final class io/sentry/android/core/AppState$LifecycleObserver : androidx/lifecycle/DefaultLifecycleObserver {
+	public fun <init> (Lio/sentry/android/core/AppState;)V
+	public fun getListeners ()Ljava/util/List;
+	public fun onStart (Landroidx/lifecycle/LifecycleOwner;)V
+	public fun onStop (Landroidx/lifecycle/LifecycleOwner;)V
 }
 
 public final class io/sentry/android/core/BuildConfig {
@@ -422,11 +441,13 @@ public class io/sentry/android/core/SpanFrameMetricsCollector : io/sentry/IPerfo
 	public fun onSpanStarted (Lio/sentry/ISpan;)V
 }
 
-public final class io/sentry/android/core/SystemEventsBreadcrumbsIntegration : io/sentry/Integration, java/io/Closeable {
+public final class io/sentry/android/core/SystemEventsBreadcrumbsIntegration : io/sentry/Integration, io/sentry/android/core/AppState$AppStateListener, java/io/Closeable {
 	public fun <init> (Landroid/content/Context;)V
 	public fun <init> (Landroid/content/Context;Ljava/util/List;)V
 	public fun close ()V
 	public static fun getDefaultActions ()Ljava/util/List;
+	public fun onBackground ()V
+	public fun onForeground ()V
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 

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

@@ -128,6 +128,7 @@ static void loadDefaultAndMetadataOptions(
     options.setCacheDirPath(getCacheDir(context).getAbsolutePath());
 
     readDefaultOptionValues(options, context, buildInfoProvider);
+    AppState.getInstance().registerLifecycleObserver(options);
   }
 
   @TestOnly

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

@@ -2,12 +2,12 @@
 
 import static io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion;
 
-import androidx.lifecycle.ProcessLifecycleOwner;
 import io.sentry.IScopes;
+import io.sentry.ISentryLifecycleToken;
 import io.sentry.Integration;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
-import io.sentry.android.core.internal.util.AndroidThreadChecker;
+import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.Objects;
 import java.io.Closeable;
 import java.io.IOException;
@@ -17,20 +17,11 @@
 
 public final class AppLifecycleIntegration implements Integration, Closeable {
 
+  private final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
   @TestOnly @Nullable volatile LifecycleWatcher watcher;
 
   private @Nullable SentryAndroidOptions options;
 
-  private final @NotNull MainLooperHandler handler;
-
-  public AppLifecycleIntegration() {
-    this(new MainLooperHandler());
-  }
-
-  AppLifecycleIntegration(final @NotNull MainLooperHandler handler) {
-    this.handler = handler;
-  }
-
   @Override
   public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions options) {
     Objects.requireNonNull(scopes, "Scopes are required");
@@ -55,85 +46,47 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
 
     if (this.options.isEnableAutoSessionTracking()
         || this.options.isEnableAppLifecycleBreadcrumbs()) {
-      try {
-        Class.forName("androidx.lifecycle.DefaultLifecycleObserver");
-        Class.forName("androidx.lifecycle.ProcessLifecycleOwner");
-        if (AndroidThreadChecker.getInstance().isMainThread()) {
-          addObserver(scopes);
-        } else {
-          // some versions of the androidx lifecycle-process require this to be executed on the main
-          // thread.
-          handler.post(() -> addObserver(scopes));
+      try (final ISentryLifecycleToken ignored = lock.acquire()) {
+        if (watcher != null) {
+          return;
         }
-      } catch (ClassNotFoundException e) {
-        options
-            .getLogger()
-            .log(
-                SentryLevel.WARNING,
-                "androidx.lifecycle is not available, AppLifecycleIntegration won't be installed");
-      } catch (IllegalStateException e) {
-        options
-            .getLogger()
-            .log(SentryLevel.ERROR, "AppLifecycleIntegration could not be installed", e);
-      }
-    }
-  }
 
-  private void addObserver(final @NotNull IScopes scopes) {
-    // this should never happen, check added to avoid warnings from NullAway
-    if (this.options == null) {
-      return;
-    }
+        watcher =
+            new LifecycleWatcher(
+                scopes,
+                this.options.getSessionTrackingIntervalMillis(),
+                this.options.isEnableAutoSessionTracking(),
+                this.options.isEnableAppLifecycleBreadcrumbs());
 
-    watcher =
-        new LifecycleWatcher(
-            scopes,
-            this.options.getSessionTrackingIntervalMillis(),
-            this.options.isEnableAutoSessionTracking(),
-            this.options.isEnableAppLifecycleBreadcrumbs());
+        AppState.getInstance().addAppStateListener(watcher);
+      }
 
-    try {
-      ProcessLifecycleOwner.get().getLifecycle().addObserver(watcher);
       options.getLogger().log(SentryLevel.DEBUG, "AppLifecycleIntegration installed.");
       addIntegrationToSdkVersion("AppLifecycle");
-    } catch (Throwable e) {
-      // This is to handle a potential 'AbstractMethodError' gracefully. The error is triggered in
-      // connection with conflicting dependencies of the androidx.lifecycle.
-      // //See the issue here: https://github.com/getsentry/sentry-java/pull/2228
-      watcher = null;
-      options
-          .getLogger()
-          .log(
-              SentryLevel.ERROR,
-              "AppLifecycleIntegration failed to get Lifecycle and could not be installed.",
-              e);
     }
   }
 
   private void removeObserver() {
-    final @Nullable LifecycleWatcher watcherRef = watcher;
+    final @Nullable LifecycleWatcher watcherRef;
+    try (final ISentryLifecycleToken ignored = lock.acquire()) {
+      watcherRef = watcher;
+      watcher = null;
+    }
+
     if (watcherRef != null) {
-      ProcessLifecycleOwner.get().getLifecycle().removeObserver(watcherRef);
+      AppState.getInstance().removeAppStateListener(watcherRef);
       if (options != null) {
         options.getLogger().log(SentryLevel.DEBUG, "AppLifecycleIntegration removed.");
       }
     }
-    watcher = null;
   }
 
   @Override
   public void close() throws IOException {
-    if (watcher == null) {
-      return;
-    }
-    if (AndroidThreadChecker.getInstance().isMainThread()) {
-      removeObserver();
-    } else {
-      // some versions of the androidx lifecycle-process require this to be executed on the main
-      // thread.
-      // avoid method refs on Android due to some issues with older AGP setups
-      // noinspection Convert2MethodRef
-      handler.post(() -> removeObserver());
-    }
+    removeObserver();
+    // TODO: probably should move it to Scopes.close(), but that'd require a new interface and
+    //  different implementations for Java and Android. This is probably fine like this too, because
+    //  integrations are closed in the same place
+    AppState.getInstance().unregisterLifecycleObserver();
   }
 }