Merge branch 'main' into fix/finish-webflux-transaction-before-scope-pop

Author: adinauer

.github/workflows/agp-matrix.yml

@@ -1,4 +1,4 @@
-name: AGP Matrix Sample Release
+name: AGP Matrix Compatibility
 
 on:
   push:
@@ -16,29 +16,50 @@ jobs:
         with:
           access_token: ${{ github.token }}
 
-  agp-matrix-sample-release:
-    runs-on: ubuntu-latest
+  agp-matrix-compatibility:
+    timeout-minutes: 25
+    runs-on: macos-latest
     strategy:
       fail-fast: false
       matrix:
-        agp: ['8.0.0-rc01','8.1.0-alpha11']
+        agp: [ '8.0.0','8.1.0-alpha11' ]
+        ndk: [ true, false ]
 
-    name: AGP Matrix Sample Release - AGP ${{ matrix.agp }}
+    name: AGP Matrix Release - AGP ${{ matrix.agp }} - NDK ${{ matrix.ndk }}
     env:
       VERSION_AGP: ${{ matrix.agp }}
+      APPLY_NDK: ${{ matrix.ndk }}
 
     steps:
       - name: Checkout Repo
         uses: actions/checkout@v3
 
+      - name: Setup Gradle
+        uses: gradle/gradle-build-action@749f47bda3e44aa060e82d7b3ef7e40d953bd629 # pin@v2
+
       - name: Setup Java Version
         uses: actions/setup-java@v3
         with:
           distribution: 'temurin'
           java-version: '17'
 
-      - name: Build the Release variant
-        uses: gradle/gradle-build-action@749f47bda3e44aa060e82d7b3ef7e40d953bd629 # pin@v2
+      # Clean, build and release a test apk
+      - name: Make assembleUiTests
+        run: make assembleUiTests
+
+      # We stop gradle at the end to make sure the cache folders
+      # don't contain any lock files and are free to be cached.
+      - name: Make stop
+        run: make stop
+
+      - name: Run instrumentation tests
+        uses: reactivecircus/android-emulator-runner@d94c3fbe4fe6a29e4a5ba47c12fb47677c73656b # pin@v2
         with:
-          cache-read-only: ${{ github.ref != 'refs/heads/main' }}
-          arguments: sentry-android-integration-tests:sentry-test-agp:assembleRelease
+          api-level: 30
+          force-avd-creation: false
+          emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none
+          disable-animations: true
+          disable-spellchecker: true
+          target: 'aosp_atd'
+          channel: canary # Necessary for ATDs
+          script: ./gradlew sentry-android-integration-tests:sentry-uitest-android:connectedReleaseAndroidTest -DtestBuildType=release --daemon

.github/workflows/integration-tests-ui.yml

@@ -1,4 +1,4 @@
-name: 'Integration Tests - Ui tests'
+name: 'Integration Tests'
 on:
   push:
     branches:
@@ -7,6 +7,14 @@ on:
   pull_request:
 
 jobs:
+  cancel-previous-workflow:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Cancel Previous Runs
+        uses: styfle/cancel-workflow-action@b173b6ec0100793626c2d9e6b90435061f4fc3e5 # [email protected]
+        with:
+          access_token: ${{ github.token }}
+
   test:
     name: Ui tests
     runs-on: ubuntu-latest
@@ -43,3 +51,4 @@ jobs:
           sauce-access-key: ${{ secrets.SAUCE_ACCESS_KEY }}
           config-file: .sauce/sentry-uitest-android-ui.yml
         if: env.SAUCE_USERNAME != null
+

CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+### Fixes
+
+- Base64 encode internal Apollo3 Headers ([#2707](https://github.com/getsentry/sentry-java/pull/2707))
+- Finish WebFlux transaction before popping scope ([#2724](https://github.com/getsentry/sentry-java/pull/2724))
+
+## 6.19.1
+
+### Fixes
+
+- Ensure screenshots and view hierarchies are captured on the main thread ([#2712](https://github.com/getsentry/sentry-java/pull/2712))
+
+## 6.19.0
+
 ### Features
 
 - Add Screenshot and ViewHierarchy to integrations list ([#2698](https://github.com/getsentry/sentry-java/pull/2698))
@@ -23,7 +36,8 @@
 - Android Profiler on calling thread ([#2691](https://github.com/getsentry/sentry-java/pull/2691))
 - Use `configureScope` instead of `withScope` in `Hub.close()`. This ensures that the main scope releases the in-memory data when closing a hub instance. ([#2688](https://github.com/getsentry/sentry-java/pull/2688))
 - Remove null keys/values before creating concurrent hashmap in order to avoid NPE ([#2708](https://github.com/getsentry/sentry-java/pull/2708))
-- Finish WebFlux transaction before popping scope ([#2724](https://github.com/getsentry/sentry-java/pull/2724))
+- Exclude SentryOptions from R8/ProGuard obfuscation ([#2699](https://github.com/getsentry/sentry-java/pull/2699))
+  - This fixes AGP 8.+ incompatibility, where full R8 mode is enforced
 
 ### Dependencies
 

build.gradle.kts

@@ -160,6 +160,16 @@ subprojects {
                 assignAarTypes()
             }
 
+            // this is needed for sentry-unity to consume our artifacts locally as proper maven publication
+            configure<PublishingExtension> {
+                repositories {
+                    maven {
+                        name = "unityMaven"
+                        url = file("${rootProject.buildDir}/unityMaven").toURI()
+                    }
+                }
+            }
+
             // maven central info go to:
             // ~/.gradle/gradle.properties
 

gradle.properties

@@ -10,7 +10,7 @@ android.useAndroidX=true
 android.defaults.buildfeatures.buildconfig=true
 
 # Release information
-versionName=6.18.1
+versionName=6.19.1
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

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

@@ -317,8 +317,9 @@ public final class io/sentry/android/core/ViewHierarchyEventProcessor : io/sentr
 	public fun <init> (Lio/sentry/android/core/SentryAndroidOptions;)V
 	public fun process (Lio/sentry/SentryEvent;Lio/sentry/Hint;)Lio/sentry/SentryEvent;
 	public static fun snapshotViewHierarchy (Landroid/app/Activity;Lio/sentry/ILogger;)Lio/sentry/protocol/ViewHierarchy;
+	public static fun snapshotViewHierarchy (Landroid/app/Activity;Lio/sentry/util/thread/IMainThreadChecker;Lio/sentry/ILogger;)Lio/sentry/protocol/ViewHierarchy;
 	public static fun snapshotViewHierarchy (Landroid/view/View;)Lio/sentry/protocol/ViewHierarchy;
-	public static fun snapshotViewHierarchyAsData (Landroid/app/Activity;Lio/sentry/ISerializer;Lio/sentry/ILogger;)[B
+	public static fun snapshotViewHierarchyAsData (Landroid/app/Activity;Lio/sentry/util/thread/IMainThreadChecker;Lio/sentry/ISerializer;Lio/sentry/ILogger;)[B
 }
 
 public final class io/sentry/android/core/cache/AndroidEnvelopeCache : io/sentry/cache/EnvelopeCache {

sentry-android-core/proguard-rules.pro

@@ -32,4 +32,8 @@
 # Keep Classnames for integrations
 -keepnames class * implements io.sentry.IntegrationName
 
+# Keep any custom option classes like SentryAndroidOptions, as they're loaded via reflection
+# Also keep method names, as they're e.g. used by native via JNI calls
+-keep class * extends io.sentry.SentryOptions { *; }
+
 ##---------------End: proguard configuration for android-core  ----------

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

@@ -52,7 +52,9 @@ public ScreenshotEventProcessor(
       return event;
     }
 
-    final byte[] screenshot = takeScreenshot(activity, options.getLogger(), buildInfoProvider);
+    final byte[] screenshot =
+        takeScreenshot(
+            activity, options.getMainThreadChecker(), options.getLogger(), buildInfoProvider);
     if (screenshot == null) {
       return event;
     }

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

@@ -13,13 +13,18 @@
 import io.sentry.SentryEvent;
 import io.sentry.SentryLevel;
 import io.sentry.android.core.internal.gestures.ViewUtils;
+import io.sentry.android.core.internal.util.AndroidMainThreadChecker;
 import io.sentry.protocol.ViewHierarchy;
 import io.sentry.protocol.ViewHierarchyNode;
 import io.sentry.util.HintUtils;
 import io.sentry.util.JsonSerializationUtils;
 import io.sentry.util.Objects;
+import io.sentry.util.thread.IMainThreadChecker;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -29,6 +34,7 @@
 public final class ViewHierarchyEventProcessor implements EventProcessor, IntegrationName {
 
   private final @NotNull SentryAndroidOptions options;
+  private static final long CAPTURE_TIMEOUT_MS = 1000;
 
   public ViewHierarchyEventProcessor(final @NotNull SentryAndroidOptions options) {
     this.options = Objects.requireNonNull(options, "SentryAndroidOptions is required");
@@ -54,7 +60,7 @@ public ViewHierarchyEventProcessor(final @NotNull SentryAndroidOptions options)
 
     final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
     final @Nullable ViewHierarchy viewHierarchy =
-        snapshotViewHierarchy(activity, options.getLogger());
+        snapshotViewHierarchy(activity, options.getMainThreadChecker(), options.getLogger());
 
     if (viewHierarchy != null) {
       hint.setViewHierarchy(Attachment.fromViewHierarchy(viewHierarchy));
@@ -63,10 +69,13 @@ public ViewHierarchyEventProcessor(final @NotNull SentryAndroidOptions options)
     return event;
   }
 
-  @Nullable
   public static byte[] snapshotViewHierarchyAsData(
-      @Nullable Activity activity, @NotNull ISerializer serializer, @NotNull ILogger logger) {
-    @Nullable ViewHierarchy viewHierarchy = snapshotViewHierarchy(activity, logger);
+      @Nullable Activity activity,
+      @NotNull IMainThreadChecker mainThreadChecker,
+      @NotNull ISerializer serializer,
+      @NotNull ILogger logger) {
+    @Nullable
+    ViewHierarchy viewHierarchy = snapshotViewHierarchy(activity, mainThreadChecker, logger);
 
     if (viewHierarchy == null) {
       logger.log(SentryLevel.ERROR, "Could not get ViewHierarchy.");
@@ -90,6 +99,14 @@ public static byte[] snapshotViewHierarchyAsData(
   @Nullable
   public static ViewHierarchy snapshotViewHierarchy(
       @Nullable Activity activity, @NotNull ILogger logger) {
+    return snapshotViewHierarchy(activity, AndroidMainThreadChecker.getInstance(), logger);
+  }
+
+  @Nullable
+  public static ViewHierarchy snapshotViewHierarchy(
+      @Nullable Activity activity,
+      @NotNull IMainThreadChecker mainThreadChecker,
+      @NotNull ILogger logger) {
     if (activity == null) {
       logger.log(SentryLevel.INFO, "Missing activity for view hierarchy snapshot.");
       return null;
@@ -108,12 +125,28 @@ public static ViewHierarchy snapshotViewHierarchy(
     }
 
     try {
-      final @NotNull ViewHierarchy viewHierarchy = snapshotViewHierarchy(decorView);
-      return viewHierarchy;
+      if (mainThreadChecker.isMainThread()) {
+        return snapshotViewHierarchy(decorView);
+      } else {
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<ViewHierarchy> viewHierarchy = new AtomicReference<>(null);
+        activity.runOnUiThread(
+            () -> {
+              try {
+                viewHierarchy.set(snapshotViewHierarchy(decorView));
+                latch.countDown();
+              } catch (Throwable t) {
+                logger.log(SentryLevel.ERROR, "Failed to process view hierarchy.", t);
+              }
+            });
+        if (latch.await(CAPTURE_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+          return viewHierarchy.get();
+        }
+      }
     } catch (Throwable t) {
       logger.log(SentryLevel.ERROR, "Failed to process view hierarchy.", t);
-      return null;
     }
+    return null;
   }
 
   @NotNull

sentry-android-core/src/main/java/io/sentry/android/core/internal/util/ScreenshotUtils.java

@@ -10,16 +10,32 @@
 import io.sentry.ILogger;
 import io.sentry.SentryLevel;
 import io.sentry.android.core.BuildInfoProvider;
+import io.sentry.util.thread.IMainThreadChecker;
 import java.io.ByteArrayOutputStream;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 @ApiStatus.Internal
 public class ScreenshotUtils {
+
+  private static final long CAPTURE_TIMEOUT_MS = 1000;
+
+  public static @Nullable byte[] takeScreenshot(
+      final @NotNull Activity activity,
+      final @NotNull ILogger logger,
+      final @NotNull BuildInfoProvider buildInfoProvider) {
+    return takeScreenshot(
+        activity, AndroidMainThreadChecker.getInstance(), logger, buildInfoProvider);
+  }
+
   public static @Nullable byte[] takeScreenshot(
       final @NotNull Activity activity,
+      final @NotNull IMainThreadChecker mainThreadChecker,
       final @NotNull ILogger logger,
       final @NotNull BuildInfoProvider buildInfoProvider) {
+
     if (!isActivityValid(activity, buildInfoProvider)
         || activity.getWindow() == null
         || activity.getWindow().getDecorView() == null
@@ -40,7 +56,23 @@ public class ScreenshotUtils {
           Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_8888);
 
       final Canvas canvas = new Canvas(bitmap);
-      view.draw(canvas);
+      if (mainThreadChecker.isMainThread()) {
+        view.draw(canvas);
+      } else {
+        final @NotNull CountDownLatch latch = new CountDownLatch(1);
+        activity.runOnUiThread(
+            () -> {
+              try {
+                view.draw(canvas);
+                latch.countDown();
+              } catch (Throwable e) {
+                logger.log(SentryLevel.ERROR, "Taking screenshot failed (view.draw).", e);
+              }
+            });
+        if (!latch.await(CAPTURE_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+          return null;
+        }
+      }
 
       // 0 meaning compress for small size, 100 meaning compress for max quality.
       // Some formats, like PNG which is lossless, will ignore the quality setting.

sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt

@@ -10,13 +10,17 @@ import io.sentry.MainEventProcessor
 import io.sentry.SentryEvent
 import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.TypeCheckHint.ANDROID_ACTIVITY
+import io.sentry.util.thread.IMainThreadChecker
 import org.junit.runner.RunWith
+import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
@@ -30,6 +34,7 @@ class ScreenshotEventProcessorTest {
         val window = mock<Window>()
         val view = mock<View>()
         val rootView = mock<View>()
+        val mainThreadChecker = mock<IMainThreadChecker>()
         val options = SentryAndroidOptions().apply {
             dsn = "https://[email protected]/proj"
         }
@@ -41,10 +46,16 @@ class ScreenshotEventProcessorTest {
             whenever(view.rootView).thenReturn(rootView)
             whenever(window.decorView).thenReturn(view)
             whenever(activity.window).thenReturn(window)
+            whenever(activity.runOnUiThread(any())).then {
+                it.getArgument<Runnable>(0).run()
+            }
+
+            whenever(mainThreadChecker.isMainThread).thenReturn(true)
         }
 
         fun getSut(attachScreenshot: Boolean = false): ScreenshotEventProcessor {
             options.isAttachScreenshot = attachScreenshot
+            options.mainThreadChecker = mainThreadChecker
 
             return ScreenshotEventProcessor(options, buildInfo)
         }
@@ -156,6 +167,20 @@ class ScreenshotEventProcessorTest {
     }
 
     @Test
+    fun `when screenshot event processor is called from background thread it executes on main thread`() {
+        val sut = fixture.getSut(true)
+        whenever(fixture.mainThreadChecker.isMainThread).thenReturn(false)
+
+        CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+
+        val hint = Hint()
+        val event = fixture.mainProcessor.process(getEvent(), hint)
+        sut.process(event, hint)
+
+        verify(fixture.activity).runOnUiThread(any())
+        assertNotNull(hint.screenshot)
+    }
+
     fun `when enabled, the feature is added to the integration list`() {
         SentryIntegrationPackageStorage.getInstance().clearStorage()
         val hint = Hint()