From 6d505df142b05d2bd076d07d78f288f3b7d35e88 Mon Sep 17 00:00:00 2001 From: Nelson Osacky Date: Thu, 2 Jul 2026 14:45:11 +0200 Subject: [PATCH] fix(auto-install): Pass install state via rule params (GRADLE-112) The auto-install component metadata rules read the resolved Sentry version and enabled flag from AutoInstallState, a process-global mutable singleton. Each project that applied the plugin wrote its own values into that shared instance during configuration, which breaks project isolation and could let one project observe another project's auto-install version. Resolve the version and enabled flag inside the implementation configuration's withDependencies hook and pass them to each rule as ComponentMetadataRule params, so the rules no longer depend on shared mutable state. Delete AutoInstallState and the per-build cleanup task the singleton required. Co-Authored-By: Claude Opus 4.8 --- CHANGELOG.md | 4 ++ .../autoinstall/AbstractInstallStrategy.kt | 17 ++--- .../android/gradle/autoinstall/AutoInstall.kt | 27 ++++---- .../gradle/autoinstall/AutoInstallState.kt | 63 ------------------- .../autoinstall/InstallStrategyRegistrar.kt | 6 +- .../compose/ComposeInstallStrategy.kt | 24 ++++--- .../fragment/FragmentInstallStrategy.kt | 21 +++++-- .../graphql/Graphql22InstallStrategy.kt | 21 +++++-- .../graphql/GraphqlInstallStrategy.kt | 21 +++++-- .../autoinstall/jdbc/JdbcInstallStrategy.kt | 45 ++++++++++--- .../kotlin/KotlinExtensionsInstallStrategy.kt | 21 +++++-- .../log4j2/Log4j2InstallStrategy.kt | 21 +++++-- .../logback/LogbackInstallStrategy.kt | 21 +++++-- .../okhttp/AndroidOkHttpInstallStrategy.kt | 21 +++++-- .../okhttp/OkHttpInstallStrategy.kt | 21 +++++-- .../override/WarnOnOverrideStrategy.kt | 28 ++++++--- .../quartz/QuartzInstallStrategy.kt | 21 +++++-- .../spring/Spring5InstallStrategy.kt | 21 +++++-- .../spring/Spring6InstallStrategy.kt | 21 +++++-- .../spring/Spring7InstallStrategy.kt | 21 +++++-- .../spring/SpringBoot2InstallStrategy.kt | 21 +++++-- .../spring/SpringBoot3InstallStrategy.kt | 21 +++++-- .../spring/SpringBoot4InstallStrategy.kt | 21 +++++-- .../sqlite/SQLiteInstallStrategy.kt | 21 +++++-- .../timber/TimberInstallStrategy.kt | 21 +++++-- .../AbstractInstallStrategyTest.kt | 6 +- .../compose/ComposeInstallStrategyTest.kt | 13 ++-- .../fragment/FragmentInstallStrategyTest.kt | 13 ++-- .../graphql/Graphql22InstallStrategyTest.kt | 17 ++--- .../graphql/GraphqlInstallStrategyTest.kt | 13 ++-- .../jdbc/JdbcInstallStrategyTest.kt | 13 ++-- .../KotlinExtensionsInstallStrategyTest.kt | 18 +++--- .../log4j2/Log4j2InstallStrategyTest.kt | 13 ++-- .../logback/LogbackInstallStrategyTest.kt | 13 ++-- .../AndroidOkHttpInstallStrategyTest.kt | 18 +++--- .../okhttp/OkHttpInstallStrategyTest.kt | 17 ++--- .../override/WarnOnOverrideStrategyTest.kt | 17 ++--- .../quartz/QuartzInstallStrategyTest.kt | 13 ++-- .../spring/Spring5InstallStrategyTest.kt | 13 ++-- .../spring/Spring6InstallStrategyTest.kt | 13 ++-- .../spring/Spring7InstallStrategyTest.kt | 13 ++-- .../spring/SpringBoot2InstallStrategyTest.kt | 17 ++--- .../spring/SpringBoot3InstallStrategyTest.kt | 17 ++--- .../spring/SpringBoot4InstallStrategyTest.kt | 17 ++--- .../sqlite/SqliteInstallStrategyTest.kt | 13 ++-- .../timber/TimberInstallStrategyTest.kt | 13 ++-- .../BaseSentryNonAndroidPluginTest.kt | 21 ------- .../integration/BaseSentryPluginTest.kt | 19 ------ 48 files changed, 548 insertions(+), 363 deletions(-) delete mode 100644 plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AutoInstallState.kt diff --git a/CHANGELOG.md b/CHANGELOG.md index 1f9de4512..73ed62c6c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +### Fixes + +- Pass auto-install state to component metadata rules instead of a global singleton, fixing project isolation ([#1352](https://github.com/getsentry/sentry-android-gradle-plugin/pull/1352)) + ### Dependencies - Bump Android SDK from v8.45.0 to v8.46.0 ([#1343](https://github.com/getsentry/sentry-android-gradle-plugin/pull/1343)) diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AbstractInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AbstractInstallStrategy.kt index 68a77ce4f..b65798997 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AbstractInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AbstractInstallStrategy.kt @@ -8,7 +8,10 @@ import org.gradle.api.artifacts.ComponentMetadataContext import org.gradle.api.artifacts.ComponentMetadataRule import org.slf4j.Logger -abstract class AbstractInstallStrategy : ComponentMetadataRule { +abstract class AbstractInstallStrategy( + private val autoInstallEnabled: Boolean, + private val sentryVersion: String, +) : ComponentMetadataRule { protected lateinit var logger: Logger @@ -23,8 +26,7 @@ abstract class AbstractInstallStrategy : ComponentMetadataRule { protected open val maxSupportedSentryVersion: SemVer = SemVer(0, 0, 0) override fun execute(context: ComponentMetadataContext) { - val autoInstallState = AutoInstallState.getInstance() - if (!autoInstallState.enabled) { + if (!autoInstallEnabled) { logger.info { "$sentryModuleId won't be installed because autoInstallation is disabled" } return } @@ -53,7 +55,7 @@ abstract class AbstractInstallStrategy : ComponentMetadataRule { if (minSupportedSentryVersion.major > 0) { try { - val sentrySemVersion = SemVer.parse(autoInstallState.sentryVersion) + val sentrySemVersion = SemVer.parse(sentryVersion) if (sentrySemVersion < minSupportedSentryVersion) { logger.warn { "$sentryModuleId won't be installed because the current sentry version " + @@ -65,7 +67,7 @@ abstract class AbstractInstallStrategy : ComponentMetadataRule { } catch (ex: IllegalArgumentException) { logger.warn { "$sentryModuleId won't be installed because the provided " + - "sentry version(${autoInstallState.sentryVersion}) could not be " + + "sentry version(${sentryVersion}) could not be " + "processed as a semantic version." } return @@ -74,7 +76,7 @@ abstract class AbstractInstallStrategy : ComponentMetadataRule { if (maxSupportedSentryVersion.major > 0) { try { - val sentrySemVersion = SemVer.parse(autoInstallState.sentryVersion) + val sentrySemVersion = SemVer.parse(sentryVersion) if (sentrySemVersion > maxSupportedSentryVersion) { logger.debug { "$sentryModuleId won't be installed because the current sentry version " + @@ -86,7 +88,7 @@ abstract class AbstractInstallStrategy : ComponentMetadataRule { } catch (ex: IllegalArgumentException) { logger.warn { "$sentryModuleId won't be installed because the provided " + - "sentry version(${autoInstallState.sentryVersion}) could not be " + + "sentry version(${sentryVersion}) could not be " + "processed as a semantic version." } return @@ -95,7 +97,6 @@ abstract class AbstractInstallStrategy : ComponentMetadataRule { context.details.allVariants { metadata -> metadata.withDependencies { dependencies -> - val sentryVersion = autoInstallState.sentryVersion dependencies.add("$SENTRY_GROUP:$sentryModuleId:$sentryVersion") logger.info { "$sentryModuleId was successfully installed with version: $sentryVersion" } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AutoInstall.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AutoInstall.kt index 642bee62a..f16214598 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AutoInstall.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AutoInstall.kt @@ -1,5 +1,6 @@ package io.sentry.android.gradle.autoinstall +import io.sentry.android.gradle.SentryPlugin.Companion.SENTRY_SDK_VERSION import io.sentry.android.gradle.autoinstall.compose.ComposeInstallStrategy import io.sentry.android.gradle.autoinstall.fragment.FragmentInstallStrategy import io.sentry.android.gradle.autoinstall.graphql.Graphql22InstallStrategy @@ -64,29 +65,31 @@ private val delayedStrategies = fun Project.installDependencies(extension: SentryPluginExtension, isAndroid: Boolean) { configurations.named("implementation").configure { configuration -> configuration.withDependencies { dependencies -> - project.dependencies.components { component -> - delayedStrategies.forEach { it.register(component) } - } + val autoInstallEnabled = extension.autoInstallation.enabled.get() - // if autoInstallation is disabled, the autoInstallState will contain initial values - // which all default to false, hence, the integrations won't be installed as well - if (extension.autoInstallation.enabled.get()) { - val sentryVersion = dependencies.findSentryVersion(isAndroid) - with(AutoInstallState.getInstance(gradle)) { + // The version and enabled flag are resolved here and passed to the component metadata rules + // as parameters, so the rules don't rely on shared mutable state across projects. + val sentryVersion = + if (autoInstallEnabled) { + val detectedVersion = dependencies.findSentryVersion(isAndroid) val sentryArtifactId = if (isAndroid) { SentryModules.SENTRY_ANDROID.name } else { SentryModules.SENTRY.name } - this.sentryVersion = - installSentrySdk(sentryVersion, dependencies, sentryArtifactId, extension) - this.enabled = true + installSentrySdk(detectedVersion, dependencies, sentryArtifactId, extension) + } else { + SENTRY_SDK_VERSION + } + + project.dependencies.components { component -> + (strategies + delayedStrategies).forEach { + it.register(component, autoInstallEnabled, sentryVersion) } } } } - project.dependencies.components { component -> strategies.forEach { it.register(component) } } } private fun Project.installSentrySdk( diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AutoInstallState.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AutoInstallState.kt deleted file mode 100644 index dd67bdabc..000000000 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/AutoInstallState.kt +++ /dev/null @@ -1,63 +0,0 @@ -package io.sentry.android.gradle.autoinstall - -import io.sentry.android.gradle.SentryPlugin.Companion.SENTRY_SDK_VERSION -import java.io.Serializable -import org.gradle.api.invocation.Gradle -import org.jetbrains.annotations.TestOnly - -class AutoInstallState private constructor() : Serializable { - - @get:Synchronized @set:Synchronized var sentryVersion: String = SENTRY_SDK_VERSION - - @get:Synchronized @set:Synchronized var enabled: Boolean = false - - override fun toString(): String { - return "AutoInstallState(sentryVersion='$sentryVersion', enabled=$enabled)" - } - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as AutoInstallState - - if (sentryVersion != other.sentryVersion) return false - return enabled == other.enabled - } - - override fun hashCode(): Int { - var result = sentryVersion.hashCode() - result = 31 * result + enabled.hashCode() - return result - } - - // We can't use Kotlin object because we need new instance on each Gradle rebuild - // But if we're inside Gradle daemon, Kotlin object will be shared between builds - companion object { - @field:Volatile private var instance: AutoInstallState? = null - - @JvmStatic - @Synchronized - fun getInstance(gradle: Gradle? = null): AutoInstallState { - if (instance != null) { - return instance!! - } - - val state = AutoInstallState() - instance = state - - if (gradle != null) { - BuildFinishedListenerService.getInstance(gradle).onClose { instance = null } - } - - return state - } - - @JvmStatic - @Synchronized - @TestOnly - fun clearReference() { - instance = null - } - } -} diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/InstallStrategyRegistrar.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/InstallStrategyRegistrar.kt index d81988639..42e4dc5f4 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/InstallStrategyRegistrar.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/InstallStrategyRegistrar.kt @@ -3,5 +3,9 @@ package io.sentry.android.gradle.autoinstall import org.gradle.api.artifacts.dsl.ComponentMetadataHandler interface InstallStrategyRegistrar { - fun register(component: ComponentMetadataHandler) + fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/compose/ComposeInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/compose/ComposeInstallStrategy.kt index 28638969d..bc3a55220 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/compose/ComposeInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/compose/ComposeInstallStrategy.kt @@ -10,13 +10,20 @@ import org.slf4j.Logger abstract class ComposeInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_COMPOSE_ID @@ -31,11 +38,14 @@ abstract class ComposeInstallStrategy : AbstractInstallStrategy { internal const val SENTRY_COMPOSE_ID = "sentry-compose-android" - override fun register(component: ComponentMetadataHandler) { - component.withModule( - "androidx.compose.runtime:runtime", - ComposeInstallStrategy::class.java, - ) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("androidx.compose.runtime:runtime", ComposeInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/fragment/FragmentInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/fragment/FragmentInstallStrategy.kt index 25babf782..a6100c2c1 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/fragment/FragmentInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/fragment/FragmentInstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule // TODO: make it cacheable somehow (probably depends on parameters) abstract class FragmentInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_FRAGMENT_ID @@ -30,8 +37,14 @@ abstract class FragmentInstallStrategy : AbstractInstallStrategy { private const val FRAGMENT_ID = "fragment" internal const val SENTRY_FRAGMENT_ID = "sentry-android-fragment" - override fun register(component: ComponentMetadataHandler) { - component.withModule("$FRAGMENT_GROUP:$FRAGMENT_ID", FragmentInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$FRAGMENT_GROUP:$FRAGMENT_ID", FragmentInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/graphql/Graphql22InstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/graphql/Graphql22InstallStrategy.kt index fb998f940..89bc6c243 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/graphql/Graphql22InstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/graphql/Graphql22InstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class Graphql22InstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_GRAPHQL_ID @@ -35,8 +42,14 @@ abstract class Graphql22InstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(22, 0, 0) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$GRAPHQL_GROUP:$GRAPHQL_ID", Graphql22InstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$GRAPHQL_GROUP:$GRAPHQL_ID", Graphql22InstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/graphql/GraphqlInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/graphql/GraphqlInstallStrategy.kt index 22aa1862d..c42684325 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/graphql/GraphqlInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/graphql/GraphqlInstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class GraphqlInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_GRAPHQL_ID @@ -37,8 +44,14 @@ abstract class GraphqlInstallStrategy : AbstractInstallStrategy { private val MAX_SUPPORTED_VERSION = SemVer(21, 9999, 9999) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$GRAPHQL_GROUP:$GRAPHQL_ID", GraphqlInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$GRAPHQL_GROUP:$GRAPHQL_ID", GraphqlInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/jdbc/JdbcInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/jdbc/JdbcInstallStrategy.kt index ac8bb724f..64bb283ac 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/jdbc/JdbcInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/jdbc/JdbcInstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class JdbcInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_JDBC_ID @@ -47,23 +54,41 @@ abstract class JdbcInstallStrategy : AbstractInstallStrategy { internal const val SENTRY_JDBC_ID = "sentry-jdbc" - override fun register(component: ComponentMetadataHandler) { - component.withModule("$SPRING_JDBC_GROUP:$SPRING_JDBC_ID", JdbcInstallStrategy::class.java) {} - component.withModule("$HSQL_GROUP:$HSQL_ID", JdbcInstallStrategy::class.java) {} - component.withModule("$MYSQL_GROUP:$MYSQL_ID", JdbcInstallStrategy::class.java) {} - component.withModule("$MARIADB_GROUP:$MARIADB_ID", JdbcInstallStrategy::class.java) {} - component.withModule("$POSTGRES_GROUP:$POSTGRES_ID", JdbcInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$SPRING_JDBC_GROUP:$SPRING_JDBC_ID", JdbcInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } + component.withModule("$HSQL_GROUP:$HSQL_ID", JdbcInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } + component.withModule("$MYSQL_GROUP:$MYSQL_ID", JdbcInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } + component.withModule("$MARIADB_GROUP:$MARIADB_ID", JdbcInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } + component.withModule("$POSTGRES_GROUP:$POSTGRES_ID", JdbcInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } (5..14).forEach { component.withModule( "$ORACLE_GROUP:$ORACLE_OJDBC_ID_PREFIX$it", JdbcInstallStrategy::class.java, - ) {} + ) { + it.params(autoInstallEnabled, sentryVersion) + } component.withModule( "$ORACLE_DATABASE_GROUP:$ORACLE_OJDBC_ID_PREFIX$it", JdbcInstallStrategy::class.java, - ) {} + ) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/kotlin/KotlinExtensionsInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/kotlin/KotlinExtensionsInstallStrategy.kt index 001299119..650a36fc4 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/kotlin/KotlinExtensionsInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/kotlin/KotlinExtensionsInstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class KotlinExtensionsInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_KOTLIN_EXTENSIONS_ID @@ -37,11 +44,17 @@ abstract class KotlinExtensionsInstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(1, 6, 1) - override fun register(component: ComponentMetadataHandler) { + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { component.withModule( "$KOTLINX_GROUP:$KOTLIN_COROUTINES_ID", KotlinExtensionsInstallStrategy::class.java, - ) {} + ) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/log4j2/Log4j2InstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/log4j2/Log4j2InstallStrategy.kt index 83747c8aa..14b16e159 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/log4j2/Log4j2InstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/log4j2/Log4j2InstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class Log4j2InstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_LOG4J2_ID @@ -35,8 +42,14 @@ abstract class Log4j2InstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(2, 0, 0) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$LOG4J2_GROUP:$LOG4J2_ID", Log4j2InstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$LOG4J2_GROUP:$LOG4J2_ID", Log4j2InstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/logback/LogbackInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/logback/LogbackInstallStrategy.kt index 9b5a7f309..9907f76a2 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/logback/LogbackInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/logback/LogbackInstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class LogbackInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_LOGBACK_ID @@ -35,8 +42,14 @@ abstract class LogbackInstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(1, 0, 0) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$LOGBACK_GROUP:$LOGBACK_ID", LogbackInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$LOGBACK_GROUP:$LOGBACK_ID", LogbackInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/okhttp/AndroidOkHttpInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/okhttp/AndroidOkHttpInstallStrategy.kt index 88fdde3c8..f57cce04f 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/okhttp/AndroidOkHttpInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/okhttp/AndroidOkHttpInstallStrategy.kt @@ -10,13 +10,20 @@ import org.slf4j.Logger abstract class AndroidOkHttpInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_ANDROID_OKHTTP_ID @@ -37,8 +44,14 @@ abstract class AndroidOkHttpInstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(3, 13, 0) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$OKHTTP_GROUP:$OKHTTP_ID", AndroidOkHttpInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$OKHTTP_GROUP:$OKHTTP_ID", AndroidOkHttpInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/okhttp/OkHttpInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/okhttp/OkHttpInstallStrategy.kt index d1dd8d6db..7592d12b6 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/okhttp/OkHttpInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/okhttp/OkHttpInstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class OkHttpInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_OKHTTP_ID @@ -35,8 +42,14 @@ abstract class OkHttpInstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(3, 13, 0) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$OKHTTP_GROUP:$OKHTTP_ID", OkHttpInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$OKHTTP_GROUP:$OKHTTP_ID", OkHttpInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/override/WarnOnOverrideStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/override/WarnOnOverrideStrategy.kt index 0a047673d..482f8635d 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/override/WarnOnOverrideStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/override/WarnOnOverrideStrategy.kt @@ -1,7 +1,6 @@ package io.sentry.android.gradle.autoinstall.override import io.sentry.android.gradle.SentryPlugin -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.autoinstall.InstallStrategyRegistrar import io.sentry.android.gradle.util.SemVer import io.sentry.android.gradle.util.SentryModules @@ -15,23 +14,28 @@ import org.slf4j.Logger abstract class WarnOnOverrideStrategy : ComponentMetadataRule { private var logger: Logger + private val autoInstallEnabled: Boolean + private val sentryVersion: String - constructor(logger: Logger) : super() { + constructor(autoInstallEnabled: Boolean, sentryVersion: String, logger: Logger) : super() { + this.autoInstallEnabled = autoInstallEnabled + this.sentryVersion = sentryVersion this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override fun execute(context: ComponentMetadataContext) { - val autoInstallState = AutoInstallState.getInstance() - - if (!autoInstallState.enabled) { + if (!autoInstallEnabled) { return } - val providedVersion = parseVersionSafely(autoInstallState.sentryVersion) ?: return + val providedVersion = parseVersionSafely(sentryVersion) ?: return val userVersion = parseVersionSafely(context.details.id.version) ?: return if (userVersion < providedVersion) { @@ -82,9 +86,15 @@ abstract class WarnOnOverrideStrategy : ComponentMetadataRule { SentryModules.SENTRY_SPRING_BOOT4, ) - override fun register(component: ComponentMetadataHandler) { + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { sentryModules.forEach { module -> - component.withModule(module.toString(), WarnOnOverrideStrategy::class.java) {} + component.withModule(module.toString(), WarnOnOverrideStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/quartz/QuartzInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/quartz/QuartzInstallStrategy.kt index 461efdd8f..eae4f413e 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/quartz/QuartzInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/quartz/QuartzInstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class QuartzInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_QUARTZ_ID @@ -30,8 +37,14 @@ abstract class QuartzInstallStrategy : AbstractInstallStrategy { private const val QUARTZ_ID = "quartz" internal const val SENTRY_QUARTZ_ID = "sentry-quartz" - override fun register(component: ComponentMetadataHandler) { - component.withModule("$QUARTZ_GROUP:$QUARTZ_ID", QuartzInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$QUARTZ_GROUP:$QUARTZ_ID", QuartzInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring5InstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring5InstallStrategy.kt index c69e89b26..0ba1fd807 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring5InstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring5InstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class Spring5InstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_SPRING_5_ID @@ -39,8 +46,14 @@ abstract class Spring5InstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(5, 1, 2) private val MAX_SUPPORTED_VERSION = SemVer(5, 9999, 9999) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$SPRING_GROUP:$SPRING_5_ID", Spring5InstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$SPRING_GROUP:$SPRING_5_ID", Spring5InstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring6InstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring6InstallStrategy.kt index ac1cdbfd3..809a0f9fa 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring6InstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring6InstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class Spring6InstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_SPRING_6_ID @@ -39,8 +46,14 @@ abstract class Spring6InstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(6, 0, 0) private val MAX_SUPPORTED_VERSION = SemVer(6, 9999, 9999) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$SPRING_GROUP:$SPRING_6_ID", Spring6InstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$SPRING_GROUP:$SPRING_6_ID", Spring6InstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring7InstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring7InstallStrategy.kt index ae64fc521..191014dcc 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring7InstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring7InstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class Spring7InstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_SPRING_7_ID @@ -39,8 +46,14 @@ abstract class Spring7InstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(7, 0, 0, "M1") private val MAX_SUPPORTED_VERSION = SemVer(7, 9999, 9999) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$SPRING_GROUP:$SPRING_7_ID", Spring7InstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$SPRING_GROUP:$SPRING_7_ID", Spring7InstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot2InstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot2InstallStrategy.kt index eccf06090..2138485b9 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot2InstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot2InstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class SpringBoot2InstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_SPRING_BOOT_2_ID @@ -39,11 +46,17 @@ abstract class SpringBoot2InstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(2, 1, 0) private val MAX_SUPPORTED_VERSION = SemVer(2, 9999, 9999) - override fun register(component: ComponentMetadataHandler) { + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { component.withModule( "$SPRING_GROUP:$SPRING_BOOT_2_ID", SpringBoot2InstallStrategy::class.java, - ) {} + ) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot3InstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot3InstallStrategy.kt index b0c384df3..2b2e861ca 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot3InstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot3InstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class SpringBoot3InstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_SPRING_BOOT_3_ID @@ -39,11 +46,17 @@ abstract class SpringBoot3InstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(3, 0, 0) private val MAX_SUPPORTED_VERSION = SemVer(3, 9999, 9999) - override fun register(component: ComponentMetadataHandler) { + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { component.withModule( "$SPRING_GROUP:$SPRING_BOOT_3_ID", SpringBoot3InstallStrategy::class.java, - ) {} + ) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot4InstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot4InstallStrategy.kt index 801c2cdde..ff3e42468 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot4InstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot4InstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class SpringBoot4InstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_SPRING_BOOT_4_ID @@ -39,11 +46,17 @@ abstract class SpringBoot4InstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(4, 0, 0, "M1") private val MAX_SUPPORTED_VERSION = SemVer(4, 9999, 9999) - override fun register(component: ComponentMetadataHandler) { + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { component.withModule( "$SPRING_GROUP:$SPRING_BOOT_4_ID", SpringBoot4InstallStrategy::class.java, - ) {} + ) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/sqlite/SQLiteInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/sqlite/SQLiteInstallStrategy.kt index 771dd317f..78527930a 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/sqlite/SQLiteInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/sqlite/SQLiteInstallStrategy.kt @@ -10,13 +10,20 @@ import org.slf4j.Logger abstract class SQLiteInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_SQLITE_ID @@ -34,8 +41,14 @@ abstract class SQLiteInstallStrategy : AbstractInstallStrategy { private val MIN_SUPPORTED_VERSION = SemVer(2, 0, 0) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$SQLITE_GROUP:$SQLITE_ID", SQLiteInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$SQLITE_GROUP:$SQLITE_ID", SQLiteInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/timber/TimberInstallStrategy.kt b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/timber/TimberInstallStrategy.kt index ff0b3a4fe..bcb8a6f64 100644 --- a/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/timber/TimberInstallStrategy.kt +++ b/plugin-build/src/main/kotlin/io/sentry/android/gradle/autoinstall/timber/TimberInstallStrategy.kt @@ -11,13 +11,20 @@ import org.slf4j.Logger // @CacheableRule abstract class TimberInstallStrategy : AbstractInstallStrategy { - constructor(logger: Logger) : super() { + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : super(autoInstallEnabled, sentryVersion) { this.logger = logger } @Suppress("unused") // used by Gradle @Inject // inject is needed to avoid Gradle error - constructor() : this(SentryPlugin.logger) + constructor( + autoInstallEnabled: Boolean, + sentryVersion: String, + ) : this(autoInstallEnabled, sentryVersion, SentryPlugin.logger) override val sentryModuleId: String get() = SENTRY_TIMBER_ID @@ -34,8 +41,14 @@ abstract class TimberInstallStrategy : AbstractInstallStrategy { internal const val SENTRY_TIMBER_ID = "sentry-android-timber" private val MIN_SUPPORTED_VERSION = SemVer(4, 6, 0) - override fun register(component: ComponentMetadataHandler) { - component.withModule("$TIMBER_GROUP:$TIMBER_ID", TimberInstallStrategy::class.java) {} + override fun register( + component: ComponentMetadataHandler, + autoInstallEnabled: Boolean, + sentryVersion: String, + ) { + component.withModule("$TIMBER_GROUP:$TIMBER_ID", TimberInstallStrategy::class.java) { + it.params(autoInstallEnabled, sentryVersion) + } } } } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/AbstractInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/AbstractInstallStrategyTest.kt index 6eb270d0d..a9a8fd5fb 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/AbstractInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/AbstractInstallStrategyTest.kt @@ -19,8 +19,7 @@ class AbstractInstallStrategyTest { mock { whenever(it.details).thenReturn(metadataDetails) } fun getSut(): AbstractInstallStrategy { - with(AutoInstallState.getInstance()) { this.enabled = false } - return RandomInstallStrategy(logger) + return RandomInstallStrategy(autoInstallEnabled = false, logger = logger) } } @@ -39,9 +38,10 @@ class AbstractInstallStrategyTest { } private class RandomInstallStrategy( + autoInstallEnabled: Boolean, logger: Logger, override val sentryModuleId: String = "random-module", - ) : AbstractInstallStrategy() { + ) : AbstractInstallStrategy(autoInstallEnabled, "0.0.0") { init { this.logger = logger } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/compose/ComposeInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/compose/ComposeInstallStrategyTest.kt index 6b02ae90b..78b772b15 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/compose/ComposeInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/compose/ComposeInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.compose -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -46,11 +45,7 @@ class ComposeInstallStrategyTest { val id = mock { whenever(it.version).doReturn(composeVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.7.0" - } - return ComposeInstallStrategyImpl(logger) + return ComposeInstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.7.0", logger) } } @@ -82,5 +77,9 @@ class ComposeInstallStrategyTest { .add(check { assertEquals("io.sentry:sentry-compose-android:6.7.0", it) }) } - private class ComposeInstallStrategyImpl(logger: Logger) : ComposeInstallStrategy(logger) + private class ComposeInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : ComposeInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/fragment/FragmentInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/fragment/FragmentInstallStrategyTest.kt index 2093732fb..230d596ec 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/fragment/FragmentInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/fragment/FragmentInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.fragment -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,7 @@ class FragmentInstallStrategyTest { val id = mock { whenever(it.version).doReturn("1.3.5") } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "5.6.1" - } - return FragmentInstallStrategyImpl(logger) + return FragmentInstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "5.6.1", logger) } } @@ -68,5 +63,9 @@ class FragmentInstallStrategyTest { .add(check { assertEquals("io.sentry:sentry-android-fragment:5.6.1", it) }) } - private class FragmentInstallStrategyImpl(logger: Logger) : FragmentInstallStrategy(logger) + private class FragmentInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : FragmentInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/graphql/Graphql22InstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/graphql/Graphql22InstallStrategyTest.kt index 228f22439..3ab03b831 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/graphql/Graphql22InstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/graphql/Graphql22InstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.graphql -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,11 @@ class Graphql22InstallStrategyTest { val id = mock { whenever(it.version).doReturn(graphqlVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "8.0.0" - } - return Graphql22InstallStrategyImpl(logger) + return Graphql22InstallStrategyImpl( + autoInstallEnabled = true, + sentryVersion = "8.0.0", + logger, + ) } } @@ -83,5 +82,9 @@ class Graphql22InstallStrategyTest { verify(fixture.metadataDetails, never()).allVariants(any()) } - private class Graphql22InstallStrategyImpl(logger: Logger) : Graphql22InstallStrategy(logger) + private class Graphql22InstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : Graphql22InstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/graphql/GraphqlInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/graphql/GraphqlInstallStrategyTest.kt index 7019d7630..728bdab7c 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/graphql/GraphqlInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/graphql/GraphqlInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.graphql -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,7 @@ class GraphqlInstallStrategyTest { val id = mock { whenever(it.version).doReturn(graphqlVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.25.2" - } - return GraphqlInstallStrategyImpl(logger) + return GraphqlInstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.25.2", logger) } } @@ -81,5 +76,9 @@ class GraphqlInstallStrategyTest { verify(fixture.metadataDetails, never()).allVariants(any()) } - private class GraphqlInstallStrategyImpl(logger: Logger) : GraphqlInstallStrategy(logger) + private class GraphqlInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : GraphqlInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/jdbc/JdbcInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/jdbc/JdbcInstallStrategyTest.kt index 7e1582f0c..e309dc0d6 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/jdbc/JdbcInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/jdbc/JdbcInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.jdbc -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -44,11 +43,7 @@ class JdbcInstallStrategyTest { val id = mock { whenever(it.version).doReturn(jdbcVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.21.0" - } - return JdbcInstallStrategyImpl(logger) + return JdbcInstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.21.0", logger) } } @@ -67,5 +62,9 @@ class JdbcInstallStrategyTest { .add(org.mockito.kotlin.check { assertEquals("io.sentry:sentry-jdbc:6.21.0", it) }) } - private class JdbcInstallStrategyImpl(logger: Logger) : JdbcInstallStrategy(logger) + private class JdbcInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : JdbcInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/kotlin/KotlinExtensionsInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/kotlin/KotlinExtensionsInstallStrategyTest.kt index 9ca671134..bc024258a 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/kotlin/KotlinExtensionsInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/kotlin/KotlinExtensionsInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.kotlin -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -46,11 +45,11 @@ class KotlinExtensionsInstallStrategyTest { mock { whenever(it.version).doReturn(kotlinExtensionsVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.25.2" - } - return KotlinExtensionsInstallStrategyImpl(logger) + return KotlinExtensionsInstallStrategyImpl( + autoInstallEnabled = true, + sentryVersion = "6.25.2", + logger, + ) } } @@ -86,6 +85,9 @@ class KotlinExtensionsInstallStrategyTest { ) } - private class KotlinExtensionsInstallStrategyImpl(logger: Logger) : - KotlinExtensionsInstallStrategy(logger) + private class KotlinExtensionsInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : KotlinExtensionsInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/log4j2/Log4j2InstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/log4j2/Log4j2InstallStrategyTest.kt index 181468f21..dac1c2ede 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/log4j2/Log4j2InstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/log4j2/Log4j2InstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.log4j2 -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,7 @@ class Log4j2InstallStrategyTest { val id = mock { whenever(it.version).doReturn(log4j2Version) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.25.2" - } - return Log4j2InstallStrategyImpl(logger) + return Log4j2InstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.25.2", logger) } } @@ -81,5 +76,9 @@ class Log4j2InstallStrategyTest { .add(org.mockito.kotlin.check { assertEquals("io.sentry:sentry-log4j2:6.25.2", it) }) } - private class Log4j2InstallStrategyImpl(logger: Logger) : Log4j2InstallStrategy(logger) + private class Log4j2InstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : Log4j2InstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/logback/LogbackInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/logback/LogbackInstallStrategyTest.kt index e278b566b..86d6e8f6a 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/logback/LogbackInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/logback/LogbackInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.logback -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,7 @@ class LogbackInstallStrategyTest { val id = mock { whenever(it.version).doReturn(logbackVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.25.2" - } - return LogbackInstallStrategyImpl(logger) + return LogbackInstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.25.2", logger) } } @@ -81,5 +76,9 @@ class LogbackInstallStrategyTest { .add(org.mockito.kotlin.check { assertEquals("io.sentry:sentry-logback:6.25.2", it) }) } - private class LogbackInstallStrategyImpl(logger: Logger) : LogbackInstallStrategy(logger) + private class LogbackInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : LogbackInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/okhttp/AndroidOkHttpInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/okhttp/AndroidOkHttpInstallStrategyTest.kt index b71c65c91..3c71de084 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/okhttp/AndroidOkHttpInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/okhttp/AndroidOkHttpInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.okhttp -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -49,11 +48,11 @@ class AndroidOkHttpInstallStrategyTest { val id = mock { whenever(it.version).doReturn(okHttpVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = sentryVersion - } - return AndroidOkHttpInstallStrategyImpl(logger) + return AndroidOkHttpInstallStrategyImpl( + autoInstallEnabled = true, + sentryVersion = sentryVersion, + logger, + ) } } @@ -98,6 +97,9 @@ class AndroidOkHttpInstallStrategyTest { .add(check { assertEquals("io.sentry:sentry-android-okhttp:5.6.1", it) }) } - private class AndroidOkHttpInstallStrategyImpl(logger: Logger) : - AndroidOkHttpInstallStrategy(logger) + private class AndroidOkHttpInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : AndroidOkHttpInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/okhttp/OkHttpInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/okhttp/OkHttpInstallStrategyTest.kt index 0b6a7c58b..4fa1d86b9 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/okhttp/OkHttpInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/okhttp/OkHttpInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.okhttp -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -49,11 +48,11 @@ class OkHttpInstallStrategyTest { val id = mock { whenever(it.version).doReturn(okHttpVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = sentryVersion - } - return OkHttpInstallStrategyImpl(logger) + return OkHttpInstallStrategyImpl( + autoInstallEnabled = true, + sentryVersion = sentryVersion, + logger, + ) } } @@ -98,5 +97,9 @@ class OkHttpInstallStrategyTest { .add(check { assertEquals("io.sentry:sentry-okhttp:7.0.0", it) }) } - private class OkHttpInstallStrategyImpl(logger: Logger) : OkHttpInstallStrategy(logger) + private class OkHttpInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : OkHttpInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/override/WarnOnOverrideStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/override/WarnOnOverrideStrategyTest.kt index 444f032f3..43ce8136c 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/override/WarnOnOverrideStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/override/WarnOnOverrideStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.override -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import io.sentry.android.gradle.util.SentryModules import kotlin.test.assertNull @@ -35,11 +34,11 @@ class WarnOnOverrideStrategyTest { } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = enabled - this.sentryVersion = "6.34.0" - } - return WarnOnOverrideStrategyImpl(logger) + return WarnOnOverrideStrategyImpl( + autoInstallEnabled = enabled, + sentryVersion = "6.34.0", + logger, + ) } } @@ -83,5 +82,9 @@ class WarnOnOverrideStrategyTest { } } - private class WarnOnOverrideStrategyImpl(logger: Logger) : WarnOnOverrideStrategy(logger) + private class WarnOnOverrideStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : WarnOnOverrideStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/quartz/QuartzInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/quartz/QuartzInstallStrategyTest.kt index 5fd835650..7aabd51e3 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/quartz/QuartzInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/quartz/QuartzInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.quartz -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -44,11 +43,7 @@ class QuartzInstallStrategyTest { val id = mock { whenever(it.version).doReturn(quartzVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.30.0" - } - return QuartzInstallStrategyImpl(logger) + return QuartzInstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.30.0", logger) } } @@ -67,5 +62,9 @@ class QuartzInstallStrategyTest { .add(org.mockito.kotlin.check { assertEquals("io.sentry:sentry-quartz:6.30.0", it) }) } - private class QuartzInstallStrategyImpl(logger: Logger) : QuartzInstallStrategy(logger) + private class QuartzInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : QuartzInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring5InstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring5InstallStrategyTest.kt index 51c57f3e9..8bd0ccec6 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring5InstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring5InstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.spring -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,7 @@ class Spring5InstallStrategyTest { val id = mock { whenever(it.version).doReturn(springVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.21.0" - } - return Spring5InstallStrategyImpl(logger) + return Spring5InstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.21.0", logger) } } @@ -94,5 +89,9 @@ class Spring5InstallStrategyTest { .add(org.mockito.kotlin.check { assertEquals("io.sentry:sentry-spring:6.21.0", it) }) } - private class Spring5InstallStrategyImpl(logger: Logger) : Spring5InstallStrategy(logger) + private class Spring5InstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : Spring5InstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring6InstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring6InstallStrategyTest.kt index 5e9ba3ff5..af944810a 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring6InstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring6InstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.spring -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,7 @@ class Spring6InstallStrategyTest { val id = mock { whenever(it.version).doReturn(springVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.21.0" - } - return Spring6InstallStrategyImpl(logger) + return Spring6InstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.21.0", logger) } } @@ -98,5 +93,9 @@ class Spring6InstallStrategyTest { ) } - private class Spring6InstallStrategyImpl(logger: Logger) : Spring6InstallStrategy(logger) + private class Spring6InstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : Spring6InstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring7InstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring7InstallStrategyTest.kt index f4928f0ae..16c21649b 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring7InstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/Spring7InstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.spring -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,7 @@ class Spring7InstallStrategyTest { val id = mock { whenever(it.version).doReturn(springVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "8.21.0" - } - return Spring7InstallStrategyImpl(logger) + return Spring7InstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "8.21.0", logger) } } @@ -96,5 +91,9 @@ class Spring7InstallStrategyTest { ) } - private class Spring7InstallStrategyImpl(logger: Logger) : Spring7InstallStrategy(logger) + private class Spring7InstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : Spring7InstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot2InstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot2InstallStrategyTest.kt index 755b99145..36a47e473 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot2InstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot2InstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.spring -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,11 @@ class SpringBoot2InstallStrategyTest { val id = mock { whenever(it.version).doReturn(springVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.28.0" - } - return SpringBoot2InstallStrategyImpl(logger) + return SpringBoot2InstallStrategyImpl( + autoInstallEnabled = true, + sentryVersion = "6.28.0", + logger, + ) } } @@ -96,5 +95,9 @@ class SpringBoot2InstallStrategyTest { ) } - private class SpringBoot2InstallStrategyImpl(logger: Logger) : SpringBoot2InstallStrategy(logger) + private class SpringBoot2InstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : SpringBoot2InstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot3InstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot3InstallStrategyTest.kt index 06cdac6d8..926b85095 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot3InstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot3InstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.spring -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,11 @@ class SpringBoot3InstallStrategyTest { val id = mock { whenever(it.version).doReturn(springVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.28.0" - } - return SpringBoot3InstallStrategyImpl(logger) + return SpringBoot3InstallStrategyImpl( + autoInstallEnabled = true, + sentryVersion = "6.28.0", + logger, + ) } } @@ -98,5 +97,9 @@ class SpringBoot3InstallStrategyTest { ) } - private class SpringBoot3InstallStrategyImpl(logger: Logger) : SpringBoot3InstallStrategy(logger) + private class SpringBoot3InstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : SpringBoot3InstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot4InstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot4InstallStrategyTest.kt index 4a06ab0ea..f94e05fdf 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot4InstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/spring/SpringBoot4InstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.spring -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,11 @@ class SpringBoot4InstallStrategyTest { val id = mock { whenever(it.version).doReturn(springVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "8.21.0" - } - return SpringBoot4InstallStrategyImpl(logger) + return SpringBoot4InstallStrategyImpl( + autoInstallEnabled = true, + sentryVersion = "8.21.0", + logger, + ) } } @@ -132,5 +131,9 @@ class SpringBoot4InstallStrategyTest { ) } - private class SpringBoot4InstallStrategyImpl(logger: Logger) : SpringBoot4InstallStrategy(logger) + private class SpringBoot4InstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : SpringBoot4InstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/sqlite/SqliteInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/sqlite/SqliteInstallStrategyTest.kt index d7c1adb4a..6b9df3feb 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/sqlite/SqliteInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/sqlite/SqliteInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.sqlite -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -45,11 +44,7 @@ class SqliteInstallStrategyTest { val id = mock { whenever(it.version).doReturn(sqliteVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "6.21.0" - } - return SQLiteInstallStrategyImpl(logger) + return SQLiteInstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "6.21.0", logger) } } @@ -85,5 +80,9 @@ class SqliteInstallStrategyTest { ) } - private class SQLiteInstallStrategyImpl(logger: Logger) : SQLiteInstallStrategy(logger) + private class SQLiteInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : SQLiteInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/timber/TimberInstallStrategyTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/timber/TimberInstallStrategyTest.kt index 6fce8c637..e9be01cab 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/timber/TimberInstallStrategyTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/autoinstall/timber/TimberInstallStrategyTest.kt @@ -1,6 +1,5 @@ package io.sentry.android.gradle.autoinstall.timber -import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.instrumentation.fakes.CapturingTestLogger import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -46,11 +45,7 @@ class TimberInstallStrategyTest { val id = mock { whenever(it.version).doReturn(timberVersion) } whenever(metadataDetails.id).thenReturn(id) - with(AutoInstallState.getInstance()) { - this.enabled = true - this.sentryVersion = "5.6.1" - } - return TimberInstallStrategyImpl(logger) + return TimberInstallStrategyImpl(autoInstallEnabled = true, sentryVersion = "5.6.1", logger) } } @@ -82,5 +77,9 @@ class TimberInstallStrategyTest { .add(check { assertEquals("io.sentry:sentry-android-timber:5.6.1", it) }) } - private class TimberInstallStrategyImpl(logger: Logger) : TimberInstallStrategy(logger) + private class TimberInstallStrategyImpl( + autoInstallEnabled: Boolean, + sentryVersion: String, + logger: Logger, + ) : TimberInstallStrategy(autoInstallEnabled, sentryVersion, logger) } diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/integration/BaseSentryNonAndroidPluginTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/integration/BaseSentryNonAndroidPluginTest.kt index 00560ba79..cc66b1dc1 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/integration/BaseSentryNonAndroidPluginTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/integration/BaseSentryNonAndroidPluginTest.kt @@ -7,7 +7,6 @@ import java.io.OutputStreamWriter import org.gradle.testkit.runner.GradleRunner import org.gradle.testkit.runner.internal.PluginUnderTestMetadataReading import org.gradle.testkit.runner.internal.io.SynchronizedOutputStream -import org.junit.After import org.junit.Before import org.junit.Rule import org.junit.rules.TemporaryFolder @@ -53,7 +52,6 @@ abstract class BaseSentryNonAndroidPluginTest(private val gradleVersion: String) testProjectDir.writeFile("build.gradle") { // language=Groovy """ - import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.util.GradleVersions buildscript { @@ -79,16 +77,6 @@ abstract class BaseSentryNonAndroidPluginTest(private val gradleVersion: String) } } - subprojects { - pluginManager.withPlugin('io.sentry.jvm.gradle') { - tasks.register('cleanupAutoInstallState') { - doLast { - AutoInstallState.clearReference() - } - } - } - } - // unlock transforms because we're running tests in parallel therefore they may conflict print(providers.exec { commandLine 'find', project.gradle.gradleUserHomeDir, '-type', 'f', '-name', 'transforms-3.lock', '-delete' @@ -108,15 +96,6 @@ abstract class BaseSentryNonAndroidPluginTest(private val gradleVersion: String) .forwardStdError(writer) } - @After - fun teardown() { - try { - runner.appendArguments("app:cleanupAutoInstallState").build() - } catch (ignored: Throwable) { - // may fail if we are relying on BuildFinishesListener, but we don't care here - } - } - companion object { internal fun GradleRunner.appendArguments(vararg arguments: String) = diff --git a/plugin-build/src/test/kotlin/io/sentry/android/gradle/integration/BaseSentryPluginTest.kt b/plugin-build/src/test/kotlin/io/sentry/android/gradle/integration/BaseSentryPluginTest.kt index fc65d7c91..1cd50c656 100644 --- a/plugin-build/src/test/kotlin/io/sentry/android/gradle/integration/BaseSentryPluginTest.kt +++ b/plugin-build/src/test/kotlin/io/sentry/android/gradle/integration/BaseSentryPluginTest.kt @@ -7,7 +7,6 @@ import java.io.OutputStreamWriter import org.gradle.testkit.runner.GradleRunner import org.gradle.testkit.runner.internal.PluginUnderTestMetadataReading import org.gradle.testkit.runner.internal.io.SynchronizedOutputStream -import org.junit.After import org.junit.Before import org.junit.Rule import org.junit.rules.TemporaryFolder @@ -52,7 +51,6 @@ abstract class BaseSentryPluginTest( testProjectDir.writeFile("build.gradle") { // language=Groovy """ - import io.sentry.android.gradle.autoinstall.AutoInstallState import io.sentry.android.gradle.util.GradleVersions import org.gradle.util.internal.VersionNumber @@ -111,14 +109,6 @@ abstract class BaseSentryPluginTest( $additionalRootProjectConfig } } - - pluginManager.withPlugin('io.sentry.android.gradle') { - tasks.register('cleanupAutoInstallState') { - doLast { - AutoInstallState.clearReference() - } - } - } } """ .trimIndent() @@ -158,15 +148,6 @@ abstract class BaseSentryPluginTest( } } - @After - fun teardown() { - try { - runner.withArguments("app:cleanupAutoInstallState").build() - } catch (ignored: Throwable) { - // may fail if we are relying on BuildFinishesListener, but we don't care here - } - } - companion object { internal fun GradleRunner.appendArguments(vararg arguments: String) =