RUM-16370: Support Android API 37

Author: kikoveiga

.gitlab-ci.yml

@@ -19,6 +19,11 @@ variables:
 
   CACHE_FALLBACK_KEY: "develop"
 
+  # Unify the Gradle user home across ALL jobs so every Gradle invocation shares one
+  # GitLab-cacheable location ($CI_PROJECT_DIR/cache) instead of some jobs using the default,
+  # non-cached /root/.gradle. Jobs that pass --gradle-user-home cache/ already match this.
+  GRADLE_USER_HOME: "$CI_PROJECT_DIR/cache"
+
   # Magic Mirror Depot proxy URLs. The depot proxies both Maven Central and the Gradle
   # Plugin Portal for the Java ecosystem from the same endpoint. Setting these routes
   # dependency/plugin resolution through Datadog's internal mirror to avoid HTTP 429

LICENSE-3rdparty.csv

@@ -52,6 +52,8 @@ import,androidx.versionedparcelable,Apache-2.0,Copyright 2018 The Android Open S
 import,androidx.viewpager,Apache-2.0,Copyright 2018 The Android Open Source Project
 import,androidx.wear,Apache-2.0,Copyright 2018 The Android Open Source Project
 import,androidx.work,Apache-2.0,Copyright 2018 The Android Open Source Project
+import,app.cash.sql-psi,Apache-2.0,"Copyright 2016 Square, Inc"
+import,app.cash.sqldelight,Apache-2.0,"Copyright 2016 Square, Inc"
 import,com.android.tools,Apache-2.0,Copyright 2018 The Android Open Source Project
 import,com.apollographql.apollo,MIT,"Copyright (c) 2016-2024 Apollo Graph, Inc. (Formerly Meteor Development Group, Inc.)"
 import,com.benasher44,MIT,"Copyright (c) 2019 Ben Asher"
@@ -140,6 +142,7 @@ import(test),com.jakewharton.android.repackaged,Apache-2.0,"Copyright (C) 2007 T
 import(test),com.parse.bolts,"BSD License","Copyright (c) Facebook, Inc. and its affiliates."
 import(test),com.squareup,Apache-2.0,"Copyright 2015 Square, Inc."
 import(test),dev.drewhamilton.poko,Apache-2.0,Copyright 2020-Present Drew Hamilton
+import(test),dev.zacsweers.kctfork,MPL-2.0,Copyright (C) 2022 Zac Sweers
 import(test),greatest,ICT,"Copyright (c) 2011-2018 Scott Vokes <vokes.s@gmail.com>"
 import(test),io.github.davidburstrom.contester,Apache-2.0,"Copyright 2022-2024 David Burström"
 import(test),io.github.detekt.sarif4k,Apache-2.0,"Copyright 2021 Artur Bosch & Contributors"
@@ -183,7 +186,6 @@ build,com.fasterxml.jackson.core,Apache-2.0,"Copyright (c) 2007- Tatu Saloranta"
 build,com.fasterxml.jackson.dataformat,Apache-2.,"Copyright (c) 2007- Tatu Saloranta"
 build,com.fasterxml.jackson.module,Apache-2.0,"Copyright (c) 2007- Tatu Saloranta"
 build,com.fasterxml.woodstox,Apache-2.0,"Copyright (c) 2007- Tatu Saloranta"
-build,com.github.tschuchortdev,MPL-2.0,"Copyright (C) 2023 Thilo Schuchort"
 build,com.google.android,Apache-2.0,Copyright (C) 2013 The Android Open Source Project
 build,com.google.api.grpc,Apache-2.0,Copyright 2020 Google LLC
 build,com.google.auto,Apache-2.0,"Copyright 2014 Google LLC"
@@ -208,6 +210,7 @@ build,commons-io,Apache-2.0,Copyright 2002-2024 The Apache Software Foundation
 build,commons-logging,Apache-2.0,Copyright 2002-2024 The Apache Software Foundation
 build,io.github.aakira,Apache-2.0,"Copyright (C) 2019 A.Akira"
 build,io.github.classgraph,MIT,"Copyright (c) 2019 Luke Hutchison"
