Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion .claude/skills/test/SKILL.md
Original file line number Diff line number Diff line change
Expand Up @@ -46,7 +46,7 @@ Determine the Gradle test task:
| Module Pattern | Test Task |
|---------------|-----------|
| `sentry-android-*` | `testReleaseUnitTest` |
| `sentry-compose*` | `testReleaseUnitTest` |
| `sentry-compose*` | `testAndroidHostTest` |
| `*-android` | `testReleaseUnitTest` |
| Everything else | `test` |

Expand Down
1 change: 1 addition & 0 deletions build-logic/build.gradle.kts
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@ dependencies {
implementation(libs.vanniktechMavenPublishLib)
implementation(libs.asm)
compileOnly(libs.kotlin.gradle.plugin)
compileOnly(libs.kotlin.abi.tools.api)
compileOnly(libs.android.gradle.plugin)
}

Expand Down
211 changes: 211 additions & 0 deletions build-logic/src/main/kotlin/io/sentry/gradle/AndroidAbiValidation.kt
Original file line number Diff line number Diff line change
@@ -0,0 +1,211 @@
package io.sentry.gradle

import com.android.build.api.artifact.ScopedArtifact
import com.android.build.api.variant.AndroidComponentsExtension
import com.android.build.api.variant.ScopedArtifacts
import com.android.build.api.variant.VariantSelector
import java.io.File
import java.util.zip.ZipFile
import javax.inject.Inject
import org.gradle.api.DefaultTask
import org.gradle.api.GradleException
import org.gradle.api.Project
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.Directory
import org.gradle.api.file.DirectoryProperty
import org.gradle.api.file.RegularFile
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.ListProperty
import org.gradle.api.provider.SetProperty
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.Classpath
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.InputFiles
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.TaskAction
import org.gradle.work.DisableCachingByDefault
import org.gradle.workers.WorkAction
import org.gradle.workers.WorkParameters
import org.gradle.workers.WorkerExecutor
import org.jetbrains.kotlin.abi.tools.AbiFilters
import org.jetbrains.kotlin.abi.tools.AbiTools
import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion

/**
* The Kotlin Gradle plugin's ABI validation only covers the `org.jetbrains.kotlin.android` plugin
* and the legacy KMP `androidTarget`. Neither AGP's built-in Kotlin nor the KMP Android library
* plugin gets it, so their modules would silently stop checking their ABI. This dumps the classes
* of one variant with the same ABI tools the Kotlin Gradle plugin uses, into the dump file it used
* to write, and hooks the check and update into `checkKotlinAbi` and `updateKotlinAbi`.
*/
internal fun Project.validateAndroidAbi(
extension: ApiValidationExtension,
referenceDump: String,
selectVariant: (VariantSelector) -> VariantSelector,
) {
val abiTools =
configurations.detachedConfiguration(
dependencies.create("org.jetbrains.kotlin:abi-tools:${getKotlinPluginVersion()}")
)
val dump =
tasks.register("dumpAndroidAbi", DumpAndroidAbi::class.java) {
description = "Dumps the public ABI of the Android classes."
classpath.from(abiTools)
ignoredPackages.set(extension.ignoredPackages)
dumpFile.set(layout.buildDirectory.file("kotlin/abi-android/${project.name}.api"))
}
extensions.getByType(AndroidComponentsExtension::class.java).onVariants(
selectVariant(extensions.getByType(AndroidComponentsExtension::class.java).selector())
) { variant ->
variant.artifacts
.forScope(ScopedArtifacts.Scope.PROJECT)
.use(dump)
.toGet(ScopedArtifact.CLASSES, DumpAndroidAbi::classJars, DumpAndroidAbi::classDirs)
}

val check =
tasks.register("checkAndroidAbi", CheckAndroidAbi::class.java) {
description = "Checks the public ABI of the Android classes against $referenceDump."
group = "verification"
classpath.from(abiTools)
actual.set(dump.flatMap { it.dumpFile })
expected.set(layout.projectDirectory.file(referenceDump))
}
val update =
tasks.register("updateAndroidAbi", UpdateAndroidAbi::class.java) {
description = "Writes the public ABI of the Android classes to $referenceDump."
actual.set(dump.flatMap { it.dumpFile })
expected.set(layout.projectDirectory.file(referenceDump))
}
tasks.maybeRegister("checkKotlinAbi").configure { dependsOn(check) }
tasks.maybeRegister("updateKotlinAbi").configure { dependsOn(update) }
tasks.named("check").configure { dependsOn(check) }
}

private fun org.gradle.api.tasks.TaskContainer.maybeRegister(name: String) =
if (name in names) named(name) else register(name)

