fix(telemetry): Resolve default org via ValueSource at execution (GRADLE-82) (#1263)

* fix(telemetry): Resolve default org via ValueSource at execution (GRADLE-82)

When telemetry is enabled (the default), the plugin resolved the default
Sentry organization and CLI version at configuration time via two
ValueSources that each spawned a sentry-cli process. Because they were
`.get()`-ed during configuration, Gradle tracked them as configuration
inputs and re-ran both processes on every configuration-cache-hit build,
adding significant overhead even when no Sentry task executed.

Replace them with a single SentryOrgValueSource that is queried lazily on
the first tracked task, so the sentry-cli process runs during execution
and stays off the configuration phase. The CLI version now comes
straight from BuildConfig.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* docs(changelog): Add entry for telemetry org lookup fix (GRADLE-82)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* ref(telemetry): Guard default-org attach with AtomicBoolean

attachDefaultOrg() runs on the first tracked task and may be invoked
concurrently from parallel task threads. Replace the plain Boolean flag
and its check-then-set with an AtomicBoolean compareAndSet so the attach
body runs exactly once and the flag's visibility is guaranteed across
threads.

This is a robustness tightening, not a fix for duplicate sentry-cli
processes: the process is spawned inside the SentryOrgValueSource, which
Gradle evaluates at most once per build regardless of this flag.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: runningcode

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - Resolve the sentry-cli path as a task input instead of memoizing it in a static field, fixing stale-path build failures when switching branches with the configuration cache enabled ([#1264](https://github.com/getsentry/sentry-android-gradle-plugin/pull/1264))
   - This fixed the issue where sentry-cli could not be found (`A problem occurred starting process 'command  ../sentry-cliXXX.exe'`)
+- Defer the telemetry default-org lookup to execution time so the configuration cache no longer re-runs `sentry-cli` on every build ([#1263](https://github.com/getsentry/sentry-android-gradle-plugin/pull/1263))
 
 ## 6.10.0
 

plugin-build/src/main/kotlin/io/sentry/android/gradle/AndroidComponentsConfig.kt

@@ -83,7 +83,7 @@ fun ApplicationAndroidComponentsExtension.configure(
     if (isVariantAllowed(extension, variant.name, variant.flavorName, variant.buildType)) {
       val paths = OutputPaths(project, variant.name)
       val sentryTelemetryProvider =
-        variant.configureTelemetry(project, extension, cliExecutable, sentryOrg, buildEvents)
+        variant.configureTelemetry(project, extension, sentryOrg, buildEvents)
 
       variant.configureDependenciesTask(project, extension, sentryTelemetryProvider)
 
@@ -265,22 +265,14 @@ fun ApplicationAndroidComponentsExtension.configure(
 private fun Variant.configureTelemetry(
   project: Project,
   extension: SentryPluginExtension,
-  cliExecutable: Provider<String>,
   sentryOrg: String?,
   buildEvents: BuildEventListenerRegistryInternal,
 ): Provider<SentryTelemetryService> {
   val variant = AndroidVariant74(this)
   val sentryTelemetryProvider = SentryTelemetryService.register(project)
   project.gradle.taskGraph.whenReady {
     sentryTelemetryProvider.get().start {
-      SentryTelemetryService.createParameters(
-        project,
-        variant,
-        extension,
-        cliExecutable,
-        sentryOrg,
-        "Android",
-      )
+      SentryTelemetryService.createParameters(project, variant, extension, sentryOrg, "Android")
     }
     buildEvents.onOperationCompletion(sentryTelemetryProvider)
   }

plugin-build/src/main/kotlin/io/sentry/android/gradle/SentryCliProvider.kt

@@ -13,14 +13,17 @@ import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.util.Locale
 import java.util.Properties
+import java.util.concurrent.TimeUnit
 import org.gradle.api.Project
 import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.RegularFile
+import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.provider.ValueSource
 import org.gradle.api.provider.ValueSourceParameters
 import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Optional
 
 internal object SentryCliProvider {
 
@@ -196,3 +199,90 @@ private fun Project.getIsolatedRootProjectDir(): Directory {
     rootProject.layout.projectDirectory
   }
 }
+
+/**
+ * Resolves the default Sentry organization by running `sentry-cli info`. Implemented as a
+ * ValueSource so the external process is started in a configuration-cache compatible way; querying
+ * the returned provider during task execution keeps the process off the configuration phase.
+ */
+abstract class SentryOrgValueSource : ValueSource<String, SentryOrgValueSource.Params> {
+  interface Params : ValueSourceParameters {
+    @get:Input val projectDir: DirectoryProperty
+
+    @get:Input val projectBuildDir: DirectoryProperty
+
+    @get:Input val rootProjDir: DirectoryProperty
+
+    @get:Input @get:Optional val url: Property<String>
+
+    @get:Input @get:Optional val authToken: Property<String>
+
+    @get:Input @get:Optional val propertiesFilePath: Property<String>
+  }
+
+  override fun obtain(): String? {
+    return try {
+      val cliPath =
+        SentryCliProvider.getSentryCliPath(
+          parameters.projectDir,
+          parameters.projectBuildDir,
+          parameters.rootProjDir,
+        )
+      val resolvedCli =
+        SentryCliProvider.maybeExtractFromResources(parameters.projectBuildDir, cliPath)
+
+      val args = mutableListOf(resolvedCli)
+      parameters.url.orNull?.let {
+        args.add("--url")
+        args.add(it)
+      }
+      args.add("--log-level=error")
+      args.add("info")
+
+      val processBuilder = ProcessBuilder(args).redirectErrorStream(true)
+      parameters.propertiesFilePath.orNull?.let {
+        processBuilder.environment()["SENTRY_PROPERTIES"] = it
+      }
+      parameters.authToken.orNull?.let { processBuilder.environment()["SENTRY_AUTH_TOKEN"] = it }
+      processBuilder.environment()["SENTRY_PIPELINE"] =
+        "sentry-gradle-plugin/${BuildConfig.Version}"
+
+      val process = processBuilder.start()
+      // Wait with the timeout before reading the output: reading first would block indefinitely if
+      // the process hangs (e.g. a network stall), bypassing the timeout. `info` output is small and
+      // bounded, so it cannot fill the pipe buffer and stall the process before we read it here.
+      if (!process.waitFor(CLI_INFO_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
+        process.destroyForcibly()
+        return null
+      }
+      if (process.exitValue() != 0) {
+        return null
+      }
+      val output = process.inputStream.bufferedReader().readText()
+      ORG_REGEX.find(output)?.groupValues?.getOrNull(1)?.takeUnless { it == "-" }
+    } catch (t: Throwable) {
+      logger.info { "Failed to fetch default org from sentry-cli: ${t.message}" }
+      null
+    }
+  }
+
+  companion object {
+    private val ORG_REGEX = Regex("""(?m)Default Organization: (.*)$""")
+    private const val CLI_INFO_TIMEOUT_SECONDS = 5L
+  }
+}
+
+fun Project.defaultOrgProvider(
+  url: String?,
+  authToken: String?,
+  propertiesFilePath: String?,
+): Provider<String> {
+  return providers.of(SentryOrgValueSource::class.java) {
+    it.parameters.projectDir.set(layout.projectDirectory)
+    it.parameters.projectBuildDir.set(layout.buildDirectory)
+    it.parameters.rootProjDir.set(getIsolatedRootProjectDir())
+    url?.let { value -> it.parameters.url.set(value) }
+    authToken?.let { value -> it.parameters.authToken.set(value) }
+    propertiesFilePath?.let { value -> it.parameters.propertiesFilePath.set(value) }
+  }
+}