+build,io.github.java-diff-utils,Apache-2.0,"Copyright java-diff-utils contributors"
 build,io.github.microutils,Apache-2.0,Copyright (c) 2016-2018 Ohad Shai
 build,io.gitlab.arturbosch.detekt,Apache-2.0,Copyright 2016-2019 the original author or authors
 build,io.grpc,Apache-2.0,Copyright 2014 The gRPC Authors

build.gradle.kts

@@ -5,7 +5,6 @@
  */
 @file:Suppress("StringLiteralDuplication")
 
-import com.android.build.gradle.LibraryExtension
 import com.datadog.gradle.config.AndroidConfig
 import com.datadog.gradle.config.depotProxied
 import com.datadog.gradle.config.registerSubModuleAggregationTask
@@ -29,7 +28,6 @@ plugins {
     // don't add these to the classpath, otherwise there will be a conflict, because they are already coming
     // from buildSrc classpath. May be solved with convention plugins though.
     // alias(libs.plugins.androidLibraryPlugin) apply false
-    // alias(libs.plugins.kotlinAndroidPlugin) apply false
     // alias(libs.plugins.dokkaGradlePlugin) apply false
     // alias(libs.plugins.versionsGradlePlugin) apply false
 }
@@ -207,20 +205,14 @@ tasks.register("printSdkDebugRuntimeClasspath") {
     allprojects.minus(project).forEach { subproject ->
         val childTask = subproject.tasks.register("printDebugRuntimeClasspath") {
             doLast {
-                val ext =
-                    subproject.extensions.findByType(LibraryExtension::class.java) ?: return@doLast
-                val classpath = ext.libraryVariants
-                    .filter { it.name == "jvmDebug" || it.name == "debug" }
-                    .map { libVariant ->
-                        // returns also test part of classpath for now, no idea how to filter it out
-                        libVariant.getCompileClasspath(null).filter { it.exists() }
-                    }
-                    .first()
-                if (classpath is FileTree) {
-                    fileTreeClassPathCollector.addToUnion(classpath)
-                } else {
-                    nonFileTreeClassPathCollector += classpath
-                }
+                val config = subproject.configurations.findByName("jvmDebugCompileClasspath")
+                    ?: subproject.configurations.findByName("debugCompileClasspath")
+                    ?: return@doLast
+                // Use lenient resolution: AGP 9 variant resolution can fail for local project
+                // dependencies when kotlin.platform.type attributes are missing on providers.
+                val classpath = config.incoming.artifactView { isLenient = true }.files
+                    .filter { it.exists() }
+                nonFileTreeClassPathCollector += classpath
             }
         }
         this@register.dependsOn(childTask)

buildSrc/build.gradle.kts

@@ -85,6 +85,10 @@ gradlePlugin {
             id = "verificationXml" // the alias
             implementationClass = "com.datadog.gradle.plugin.verification.VerificationXmlPlugin"
         }
+        register("unitTestConvention") {
+            id = "datadog.unit-test" // the alias
+            implementationClass = "com.datadog.gradle.plugin.config.UnitTestConventionPlugin"
+        }
     }
 }
 

buildSrc/src/main/kotlin/com/datadog/gradle/config/AndroidConfig.kt

@@ -8,16 +8,19 @@ package com.datadog.gradle.config
 
 import com.android.build.api.dsl.CompileOptions
 import com.android.build.api.dsl.LibraryExtension
+import com.android.build.api.variant.HostTestBuilder
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.android.build.api.variant.LibraryVariantBuilder
 import com.datadog.gradle.utils.Version
 import org.gradle.api.JavaVersion
 import org.gradle.api.Project
 
 object AndroidConfig {
 
-    const val TARGET_SDK = 36
+    const val TARGET_SDK = 37
     const val MIN_SDK = 23
     const val MIN_SDK_FOR_AUTO = 29
-    const val BUILD_TOOLS_VERSION = "36.0.0"
+    const val BUILD_TOOLS_VERSION = "37.0.0"
 
     val VERSION = Version(3, 12, 0, Version.Type.Snapshot)
 }