@CacheableTask
abstract class DumpAndroidAbi @Inject constructor(private val workers: WorkerExecutor) :
DefaultTask() {
@get:Classpath abstract val classpath: ConfigurableFileCollection

@get:Classpath abstract val classJars: ListProperty<RegularFile>

@get:Classpath abstract val classDirs: ListProperty<Directory>

@get:Input abstract val ignoredPackages: SetProperty<String>

@get:OutputFile abstract val dumpFile: RegularFileProperty

@TaskAction
fun dump() {
workers
.classLoaderIsolation { classpath.from(this@DumpAndroidAbi.classpath) }
.submit(DumpAbiAction::class.java) {
classJars.from(this@DumpAndroidAbi.classJars)
classDirs.from(this@DumpAndroidAbi.classDirs)
excludedClasses.set(ignoredPackages.map { packages -> packages.map { "$it.**" }.toSet() })
unpackDir.set(temporaryDir)
dumpFile.set(this@DumpAndroidAbi.dumpFile)
}
}
}

@DisableCachingByDefault(because = "Comparing two small files is cheaper than caching it")
abstract class CheckAndroidAbi @Inject constructor(private val workers: WorkerExecutor) :
DefaultTask() {
@get:Classpath abstract val classpath: ConfigurableFileCollection

@get:InputFiles @get:PathSensitive(PathSensitivity.NONE) abstract val actual: RegularFileProperty

// InputFiles rather than InputFile, so that a missing dump fails with the message below.
@get:InputFiles
@get:PathSensitive(PathSensitivity.NONE)
abstract val expected: RegularFileProperty

@TaskAction
fun check() {
val expectedFile = expected.get().asFile
if (!expectedFile.exists()) {
throw GradleException(
"The ABI dump ${expectedFile.path} is missing. Run updateKotlinAbi to create it."
)
}
workers
.classLoaderIsolation { classpath.from(this@CheckAndroidAbi.classpath) }
.submit(CheckAbiAction::class.java) {
expected.set(expectedFile)
actual.set(this@CheckAndroidAbi.actual)
}
}
}

@DisableCachingByDefault(because = "Copies one file into the source tree")
abstract class UpdateAndroidAbi : DefaultTask() {
@get:InputFiles @get:PathSensitive(PathSensitivity.NONE) abstract val actual: RegularFileProperty

@get:OutputFile abstract val expected: RegularFileProperty

@TaskAction
fun update() {
actual.get().asFile.copyTo(expected.get().asFile, overwrite = true)
}
}

interface DumpAbiParameters : WorkParameters {
val classJars: ConfigurableFileCollection
val classDirs: ConfigurableFileCollection
val excludedClasses: SetProperty<String>
val unpackDir: DirectoryProperty
val dumpFile: RegularFileProperty
}

/** The ABI tools read class files only, so jars are unpacked first. */
abstract class DumpAbiAction : WorkAction<DumpAbiParameters> {
override fun execute() {
val unpackDir = parameters.unpackDir.get().asFile
unpackDir.deleteRecursively()
parameters.classJars.forEachIndexed { index, jar -> unpack(jar, File(unpackDir, "$index")) }

val roots = parameters.classDirs.files + unpackDir
val classFiles =
roots.flatMap { root -> root.walk().filter { it.isFile && it.extension == "class" } }
val filters = AbiFilters(emptySet(), parameters.excludedClasses.get(), emptySet(), emptySet())
parameters.dumpFile.get().asFile.bufferedWriter().use {
AbiTools.getInstance().printJvmDump(it, classFiles, filters)
}
}

private fun unpack(jar: File, into: File) {
ZipFile(jar).use { zip ->
zip
.entries()
.asSequence()
.filter { !it.isDirectory && it.name.endsWith(".class") }
.forEach { entry ->
val target = File(into, entry.name)
target.parentFile.mkdirs()
zip.getInputStream(entry).use { input -> target.outputStream().use { input.copyTo(it) } }
}
}
}
}

interface CheckAbiParameters : WorkParameters {
val expected: RegularFileProperty
val actual: RegularFileProperty
}

abstract class CheckAbiAction : WorkAction<CheckAbiParameters> {
override fun execute() {
val expected = parameters.expected.get().asFile
val actual = parameters.actual.get().asFile
val diff = AbiTools.getInstance().filesDiff(expected, actual) ?: return
throw GradleException(
"The public ABI of ${expected.path} changed. Run updateKotlinAbi if that is intended.\n$diff"
)
}
}
Original file line number Diff line number Diff line change
@@ -1,7 +1,10 @@
package io.sentry.gradle

import com.android.build.api.artifact.SingleArtifact
import com.android.build.api.dsl.KotlinMultiplatformAndroidHostTestCompilation
import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
import com.android.build.api.dsl.LibraryExtension
import com.android.build.api.variant.KotlinMultiplatformAndroidComponentsExtension
import com.android.build.api.variant.LibraryAndroidComponentsExtension
import org.gradle.api.JavaVersion
import org.gradle.api.Plugin
Expand All @@ -12,9 +15,7 @@ import org.gradle.api.plugins.JavaPluginExtension
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile

/** The JDK every module compiles and tests with, whatever JDK runs Gradle. */
Expand All @@ -27,7 +28,9 @@ private val PUBLISHED_JAVA_VERSION = JavaVersion.VERSION_11
* Holds every toolchain, bytecode level decision and compilation option of a module. It does the
* following
* - sample apps target the build JDK (21)
* - unit test code will target the build JDK (21) (required for Mockito 5)
* - JVM and KMP unit test code targets the build JDK (21). Android unit tests share the main code's
* target, because AGP's built-in Kotlin compiles every component of a module for its single
* compileOptions target
* - published JVM modules main code pins the Java 11 release, for Java and for Kotlin
* - published modules Java code drops the MethodParameters attribute javac 21 adds, and their
* archives are checked for it
Expand Down Expand Up @@ -81,6 +84,15 @@ class JdkTargetConvention : Plugin<Project> {
}
}
}
project.plugins.withId("com.android.kotlin.multiplatform.library") {
project.extensions
.getByType(KotlinMultiplatformAndroidComponentsExtension::class.java)
.onVariants { variant ->
verifyMethodParameters.configure {
archives.from(variant.artifacts.get(SingleArtifact.AAR))
}
}
}
// Only works for non-android modules
// See https://issuetracker.google.com/issues/278800528
project.plugins.withId("java-library") {
Expand Down Expand Up @@ -109,8 +121,21 @@ class JdkTargetConvention : Plugin<Project> {
android.defaultConfig { aarMetadata { minCompileSdk = project.minSdk() } }
}

listOf("com.android.library", "com.android.application").forEach { pluginId ->
project.plugins.withId(pluginId) { project.targetBuildJdkForUnitTests() }
project.plugins.withId("com.android.kotlin.multiplatform.library") {
project.extensions
.getByType(KotlinMultiplatformExtension::class.java)
.targets
.withType(KotlinMultiplatformAndroidLibraryTarget::class.java)
.configureEach {
aarMetadata { minCompileSdk = project.minSdk() }
compilations
.withType(KotlinMultiplatformAndroidHostTestCompilation::class.java)
.configureEach {
compileTaskProvider.configure {
compilerOptions.jvmTarget.set(JvmTarget.fromTarget(BUILD_JDK.toString()))
}
}
}
}
}

Expand All @@ -122,37 +147,4 @@ class JdkTargetConvention : Plugin<Project> {
.orElseThrow { IllegalStateException("libs.versions.minSdk is missing") }
.requiredVersion
.toInt()

/**
* Test code - which is never published - targets the build JDK, as it does in the JVM modules,
* instead of the Java 11 target of the main code. AGP has no per variant compileOptions, so this
* goes through the Kotlin compilations: their compile task providers are configured after AGP
* wrote its own compileOptions, which an apply time configureEach would lose against.
*/
private fun Project.targetBuildJdkForUnitTests() {
plugins.withId("org.jetbrains.kotlin.android") {
extensions.getByType(KotlinAndroidProjectExtension::class.java).target.targetBuildJdk()
}
plugins.withId("org.jetbrains.kotlin.multiplatform") {
extensions
.getByType(KotlinMultiplatformExtension::class.java)
.targets
.withType(KotlinAndroidTarget::class.java)
.configureEach { targetBuildJdk() }
}
}

private fun KotlinAndroidTarget.targetBuildJdk() {
compilations.configureEach {
if (name.endsWith("UnitTest")) {
compileTaskProvider.configure {
compilerOptions.jvmTarget.set(JvmTarget.fromTarget(BUILD_JDK.toString()))
}
compileJavaTaskProvider?.configure {
sourceCompatibility = BUILD_JDK.toString()
targetCompatibility = BUILD_JDK.toString()
}
}
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -12,13 +12,13 @@ import org.jetbrains.kotlin.gradle.dsl.abi.ExperimentalAbiValidation
private val KOTLIN_PLUGIN_IDS =
listOf(
"org.jetbrains.kotlin.jvm",
"org.jetbrains.kotlin.android",
"org.jetbrains.kotlin.multiplatform",
)

/**
* Checks the public ABI of a module against the dump checked into its `api` directory, using the
* Kotlin Gradle plugin's own ABI validation. Adds `checkKotlinAbi`, which `check` depends on, and
* Kotlin Gradle plugin's own ABI validation, or [validateAndroidAbi] for Android modules, which it
* doesn't cover. Adds `checkKotlinAbi`, which `check` depends on, and
* `updateKotlinAbi`, which rewrites the dump.
*/
@OptIn(ExperimentalAbiValidation::class)
Expand All @@ -31,6 +31,14 @@ class SentryApiValidationPlugin : Plugin<Project> {
KOTLIN_PLUGIN_IDS.forEach {
project.pluginManager.withPlugin(it) { enable(project, extension) }
}
project.pluginManager.withPlugin("com.android.kotlin.multiplatform.library") {
project.validateAndroidAbi(extension, "api/android/${project.name}.api") { it }
}
project.pluginManager.withPlugin("com.android.library") {
project.validateAndroidAbi(extension, "api/${project.name}.api") {
it.withBuildType("release")
}
}
}

private fun enable(project: Project, extension: ApiValidationExtension) {
Expand Down
Loading
Loading