Merge branch 'main' into rz/fix/session-replay-improvements

Author: romtsn

.craft.yml

@@ -1,10 +1,6 @@
 minVersion: 0.29.3
 changelogPolicy: auto
 targets:
-  - name: symbol-collector
-    includeNames: /libsentry(-android)?\.so/
-    batchType: android
-    bundleIdPrefix: sentry-android-ndk-
   - name: maven
     includeNames: /^sentry.*$/
     gradleCliPath: ./gradlew

CHANGELOG.md

@@ -2,10 +2,26 @@
 
 ## Unreleased
 
+### Features
+
+- The `ignoredErrors` option is now configurable via the manifest property `io.sentry.traces.ignored-errors` ([#4178](https://github.com/getsentry/sentry-java/pull/4178))
+- A list of active Spring profiles is attached to payloads sent to Sentry (errors, traces, etc.) and displayed in the UI when using our Spring or Spring Boot integrations ([#4147](https://github.com/getsentry/sentry-java/pull/4147))
+  - This consists of an empty list when only the default profile is active
+- Added `enableTraceIdGeneration` to the AndroidOptions. This allows Hybrid SDKs to "freeze" and control the trace and connect errors on different layers of the application ([4188](https://github.com/getsentry/sentry-java/pull/4188))
+- Move to a single NetworkCallback listener to reduce number of IPC calls on Android ([#4164](https://github.com/getsentry/sentry-java/pull/4164))
+- Add GraphQL Apollo Kotlin 4 integration ([#4166](https://github.com/getsentry/sentry-java/pull/4166))
+
 ### Fixes
 
 - `SentryOptions.setTracePropagationTargets` is no longer marked internal ([#4170](https://github.com/getsentry/sentry-java/pull/4170))
 - Session Replay: Fix crash when a navigation breadcrumb does not have "to" destination ([#4185](https://github.com/getsentry/sentry-java/pull/4185))
+- Session Replay: Cap video segment duration to maximum 5 minutes to prevent endless video encoding in background ([#4185](https://github.com/getsentry/sentry-java/pull/4185))
+- Check `tracePropagationTargets` in OpenTelemetry propagator ([#4191](https://github.com/getsentry/sentry-java/pull/4191))
+  - If a URL can be retrieved from OpenTelemetry span attributes, we check it against `tracePropagationTargets` before attaching `sentry-trace` and `baggage` headers to outgoing requests
+  - If no URL can be retrieved we always attach the headers
+- Fix `ignoredErrors`, `ignoredTransactions` and `ignoredCheckIns` being unset by external options like `sentry.properties` or ENV vars ([#4207](https://github.com/getsentry/sentry-java/pull/4207))
+  - Whenever parsing of external options was enabled (`enableExternalConfiguration`), which is the default for many integrations, the values set on `SentryOptions` passed to `Sentry.init` would be lost
+  - Even if the value was not set in any external configuration it would still be set to an empty list
 
 ### Behavioural Changes
 
@@ -115,7 +131,11 @@ Version 8 of the Sentry Android/Java SDK brings a variety of features and fixes.
 - New `Scope` types have been introduced, see "Behavioural Changes" for more details.
 - Lifecycle tokens have been introduced to manage `Scope` lifecycle, see "Behavioural Changes" for more details.
 - Bumping `minSdk` level to 21 (Android 5.0)
-- Our `sentry-opentelemetry-agent` has been improved and now works in combination with the rest of Sentry. You may now mix and match OpenTelemetry and Sentry API for instrumenting your application.
+- Our `sentry-opentelemetry-agent` has been improved and now works in combination with the rest of Sentry. You may now combine OpenTelemetry and Sentry for instrumenting your application.
+    - You may now use both OpenTelemetry SDK and Sentry SDK to capture transactions and spans. They can also be mixed and end up on the same transaction.
+    - OpenTelemetry extends the Sentry SDK by adding spans for numerous integrations, like Ktor, Vert.x and MongoDB. Please check [the OpenTelemetry GitHub repository](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation) for a full list.
+    - OpenTelemetry allows propagating trace information from and to additional libraries, that Sentry did not support before, for example gRPC.
+    - OpenTelemetry also has broader support for propagating the Sentry `Scopes` through reactive libraries like RxJava.
 - The SDK is now compatible with Spring Boot 3.4
 - We now support GraphQL v22 (`sentry-graphql-22`)
 - Metrics have been removed

CONTRIBUTING.md

@@ -27,6 +27,36 @@ To run the build and tests:
 make compile
 ```
 
+# Format
+
+To format the changed code and make CI happy you can run:
+
+```shell
+make format
+```
+
+or
+
+```shell
+./gradlew spotlessApply
+```
+
+# Binary compatibility validation
+
+To prevent breaking ABI changes and exposing things we should not, we make use of https://github.com/Kotlin/binary-compatibility-validator. If your change intended to introduce a new public method/property or modify the existing one you can overwrite the API declarations to make CI happy as follows (overwrites them from scratch):
+
+```shell
+make api
+```
+
+or 
+
+```shell
+./gradlew apiDump
+```
+
+However, if your change did not intend to modify the public API, consider changing the method/property visibility or removing the change altogether.
+
 # CI
 
 Build and tests are automatically run against branches and pull requests

buildSrc/src/main/java/Config.kt

@@ -157,6 +157,7 @@ object Config {
         val composeCoil = "io.coil-kt:coil-compose:2.6.0"
 
         val apolloKotlin = "com.apollographql.apollo3:apollo-runtime:3.8.2"
+        val apolloKotlin4 = "com.apollographql.apollo:apollo-runtime:4.1.1"
 
         val sentryNativeNdk = "io.sentry:sentry-native-ndk:0.7.20"
 
@@ -250,6 +251,7 @@ object Config {
         val SENTRY_SPRING_BOOT_JAKARTA_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.spring-boot.jakarta"
         val SENTRY_OPENTELEMETRY_AGENT_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.opentelemetry.agent"
         val SENTRY_APOLLO3_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.apollo3"
+        val SENTRY_APOLLO4_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.apollo4"
         val SENTRY_APOLLO_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.apollo"
         val SENTRY_GRAPHQL_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.graphql"
         val SENTRY_GRAPHQL22_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.graphql22"

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

@@ -292,6 +292,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun isEnableAppComponentBreadcrumbs ()Z
 	public fun isEnableAppLifecycleBreadcrumbs ()Z
 	public fun isEnableAutoActivityLifecycleTracing ()Z
+	public fun isEnableAutoTraceIdGeneration ()Z
 	public fun isEnableFramesTracking ()Z
 	public fun isEnableNdk ()Z
 	public fun isEnableNetworkEventBreadcrumbs ()Z
@@ -315,6 +316,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun setEnableAppComponentBreadcrumbs (Z)V
 	public fun setEnableAppLifecycleBreadcrumbs (Z)V
 	public fun setEnableAutoActivityLifecycleTracing (Z)V
+	public fun setEnableAutoTraceIdGeneration (Z)V
 	public fun setEnableFramesTracking (Z)V
 	public fun setEnableNdk (Z)V
 	public fun setEnableNetworkEventBreadcrumbs (Z)V

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

@@ -161,7 +161,9 @@ private void startTracing(final @NotNull Activity activity) {
     if (scopes != null && !isRunningTransactionOrTrace(activity)) {
       if (!performanceEnabled) {
         activitiesWithOngoingTransactions.put(activity, NoOpTransaction.getInstance());
-        TracingUtils.startNewTrace(scopes);
+        if (options.isEnableAutoTraceIdGeneration()) {
+          TracingUtils.startNewTrace(scopes);
+        }
       } else {
         // as we allow a single transaction running on the bound Scope, we finish the previous ones
         stopPreviousTransactions();

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

@@ -105,6 +105,11 @@ final class ManifestMetadataReader {
 
   static final String MAX_BREADCRUMBS = "io.sentry.max-breadcrumbs";
 
+  static final String IGNORED_ERRORS = "io.sentry.ignored-errors";
+
+  static final String ENABLE_AUTO_TRACE_ID_GENERATION =
+      "io.sentry.traces.enable-auto-id-generation";
+
   /** ManifestMetadataReader ctor */
   private ManifestMetadataReader() {}
 
@@ -378,6 +383,13 @@ static void applyMetadata(
             readBool(
                 metadata, logger, ENABLE_SCOPE_PERSISTENCE, options.isEnableScopePersistence()));
 
+        options.setEnableAutoTraceIdGeneration(
+            readBool(
+                metadata,
+                logger,
+                ENABLE_AUTO_TRACE_ID_GENERATION,
+                options.isEnableAutoTraceIdGeneration()));
+
         if (options.getSessionReplay().getSessionSampleRate() == null) {
           final Double sessionSampleRate =
               readDouble(metadata, logger, REPLAYS_SESSION_SAMPLE_RATE);
@@ -400,6 +412,8 @@ static void applyMetadata(
         options
             .getSessionReplay()
             .setMaskAllImages(readBool(metadata, logger, REPLAYS_MASK_ALL_IMAGES, true));
+
+        options.setIgnoredErrors(readList(metadata, logger, IGNORED_ERRORS));
       }
 
       options

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

@@ -166,6 +166,12 @@ public final class SentryAndroidOptions extends SentryOptions {
    */
   private boolean enableScopeSync = true;
 
+  /**
+   * Whether to enable automatic trace ID generation. This is mainly used by the Hybrid SDKs to
+   * control the trace ID generation from the outside.
+   */
+  private boolean enableAutoTraceIdGeneration = true;
+
   public interface BeforeCaptureCallback {
 
     /**
@@ -594,4 +600,12 @@ public void setFrameMetricsCollector(
       final @Nullable SentryFrameMetricsCollector frameMetricsCollector) {
     this.frameMetricsCollector = frameMetricsCollector;
   }
+
+  public boolean isEnableAutoTraceIdGeneration() {
+    return enableAutoTraceIdGeneration;
+  }
+
+  public void setEnableAutoTraceIdGeneration(final boolean enableAutoTraceIdGeneration) {
+    this.enableAutoTraceIdGeneration = enableAutoTraceIdGeneration;
+  }
 }

sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java

@@ -202,7 +202,9 @@ private void startTracing(final @NotNull UiElement target, final @NotNull Gestur
 
     if (!(options.isTracingEnabled() && options.isEnableUserInteractionTracing())) {
       if (isNewInteraction) {
-        TracingUtils.startNewTrace(scopes);
+        if (options.isEnableAutoTraceIdGeneration()) {
+          TracingUtils.startNewTrace(scopes);
+        }
         activeUiElement = target;
         activeEventType = eventType;
       }

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

@@ -4,17 +4,19 @@
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.net.ConnectivityManager;
+import android.net.ConnectivityManager.NetworkCallback;
 import android.net.Network;
 import android.net.NetworkCapabilities;
 import android.os.Build;
-import androidx.annotation.NonNull;
 import io.sentry.IConnectionStatusProvider;
 import io.sentry.ILogger;
+import io.sentry.ISentryLifecycleToken;
 import io.sentry.SentryLevel;
 import io.sentry.android.core.BuildInfoProvider;
 import io.sentry.android.core.ContextUtils;
-import java.util.HashMap;
-import java.util.Map;
+import io.sentry.util.AutoClosableReentrantLock;
+import java.util.ArrayList;
+import java.util.List;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -31,8 +33,9 @@ public final class AndroidConnectionStatusProvider implements IConnectionStatusP
   private final @NotNull Context context;
   private final @NotNull ILogger logger;
   private final @NotNull BuildInfoProvider buildInfoProvider;
-  private final @NotNull Map<IConnectionStatusObserver, ConnectivityManager.NetworkCallback>
-      registeredCallbacks;
+  private final @NotNull List<IConnectionStatusObserver> connectionStatusObservers;
+  private final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
+  private volatile @Nullable NetworkCallback networkCallback;
 
   public AndroidConnectionStatusProvider(
       @NotNull Context context,
@@ -41,7 +44,7 @@ public AndroidConnectionStatusProvider(
     this.context = ContextUtils.getApplicationContext(context);
     this.logger = logger;
     this.buildInfoProvider = buildInfoProvider;
-    this.registeredCallbacks = new HashMap<>();
+    this.connectionStatusObservers = new ArrayList<>();
   }
 
   @Override
@@ -65,40 +68,64 @@ public AndroidConnectionStatusProvider(
 
   @Override
   public boolean addConnectionStatusObserver(final @NotNull IConnectionStatusObserver observer) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      connectionStatusObservers.add(observer);
+    }
 
-    final ConnectivityManager.NetworkCallback callback =
-        new ConnectivityManager.NetworkCallback() {
-          @Override
-          public void onAvailable(@NonNull Network network) {
-            observer.onConnectionStatusChanged(getConnectionStatus());
-          }
-
-          @Override
-          public void onLosing(@NonNull Network network, int maxMsToLive) {
-            observer.onConnectionStatusChanged(getConnectionStatus());
-          }
-
-          @Override
-          public void onLost(@NonNull Network network) {
-            observer.onConnectionStatusChanged(getConnectionStatus());
-          }
-
-          @Override
-          public void onUnavailable() {
-            observer.onConnectionStatusChanged(getConnectionStatus());
+    if (networkCallback == null) {
+      try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+        if (networkCallback == null) {
+          final @NotNull NetworkCallback newNetworkCallback =
+              new NetworkCallback() {
+                @Override
+                public void onAvailable(final @NotNull Network network) {
+                  updateObservers();
+                }
+
+                @Override
+                public void onUnavailable() {
+                  updateObservers();
+                }
+
+                @Override
+                public void onLost(final @NotNull Network network) {
+                  updateObservers();
+                }
+
+                public void updateObservers() {
+                  final @NotNull ConnectionStatus status = getConnectionStatus();
+                  try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+                    for (final @NotNull IConnectionStatusObserver observer :
+                        connectionStatusObservers) {
+                      observer.onConnectionStatusChanged(status);
+                    }
+                  }
+                }
+              };
+
+          if (registerNetworkCallback(context, logger, buildInfoProvider, newNetworkCallback)) {
+            networkCallback = newNetworkCallback;
+            return true;
+          } else {
+            return false;
           }
-        };
-
-    registeredCallbacks.put(observer, callback);
-    return registerNetworkCallback(context, logger, buildInfoProvider, callback);
+        }
+      }
+    }
+    // networkCallback is already registered, so we can safely return true
+    return true;
   }
 
   @Override
   public void removeConnectionStatusObserver(final @NotNull IConnectionStatusObserver observer) {
-    final @Nullable ConnectivityManager.NetworkCallback callback =
-        registeredCallbacks.remove(observer);
-    if (callback != null) {
-      unregisterNetworkCallback(context, logger, callback);
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      connectionStatusObservers.remove(observer);
+      if (connectionStatusObservers.isEmpty()) {
+        if (networkCallback != null) {
+          unregisterNetworkCallback(context, logger, networkCallback);
+          networkCallback = null;
+        }
+      }
     }
   }
 
@@ -281,7 +308,7 @@ public static boolean registerNetworkCallback(
       final @NotNull Context context,
       final @NotNull ILogger logger,
       final @NotNull BuildInfoProvider buildInfoProvider,
-      final @NotNull ConnectivityManager.NetworkCallback networkCallback) {
+      final @NotNull NetworkCallback networkCallback) {
     if (buildInfoProvider.getSdkInfoVersion() < Build.VERSION_CODES.N) {
       logger.log(SentryLevel.DEBUG, "NetworkCallbacks need Android N+.");
       return false;
@@ -307,7 +334,7 @@ public static boolean registerNetworkCallback(
   public static void unregisterNetworkCallback(
       final @NotNull Context context,
       final @NotNull ILogger logger,
-      final @NotNull ConnectivityManager.NetworkCallback networkCallback) {
+      final @NotNull NetworkCallback networkCallback) {
 
     final ConnectivityManager connectivityManager = getConnectivityManager(context, logger);
     if (connectivityManager == null) {
@@ -322,8 +349,13 @@ public static void unregisterNetworkCallback(
 
   @TestOnly
   @NotNull
-  public Map<IConnectionStatusObserver, ConnectivityManager.NetworkCallback>
-      getRegisteredCallbacks() {
-    return registeredCallbacks;
+  public List<IConnectionStatusObserver> getStatusObservers() {
+    return connectionStatusObservers;
+  }
+
+  @TestOnly
+  @Nullable
+  public NetworkCallback getNetworkCallback() {
+    return networkCallback;
   }
 }