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

[github-actions]

Bumps scripts/update-android.sh from 8.50.1 to 8.58.0.

Auto-generated by a dependency updater.

Changelog

8.58.0

Features

• Add LocalSentrySpan to sentry-compose so apps can provide a parent ISpan to a composable subtree and have nested SentryTraced spans attach to it ([#6112]feat(compose): Introduce LocalSentrySpan sentry-java#6112)

• Add dataCollection, a fine-grained replacement for sendDefaultPii, for controlling data collected automatically by SDK integrations (#5759)

  [!WARNING]
  sendDefaultPii will be removed in the next major SDK version. Migrate to dataCollection before upgrading.

  • Until then, when dataCollection is not configured, the SDK preserves the existing sendDefaultPii behavior.
  • Configuring any dataCollection option makes it the source of truth. sendDefaultPii is then ignored, and omitted dataCollection options use the defaults below.
  • The Logback appender is a compatibility exception. When an encoder is configured, sendDefaultPii=true continues to include the original message template and parameters. To opt in independently of sendDefaultPii, set <includeUnencodedMessage>true</includeUnencodedMessage> on the Sentry appender in logback.xml or logback-spring.xml.
  • Data explicitly supplied through APIs such as Sentry.setUser, scopes, event processors, or beforeSend is not affected.

  To opt in to the documented dataCollection defaults without configuring an individual option:

  Sentry.init(options -> options.getDataCollection().forceDataCollection());

  Option	Default	Behavior
  userInfo	true	Allows integrations to populate user identity and IP address information automatically.
  cookies	{ mode: DENY_LIST, terms: [] }	Collects cookies while filtering sensitive values.
  httpHeaders.request	{ mode: DENY_LIST, terms: [] }	Collects request headers while filtering sensitive values.
  httpHeaders.response	{ mode: DENY_LIST, terms: [] }	Collects response headers while filtering sensitive values.
  httpBodies	All supported body types	Collects supported incoming and outgoing request and response bodies. An empty set disables body collection.
  urlQueryParams	{ mode: DENY_LIST, terms: [] }	Collects URL query parameters while filtering sensitive values.
  graphql.document	true	Collects GraphQL documents.
  graphql.variables	true	Collects GraphQL variables.
  databaseQueryData	true	Allows collection of associated query data, such as bound parameters, write payloads, and results, where supported. Sanitized query statements and structural database metadata remain available.
  filePaths	true	Allows file-system instrumentation to collect file and directory paths. File extensions and byte counts remain available when disabled.

  Cookies, HTTP headers, and URL query parameters support three modes:

  • OFF: Do not collect the category.
  • DENY_LIST: Collect values except those matching the built-in sensitive deny-list or additional configured terms.
  • ALLOW_LIST: Only send plaintext values for matching terms. The built-in sensitive deny-list still applies.

  Matching is case-insensitive and partial. The built-in sensitive deny-list contains auth, token, secret, password, passwd, pwd, key, jwt, bearer, sso, saml, csrf, xsrf, credentials, session, sid, and identity. Filtered values are replaced with "[Filtered]". Custom deny-list terms extend rather than replace this list.

  Configure all HTTP body types, a custom cookie deny-list, a request-header allow-list, and disable URL query parameter and file path collection in an options callback:

  Sentry.init(
      options -> {
        options
            .getDataCollection()
            .setHttpBodies(
                EnumSet.of(
                    HttpBodyType.INCOMING_REQUEST,
                    HttpBodyType.OUTGOING_REQUEST,
                    HttpBodyType.INCOMING_RESPONSE,
                    HttpBodyType.OUTGOING_RESPONSE));
        options
            .getDataCollection()
            .setCookies(
                KeyValueCollectionBehavior.denyList(
                    "forwarded", "-ip", "remote-", "via", "-user"));
        options
            .getDataCollection()
            .getHttpHeaders()
            .setRequest(
                KeyValueCollectionBehavior.allowList("content-type", "x-request-id"));
        options
            .getDataCollection()
            .setUrlQueryParams(KeyValueCollectionBehavior.off());
        options.getDataCollection().setFilePaths(false);
      });

  Configure the same options in sentry.properties:

  data-collection.http-bodies=incoming_request,outgoing_request,incoming_response,outgoing_response
  data-collection.cookies.mode=deny_list
  data-collection.cookies.terms=forwarded,-ip,remote-,via,-user
  data-collection.http-headers.request.mode=allow_list
  data-collection.http-headers.request.terms=content-type,x-request-id
  data-collection.url-query-params.mode=off
  data-collection.file-paths=false

  Configure them with Spring Boot properties:

  sentry.data-collection.http-bodies=incoming-request,outgoing-request,incoming-response,outgoing-response
  sentry.data-collection.cookies.mode=deny-list
  sentry.data-collection.cookies.terms=forwarded,-ip,remote-,via,-user
  sentry.data-collection.http-headers.request.mode=allow-list
  sentry.data-collection.http-headers.request.terms=content-type,x-request-id
  sentry.data-collection.url-query-params.mode=off
  sentry.data-collection.file-paths=false

  Configure them in AndroidManifest.xml:

  <meta-data
      android:name="io.sentry.data-collection.http-bodies"
      android:value="incoming_request,outgoing_request,incoming_response,outgoing_response" />
  <meta-data
      android:name="io.sentry.data-collection.cookies.mode"
      android:value="deny_list" />
  <meta-data
      android:name="io.sentry.data-collection.cookies.terms"
      android:value="forwarded,-ip,remote-,via,-user" />
  <meta-data
      android:name="io.sentry.data-collection.http-headers.request.mode"
      android:value="allow_list" />
  <meta-data
      android:name="io.sentry.data-collection.http-headers.request.terms"
      android:value="content-type,x-request-id" />
  <meta-data
      android:name="io.sentry.data-collection.url-query-params.mode"
      android:value="off" />
  <meta-data
      android:name="io.sentry.data-collection.file-paths"
      android:value="false" />

  See the Data Collection documentation for all configuration keys, supported integrations, and migration guidance.

Fixes

• Disable URL caching when reading META-INF/MANIFEST.MF files during version detection so that the SDK no longer keeps jar file handles open for the life of the process (#6124
• Keep the EventListener wrapped by SentryOkHttpEventListener per Call (#6003)

8.57.0

Behavioral Changes

• Measure HTTP rate-limit backoff on a monotonic clock instead of the wall clock, so that a device time change no longer lifts or extends an active rate limit (#6030)

Features

• Add Android SDK support for reporting MemoryLimiter app exits recovered from ApplicationExitInfo (#6111).
• Sentry can now configure Log4j2 automatically for Spring Boot 4 when sentry-log4j2 is on the classpath and Log4j2 Core is the active logging backend (#5403)
  • Enable automatic appender registration with:

    sentry.logging.enabled=true

    Automatic registration is disabled by default for now and will be enabled by default in the next major release.
  • The appender is attached to the root logger by default. To attach it to specific loggers instead, configure one or more non-overlapping logger names:

    sentry.logging.loggers[0]=com.example
    sentry.logging.loggers[1]=org.example

  • Configure the minimum level for creating breadcrumbs. The default is INFO:

    sentry.logging.minimum-breadcrumb-level=INFO

  • Configure the minimum level for creating Sentry error events. The default is ERROR:

    sentry.logging.minimum-event-level=ERROR

  • Configure the minimum level for sending Sentry structured logs. The default is INFO:

    sentry.logging.minimum-level=INFO

    Structured logs must also be enabled:

    sentry.logs.enabled=true

• Sentry can now configure Log4j2 automatically for Spring Boot 3 when sentry-log4j2 is on the classpath and Log4j2 Core is the active logging backend (#6072)
  • Disabled by default for now; enable it and configure levels the same way as described in the Spring Boot 4 entry above (sentry.logging.enabled=true)

Fixes

• Support ws and wss URL parsing for WebSocket instrumentation (#6064)
• Keep resolving the server name after Sentry.close() or a re-init. Closing the SDK shut down the shared hostname cache for the life of the process, so server_name silently froze at the value it had last resolved (#6119)
• Order breadcrumbs by the timestamp they carry rather than by when they were created in the current process, so breadcrumbs restored from disk or handed over by a hybrid SDK no longer sort as if they had just happened (#6097)

Internal

• Deprecate RateLimiter(ICurrentDateProvider, SentryOptions) in favor of RateLimiter(SentryOptions), whose backoff is measured on a monotonic ticker (#6030)
• Deprecate AndroidCurrentDateProvider.getInstance() in favor of MonotonicTicker, which counts time spent in deep sleep and cannot be confused with the epoch-based CurrentDateProvider (#6103)

8.56.0

Fixes

• Update SentryTraced so that it now honors options.setIgnoredSpanOrigins (#6058)
• SentryTraced now checks for its owning transaction dynamically rather than once per app process. The latter caused SentryTraced spans to be dropped process-wide once the original transaction finished (#6057)
• Fix typos in Spring GraphQL integration names (GrahQL to GraphQL) (#6061)
• Populate the Android connection status cache during the first two minutes after boot, instead of treating the empty cache as up to date (#6029)
• Prevent SentryTraced from producing dangling spans if recomposition is abandoned or drawing fails (#6049)
• Report a consistent app start type across the app start measurement, contexts.app and the app.start span attributes (#6006)

Improvements

• Emit a single ui.compose span per SentryTraced on initial composition instead of one on every recomposition, and set the origin on ui.render spans (#6051)

Internal

• Add an internal MonotonicTicker abstraction with Deadline and Stopwatch primitives (#6028)
• Add internal Timestamp, EpochClock and AnchoredClock, so related instants project from one wall-clock reading instead of each reading the clock (#6045)

Dependencies

• Bump Native SDK from v0.16.5 to v0.16.6 (#6079)
  • changelog
  • diff

8.55.0

Features

• Add Session.State.Unhandled for unhandled errors that do not terminate the process (#5919)

Improvements

• Move ANR profiling out of experimental (#6042)

Fixes

• Keep dropped tombstone and ANR events dropped, instead of reporting the same app exit again at every app start (#6002)
• Apply Sentry.withScope and Sentry.withIsolationScope data to events captured inside the callback when globalHubMode is enabled (#6004)
  • globalHubMode is enabled by default on Android, where tags, extras, contexts and level set inside the callback were silently dropped
  • Scopes that are explicitly made current, e.g. via Sentry.setCurrentScopes or the SentryContext coroutine integration, are now also honoured when globalHubMode is enabled
  • Sentry.pushScope, Sentry.pushIsolationScope and Sentry.popScope remain no-ops when globalHubMode is enabled
• Drop the profiler_id from transactions and spans when no Perfetto profile covers them, e.g. when Android's ProfilingManager rate limits the profiling request (#6015)
• Prevent events from being dropped when feature flags are added while an event is being captured (#5989)

Internal

• Add InternalSentrySdk.captureEnvelopeNonTerminating for hybrid SDKs (e.g. Flutter) so unhandled exceptions that don't terminate the process no longer end the session as crashed (#5921)
• Add InternalSentrySdk.updateSessionForDroppedEventNonTerminating so hybrid SDKs can still update the session when an error is dropped by sampling (#5990)

Dependencies

• Bump Native SDK from v0.16.4 to v0.16.5 (#6034)
  • changelog
  • diff

8.54.0

Features

• Set app.vitals.start.screen and app.vitals.start.type on standalone app.start children (#6005)
• Add screenshot attachment button to the Android user feedback widget (#5828)
  • Users can now attach a screenshot when submitting feedback. Enabled by default; can be disabled via SentryFeedbackOptions.setEnableAttachScreenshot(false) or the io.sentry.feedback.enable-attach-screenshot manifest flag.
  • Requires the androidx.activity >=1.8.2 dependency
• Add manual Session Replay controls through Sentry.replay() (#5978)
  • Explicit start() and startBuffering() calls bypass the configured replay sample rates; sampling still controls automatic startup.
  • start() starts a full-session replay and does nothing if one is already recording.
  • startBuffering() keeps a rolling buffer that is sent on flush() or an error, then continues in session mode.
  • stop() ends the current replay; the next start() creates a new replay session.
  • pause() suspends recording until resume() and remains paused across background and foreground transitions and automatic replay restarts in the same process.
  • resume() continues the same manually paused replay.
  • flush() sends the current replay data, or starts a full-session replay when recording is stopped.

Fixes

• Prevents inclusion of null. prefix before default-package class names when parsing Java and JNI frames from Android ANR thread dumps (#5979)
• Prevent duplicated breadcrumbs on tombstone-merged native crash events (#5888)
• Prevent a class of Session Replay deadlocks by confining lifecycle state changes to Android's main thread (#5965)
• Symbolicate tombstone native frames for libraries loaded directly from APKs (#5992)
• Prevent a deadlock between the app start extension and the Android performance event processor (#6007)

Performance

• Defer starting Session Replay off the SDK initialization critical path (#5965)
• Use manifest metadata resolved at build time to reduce Android SDK initialization overhead (#5976)

Dependencies

• Bump Native SDK from v0.16.2 to v0.16.4 (#5962, #5996)
  • changelog
  • diff

8.53.0

Features

• Allow child spans to use explicit start timestamps through ISpan (#5929)
• Make ISpan.startChild overloads with SpanOptions public (#5927)
• Add Sentry.feedback().enableOnShake(), Sentry.feedback().disableOnShake(), and Sentry.feedback().isOnShakeEnabled() to toggle and query shake-to-report at runtime (#5827)

Improvements

• Remove ApiStatus.Experimental annotation from SentrySQLiteDriver (#5938)

Fixes

• Clear contexts when calling Scope.clear() (#5902)
• Preserve custom Throwable identities when R8 optimizes Android apps (#5881)
• Report the correct cpu usage for the first performance sample of a transaction, which was measured against the time since device boot (#5926)
• Prevent an ANR when the Session Replay video encoder gets stuck (#5842)
  • Some hardware encoders never signal end-of-stream, which made the replay worker spin forever while holding the encoder lock. The app's lifecycle callbacks then blocked on that lock and the app froze until the system killed it. The encoder now gives up instead of spinning, and closing the replay cache no longer waits indefinitely for a wedged encoder.

Performance

• Read the clock once per performance collection round instead of once per in-flight transaction (#5934)
• Reduce allocations while collecting cpu usage during transactions by reading the process cpu time via Process.getElapsedCpuTime() instead of parsing /proc/self/stat (33.6kB to 16 bytes per sample on a Pixel 3) (#5926)
• Store performance measurements as primitives, removing a boxed allocation per measurement per performance sample (#5935)

Dependencies

• Bump Native SDK from v0.16.1 to v0.16.2 (#5910)
  • changelog
  • diff

8.52.0

Fixes

• Restore the interrupt flag when cached envelope processing is interrupted between files (#5884)
• Reduce false-positive SDK crash attribution for host app SQLite cursor crashes (#5883)
• Prevent inflated cold app start when the OS spawns the process in the background (e.g. FCM push) on API 35+ (#5841, #5880)
• Preserve single-sample ANR profile chunks so profiles remain available on ANR events (#5872)
• Avoid a CPU busy-loop when recording discarded log or metric envelopes under rate limiting (#5835)
  • ClientReportRecorder now reads the item count from the envelope item header instead of deserializing the payload, which under sustained rate limiting could pin CPU cores while repeatedly throwing exceptions
• Report tasks handed to a no-op ISentryExecutorService as cancelled (#5874)
  • NoOpSentryExecutorService previously returned a Future that was never run and never cancelled, so callers could not tell a dropped task from a queued one and get() would block until its timeout

Performance

• Defer use of reflection by SentryFrameMetricsCollector during Sentry.init (#5886)
• Avoid waiting up to shutdownTimeoutMillis when closing the SDK with a pending transaction timeout or session-end task (#5851)
• Use RGB_565 instead of ARGB_8888 for screenshot and replay capture bitmaps, halving per-frame memory usage (#5821)
• Remove an unused lock from SentryPerformanceProvider, which was allocated on every cold start in ContentProvider.onCreate without ever being acquired (#5871)
• Reduce main-thread allocations when parsing the app start profiling config (#5867)
• Batch and coalesce scope-persistence disk writes to reduce startup cost (#5791)
  • Scope mutations are now coalesced (latest value per field) and breadcrumbs are appended in batches behind a single fsync, instead of one synchronous disk write per mutation.
• Reduce the number of SDK threads: the HostnameCache worker thread now times out while idle instead of staying alive for the whole process lifetime (#5817)

Dependencies

• Bump Native SDK from v0.16.0 to v0.16.1 (#5879)
  • changelog
  • diff

8.51.0

Features

• Use Android's ProfilingManager (Perfetto) for continuous profiling on API 35+ devices (#5251)
  • On API 35+ devices, continuous profiling now automatically uses Android's system ProfilingManager with Perfetto-based stack sampling, providing lower-overhead and more accurate profiles. No configuration change is required.
  • Devices below API 35 keep using the legacy Debug-based profiler.
  • Added an enableLegacyProfiling option (default true) to disable the legacy Debug-based profiler. Setting it to false disables continuous profiling on API < 35 devices as well as transaction-based profiling (profilesSampleRate/profilesSampler) on all devices, since transaction-based profiling is not supported by Perfetto.
  • It can also be configured via the io.sentry.profiling.enable-legacy-profiling manifest flag.
  • See the Android profiling docs for details.

Behavioral Changes

• The outbox and cache directories are no longer created by Sentry.init (#5792)
  • They are now created lazily by whichever component first writes into them, off the init thread. As a result, the directories at SentryOptions.getOutboxPath() and SentryOptions.getCacheDirPath() are not guaranteed to exist once Sentry.init returns.
  • If you write envelopes into the outbox path yourself instead of going through the SDK — as hybrid SDKs do for captureEnvelope — create the directory first, e.g. new File(outboxPath).mkdirs().

Improvements

• Skip building Android manifest metadata debug log messages when debug logging is disabled, reducing allocations during SDK init (#5790)

Fixes

• Use the original app build's ProGuard UUID for ANR profile chunks (#5852)
• Fix potential ANR/deadlock in Session Replay when checkCanRecord runs on the replay executor thread (#5837)
• Prevent concurrent PixelCopy access during Session Replay masking and bitmap cleanup (#5808)
• Release MediaMuxer when the replay video encoder fails to start to avoid a resource leak (#5607)
• Set the correct platform (android instead of java) on ANR profile chunks so they are billed as UI Profile Hours rather than Continuous Profile Hours (#5836)
• Skip encoding and capturing buffered session replay segments while rate-limited, so we don't waste resources on envelopes the transport will drop (#5813)
  • These skipped replays are now reported as ratelimit_backoff discarded events in client reports, so they no longer disappear from drop statistics. One event is recorded per buffer flush rather than per segment.
  • Buffer mode is also kept while rate-limited instead of switching to session mode, so the rolling buffer stays warm and the next error after the rate limit expires can send a complete replay.

Performance

• Create the outbox and cache directories lazily in their consumers instead of during SDK init, moving the mkdirs() calls off the init (main) thread (#5792)
• Reduce the number of SDK threads: LifecycleWatcher now schedules the session-end task on the shared timer executor instead of creating a dedicated java.util.Timer thread (#5819)
• Reduce the number of SDK threads: RateLimiter now schedules its rate-limit-lifted notifications on the shared timer executor instead of creating a dedicated java.util.Timer thread (#5814)
• Speed up deserialization of arbitrary JSON objects by typing numbers without throwing exceptions (#5783)

Dependencies

• Bump Native SDK from v0.15.4 to v0.16.0 (#5845)
  • changelog
  • diff

[sentry]

Bug: The captureEnvelope method does not create the outbox directory before writing, a new requirement in sentry-java 8.51.0, which can lead to silent event loss.
_{Severity: HIGH}

Suggested Fix

Before the call to InternalSentrySdk.captureEnvelope in SentryCapacitor.java, ensure the outbox directory exists. This can be done by getting the outbox path from the Sentry options and calling new File(outboxPath).mkdirs().

Prompt for AI Agent

Review the code at the location below. A potential bug has been identified by an AI
agent. Verify if this is a real issue. If it is, propose a fix; if not, explain why it's
not valid.

Location: android/build.gradle#L94

Potential issue: The update to `sentry-java` version 8.51.0 requires that the outbox
directory is created before writing envelopes to it. The `captureEnvelope` method in
`SentryCapacitor.java` calls `InternalSentrySdk.captureEnvelope` without first creating
this directory. If the directory does not exist, the operation will fail. This failure
is caught and results in a rejected promise on the JavaScript side, causing events to be
silently dropped instead of being sent to Sentry. This is a functional regression that
leads to data loss.

Also affects:

• android/src/main/java/io/sentry/capacitor/SentryCapacitor.java:259~270

_{Did we get this right? 👍 / 👎 to inform future reviews.}

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit fbd60dd. Configure here.}

[sentry]

Bug: The dependency bump for the Sentry Android SDK may cause silent data loss. The code relies on an internal API, InternalSentrySdk.serializeScope(), whose structure could have changed, leading to missing event data.
_{Severity: MEDIUM}

Suggested Fix

Verify the structure of the map returned by InternalSentrySdk.serializeScope() in Sentry Android SDK v8.58.0. If the keys have changed, update the code to use the new keys. Consider adding logging for when expected keys are not found to make future breakages more visible. If possible, switch to a public, stable API to avoid this issue with future updates.

Prompt for AI Agent

Review the code at the location below. A potential bug has been identified by an AI
agent. Verify if this is a real issue. If it is, propose a fix; if not, explain why it's
not valid.

Location: android/build.gradle#L94

Potential issue: The code relies on the internal Sentry API
`InternalSentrySdk.serializeScope()` to fetch native device contexts and log attributes,
specifically checking for keys like `"breadcrumbs"`, `"contexts"`, and `"release"`. The
Sentry Android SDK is being upgraded across 8 minor versions (8.50.1 to 8.58.0). As this
is an internal, undocumented API, its return structure may have changed. If the key
names in the map returned by `serializeScope()` have been altered in the new version,
the existing `containsKey()` checks will fail silently. This will not cause a crash but
will result in the loss of native context and breadcrumbs from Sentry events, leading to
incomplete diagnostic data.