@@ -47,13 +50,12 @@ fun Project.androidLibraryConfig() {
         }
 
         sourceSets.all {
-            java.srcDir("src/$name/kotlin")
+            java.directories.add("src/$name/kotlin")
         }
         sourceSets.named("main") {
-            java.srcDir("build/generated/json2kotlin/main/kotlin")
+            kotlin.directories.add("build/generated/json2kotlin/main/kotlin")
         }
 
-        @Suppress("UnstableApiUsage")
         testOptions {
             unitTests.isReturnDefaultValues = true
         }
@@ -86,4 +88,9 @@ fun Project.androidLibraryConfig() {
             }
         }
     }
+    extensionConfig<LibraryAndroidComponentsExtension> {
+        beforeVariants { variant: LibraryVariantBuilder ->
+            variant.hostTests[HostTestBuilder.UNIT_TEST_TYPE]?.enable = true
+        }
+    }
 }

buildSrc/src/main/kotlin/com/datadog/gradle/config/DetektCustomConfig.kt

@@ -128,20 +128,29 @@ fun Project.detektCustomConfig() {
         args("-ex", "**/*.kts")
         args("--jvm-target", "11")
 
+        // Resolve project paths at configuration time (config-cache friendly), but defer all
+        // detekt_classpath file I/O to execution time. The file is produced by the
+        // printDetektClasspath task, so it may not exist when this task is configured (e.g. while
+        // computing the task graph for assembleLibrariesRelease). Reading it here would fail task
+        // creation and break the whole build.
         val moduleDependencies = collectTransitiveProjectDependencies(project)
+        val rootDirPath = rootDir.absolutePath
+        val detektClasspathFile = File("${projectDir.absolutePath}/detekt_classpath")
 
-        val externalDependencies = File("${projectDir.absolutePath}/detekt_classpath").readText()
-        val moduleDependenciesClasses = moduleDependencies.joinToString(":") {
-            "${rootDir.absolutePath}${it.replace(':', '/')}/build/extracted/classes.jar"
-        }
+        doFirst {
+            val externalDependencies = detektClasspathFile.readText()
+            val moduleDependenciesClasses = moduleDependencies.joinToString(":") {
+                "$rootDirPath${it.replace(':', '/')}/build/extracted/classes.jar"
+            }
 
-        val dependencies = if (moduleDependenciesClasses.isBlank()) {
-            externalDependencies
-        } else {
-            "$externalDependencies:$moduleDependenciesClasses"
-        }
+            val dependencies = if (moduleDependenciesClasses.isBlank()) {
+                externalDependencies
+            } else {
+                "$externalDependencies:$moduleDependenciesClasses"
+            }
 
-        args("-cp", dependencies)
+            args("-cp", dependencies)
+        }
     }
 }
 

buildSrc/src/main/kotlin/com/datadog/gradle/config/KotlinConfig.kt

@@ -21,8 +21,8 @@ fun Project.kotlinConfig(
             jvmTarget.set(jvmBytecodeTarget)
             val isCI = System.getenv("CI").toBoolean()
             allWarningsAsErrors.set(evaluateWarningsAsErrors && isCI)
-            apiVersion.set(KotlinVersion.KOTLIN_1_8)
-            languageVersion.set(KotlinVersion.KOTLIN_1_8)
+            apiVersion.set(KotlinVersion.KOTLIN_2_1)
+            languageVersion.set(KotlinVersion.KOTLIN_2_1)
         }
     }
 }

buildSrc/src/main/kotlin/com/datadog/gradle/config/TestPyramidConfig.kt

