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) =