Avoid multiple finalizations of generalConfigurationMetrics

Removed the finalization of BuildFusService.generalConfigurationMetrics
in FinalizeConfigurationFusMetricAction to prevent the repeated
finalization that could occur with each sub-project.

#KT-73842 Verification Pending

Author: nav-nav

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/FusStatisticsIT.kt

@@ -18,6 +18,7 @@ import kotlin.io.path.deleteIfExists
 import kotlin.io.path.writeText
 import kotlin.io.path.deleteRecursively
 import kotlin.io.path.listDirectoryEntries
+import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 @DisplayName("FUS statistic")
@@ -515,7 +516,8 @@ class FusStatisticsIT : KGPBaseTest() {
                 |        }
                 |    }
                 |}
-                """.trimMargin())
+                """.trimMargin()
+            )
 
             build("linkDebugExecutableHost", "-Pkotlin.session.logger.root.path=$projectPath") {
                 assertFileContains(
@@ -537,13 +539,60 @@ class FusStatisticsIT : KGPBaseTest() {
         //Test uses deprecated Gradle features
         project("multiplatformFlowAction", gradleVersion, buildOptions = defaultBuildOptions.copy(warningMode = WarningMode.Summary)) {
             buildScriptInjection {
-                project.tasks.register("doNothing"){}
+                project.tasks.register("doNothing") {}
             }
-
             build("doNothing")
         }
     }
 
+    @DisplayName("add configuration metrics after build was finish")
+    @GradleTest
+    @JvmGradlePluginTests
+    @GradleTestVersions(
+        minVersion = TestVersions.Gradle.G_8_2,
+    )
+    fun concurrencyModificationExceptionTest(gradleVersion: GradleVersion) {
+        val rounds = 100
+        project(
+            "multiClassloaderProject", gradleVersion,
+        ) {
+            repeat(rounds) {
+                build(
+                    "compileKotlin", "-Pkotlin.session.logger.root.path=$projectPath", "-Dorg.gradle.parallel=true",
+                    buildOptions = defaultBuildOptions.copy(
+                        buildReport = listOf(BuildReportType.FILE),
+                        isolatedProjects = IsolatedProjectsMode.ENABLED,
+                    ),
+                ) {
+                    assertOutputDoesNotContain("BuildFusService was not registered")
+                }
+
+                build("clean", buildOptions = buildOptions)
+            }
+
+            val fusReports = baseFusStatisticsDirectory.listDirectoryEntries()
+            assertEquals(getExpectedFusFilesCount(gradleVersion, rounds), fusReports.size)
+
+            fusReports.forEach { path ->
+                assertFileContains(
+                    path,
+                    "CONFIGURATION_IMPLEMENTATION_COUNT",
+                    "NUMBER_OF_SUBPROJECTS",
+                )
+            }
+        }
+    }
+
+    private fun getExpectedFusFilesCount(gradleVersion: GradleVersion, rounds: Int): Int {
+        val expectedFiles = if (gradleVersion >= GradleVersion.version(TestVersions.Gradle.G_8_9)) {
+            //every submodule will create a separate file. There are two modules in the project
+            rounds * 2
+        } else {
+            rounds
+        }
+        return expectedFiles
+    }
+
     private fun TestProject.applyDokka(version: String) {
         buildGradle.replaceText(
             "plugins {",

libraries/tools/kotlin-gradle-plugin/api/all/kotlin-gradle-plugin.api

@@ -1997,6 +1997,7 @@ public abstract interface class org/jetbrains/kotlin/gradle/plugin/statistics/Bu
 	public abstract fun getBuildId ()Lorg/gradle/api/provider/Property;
 	public abstract fun getBuildStatisticsConfiguration ()Lorg/gradle/api/provider/Property;
 	public abstract fun getGeneralConfigurationMetrics ()Lorg/gradle/api/provider/Property;
+	public abstract fun getGeneralMetricsFinalized ()Lorg/gradle/api/provider/Property;
 }
 
 public abstract class org/jetbrains/kotlin/gradle/plugin/statistics/CloseActionBuildFusService : org/jetbrains/kotlin/gradle/plugin/statistics/BuildFusService {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/statistics/BuildFusService.kt

@@ -58,6 +58,7 @@ abstract class BuildFusService<T : BuildFusService.Parameters> :
     }
 
     interface Parameters : BuildServiceParameters {
+        val generalMetricsFinalized: Property<Boolean>
         val generalConfigurationMetrics: Property<MetricContainer>
         val buildStatisticsConfiguration: Property<KotlinBuildStatsConfiguration>
         val buildId: Property<String>
@@ -83,6 +84,18 @@ abstract class BuildFusService<T : BuildFusService.Parameters> :
         internal val serviceName = "${BuildFusService::class.simpleName}_${BuildFusService::class.java.classLoader.hashCode()}"
         private var buildStartTime: Long = System.currentTimeMillis()
 
+        internal fun getBuildFusService(project: Project) =
+            if (project.buildServiceShouldBeCreated) {
+                project.gradle.sharedServices.registrations.findByName(serviceName).also {
+                    if (it == null) {
+                        project.logger.info("BuildFusService was not registered")
+                    }
+                }
+            } else {
+                null
+            }
+
+
         fun registerIfAbsent(project: Project, pluginVersion: String, buildUidService: Provider<BuildUidService>) =
             if (project.buildServiceShouldBeCreated) {
                 registerIfAbsentImpl(project, pluginVersion, buildUidService).also { serviceProvider ->
@@ -224,4 +237,13 @@ class MetricContainer : Serializable {
 }
 
 private val Project.buildServiceShouldBeCreated
-    get() = !isInIdeaSync.get() && kotlinPropertiesProvider.enableFusMetricsCollection
+    get() = !isInIdeaSync.get() && kotlinPropertiesProvider.enableFusMetricsCollection
+
+internal fun BuildFusService.Parameters.finalizeGeneralConfigurationMetrics() {
+    if (generalMetricsFinalized.get()) return
+    synchronized(this) {
+        if (generalMetricsFinalized.get()) return
+        generalMetricsFinalized.set(true)
+        generalConfigurationMetrics.finalizeValue()
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/statistics/CloseActionBuildFusService.kt

@@ -20,6 +20,7 @@ abstract class CloseActionBuildFusService:
         ): Provider<CloseActionBuildFusService> {
             return project.gradle.sharedServices.registerIfAbsent(serviceName, CloseActionBuildFusService::class.java) { spec ->
                 spec.parameters.generalConfigurationMetrics.set(generalConfigurationMetricsProvider)
+                spec.parameters.generalMetricsFinalized.set(false)
                 spec.parameters.buildStatisticsConfiguration.set(KotlinBuildStatsConfiguration(project))
                 spec.parameters.buildId.value(buildUidService.map { it.buildId }).disallowChanges()
                 //init value to avoid `java.lang.IllegalStateException: GradleScopeServices has been closed` exception on close

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/statistics/ConfigurationMetricParameterFlowActionBuildFusService.kt

@@ -23,6 +23,7 @@ abstract class ConfigurationMetricParameterFlowActionBuildFusService() : BuildFu
                 ConfigurationMetricParameterFlowActionBuildFusService::class.java
             ) { spec ->
                 spec.parameters.generalConfigurationMetrics.set(generalConfigurationMetricsProvider)
+                spec.parameters.generalMetricsFinalized.set(false)
                 spec.parameters.buildStatisticsConfiguration.set(KotlinBuildStatsConfiguration(project))
                 spec.parameters.buildId.value(buildUidService.map { it.buildId }).disallowChanges()
                 //init value to avoid `java.lang.IllegalStateException: GradleScopeServices has been closed` exception on close

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/statistics/FinalizeConfigurationFusMetricAction.kt

@@ -13,20 +13,22 @@ import org.jetbrains.kotlin.gradle.plugin.await
 internal val FinalizeConfigurationFusMetricAction = KotlinProjectSetupCoroutine {
     KotlinPluginLifecycle.Stage.ReadyForExecution.await()
 
-    project.gradle.sharedServices.registrations.findByName(BuildFusService.serviceName)?.also {
+    BuildFusService.getBuildFusService(project)?.also {
         val parameters = it.parameters
         if (parameters is ConfigurationMetricsBuildFusParameters) {
             //build service parameter is used,
             //it is important to avoid service parameters initialization before all configuration metrics are collected
-            parameters.generalConfigurationMetrics.finalizeValue()
+            parameters.finalizeGeneralConfigurationMetrics()
             parameters.configurationMetrics.add(KotlinProjectConfigurationMetrics.collectMetrics(project))
         } else {
-            (parameters as BuildFusService.Parameters).generalConfigurationMetrics.finalizeValue()
+            (parameters as BuildFusService.Parameters).finalizeGeneralConfigurationMetrics()
 
             //build service field is used,
             //it is safe to access build service, as configuration metrics will be cached in [BuildFinishFlowAction]
             val buildFusService = it.service.orNull as FlowActionBuildFusService
             buildFusService.addConfigurationTimeMetric(KotlinProjectConfigurationMetrics.collectMetrics(project))
         }
     }
+
+
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/statistics/FlowActionBuildFusService.kt

@@ -34,6 +34,7 @@ abstract class FlowActionBuildFusService @Inject constructor(
         ): Provider<out BuildFusService<out Parameters>> {
             return project.gradle.sharedServices.registerIfAbsent(serviceName, FlowActionBuildFusService::class.java) { spec ->
                 spec.parameters.generalConfigurationMetrics.set(generalConfigurationMetricsProvider)
+                spec.parameters.generalMetricsFinalized.set(false)
                 spec.parameters.buildStatisticsConfiguration.set(KotlinBuildStatsConfiguration(project))
                 spec.parameters.buildId.value(buildUidService.map { it.buildId }).disallowChanges()
             }.also { buildService ->