chore(deps): update Android SDK to v8.38.0

[github-actions]

Bumps scripts/update-android.sh from 8.37.1 to 8.38.0.

Auto-generated by a dependency updater.

Changelog

8.38.0

Features

• Prevent cross-organization trace continuation (#5136)
  • By default, the SDK now extracts the organization ID from the DSN (e.g. o123.ingest.sentry.io) and compares it with the sentry-org_id value in incoming baggage headers. When the two differ, the SDK starts a fresh trace instead of continuing the foreign one. This guards against accidentally linking traces across organizations.
  • New option enableStrictTraceContinuation (default false): when enabled, both the SDK's org ID and the incoming baggage org ID must be present and match for a trace to be continued. Traces with a missing org ID on either side are rejected. Configurable via code (setStrictTraceContinuation(true)), sentry.properties (enable-strict-trace-continuation=true), Android manifest (io.sentry.strict-trace-continuation.enabled), or Spring Boot (sentry.strict-trace-continuation=true).
  • New option orgId: allows explicitly setting the organization ID for self-hosted and Relay setups where it cannot be extracted from the DSN. Configurable via code (setOrgId("123")), sentry.properties (org-id=123), Android manifest (io.sentry.org-id), or Spring Boot (sentry.org-id=123).
• Android: Attachments on the scope will now be synced to native (#5211)
• Add THIRD_PARTY_NOTICES.md for vendored third-party code, bundled as SENTRY_THIRD_PARTY_NOTICES.md in the sentry JAR under META-INF (#5186)

Improvements

• Do not retrieve ActivityManager if API < 35 on SDK init (#5275)

  • To enable, add url regexes via the io.sentry.session-replay.network-detail-allow-urls metadata tag in AndroidManifest (code sample) - Or you can manually specify SentryReplayOptions via SentryAndroid#init:
    (Make sure you disable the auto init via manifest meta-data: io.sentry.auto-init=false)

Fixes

```java
Sentry.init(options -> {
  ...
  options.setOnDiscard(
   (reason, category, number) -> {
     // Your logic to process discarded data
   });
});
```

• This fixes StackOverflowError when using OSS Licenses plugin

• This widget is a custom button that can be used to show the user feedback form

• We now introduce SentryUserFeedbackDialog, which extends AlertDialog, inheriting the show() and cancel() methods, among others.
  To use it, just instantiate it and call show() on the instance (Sentry must be previously initialized).
  For customization options, please check the User Feedback documentation.

  import io.sentry.android.core.SentryUserFeedbackDialog;
  
  new SentryUserFeedbackDialog.Builder(context).create().show();

  import io.sentry.android.core.SentryUserFeedbackDialog
  
  SentryUserFeedbackDialog.Builder(context).create().show()

• Use Sentry.replay().enableDebugMaskingOverlay() to overlay the screen with the Session Replay masks.

• The masks will be invalidated at most once per frameRate (default 1 fps).

• We now introduced Sentry.captureFeedback, which supersedes Sentry.captureUserFeedback

• The feature is disabled by default and needs to be enabled by:

  • options.getLogs().setEnabled(true) in Sentry.init / SentryAndroid.init
  • <meta-data android:name="io.sentry.logs.enabled" android:value="true" /> in AndroidManifest.xml
  • logs.enabled=true in sentry.properties
  • sentry.logs.enabled=true in application.properties
  • sentry.logs.enabled: true in application.yml

• Logs can be captured using Sentry.logger().info() and similar methods.

• Logs also take a format string and arguments which we then send through String.format.

• Please use options.getLogs().setBeforeSend() to filter outgoing logs

• This is only relevant if you see java.lang.IllegalStateException: Found multiple ContextStorageProvider. Set the io.opentelemetry.context.ContextStorageProvider property to the fully qualified class name of the provider to use. Falling back to default ContextStorage. Found providers: ...

Note: Both options.profilesSampler and options.profilesSampleRate must not be set to enable UI Profiling.
To keep the same transaction-based behaviour, without the 30 seconds limitation, you can use the trace lifecycle mode.

• This enables symbolication for stripped native code in ANRs
  To enable Continuous Profiling use the Sentry.startProfiler and Sentry.stopProfiler experimental APIs. Sampling rate can be set through options.profileSessionSampleRate, which defaults to null (disabled).

• Please ensure the SentryOkHttpInterceptor is added last to your OkHttpClient, as otherwise changes to the Request by subsequent interceptors won't be considered

• The new module will be exposed as an api dependency when using sentry-spring-boot-jakarta (Spring Boot 3) or sentry-spring-jakarta (Spring 6).

• This allows sharing the same SentryNavigationListener instance across fragments and composables to preserve the trace

• 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 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.

• Metrics will return but we don't know in what exact form yet

• Please set tracesSampleRate to a value >= 0.0 for enabling performance instead. The default value is null which means performance is disabled.

• If you are subclassing any Sentry classes, please check if the parent class used synchronized before. Please make sure to use the same lock object as the parent class in that case.

• The Session constructor now takes a String instead of a UUID for the sessionId parameter.

• Session.getSessionId() now returns a String instead of a UUID.

• This will reduce the number of spans created by the SDK

• Global scope is attached to all events created by the SDK. It can also be modified before Sentry.init has been called. It can be manipulated using Sentry.configureScope(ScopeType.GLOBAL, (scope) -> { ... }).

• Isolation scope can be used e.g. to attach data to all events that come up while handling an incoming request. It can also be used for other isolation purposes. It can be manipulated using Sentry.configureScope(ScopeType.ISOLATION, (scope) -> { ... }). The SDK automatically forks isolation scope in certain cases like incoming requests, CRON jobs, Spring Async and more.

• Current scope is forked often and data added to it is only added to events that are created while this scope is active. Data is also passed on to newly forked child scopes but not to parents. It can be manipulated using Sentry.configureScope(ScopeType.CURRENT, (scope) -> { ... }).

• For Android the type defaults to CURRENT scope

• For Backend and other JVM applicatons it defaults to ISOLATION scope

• With this change cold app start spans will include spans for ContentProviders, Application and Activity load.

• This now includes prefab support for sentry-native, allowing you to link and access the sentry-native API within your native app code

• Checkout the sentry-samples/sentry-samples-android example on how to configure CMake and consume sentry.h

• You may also want to give this new agent a try even if you haven't used OpenTelemetry (with Sentry) before. It offers support for many more libraries and frameworks, improving on our trace propagation, Scopes (used to be Hub) propagation as well as performance instrumentation (i.e. more spans).

• If you are using a framework we did not support before and currently resort to manual instrumentation, please give the agent a try. See here for a list of supported libraries, frameworks and application servers.

• Please see Java SDK docs for more details on how to set up the agent. Please make sure to select the correct SDK from the dropdown on the left side of the docs.

• What's new about the Agent

  • When the OpenTelemetry Agent is used, Sentry API creates OpenTelemetry spans under the hood, handing back a wrapper object which bridges the gap between traditional Sentry API and OpenTelemetry. We might be replacing some of the Sentry performance API in the future.
    • This is achieved by configuring the SDK to use OtelSpanFactory instead of DefaultSpanFactory which is done automatically by the auto init of the Java Agent.
  • OpenTelemetry spans are now only turned into Sentry spans when they are finished so they can be sent to the Sentry server.
  • Now registers an OpenTelemetry Sampler which uses Sentry sampling configuration
  • Other Performance integrations automatically stop creating spans to avoid duplicate spans
  • The Sentry SDK now makes use of OpenTelemetry Context for storing Sentry Scopes (which is similar to what used to be called Hub) and thus relies on OpenTelemetry for Context propagation.
  • Classes used for the previous version of our OpenTelemetry support have been deprecated but can still be used manually. We're not planning to keep the old agent around in favor of less complexity in the SDK.

• This module can be added as a dependency when using Sentry with OpenTelemetry and Spring Boot but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.

• You may want to set OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.

• This module can be added as a dependency when using Sentry with OpenTelemetry but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.

• To enable the auto configuration of it, please set -Dotel.java.global-autoconfigure.enabled=true on the java command, when starting your application.

• You may also want to set OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.

• It defaults to AUTO meaning the SDK will figure out how to best configure itself for use with OpenTelemetry

• Use of OpenTelemetry can also be disabled completely by setting it to OFF (#3995)

  • In this case even if OpenTelemetry is present, the Sentry SDK will not use it

• Use AGENT when using sentry-opentelemetry-agent

• Use AGENTLESS when using sentry-opentelemetry-agentless

• Use AGENTLESS_SPRING when using sentry-opentelemetry-agentless-spring

• can be used via ENV vars, e.g. SENTRY_IGNORED_TRANSACTIONS=POST /person/,GET /pers.*

• can also be set in options directly, e.g. options.setIgnoredTransactions(...)

• can also be set in sentry.properties, e.g. ignored-transactions=POST /person/,GET /pers.*

• can also be set in Spring config application.properties, e.g. sentry.ignored-transactions=POST /person/,GET /pers.*

• This setting only affects the SDK when used with OpenTelemetry.

• Defaults to AUTO meaning the SDK will decide whether the span should be bound to the current scope. It will not bind transactions to scope using AUTO, it will only bind spans where the parent span is on the current scope.

• ON sets the new span on the current scope.

• OFF does not set the new span on the scope.

• We pre-configure this to ignore Performance instrumentation for Spring and other integrations when using our OpenTelemetry Agent to avoid duplicate spans

• If you are using graphql-java v21 or earlier, you can use the sentry-graphql module

• For graphql-java v22 and newer please use the sentry-graphql-22 module

• It is now also possible to provide a bean of type SentryGraphqlInstrumentation.BeforeSpanCallback which is then used by SentryInstrumenter

• globalHubMode used to only be a param on Sentry.init. To make it easier to be used in e.g. Desktop environments, we now additionally added it as an option on SentryOptions that can also be set via sentry.properties.

• If both the param on Sentry.init and the option are set, the option will win. By default the option is set to null meaning whatever is passed to Sentry.init takes effect.

• Uses faster implementation to convert UUID to SentryID String

• Uses faster Random implementation to generate UUIDs

• See https://developer.android.com/guide/practices/page-sizes for more details

• You may now set forceInit=true (force-init for .properties files) to ensure a call to Sentry.init / SentryAndroid.init takes effect

• Use <meta-data android:name="io.sentry.force-init" android:value="true" /> to ensure Sentry Android auto init is not easily overwritten

• Previously request body was only attached for application/json requests

• Also does not emit transaction.data in extras anymore

• A sentry-trace header that only contains trace ID and span ID but no sampled flag (-1, -0 suffix) means the receiving system can make its own sampling decision

• When generating sentry-trace header from PropagationContext we now copy the sampled flag.

• In TransactionContext.fromPropagationContext when there is no parent sampling decision, keep the decision null so a new sampling decision is made instead of defaulting to false

• Previously some parts of Sentry were immediately closed after re-init that should have stayed open and some parts of the previous init were never closed

• Checking if a span origin, a transaction or a checkIn should be ignored is now faster

• Previously only the body was cached which could lead to problems in the FilterChain as Request parameters were not available

• Due to the backpressure monitor rescheduling a task to run every 10s, it very likely caused shutdown to wait the full shutdownTimeoutMillis (defaulting to 2s) instead of being able to terminate immediately

• Our integrations no longer call .continueTrace and also do not inject tracing headers if the integration has been added to ignoredSpanOrigins

• Our UncaughtExceptionHandlerIntegration waited for the full flush timeout duration (default 15s) when rate limited.

• Setting it to null would cause an exception.

• Transactions are dropped if trace context is missing

• The wrapper had to be put in place before any call to Context whereas ContextStorageProvider is automatically invoked at the correct time.

• This is only enabled if there is no OpenTelemetry agent available

• We prefer to use the OpenTelemetry agent as it offers more auto instrumentation

• In some cases the OpenTelemetry agent cannot be used, please see https://opentelemetry.io/docs/zero-code/java/spring-boot-starter/ for more details on when to prefer the Agent and when the Spring Boot starter makes more sense.

• In this mode the SDK makes use of the OpenTelemetry bean that is created by opentelemetry-spring-boot-starter instead of GlobalOpenTelemetry

• This means Spring Boot config mechanisms can now be combined with our OpenTelemetry agent

• The sentry-opentelemetry-extra module has been removed again, most classes have been moved to sentry-opentelemetry-bootstrap which is loaded into the bootstrap classloader (i.e. null) when our Java agent is used. The rest has been moved into sentry-opentelemetry-agentcustomization and is loaded into the agent classloader when our Java agent is used.

• The sentry-opentelemetry-bootstrap and sentry-opentelemetry-agentcustomization modules can be used without the agent as well, in which case all classes are loaded into the application classloader. Check out our sentry-samples-spring-boot-jakarta-opentelemetry-noagent sample.

• In this mode the SDK makes use of GlobalOpenTelemetry

• SentrySpanFactoryHolder has been removed as it is no longer required.

• This keeps it from being garbage collected too early

• This is required for all integrations to work together with our OpenTelemetry Java agent if its auto init has been disabled and the SDKs init should be used instead.

• Starting a child span from a transaction that wasn't in the current Context lead to multiple transactions being created (one for the transaction and another per span created).

• In certain cases we were sending transactions as "" when using OpenTelemetry

• Also fix check whether Performance is enabled when making a sampling decision in the OpenTelemetry sampler

• This allows spans to be filtered by span origin on creation

• Traces were broken because on an incoming request, OtelSentrySpanProcessor did not set the parentSpanId on the span correctly. Traces were not referencing the actual parent span but some other (random) span ID which the server doesn't know.

• Errors weren't linked to traces correctly due to parts of the SDK not knowing the current span

• When spans belonging to a single transaction were split into multiple batches for SpanExporter, we did not add all spans because the isSpanTooOld check wasn't inverted.

• There was a problem with two separate Sentry Scopes being active inside each OpenTelemetry Context due to using context keys from more than one class loader.

• This caused an issue where the span tree wasn't correct because some spans were not added to their direct parent

• Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.

• As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.

• We are planning to improve this in the future but opted for this fix first.

• changelog

• diff

• IHub has been replaced by IScopes, however you should be able to simply pass IHub instances to code expecting IScopes, allowing for an easier migration.

• HubAdapter.getInstance() has been replaced by ScopesAdapter.getInstance()

• The .clone() method on IHub/IScopes has been deprecated, please use .pushScope() or .pushIsolationScope() instead

• Some internal methods like .getCurrentHub() and .setCurrentHub() have also been replaced.

• This change gives you control over IP address collection directly on the client

• Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.

• As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.

• We are planning to improve this in the future but opted for this fix first.

• This should reduce ANRs seen with this class in the stack trace for Android 14 and above

• Fix FileNotFoundException when trying to read/write .ongoing_segment file

• Fix IllegalStateException when registering onDrawListener

• Fix SIGABRT native crashes on Motorola devices when encoding a video

• This allows Composables that use this modifier to be skippable

• This change gives you control over IP address collection directly on the client

• This change gives you control over IP address collection directly on the client

import io.sentry.SentryReplayOptions
import io.sentry.android.core.SentryAndroid
SentryAndroid.init(context) { options ->

  options.sessionReplay.sessionSampleRate = 1.0
  options.sessionReplay.onErrorSampleRate = 1.0

  // To change default redaction behavior (defaults to true)
  options.sessionReplay.redactAllImages = true
  options.sessionReplay.redactAllText = true

  // To change quality of the recording (defaults to MEDIUM)
  options.sessionReplay.quality = SentryReplayOptions.SentryReplayQuality.MEDIUM // (LOW|MEDIUM|HIGH)
}

• Fix IndexOutOfBoundsException when tracking window changes

• Fix IllegalStateException when adding/removing draw listener for a dead view

• Fix ConcurrentModificationException when registering window listeners and stopping WindowRecorder/GestureRecorder

• changelog

• diff

• See https://developer.android.com/guide/practices/page-sizes for more details

• This should significantly reduce the number of events with message "Sentry Android SDK failed to parse system thread dump..." reported

• changelog

• diff

• Using Sentry Spring Boot on a standalone tomcat caused the following error:

  • Failed to bind properties under 'sentry.parsed-dsn' to io.sentry.Dsn

• The method addIntegrationToSdkVersion(Ljava/lang/Class;)V has been removed from the core (io.sentry:sentry) package. Please make sure all of the packages (e.g. io.sentry:sentry-android-core, io.sentry:sentry-android-fragment, io.sentry:sentry-okhttp and others) are all aligned and using the same version to prevent the NoSuchMethodError exception.

  • android:tag="sentry-mask|sentry-unmask" in XML or view.setTag("sentry-mask|sentry-unmask") in code tags
    • if you already have a tag set for a view, you can set a tag by id: <tag android:id="id/sentry_privacy" android:value="mask|unmask"/> in XML or view.setTag(io.sentry.android.replay.R.id.sentry_privacy, "mask|unmask") in code
  • view.sentryReplayMask() or view.sentryReplayUnmask() extension functions
  • mask/unmask Views of a certain type by adding fully-qualified classname to one of the lists options.experimental.sessionReplay.addMaskViewClass() or options.experimental.sessionReplay.addUnmaskViewClass(). Note, that all of the view subclasses/subtypes will be masked/unmasked as well
    • For example, (this is already a default behavior) to mask all TextViews and their subclasses (RadioButton, EditText, etc.): options.experimental.sessionReplay.addMaskViewClass("android.widget.TextView")
    • If you're using code obfuscation, adjust your proguard-rules accordingly, so your custom view class name is not minified
      Breaking changes:

• Experimental: Add support for Sentry Developer Metrics (#3205, #3238, #3248, #3250)

  • For more details about Spotlight head over to https://spotlightjs.com/
  • Set options.isEnableSpotlight = true to enable Spotlight
  • This depends on the new option io.sentry.profiling.enable-app-start, other than the already existing io.sentry.traces.profiling.sample-rate.
  • Sampler functions can check the new isForNextAppStart flag, to adjust startup profiling sampling programmatically.
    Relevant PRs:
  • Decouple Profiler from Transaction (#3101)
  • Add options and sampling logic (#3121)
  • Add ContentProvider and start profile (#3128)

• The SDK will now listen to connectivity changes and try to re-upload cached events when internet connection is re-established additionally to uploading events on app restart

  • We have reduced the number of overloads by allowing to pass in a TransactionOptions object instead of having separate parameters for certain options
  • TransactionOptions has defaults set and can be customized, for example:
  • This can increase your event consumption and may affect your quota, because we will report failed network requests as Sentry events by default, if you're using the sentry-android-okhttp or sentry-apollo-3 integrations. You can customize what errors you want/don't want to have reported for OkHttp and Apollo3 respectively.
  • Previously performing a click on the same UI widget twice would keep the existing transaction running, the new behavior now better aligns with other SDKs
  • This affects all automatically generated transactions on Android (UI, clicks), the default timeout is 30s, meaning the automatic transaction will be force-finished with status deadline_exceeded when reaching the deadline
  • Instead use the "Prevent Storing of IP Addresses" option in the "Security & Privacy" project settings on sentry.io
  • Android: it works out-of-the-box as part of the default SendCachedEnvelopeIntegration
  • JVM: you'd have to install SendCachedEnvelopeFireAndForgetIntegration as mentioned in https://docs.sentry.io/platforms/java/configuration/#configuring-offline-caching and provide your own implementation of IConnectionStatusProvider via SentryOptions
  • This should prevent some app stores from flagging apps as violating their privacy
  • This will fix the link between transactions and corresponding crashes, you'll be able to see them in a single trace
  • This prevents issues when using the SDK on older AGP versions (< 4.x.x)

• Fix SIGSEV, SIGABRT and SIGBUS crashes happening after/around the August Google Play System update, see #2955 for more details (fix provided by Native SDK bump)

• Fix SIGSEV, SIGABRT and SIGBUS crashes happening after/around the August Google Play System update, see #2955 for more details (fix provided by Native SDK bump)

  • If you have already been using SentryDataFetcherExceptionHandler that still works but has been deprecated. Please use SentryGenericDataFetcherExceptionHandler combined with SentryInstrumentation instead for better error reporting.

  • More exceptions and errors caught and reported to Sentry by also looking at the ExecutionResult (more specifically its errors)

    • You may want to filter out certain errors, please see docs on filtering

  • More details for Sentry events: query, variables and response (where possible)

  • Breadcrumbs for operation (query, mutation, subscription), data fetchers and data loaders (Spring only)

  • Better hub propagation by using GraphQLContext

  • The starter modules sentry-spring-boot-starter and sentry-spring-boot-starter-jakarta now bring spring-boot-starter as a dependency

  • Add a new option setReportHistoricalAnrs; when enabled, it will report all of the ANRs from the getHistoricalExitReasons list.
    By default, the SDK only reports and enriches the latest ANR and only this one counts towards ANR rate.
    Worth noting that this option is mainly useful when updating the SDK to the version where ANRv2 has been introduced, to report all ANRs happened prior to the SDK update. After that, the SDK will always pick up the latest ANR from the historical exit reasons list on next app restart, so there should be no historical ANRs to report.
    These ANRs are reported with the HistoricalAppExitInfo mechanism.

  • Add a new option setAttachAnrThreadDump to send ANR thread dump from the system as an attachment.
    This is only useful as additional information, because the SDK attempts to parse the thread dump into proper threads with stacktraces by default.

  • If ApplicationExitInfo#getTraceInputStream returns null, the SDK no longer reports an ANR event, as these events are not very useful without it.
    .sentryTracing(captureFailedRequests = true)

  • This integration replaces the old androidx.sqlite database instrumentation in the Sentry Android Gradle plugin

  • A new capability to manually instrument your androidx.sqlite databases.

    • You can wrap your custom SupportSQLiteOpenHelper instance into SentrySupportSQLiteOpenHelper(myHelper) if you're not using the Sentry Android Gradle plugin and still benefit from performance auto-instrumentation.

  • Create spans for time spent on:

    • Proxy selection
    • DNS resolution
    • HTTPS setup
    • Connection
    • Requesting headers
    • Receiving response

  • You can attach the event listener to your OkHttpClient through client.eventListener(new SentryOkHttpEventListener()).addInterceptor(new SentryOkHttpInterceptor()).build();

  • In case you already have an event listener you can use the SentryOkHttpEventListener as well through client.eventListener(new SentryOkHttpEventListener(myListener)).addInterceptor(new SentryOkHttpInterceptor()).build();

  • This implementation completely replaces the old one (based on a watchdog) on devices running Android 11 and above:

    • New implementation provides more precise ANR events/ANR rate detection as well as system thread dump information. The new implementation reports ANRs exactly as Google Play Console, without producing false positives or missing important background ANR events.
    • New implementation reports ANR events with a new mechanism mechanism:AppExitInfo.
    • However, despite producing many false positives, the old implementation is capable of better enriching ANR errors (which is not available with the new implementation), for example:
      • Capturing screenshots at the time of ANR event;
      • Capturing transactions and profiling data corresponding to the ANR event;
      • Auxiliary information (such as current memory load) at the time of ANR event.
    • If you would like us to provide support for the old approach working alongside the new one on Android 11 and above (e.g. for raising events for slow code on main thread), consider upvoting this issue.

  • The old watchdog implementation will continue working for older API versions (Android < 11):

    • The old implementation reports ANR events with the existing mechanism mechanism:ANR.

  • Instead of relying on package scanning, we now use an annotation processor to generate Log4j2Plugins.dat

  • changelog

  • diff

• Add name and geo to User (#2556)

  • NOTE: If you're using these mechanism types (HandlerExceptionResolver, SentryWebExceptionHandler) in your dashboards please update them to use the new types.
  • This change is backwards compatible. The default is null meaning existing behaviour remains unchanged (setting either tracesSampleRate or tracesSampler enables performance).
  • If set to true, performance is enabled, even if no tracesSampleRate or tracesSampler have been configured.
  • If set to false performance is disabled, regardless of tracesSampleRate and tracesSampler options.

• Add main flag to threads and in_foreground flag for app contexts (#2516)

• Server-Side Dynamic Sampling Context support (#2226)

  • Introduce JsonSerializable and JsonDeserializer interfaces for manual json
    serialization/deserialization.
  • Introduce JsonUnknwon interface to preserve unknown properties when deserializing/serializing
    SDK classes.
  • When passing custom objects, for example in Contexts, these are supported for serialization:
    • JsonSerializable
    • Map, Collection, Array, String and all primitive types.
    • Objects with the help of refection.
      • Map, Collection, Array, String and all primitive types.
      • Call toString() on objects that have a cyclic reference to a ancestor object.
      • Call toString() where object graphs exceed max depth.
  • Remove gson dependency.
  • Remove IUnknownPropertiesConsumer

• Change order of event filtering mechanisms and only send session update for dropped events if session state changed (#2028)

• Free Local Refs manually due to Android local ref. count limits (#1179)

Previous releases for the Android SDK (version 2.x) can be found on the now archived: https://github.com/getsentry/sentry-android/

1. To add integrations it requires a manual initialization of the Android SDK.
2. Add the sentry-android-timber dependency:
3. Initialize and add the SentryTimberIntegration:
4. Use the Timber integration:

• Proguard rules are added automatically
• Permission (Internet) is added automatically
• Fixed release for jcenter and bintray
  • Proguard rules are added automatically
  • Permission (Internet) is added automatically

Full CHANGELOG.md diff

 -1,5 +1,20 
 # Changelog
 
+## 8.38.0
+
+### Features
+
+- Prevent cross-organization trace continuation ([#5136](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/5136))
+  - By default, the SDK now extracts the organization ID from the DSN (e.g. `o123.ingest.sentry.io`) and compares it with the `sentry-org_id` value in incoming baggage headers. When the two differ, the SDK starts a fresh trace instead of continuing the foreign one. This guards against accidentally linking traces across organizations.
+  - New option `enableStrictTraceContinuation` (default `false`): when enabled, both the SDK's org ID **and** the incoming baggage org ID must be present and match for a trace to be continued. Traces with a missing org ID on either side are rejected. Configurable via code (`setStrictTraceContinuation(true)`), `sentry.properties` (`enable-strict-trace-continuation=true`), Android manifest (`io.sentry.strict-trace-continuation.enabled`), or Spring Boot (`sentry.strict-trace-continuation=true`).
+  - New option `orgId`: allows explicitly setting the organization ID for self-hosted and Relay setups where it cannot be extracted from the DSN. Configurable via code (`setOrgId("123")`), `sentry.properties` (`org-id=123`), Android manifest (`io.sentry.org-id`), or Spring Boot (`sentry.org-id=123`).
+- Android: Attachments on the scope will now be synced to native ([#5211](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/5211))
+- Add THIRD_PARTY_NOTICES.md for vendored third-party code, bundled as SENTRY_THIRD_PARTY_NOTICES.md in the sentry JAR under META-INF ([#5186](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/5186))
+
+### Improvements
+
+- Do not retrieve `ActivityManager` if API < 35 on SDK init ([#5275](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/5275))
+
 ## 8.37.1
 
 ### Fixes
 -302,9 +317,8 
 - Android: Flush logs when app enters background ([#4951](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4951))
 - Add option to capture additional OkHttp network request/response details in session replays ([#4919](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4919))
   - Depends on `SentryOkHttpInterceptor` to intercept the request and extract request/response bodies
-  - To enable, add url regexes via the `io.sentry.session-replay.network-detail-allow-urls` metadata tag in AndroidManifest ([code sample](https://github-redirect.dependabot.com/getsentry/sentry-java/blob/b03edbb1b0d8b871c62a09bc02cbd8a4e1f6fea1/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml#L196-L205))
-    - Or you can manually specify SentryReplayOptions via `SentryAndroid#init`:  
-_(Make sure you disable the auto init via manifest meta-data: io.sentry.auto-init=false)_
+  - To enable, add url regexes via the `io.sentry.session-replay.network-detail-allow-urls` metadata tag in AndroidManifest ([code sample](https://github-redirect.dependabot.com/getsentry/sentry-java/blob/b03edbb1b0d8b871c62a09bc02cbd8a4e1f6fea1/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml#L196-L205)) - Or you can manually specify SentryReplayOptions via `SentryAndroid#init`:
+    _(Make sure you disable the auto init via manifest meta-data: io.sentry.auto-init=false)_
 
 <details>
   <summary>Kotlin</summary>
 -346,13 +360,12  SentryAndroid.init(
 
 </details>
 
-
 ### Improvements
 
 - Avoid forking `rootScopes` for Reactor if current thread has `NoOpScopes` ([#4793](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4793))
   - This reduces the SDKs overhead by avoiding unnecessary scope forks
 
-### Fixes 
+### Fixes
 
 - Fix missing thread stacks for ANRv1 events ([#4918](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4918))
 - Fix handling of unparseable mime-type on request filter ([#4939](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4939))
 -608,15 +621,15  SentryAndroid.init(
 
 - Add onDiscard to enable users to track the type and amount of data discarded before reaching Sentry ([#4612](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4612))
   - Stub for setting the callback on `Sentry.init`:
-     ```java
-     Sentry.init(options -> {
-       ...
-       options.setOnDiscard(
-        (reason, category, number) -> {
-          // Your logic to process discarded data
-        });
-     });
-     ```
+    ```java
+    Sentry.init(options -> {
+      ...
+      options.setOnDiscard(
+       (reason, category, number) -> {
+         // Your logic to process discarded data
+       });
+    });
+    ```
 
 ## 8.19.1
 
 -666,7 +679,7  SentryAndroid.init(
 - Move and flush unfinished previous session on init ([#4624](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4624))
   - This removes the need for unnecessary blocking our background queue for 15 seconds in the case of a background app start
 - Switch to compileOnly dependency for compose-ui-material ([#4630](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4630))
-  - This fixes `StackOverflowError` when using OSS Licenses plugin 
+  - This fixes `StackOverflowError` when using OSS Licenses plugin
 
 ### Dependencies
 
 -871,21 +884,24  SentryAndroid.init(
 ### Features
 
 - Add New User Feedback Widget ([#4450](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4450))
-    - This widget is a custom button that can be used to show the user feedback form
+  - This widget is a custom button that can be used to show the user feedback form
 - Add New User Feedback form ([#4384](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4384))
-    - We now introduce SentryUserFeedbackDialog, which extends AlertDialog, inheriting the show() and cancel() methods, among others.
-      To use it, just instantiate it and call show() on the instance (Sentry must be previously initialized).
-      For customization options, please check the [User Feedback documentation](https://docs.sentry.io/platforms/android/user-feedback/configuration/).
-      ```java
-      import io.sentry.android.core.SentryUserFeedbackDialog;
-      
-      new SentryUserFeedbackDialog.Builder(context).create().show();
-      ```
-      ```kotlin
-      import io.sentry.android.core.SentryUserFeedbackDialog
-    
-      SentryUserFeedbackDialog.Builder(context).create().show()
-      ```
+  - We now introduce SentryUserFeedbackDialog, which extends AlertDialog, inheriting the show() and cancel() methods, among others.
+    To use it, just instantiate it and call show() on the instance (Sentry must be previously initialized).
+    For customization options, please check the [User Feedback documentation](https://docs.sentry.io/platforms/android/user-feedback/configuration/).
+
+    ```java
+    import io.sentry.android.core.SentryUserFeedbackDialog;
+
+    new SentryUserFeedbackDialog.Builder(context).create().show();
+    ```
+
+    ```kotlin
+    import io.sentry.android.core.SentryUserFeedbackDialog
+
+    SentryUserFeedbackDialog.Builder(context).create().show()
+    ```
+
 - Add `user.id`, `user.name` and `user.email` to log attributes ([#4486](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4486))
 - User `name` attribute has been deprecated, please use `username` instead ([#4486](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4486))
 - Add device (`device.brand`, `device.model` and `device.family`) and OS (`os.name` and `os.version`) attributes to logs ([#4493](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4493))
 -931,8 +947,8  SentryAndroid.init(
 ### Features
 
 - Add debug mode for Session Replay masking ([#4357](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4357))
-    - Use `Sentry.replay().enableDebugMaskingOverlay()` to overlay the screen with the Session Replay masks.
-    - The masks will be invalidated at most once per `frameRate` (default 1 fps).
+  - Use `Sentry.replay().enableDebugMaskingOverlay()` to overlay the screen with the Session Replay masks.
+  - The masks will be invalidated at most once per `frameRate` (default 1 fps).
 - Extend Logs API to allow passing in `attributes` ([#4402](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4402))
   - `Sentry.logger.log` now takes a `SentryLogParameters`
   - Use `SentryLogParameters.create(SentryAttributes.of(...))` to pass attributes
 -963,17 +979,17  SentryAndroid.init(
 ### Features
 
 - Add new User Feedback API ([#4286](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4286))
-    - We now introduced Sentry.captureFeedback, which supersedes Sentry.captureUserFeedback
+  - We now introduced Sentry.captureFeedback, which supersedes Sentry.captureUserFeedback
 - Add Sentry Log Feature ([#4372](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4372))
-    - The feature is disabled by default and needs to be enabled by:
-        - `options.getLogs().setEnabled(true)` in `Sentry.init` / `SentryAndroid.init`
-        - `<meta-data android:name="io.sentry.logs.enabled" android:value="true" />` in `AndroidManifest.xml`
-        - `logs.enabled=true` in `sentry.properties`
-        - `sentry.logs.enabled=true` in `application.properties`
-        - `sentry.logs.enabled: true` in `application.yml`
-    - Logs can be captured using `Sentry.logger().info()` and similar methods.
-    - Logs also take a format string and arguments which we then send through `String.format`.
-    - Please use `options.getLogs().setBeforeSend()` to filter outgoing logs
+  - The feature is disabled by default and needs to be enabled by:
+    - `options.getLogs().setEnabled(true)` in `Sentry.init` / `SentryAndroid.init`
+    - `<meta-data android:name="io.sentry.logs.enabled" android:value="true" />` in `AndroidManifest.xml`
+    - `logs.enabled=true` in `sentry.properties`
+    - `sentry.logs.enabled=true` in `application.properties`
+    - `sentry.logs.enabled: true` in `application.yml`
+  - Logs can be captured using `Sentry.logger().info()` and similar methods.
+  - Logs also take a format string and arguments which we then send through `String.format`.
+  - Please use `options.getLogs().setBeforeSend()` to filter outgoing logs
 
 ### Fixes
 
 -1008,11 +1024,11  SentryAndroid.init(
 ### Features
 
 - Wrap configured OpenTelemetry `ContextStorageProvider` if available ([#4359](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4359))
-  - This is only relevant if you see `java.lang.IllegalStateException: Found multiple ContextStorageProvider. Set the io.opentelemetry.context.ContextStorageProvider property to the fully qualified class name of the provider to use. Falling back to default ContextStorage. Found providers: ...` 
+  - This is only relevant if you see `java.lang.IllegalStateException: Found multiple ContextStorageProvider. Set the io.opentelemetry.context.ContextStorageProvider property to the fully qualified class name of the provider to use. Falling back to default ContextStorage. Found providers: ...`
   - Set `-Dio.opentelemetry.context.contextStorageProvider=io.sentry.opentelemetry.SentryContextStorageProvider` on your `java` command
   - Sentry will then wrap the other `ContextStorageProvider` that has been configured by loading it through SPI
   - If no other `ContextStorageProvider` is available or there are problems loading it, we fall back to using `SentryOtelThreadLocalStorage`
-    
+
 ### Fixes
 
 - Update profile chunk rate limit and client report ([#4353](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4353))
 -1071,9 +1087,9  SentryAndroid.init(
 - UI Profiling GA
 
   Continuous Profiling is now GA, named UI Profiling. To enable it you can use one of the following options. More info can be found at https://docs.sentry.io/platforms/android/profiling/.
-    Note: Both `options.profilesSampler` and `options.profilesSampleRate` must **not** be set to enable UI Profiling.
-    To keep the same transaction-based behaviour, without the 30 seconds limitation, you can use the `trace` lifecycle mode.
-  
+  Note: Both `options.profilesSampler` and `options.profilesSampleRate` must **not** be set to enable UI Profiling.
+  To keep the same transaction-based behaviour, without the 30 seconds limitation, you can use the `trace` lifecycle mode.
+
   ```xml
   <application>
     <!-- Enable UI profiling, adjust in production env. This is evaluated only once per session -->
 -1084,10 +1100,11  SentryAndroid.init(
     <meta-data android:name="io.sentry.traces.profiling.start-on-app-start" android:value="true" />
   </application>

• import io.sentry.ProfileLifecycle;
  import io.sentry.android.core.SentryAndroid;

• SentryAndroid.init(context, options -> {
  // Enable UI profiling, adjust in production env. This is evaluated only once per session
  options.setProfileSessionSampleRate(1.0);
  -1097,6 +1114,7 SentryAndroid.init(
  options.setStartProfilerOnAppStart(true);
  });

• import io.sentry.ProfileLifecycle
  import io.sentry.android.core.SentryAndroid

-1167,10 +1185,10 SentryAndroid.init(

Features

• Add native stack frame address information and debug image metadata to ANR events (#4061)
• • This enables symbolication for stripped native code in ANRs

• • This enables symbolication for stripped native code in ANRs

• Add Continuous Profiling Support (#3710)

• To enable Continuous Profiling use the Sentry.startProfiler and Sentry.stopProfiler experimental APIs. Sampling rate can be set through options.profileSessionSampleRate, which defaults to null (disabled).

• To enable Continuous Profiling use the Sentry.startProfiler and Sentry.stopProfiler experimental APIs. Sampling rate can be set through options.profileSessionSampleRate, which defaults to null (disabled).
  Note: Both options.profilesSampler and options.profilesSampleRate must not be set to enable Continuous Profiling.

-1178,7 +1196,7 SentryAndroid.init(
import io.sentry.android.core.SentryAndroid;

SentryAndroid.init(context) { options ->

• // Currently under experimental options:
  options.getExperimental().setProfileSessionSampleRate(1.0);
  // In manual mode, you need to start and stop the profiler manually using Sentry.startProfiler and Sentry.stopProfiler
  -1187,16 +1205,17 SentryAndroid.init(
  }
  // Start profiling
  Sentry.startProfiler();

• // After all profiling is done, stop the profiler. Profiles can last indefinitely if not stopped.
  Sentry.stopProfiler();

• import io.sentry.ProfileLifecycle
  import io.sentry.android.core.SentryAndroid
  
  SentryAndroid.init(context) { options ->

• // Currently under experimental options:
  options.experimental.profileSessionSampleRate = 1.0
  // In manual mode, you need to start and stop the profiler manually using Sentry.startProfiler and Sentry.stopProfiler
  -1205,7 +1224,7 SentryAndroid.init(
  }
  // Start profiling
  Sentry.startProfiler()

• // After all profiling is done, stop the profiler. Profiles can last indefinitely if not stopped.
  Sentry.stopProfiler()

-1243,7 +1262,7 SentryAndroid.init(
- remove any previous value if the new value is set to null

• Add support for setting in-app-includes/in-app-excludes via AndroidManifest.xml (#4240)
• Modifications to OkHttp requests are now properly propagated to the affected span / breadcrumbs (#4238)
• • Please ensure the SentryOkHttpInterceptor is added last to your OkHttpClient, as otherwise changes to the Request by subsequent interceptors won't be considered

• • Please ensure the SentryOkHttpInterceptor is added last to your OkHttpClient, as otherwise changes to the Request by subsequent interceptors won't be considered

• Fix "class ch.qos.logback.classic.spi.ThrowableProxyVO cannot be cast to class ch.qos.logback.classic.spi.ThrowableProxy" (#4206)
  • In this case we cannot report the Throwable to Sentry as it's not available
  • If you are using OpenTelemetry v1 OpenTelemetryAppender, please consider upgrading to v2
    -1316,7 +1335,7 SentryAndroid.init(

Behavioural Changes

• The class io.sentry.spring.jakarta.webflux.ReactorUtils is now deprecated, please use io.sentry.reactor.SentryReactorUtils in the new sentry-reactor module instead (#4155)
• • The new module will be exposed as an api dependency when using sentry-spring-boot-jakarta (Spring Boot 3) or sentry-spring-jakarta (Spring 6).

• • The new module will be exposed as an api dependency when using sentry-spring-boot-jakarta (Spring Boot 3) or sentry-spring-jakarta (Spring 6).
    Therefore, if you're using one of those modules, changing your imports will suffice.

8.2.0

-1330,7 +1349,7 SentryAndroid.init(

• Create onCreate and onStart spans for all Activities (#4025)
• Add split apks info to the App context (#3193)
• Expose new withSentryObservableEffect method overload that accepts SentryNavigationListener as a parameter (#4143)
• • This allows sharing the same SentryNavigationListener instance across fragments and composables to preserve the trace

• • This allows sharing the same SentryNavigationListener instance across fragments and composables to preserve the trace

• (Internal) Add API to filter native debug images based on stacktrace addresses (#4089)
• Propagate sampling random value (#4153)
  • The random value used for sampling traces is now sent to Sentry and attached to the baggage header on outgoing requests
    -1401,6 +1420,7 SentryAndroid.init(context) { options ->

If you would like to keep some of the default broadcast events as breadcrumbs, consider opening a [GitHub issue](https://github-redirect.dependabot.com/getsentry/sentry-java/issues/new).
+
- Set mechanism `type` to `suppressed` for suppressed exceptions ([#4125](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/4125))
  - This helps to distinguish an exceptions cause from any suppressed exceptions in the Sentry UI

-1422,10 +1442,10  Version 8 of the Sentry Android/Java SDK brings a variety of features and fixes.
- 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 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-redirect.dependabot.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.
+  - 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-redirect.dependabot.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
-1442,11 +1462,11  This SDK version is compatible with a self-hosted version of Sentry `22.12.0` or
- The minSdk level for sentry-android-ndk changed from 19 to 21 ([#3851](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3851))
- Throw IllegalArgumentException when calling Sentry.init on Android ([#3596](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3596))
- Metrics have been removed from the SDK ([#3774](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3774))
-    - Metrics will return but we don't know in what exact form yet
+  - Metrics will return but we don't know in what exact form yet
- `enableTracing` option (a.k.a `enable-tracing`) has been removed from the SDK ([#3776](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3776))
-    - Please set `tracesSampleRate` to a value >= 0.0 for enabling performance instead. The default value is `null` which means performance is disabled.
+  - Please set `tracesSampleRate` to a value >= 0.0 for enabling performance instead. The default value is `null` which means performance is disabled.
- Replace `synchronized` methods and blocks with `ReentrantLock` (`AutoClosableReentrantLock`) ([#3715](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3715))
-    - If you are subclassing any Sentry classes, please check if the parent class used `synchronized` before. Please make sure to use the same lock object as the parent class in that case.
+  - If you are subclassing any Sentry classes, please check if the parent class used `synchronized` before. Please make sure to use the same lock object as the parent class in that case.
- `traceOrigins` option (`io.sentry.traces.tracing-origins` in manifest) has been removed, please use `tracePropagationTargets` (`io.sentry.traces.trace-propagation-targets` in manifest`) instead ([#3780](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3780))
- `profilingEnabled` option (`io.sentry.traces.profiling.enable` in manifest) has been removed, please use `profilesSampleRate` (`io.sentry.traces.profiling.sample-rate` instead) instead ([#3780](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3780))
- `shutdownTimeout` option has been removed, please use `shutdownTimeoutMillis` instead ([#3780](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3780))
-1466,32 +1486,32  This SDK version is compatible with a self-hosted version of Sentry `22.12.0` or
- User segment has been removed ([#3512](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3512))
- One of the `AndroidTransactionProfiler` constructors has been removed, please use a different one ([#3780](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3780))
- Use String instead of UUID for SessionId ([#3834](https://github-redirect.dependabot.com/getsentry/sentry-java/pull/3834))
-    - The `Session` constructor now takes a `String` instead of a `UUID` for the `sessionId` parameter.
-    - `Session.getSessionId()` now returns a `String` instead of a `UUID`.
+  - The `Session` constructor now takes a `String` instead of a `UUID` for the `sessionId` parameter.
+  - `Session.getSessionId()` now returns a `String` instead of a `UUID`.

> :warning: **Changelog content truncated by 106086 characters because it was over the limit (60000) and wouldn't fit into PR description.**

[github-actions]

Semver Impact of This PR

⚪ None (no version bump detected)

📋 Changelog Preview

This is how your changes will appear in the changelog.
Entries from this PR are highlighted with a left border (blockquote style).

---

• chore(deps): update Android SDK to v8.38.0 by github-actions[bot] in #5971

• fix(profiling): Fix app start transaction profile timestamp offset by antonis in #5962
• fix(android): Use componentStack as fallback for missing error stack traces by antonis in #5965
• chore(deps): bump addressable from 2.8.7 to 2.9.0 in /samples/react-native-macos by dependabot in #5967
• chore(deps): bump addressable from 2.8.7 to 2.9.0 in /samples/react-native by dependabot in #5966
• fix(ios): Add SENTRY_PROJECT_ROOT env var for monorepo support by antonis in #5961
• feat(ios): Add attachAllThreads option by antonis in #5960
• fix(core): Lazy-load Metro internal modules to prevent Expo 55 import errors by lucas-zimerman in #5958
• chore(deps): update Cocoa SDK to v9.9.0 by github-actions in #5956
• chore(deps): update Maestro to v2.4.0 by github-actions in #5955
• Feat: Fallback to stacktrace parsing by lucas-zimerman in #5946
• fix(ci): Bump Node to 22 in size-analysis and testflight workflows by antonis in #5954
• feat(playground): Open Sentry in desktop browser from Expo apps by antonis in #5947
• chore(core): Bump sample app to React Native 0.84.1 by antonis in #5941
• Size analysis for React Native SDK by alwx in #5949
• chore(deps): bump lodash from 4.17.23 to 4.18.1 by dependabot in #5953
• chore(deps): bump yauzl to ^3.2.1 by antonis in #5950
• chore(deps): bump brace-expansion to ^2.0.3 by antonis in #5951
• chore(deps): bump @xmldom/xmldom to fix XML injection by antonis in #5952

---

_{🤖 This preview updates automatically when you update the PR.}

[github-actions]

	Fails
🚫	Pull request is not ready for merge, please add the "ready-to-merge" label to the pull request
🚫	❌ Android SDK Version Mismatch Component Version sentry-android in build.gradle 8.38.0 sentry-android bundled by gradle plugin 6.3.0 8.37.1 This mismatch will cause crashes on Android with error: IllegalStateException: Sentry SDK has detected a mix of versions Fix: Update packages/core/android/build.gradle to use version 8.37.1 or wait for a gradle plugin release that bundles 8.38.0.

	Warnings
⚠️	🤖 Replay Stubs Check ✅ No changes detected in replay-stubs.jar All file contents are identical (verified by SHA-256 hash comparison).

Generated by 🚫 dangerJS against 1826df1

[sentry]

Sentry Build Distribution

App Name	App ID	Version	Configuration	Install Page
Sentry RN	io.sentry.reactnative.sample	8.7.0 (82)	Release	Install Build

Configure sentry-react-native build distribution settings