@@ -23,7 +23,16 @@ fun Project.registerSubModuleAggregationTask(
                 subProject.name.startsWith(subModuleNamePrefix) &&
                 subProject.path.startsWith(subModulePathPrefix)
             ) {
-                dependsOn("${subProject.path}:$subModuleTaskName")
+                // Depend on the task only if the submodule actually registers it, without
+                // realizing every task. `tasks.names` lists registered task names without
+                // configuring them, and `named()` returns a lazy provider. Using
+                // `tasks.matching {}` here instead would configure every task in the submodule
+                // (to evaluate the name predicate), which prematurely triggers configuration-time
+                // work in unrelated tasks. A plain `dependsOn("path:task")` would throw when a
+                // matched submodule doesn't register the task (e.g. printDetektClasspath).
+                if (subModuleTaskName in subProject.tasks.names) {
+                    dependsOn(subProject.tasks.named(subModuleTaskName))
+                }
             }
         }
         additionalConfiguration()

buildSrc/src/main/kotlin/com/datadog/gradle/plugin/apisurface/ApiSurfacePlugin.kt

@@ -40,7 +40,7 @@ class ApiSurfacePlugin : Plugin<Project> {
                 this.kotlinSurfaceFile.set(generateApiSurfaceTask.flatMap { it.surfaceFile })
                 if (target.plugins.hasPlugin(GEN_JAVA_API_LAYOUT_PLUGIN)) {
                     this.javaSurfaceFile.set(javaSurfaceFile)
-                    dependsOn(TASK_GEN_JAVA_API_SURFACE)
+                    dependsOn(target.tasks.matching { it.name == TASK_GEN_JAVA_API_SURFACE })
                 } else {
                     logger.info(
                         "No Java API layout plugin found, skipping API surface" +
@@ -72,15 +72,16 @@ class ApiSurfacePlugin : Plugin<Project> {
             // Java API generation task does a clean-up of all files in the output
             // folder, so let it run first
             if (target.plugins.hasPlugin(GEN_JAVA_API_LAYOUT_PLUGIN)) {
+                val apiDumpTasks = target.tasks.matching { it.name == TASK_GEN_JAVA_API_SURFACE }
                 val isCi = target.providers.environmentVariable("CI").isPresent
                 if (isCi) {
                     // Java API generation wires to the release build type, so we can afford triggering compilation
                     // of release type locally when we run debug compilation, but we would like to avoid it on CI
                     if (name == "compileReleaseKotlin") {
-                        finalizedBy(TASK_GEN_JAVA_API_SURFACE)
+                        finalizedBy(apiDumpTasks)
                     }
                 } else {
-                    finalizedBy(TASK_GEN_JAVA_API_SURFACE)
+                    finalizedBy(apiDumpTasks)
                 }
             }
             finalizedBy(generateApiSurfaceTask)

buildSrc/src/main/kotlin/com/datadog/gradle/plugin/config/UnitTestConventionPlugin.kt

@@ -0,0 +1,40 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.gradle.plugin.config
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.getByType
+
+/**
+ * Convention plugin that wires the shared unit-test dependencies (JUnit 5 + the common test
+ * tooling bundle: elmyr, AssertJ, mockito-kotlin, …) onto a module's `test` source set.
+ *
+ * Apply with `plugins { id("datadog.unit-test") }`. This centralizes what used to be repeated as
+ * `testImplementation(libs.bundles.jUnit5)` / `testImplementation(libs.bundles.testTools)` in every
+ * module, so the declarations live in one place instead of being duplicated (and drifting) per module.
+ *
+ * Note: `kotlin-stdlib` is intentionally NOT declared here — the Kotlin plugin adds it to every
+ * source set automatically (`kotlin.stdlib.default.dependency`), so declaring it explicitly only
+ * produces "declared multiple times" warnings.
+ */
+class UnitTestConventionPlugin : Plugin<Project> {
+
+    override fun apply(target: Project) {
+        val libs = target.extensions.getByType<VersionCatalogsExtension>().named("libs")
+        BUNDLES.forEach { bundleName ->
+            libs.findBundle(bundleName).ifPresent { bundle ->
+                target.dependencies.addProvider("testImplementation", bundle)
+            }
+        }
+    }
+
+    private companion object {
+        val BUNDLES = listOf("jUnit5", "testTools")
+    }
+}