Make statistic more readable

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

@@ -946,14 +946,15 @@ class KotlinGradleIT : BaseGradleIT() {
 
         //Should contains build metrics for all compile kotlin tasks
         assertTrue { report.contains("Time metrics:") }
-        assertTrue { report.contains("RUN_COMPILER:") }
-        assertTrue { report.contains("INCREMENTAL_COMPILATION:") }
+        assertTrue { report.contains("Run compilation:") }
+        assertTrue { report.contains("Incremental compilation in daemon:") }
         assertTrue { report.contains("Build performance metrics:") }
-        assertTrue { report.contains("OUTPUT_SIZE:") }
-        assertTrue { report.contains("SNAPSHOT_SIZE:") }
+        assertTrue { report.contains("Total size of the cache directory:") }
+        assertTrue { report.contains("Total compiler iteration:") }
+        assertTrue { report.contains("ABI snapshot size:") }
+        //for non-incremental builds
         assertTrue { report.contains("Build attributes:") }
         assertTrue { report.contains("REBUILD_REASON:") }
-        assertTrue { report.contains("COMPILE_ITERATION:") }
     }
 
     @Test
@@ -967,9 +968,9 @@ class KotlinGradleIT : BaseGradleIT() {
         assertNotNull(reports)
         assertEquals(1, reports.size)
         val report = reports[0].readText()
-        assertTrue { report.contains("CODE_ANALYSIS:") }
-        assertTrue { report.contains("CODE_GENERATION:") }
-        assertTrue { report.contains("COMPILER_INITIALIZATION:") }
+        assertTrue { report.contains("Compiler code analysis:") }
+        assertTrue { report.contains("Compiler code generation:") }
+        assertTrue { report.contains("Compiler initialization time:") }
     }
 
     @Test

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerWork.kt

@@ -7,18 +7,14 @@ package org.jetbrains.kotlin.compilerRunner
 
 import org.gradle.api.logging.Logger
 import org.jetbrains.kotlin.build.report.metrics.*
-import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
-import org.jetbrains.kotlin.cli.common.CompilerSystemProperties.COMPILE_INCREMENTAL_WITH_CLASSPATH_SNAPSHOTS
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.gradle.logging.*
 import org.jetbrains.kotlin.gradle.plugin.internal.state.TaskExecutionResults
 import org.jetbrains.kotlin.gradle.plugin.internal.state.TaskLoggers
 import org.jetbrains.kotlin.gradle.report.*
-import org.jetbrains.kotlin.gradle.report.TaskExecutionProperties.ABI_SNAPSHOT
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.tasks.cleanOutputsAndLocalState
 import org.jetbrains.kotlin.gradle.tasks.throwGradleExceptionIfError
