# sentry-java: Sentry SDK coverage across Android and the JVM

> sentry-java is a Kotlin-first Sentry SDK distributed as multiple Java and Android artifacts, with integrations for HTTP clients, databases, logging, messaging, and Jetpack Compose. It fits teams that want one error-reporting layer across JVM and Android applications, but package selection requires attention to platform-specific modules and minimum Android API levels.

**getsentry/sentry-java** — A Sentry SDK for Java, Android and other JVM languages.

- Repository: https://github.com/getsentry/sentry-java
- Website: https://docs.sentry.io/platforms/android/
- Stars: 1,357 · Forks: 482
- Language: Kotlin
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/getsentry-sentry-java

## What sentry-java covers and who needs it

sentry-java addresses application error reporting for Java, Android, and other JVM languages. It is intended for developers who want Sentry instrumentation in applications built on those platforms, rather than for a standalone command-line utility or a monitoring service that must be operated separately. The repository is written primarily in Kotlin, while its published packages use the `io.sentry` Maven coordinates and cover both general JVM software and Android applications.

The README shows a broad set of integration surfaces. Core artifacts include `sentry` and `sentry-android-core`, while `sentry-android` and `sentry-android-distribution` represent Android-oriented distribution choices. Separate modules cover `sentry-android-ndk`, `sentry-android-timber`, `sentry-android-fragment`, `sentry-android-navigation`, `sentry-android-navigation3`, `sentry-android-sqlite`, `sentry-android-replay`, and `sentry-compose-android`. For JVM-side integrations, the README lists `sentry-apache-http-client-5`, `sentry-jul`, `sentry-jdbc`, `sentry-kafka`, and `sentry-apollo`.

That split matters. The project is not merely one Android library with a generic JVM fallback. It is a collection of artifacts that map to different application layers. A team using a JDBC database, Kafka, `java.util.logging`, or a supported HTTP client may need a particular integration rather than the Android distribution. The README does not document Spring or Spring Boot initialization syntax, even though those topics appear in the repository metadata, so exact setup for those environments cannot be inferred from the README.

## The modular architecture of sentry-java artifacts

The repository layout confirms a multi-module Gradle project. Android modules occupy separate directories, including `sentry-android-core`, `sentry-android-fragment`, `sentry-android-navigation`, `sentry-android-navigation3`, `sentry-android-ndk`, `sentry-android-replay`, `sentry-android-sqlite`, and `sentry-android-timber`. Compose support is split into `sentry-compose`, `sentry-compose-android`, and `sentry-compose-desktop`.

This arrangement lets an application depend on the capability it needs. The presence of `sentry-jul` indicates a bridge for `java.util.logging`, while `sentry-jdbc` and `sentry-kafka` identify database and messaging integrations. `sentry-apollo-3`, `sentry-apollo-4`, and `sentry-apollo-5` are separate repository modules, which is consistent with supporting multiple Apollo generation lines. `sentry-apache-http-client-5` is likewise isolated from the core package.

The trade-off is dependency selection. A broad Android distribution can serve applications that want several mobile integrations, while narrower JVM artifacts can avoid unrelated components. The README does not explain transitive dependency behavior, initialization order, or whether every pair of integration modules can coexist. Those details should be checked in the module documentation and Gradle build files before an application selects its dependency set.

The repository includes `sentry-bom`, which suggests a dependency management component, but the README does not provide its configuration syntax. A Gradle BOM example would therefore be invented and is intentionally omitted. The visible structure is enough to establish that sentry-java uses focused artifacts rather than putting every database, logging, HTTP, navigation, and Compose integration into one source directory.

## Android API levels constrain sentry-java package selection

The README package table assigns a minimum Android API version to each listed Android artifact. `sentry-android`, `sentry-android-core`, `sentry-android-distribution`, `sentry-android-ndk`, `sentry-android-timber`, `sentry-android-fragment`, `sentry-android-navigation`, `sentry-android-sqlite`, and `sentry-compose-android` are marked with minimum Android API version 21. `sentry-android-navigation3` requires version 23, and `sentry-android-replay` requires version 26.

These requirements make platform support more specific than a general Java compatibility claim. An application supporting devices below API 23 cannot select an artifact whose documented minimum is API 23. An application that must run below API 26 also cannot adopt `sentry-android-replay` without changing its device support boundary or choosing another approach.

The table does not explain whether API-level compatibility is enforced during dependency resolution, compilation, or runtime. It also leaves the Android API entry for `sentry-compose-desktop` blank, so no minimum Android API version should be inferred for that artifact from this table. The blank value means only that the README does not state one in that location.

For an engineer, the API floor is the first package-level check after identifying the required integration. Navigation3 and replay have visibly higher floors than the API 21 modules. Selecting an attractive optional integration can therefore alter which devices the application supports, not merely which Sentry data it collects.

## Building, checking, and releasing the sentry-java repository

The repository is not archived. Its last push was on 2026-10-15, and recent releases include `8.61.0` on 2026-10-14, `8.60.0` on 2026-10-07, and `8.59.0` on 2026-10-01. This release sequence confirms recent project activity, although the README does not define a support window or compatibility promise for individual modules.

The project uses a Gradle wrapper and exposes repository maintenance targets through the `Makefile`. The build target runs the complete Gradle build. Format checks are separate and cover Java and Kotlin source. The `apiDump` target deals with the binary API representation, while `dependencyUpdates` checks dependency updates against a repository revision. These are maintainer and contributor operations rather than application setup steps.