@@ -131,17 +127,9 @@ internal class GradleKotlinCompilerWork @Inject constructor(
 
             throwGradleExceptionIfError(exitCode, executionStrategy)
         } finally {
-            val properties = ArrayList<TaskExecutionProperties>()
-            COMPILE_INCREMENTAL_WITH_CLASSPATH_SNAPSHOTS.value.toBooleanLenient()?.let {
-                if (it) properties.add(ABI_SNAPSHOT)
-            }
-            CompilerSystemProperties.COMPILE_INCREMENTAL_WITH_ARTIFACT_TRANSFORM.value.toBooleanLenient()?.let {
-                if (it) properties.add(TaskExecutionProperties.ARTIFACT_TRANSFORM)
-            }
-
             val taskInfo = TaskExecutionInfo(
                 changedFiles = incrementalCompilationEnvironment?.changedFiles,
-                properties = properties
+                compilerArguments = compilerArgs
             )
             val result = TaskExecutionResult(buildMetrics = metrics.getMetrics(), icLogLines = icLogLines, taskInfo = taskInfo)
             TaskExecutionResults[taskPath] = result
@@ -300,7 +288,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
         log.info("Options for KOTLIN DAEMON: $compilationOptions")
         val servicesFacade = GradleIncrementalCompilerServicesFacadeImpl(log, bufferingMessageCollector)
         val compilationResults = GradleCompilationResults(log, projectRootFile)
-        return metrics.measure(BuildTime.RUN_COMPILER) {
+        return metrics.measure(BuildTime.RUN_COMPILATION) {
             daemon.compile(sessionId, compilerArgs, compilationOptions, servicesFacade, compilationResults)
         }.also {
             metrics.addMetrics(compilationResults.buildMetrics)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinGradleBuildServices.kt

@@ -14,9 +14,7 @@ import org.gradle.api.services.BuildServiceParameters
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug
 import org.jetbrains.kotlin.gradle.plugin.internal.state.TaskExecutionResults
 import org.jetbrains.kotlin.gradle.plugin.internal.state.TaskLoggers
-import org.jetbrains.kotlin.gradle.plugin.stat.ReportStatistics
-import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatListener
-import org.jetbrains.kotlin.gradle.plugin.statistics.ReportStatisticsToBuildScan
+import org.jetbrains.kotlin.gradle.plugin.statistics.BuildScanStatisticsListener
 import org.jetbrains.kotlin.gradle.report.BuildReportType
 import org.jetbrains.kotlin.gradle.report.ReportingSettings
 import org.jetbrains.kotlin.gradle.report.reportingSettings
@@ -49,33 +47,35 @@ internal abstract class KotlinGradleBuildServices : BuildService<KotlinGradleBui
     }
 
     companion object {
-        fun registerIfAbsent(project: Project, kotlinVersion: String): Provider<KotlinGradleBuildServices> = project.gradle.sharedServices.registerIfAbsent(
-            "kotlin-build-service-${KotlinGradleBuildServices::class.java.canonicalName}_${KotlinGradleBuildServices::class.java.classLoader.hashCode()}",
-            KotlinGradleBuildServices::class.java
-        ) { service ->
-            service.parameters.rootDir = project.rootProject.rootDir
-            service.parameters.buildDir = project.rootProject.buildDir
+        fun registerIfAbsent(project: Project, kotlinVersion: String): Provider<KotlinGradleBuildServices> =
+            project.gradle.sharedServices.registerIfAbsent(
+                "kotlin-build-service-${KotlinGradleBuildServices::class.java.canonicalName}_${KotlinGradleBuildServices::class.java.classLoader.hashCode()}",
+                KotlinGradleBuildServices::class.java
+            ) { service ->
+                service.parameters.rootDir = project.rootProject.rootDir
+                service.parameters.buildDir = project.rootProject.buildDir
 
-            val reportingSettings = reportingSettings(project.rootProject)
-            addListeners(project, reportingSettings, kotlinVersion)
-        }
+                val reportingSettings = reportingSettings(project.rootProject)
+                addListeners(project, reportingSettings, kotlinVersion)
+            }
 
         fun addListeners(project: Project, reportingSettings: ReportingSettings, kotlinVersion: String) {
-            val listeners = project.rootProject.objects.listProperty(ReportStatistics::class.java)
-                .value(listOf<ReportStatistics>())
-
             project.rootProject.extensions.findByName("buildScan")
                 ?.also {
                     if (reportingSettings.buildReportOutputs.contains(BuildReportType.BUILD_SCAN)) {
-                        listeners.add(ReportStatisticsToBuildScan(it as BuildScanExtension))
+                        val listenerRegistryHolder = BuildEventsListenerRegistryHolder.getInstance(project)
+                        listenerRegistryHolder.listenerRegistry.onTaskCompletion(
+                            project.provider {
+                                BuildScanStatisticsListener(
+                                    it as BuildScanExtension,
+                                    project.rootProject.name,
+                                    reportingSettings.buildReportLabel,
+                                    kotlinVersion
+                                )
+                            }
+                        )
                     }
                 }
-
-            if (listeners.get().isNotEmpty()) {
-                val listenerRegistryHolder = BuildEventsListenerRegistryHolder.getInstance(project)
-                val statListener = KotlinBuildStatListener(project.rootProject.name, reportingSettings.buildReportLabel, kotlinVersion, listeners.get())
-                listenerRegistryHolder.listenerRegistry.onTaskCompletion(project.provider { statListener })
-            }
         }
 
         private val multipleProjectsHolder = KotlinPluginInMultipleProjectsHolder(

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/statistics/BuildScanStatisticsListener.kt

@@ -7,15 +7,24 @@ package org.jetbrains.kotlin.gradle.plugin.statistics
 
 import com.gradle.scan.plugin.BuildScanExtension
 import org.gradle.api.logging.Logging
-import org.jetbrains.kotlin.gradle.plugin.stat.CompileStatData
-import org.jetbrains.kotlin.gradle.plugin.stat.ReportStatistics
+import org.gradle.tooling.events.FinishEvent
+import org.gradle.tooling.events.OperationCompletionListener
+import org.gradle.tooling.events.task.TaskFinishEvent
+import org.jetbrains.kotlin.build.report.metrics.BuildMetricType
+import org.jetbrains.kotlin.gradle.plugin.stat.CompileStatisticsData
 import org.jetbrains.kotlin.konan.file.File
-import java.util.function.Consumer
+import org.jetbrains.kotlin.utils.addToStdlib.measureTimeMillisWithResult
+import java.util.*
+import kotlin.collections.ArrayList
+import kotlin.collections.LinkedHashSet
 import kotlin.system.measureTimeMillis
 
-class ReportStatisticsToBuildScan(
-    private val buildScan: BuildScanExtension
-) : ReportStatistics {
+class BuildScanStatisticsListener(
+    private val buildScan: BuildScanExtension,
+    val projectName: String,
+    val label: String?,
+    val kotlinVersion: String,
+) : OperationCompletionListener, AutoCloseable {
     companion object {
         const val kbSize = 1024
         const val mbSize = kbSize * kbSize
@@ -25,8 +34,28 @@ class ReportStatisticsToBuildScan(
 
     private val tags = LinkedHashSet<String>()
     private val log = Logging.getLogger(this.javaClass)
+    private val buildUuid: String = UUID.randomUUID().toString()
 
-    override fun report(data: CompileStatData) {
+    override fun onFinish(event: FinishEvent?) {
+        if (event is TaskFinishEvent) {
+            val (collectDataDuration, compileStatData) = measureTimeMillisWithResult {
+                KotlinBuildStatListener.prepareData(event, projectName, buildUuid, label, kotlinVersion)
+            }
+            log.debug("Collect data takes $collectDataDuration: $compileStatData")
+
+            compileStatData?.also {
+                val reportDataDuration = measureTimeMillis {
+                    report(it)
+                }
+                log.debug("Report data takes $reportDataDuration: $compileStatData")
+            }
+        }
+    }
+
+    override fun close() {
+    }
+
+    fun report(data: CompileStatisticsData) {
         val elapsedTime = measureTimeMillis {
 
             readableString(data).forEach { buildScan.value(data.taskName, it) }
@@ -41,19 +70,23 @@ class ReportStatisticsToBuildScan(
         log.debug("Report statistic to build scan takes $elapsedTime ms")
     }
 
-    private fun readableString(data: CompileStatData): List<String> {
-        val nonIncrementalReasons = data.nonIncrementalAttributes.filterValues { it > 0 }.keys
+    private fun readableString(data: CompileStatisticsData): List<String> {
         val readableString = StringBuilder()
-        if (nonIncrementalReasons.isEmpty()) {
+        if (data.nonIncrementalAttributes.isEmpty()) {
             readableString.append("Incremental build; ")
+            data.changes.joinTo(readableString, prefix = "Changes: [", postfix = "]; ") { it.substringAfterLast(File.separator) }
         } else {
-            nonIncrementalReasons.joinTo(readableString, prefix = "Non incremental build because: [", postfix = "]; ") { it.readableString }
+            data.nonIncrementalAttributes.joinTo(readableString, prefix = "Non incremental build because: [", postfix = "]; ") { it.readableString }
         }
-        data.changes.joinTo(readableString, prefix = "Changes: [", postfix = "]; ") { it.substringAfterLast(File.separator) }
 
         val timeData =
-            data.buildTimesMs.map { (key, value) -> "${key.readableString}: ${value}ms" } //sometimes it is better to have separate variable to be able debug
-        val perfData = data.perfData.map { (key, value) -> "${key.readableString}: ${readableFileLength(value)}" }
+            data.buildTimesMetrics.map { (key, value) -> "${key.readableString}: ${value}ms" } //sometimes it is better to have separate variable to be able debug
+        val perfData = data.performanceMetrics.map { (key, value) ->
+            when (key.type) {
+                BuildMetricType.FILE_SIZE -> "${key.readableString}: ${readableFileLength(value)}"
+                else -> "${key.readableString}: $value}"
+            }
+        }
         timeData.union(perfData).joinTo(readableString, ",", "Performance: [", "]")
 
         return splitStringIfNeed(readableString.toString(), lengthLimit)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/statistics/CompileStatisticsData.kt

@@ -9,9 +9,11 @@ import org.jetbrains.kotlin.build.report.metrics.BuildAttribute
 import org.jetbrains.kotlin.build.report.metrics.BuildPerformanceMetric
 import org.jetbrains.kotlin.build.report.metrics.BuildTime
 import java.text.SimpleDateFormat
+import java.util.*
 
-data class CompileStatData(
-    val version: Int = 1,
+//Sensitive data. This object is used directly for statistic via http
+data class CompileStatisticsData(
+    val version: Int = 2,
     val projectName: String?,
     val label: String?,
     val taskName: String?,
@@ -20,21 +22,28 @@ data class CompileStatData(
     val tags: List<String>,
     val changes: List<String>,
     val buildUuid: String = "Unset",
-    val kotlinVersion: String = "0.0.0",
+    val kotlinVersion: String,
     val hostName: String? = "Unset",
-    val timeInMillis: Long,
-    val timestamp: String = formatter.format(timeInMillis),
-    val nonIncrementalAttributes: Map<BuildAttribute, Int>,
-    val buildTimesMs: Map<BuildTime, Long>,
-    val perfData: Map<BuildPerformanceMetric, Long>
+    val finishTime: Long,
+    val timestamp: String = formatter.format(finishTime),
+    val compilerArguments: List<String>,
+    val nonIncrementalAttributes: Set<BuildAttribute>,
+    //TODO think about it,time in milliseconds
+    val buildTimesMetrics: Map<BuildTime, Long>,
+    val performanceMetrics: Map<BuildPerformanceMetric, Long>
 ) {
     companion object {
-        private val formatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'")
+        private val formatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").also { it.timeZone = TimeZone.getTimeZone("UTC")}
     }
 }
 
-
-interface ReportStatistics {
-    fun report(data: CompileStatData)
+enum class StatTag {
+    ABI_SNAPSHOT,
+    ARTIFACT_TRANSFORM,
+    INCREMENTAL,
+    NON_INCREMENTAL,
+    GRADLE_DEBUG,
+    KOTLIN_DEBUG
 }
 
+

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/statistics/KotlinBuildStatListener.kt

@@ -5,21 +5,20 @@
 
 package org.jetbrains.kotlin.gradle.plugin.statistics
 
-import org.gradle.api.logging.Logging
-import org.gradle.tooling.events.FinishEvent
-import org.gradle.tooling.events.OperationCompletionListener
 import org.gradle.tooling.events.task.TaskFailureResult
 import org.gradle.tooling.events.task.TaskFinishEvent
 import org.gradle.tooling.events.task.TaskSkippedResult
 import org.gradle.tooling.events.task.TaskSuccessResult
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
+import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import org.jetbrains.kotlin.gradle.plugin.internal.state.TaskExecutionResults
-import org.jetbrains.kotlin.gradle.plugin.stat.CompileStatData
-import org.jetbrains.kotlin.gradle.plugin.stat.ReportStatistics
+import org.jetbrains.kotlin.gradle.plugin.stat.CompileStatisticsData
+import org.jetbrains.kotlin.gradle.plugin.stat.StatTag
+import org.jetbrains.kotlin.gradle.report.TaskExecutionResult
 import org.jetbrains.kotlin.incremental.ChangedFiles
-import org.jetbrains.kotlin.utils.addToStdlib.measureTimeMillisWithResult
+import java.lang.management.ManagementFactory
 import java.net.InetAddress
 import java.util.*
-import kotlin.system.measureTimeMillis
 
 enum class TaskExecutionState {
     SKIPPED,
@@ -31,16 +30,7 @@ enum class TaskExecutionState {
     ;
 }
 
-class KotlinBuildStatListener(
-    val projectName: String,
-    val label: String?,
-    val kotlinVersion: String,
-    val reportStatistics: List<ReportStatistics>
-) : OperationCompletionListener, AutoCloseable {
-
-    private val log = Logging.getLogger(this.javaClass)
-    val buildUuid: String = UUID.randomUUID().toString()
-
+class KotlinBuildStatListener {
     companion object {
         val hostName: String? = try {
             InetAddress.getLocalHost().hostName
@@ -59,7 +49,7 @@ class KotlinBuildStatListener(
             uuid: String,
             label: String?,
             kotlinVersion: String
-        ): CompileStatData? {
+        ): CompileStatisticsData? {
             val result = event.result
             val taskPath = event.descriptor.taskPath
             val durationMs = result.endTime - result.startTime
@@ -89,33 +79,50 @@ class KotlinBuildStatListener(
                 else -> emptyList<String>()
 
             }
-            return CompileStatData(
-                durationMs = durationMs, taskResult = taskResult.name, label = label,
-                buildTimesMs = buildTimesMs, perfData = perfData, projectName = projectName, taskName = taskPath, changes = changes,
-                tags = taskExecutionResult?.taskInfo?.properties?.map { it.name } ?: emptyList(),
-                nonIncrementalAttributes = taskExecutionResult?.buildMetrics?.buildAttributes?.asMap() ?: emptyMap(),
-                hostName = hostName, kotlinVersion = kotlinVersion, buildUuid = uuid, timeInMillis = System.currentTimeMillis()
+            return CompileStatisticsData(
+                durationMs = durationMs,
+                taskResult = taskResult.name,
+                label = label,
+                buildTimesMetrics = buildTimesMs,
+                performanceMetrics = perfData,
+                projectName = projectName,
+                taskName = taskPath,
+                changes = changes,
+                tags = parseTags(taskExecutionResult).map { it.name },
+                nonIncrementalAttributes = taskExecutionResult?.buildMetrics?.buildAttributes?.asMap()?.filter { it.value > 0 }?.keys ?: emptySet(),
+                hostName = hostName,
+                kotlinVersion = kotlinVersion,
+                buildUuid = uuid,
+                finishTime = System.currentTimeMillis(),
+                compilerArguments = taskExecutionResult?.taskInfo?.compilerArguments?.asList() ?: emptyList()
             )
         }
 
-    }
-
-    override fun onFinish(event: FinishEvent?) {
-        if (event is TaskFinishEvent) {
-            val (collectDataDuration, compileStatData) = measureTimeMillisWithResult {
-                prepareData(event, projectName, buildUuid, label, kotlinVersion)
+        private fun parseTags(taskExecutionResult: TaskExecutionResult?): List<StatTag> {
+            val tags = ArrayList<StatTag>()
+            CompilerSystemProperties.COMPILE_INCREMENTAL_WITH_CLASSPATH_SNAPSHOTS.value.toBooleanLenient()?.let {
+                if (it) tags.add(StatTag.ABI_SNAPSHOT)
             }
-            log.debug("Collect data takes $collectDataDuration: $compileStatData")
-
-            val reportDataDuration = measureTimeMillis {
-                compileStatData?.also { data -> reportStatistics.forEach { it.report(data) }}
+            CompilerSystemProperties.COMPILE_INCREMENTAL_WITH_ARTIFACT_TRANSFORM.value.toBooleanLenient()?.let {
+                if (it) tags.add(StatTag.ARTIFACT_TRANSFORM)
             }
-            log.debug("Report data takes $reportDataDuration: $compileStatData")
+            val nonIncrementalAttributes = taskExecutionResult?.buildMetrics?.buildAttributes?.asMap() ?: emptyMap()
+
+            if (nonIncrementalAttributes.isEmpty()) {
+                tags.add(StatTag.INCREMENTAL)
+            } else {
+                tags.add(StatTag.NON_INCREMENTAL)
+            }
+
+            val debugConfiguration = "-agentlib:"
+            if (ManagementFactory.getRuntimeMXBean().inputArguments.firstOrNull { it.startsWith(debugConfiguration) } != null) {
+                tags.add(StatTag.GRADLE_DEBUG)
+            }
+            return tags
         }
-    }
 
-    override fun close() {
     }
 
 }
 
+

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/report/HttpReportService.kt

@@ -14,7 +14,7 @@ import org.gradle.api.services.BuildServiceParameters
 import org.gradle.tooling.events.FinishEvent
 import org.gradle.tooling.events.OperationCompletionListener
 import org.gradle.tooling.events.task.TaskFinishEvent
-import org.jetbrains.kotlin.gradle.plugin.stat.CompileStatData
+import org.jetbrains.kotlin.gradle.plugin.stat.CompileStatisticsData
 import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatListener.Companion.prepareData
 import java.net.HttpURLConnection
 import java.net.URL
@@ -72,7 +72,7 @@ abstract class HttpReportService : BuildService<HttpReportService.Parameters>,
 
     }
 
-    fun report(data: CompileStatData) {
+    fun report(data: CompileStatisticsData) {
         val elapsedTime = measureTimeMillis {
             val connection = URL(parameters.httpSettings.url).openConnection() as HttpURLConnection
 
@@ -97,7 +97,7 @@ abstract class HttpReportService : BuildService<HttpReportService.Parameters>,
                 connection.disconnect()
             }
         }
-        log.debug("Report statistic to elastic search takes $elapsedTime ms")
+        log.debug("Report statistic by http takes $elapsedTime ms")
     }
 
     private fun checkResponseAndLog(connection: HttpURLConnection) {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/report/PlainTextBuildReportWriter.kt

@@ -98,7 +98,7 @@ internal class PlainTextBuildReportWriter(
 
                 val timeMs = buildTimesMs[buildTime]
                 if (timeMs != null) {
-                    p.println("${buildTime.name}: ${formatTime(timeMs)}")
+                    p.println("${buildTime.readableString}: ${formatTime(timeMs)}")
                     p.withIndent {
                         BuildTime.children[buildTime]?.forEach { printBuildTime(it) }
                     }
@@ -123,7 +123,7 @@ internal class PlainTextBuildReportWriter(
 
         p.withIndent("Build performance metrics:") {
             for (metric in BuildPerformanceMetric.values()) {
-                allBuildMetrics[metric]?.let { p.println("${metric.name}: $it") }
+                allBuildMetrics[metric]?.let { p.println("${metric.readableString}: $it") }
             }
         }
         p.println()
@@ -136,7 +136,7 @@ internal class PlainTextBuildReportWriter(
         p.withIndent("Build attributes:") {
             val attributesByKind = allAttributes.entries.groupBy { it.key.kind }.toSortedMap()
             for ((kind, attributesCounts) in attributesByKind) {
-                printMap(p, kind.name, attributesCounts.map { (k, v) -> k.name to v }.toMap())
+                printMap(p, kind.name, attributesCounts.map { (k, v) -> k.readableString to v }.toMap())
             }
         }
         p.println()

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/report/TaskExecutionResult.kt

@@ -15,12 +15,6 @@ internal class TaskExecutionResult(
 )
 
 internal class TaskExecutionInfo(
-    val properties: List<TaskExecutionProperties> = emptyList(),
-    val changedFiles: ChangedFiles? = null
+    val changedFiles: ChangedFiles? = null,
+    val compilerArguments: Array<String> = emptyArray()
 )
-
-internal enum class TaskExecutionProperties {
-    ABI_SNAPSHOT,
-    ARTIFACT_TRANSFORM
-    ;
-}