The Makefile also exposes Android integration-test assembly and system-test targets. This shows that the repository includes more than library source code: there are dedicated integration-test modules and Python-based test infrastructure. A source checkout is not needed merely to consume a published Maven Central artifact, but cloning the repository becomes relevant when inspecting behavior, reproducing a build, or working on the SDK itself.

Maintenance work for adopters differs from work for SDK contributors. Contributors must evaluate build, formatting, API compatibility, dependency updates, migrations, and tests. Adopters must select modules, align SDK versions, review `CHANGELOG.md` and `MIGRATION.md`, and assess whether a release affects their chosen integrations. The README does not document a rollback procedure or a long-term support schedule.

## Building sentry-java and the limits of a first-use tutorial

The README links the published packages to Maven Central, but it does not include a dependency declaration or an application initialization example. It also does not show a DSN configuration, an event-capture call, or a verification procedure for Android and JVM services. Because sentry-java has several artifacts, an installation example would need to identify the application type and selected integration.

The repository does document commands for building its own source tree. After obtaining the repository, the following command performs the Gradle build. It does not install sentry-java into an application:

```bash
./gradlew build
```

The project separately exposes Java and Kotlin formatting checks:

```bash
./gradlew spotlessJavaCheck spotlessKotlinCheck
```

For Android UI test artifacts, the Makefile provides a specific assembly command:

```bash
./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest
```

These commands are source checkout operations. The README does not document how to add `io.sentry:sentry` to an application, initialize `sentry-android`, or confirm that an event arrives in Sentry. An application developer should first identify whether the use case needs `sentry`, an Android artifact, or a specialized integration. The platform documentation linked through the repository homepage is the next source for dependency and initialization details.

This gap makes repository commands unsuitable as an adoption tutorial. A real first-use guide should show an exact Maven or Gradle dependency, initialization code, and an observable event. Because none of those examples appears in the README, the documented commands are limited to source development rather than production use.

## Where sentry-java is the wrong tool

sentry-java is the wrong choice when the target is not Java, Android, or another JVM language, because its published packages are centered on those environments. It is also unsuitable when the application's supported Android range conflicts with a selected module. An application that must run below API 23 cannot use `sentry-android-navigation3` at its documented minimum, and one that must run below API 26 cannot use `sentry-android-replay` without changing its platform requirements.

The large integration catalog can also encourage unnecessary dependencies. A plain JVM application that does not use `sentry-jdbc`, `sentry-kafka`, `sentry-jul`, or an Apollo client has no documented need to include those artifacts. The repository offers narrower package choices within its own module set. That is a concrete alternative approach: select an integration-specific artifact instead of a broad Android distribution.

The README does not describe another error-reporting vendor, so a vendor comparison would require sources beyond this page. It also does not document offline event storage, endpoint-failure behavior, sampling controls, event retention, or privacy filtering. Those are legitimate adoption concerns, but their behavior cannot be inferred from the package list.

There is also a distinction between collecting errors and diagnosing application behavior. The module names show that sentry-java can instrument selected frameworks, but the README does not promise automatic coverage for every library. A project using an unsupported client or framework may need explicit integration code, and the repository excerpt does not show that code.

## MIT licensing and sentry-java upgrade costs

The repository identifies its license as MIT. That designation records the project's stated license, while `THIRD_PARTY_NOTICES.md` provides the repository's third-party notice file for reviewers to examine alongside their dependency set. The README does not provide legal interpretation, and this article does not assess licensing obligations for a particular application.

Upgrade planning should focus on the artifact family and selected integrations. `MIGRATION.md` is the most direct repository file for changes that may require application modifications. `CHANGELOG.md` records release changes, while the recent release entries establish a sequence of published versions. The README does not state whether every module always moves in lockstep or whether an integration can have a different compatibility requirement.

The Makefile provides two maintainer commands that reveal part of the repository workflow. The first updates the checked-in binary API dump:

```bash
./gradlew apiDump
```

The second checks dependency updates against the `release` revision:

```bash
./gradlew dependencyUpdates -Drevision=release
```

These commands neither install the SDK nor define a production upgrade. An adopter must review the selected module's changes, test its supported platform range, and inspect migration notes. The repository's recent push and releases indicate continuing changes, so pinning a version and reviewing the matching release files is more concrete than assuming every newer version is a drop-in change.

## Conclusion

Choose sentry-java when a JVM or Android product needs Sentry coverage and can select the matching artifact for its platform or integration. Do not adopt the distribution package blindly, especially when minimum Android API levels or optional integrations conflict with the application. Verify the exact module list, Android API floor, dependency compatibility, `MIGRATION.md`, and release notes first.

## FAQ

### Which Android module should an application use in sentry-java?

The README lists `sentry-android`, `sentry-android-core`, and `sentry-android-distribution`, plus specialized modules for Timber, Fragment, navigation, SQLite, NDK, replay, and Compose. It does not provide a decision procedure for choosing among them.

### What is the minimum Android API version for sentry-android-replay?

The README lists `sentry-android-replay` with minimum Android API version 26. It lists `sentry-android-navigation3` at API 23 and most other listed Android modules at API 21.

### How do I install sentry-java in an application?

The README links the artifacts to Maven Central but does not include an installation command, dependency declaration, or initialization example. The documented `./gradlew build` command builds the repository rather than installing the SDK in an application.

## Sources

- [getsentry/sentry-java on GitHub](https://github.com/getsentry/sentry-java)
- [License: MIT](https://github.com/getsentry/sentry-java/blob/main/LICENSE)
- [Project website](https://docs.sentry.io/platforms/android/)
- [README](https://github.com/getsentry/sentry-java/blob/main/README.md)
- [Releases](https://github.com/getsentry/sentry-java/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/getsentry-sentry-java