ru.tinkoff.plugins.buildmetrics.gradle.metrics.internal.BuildTasksMetricsFactory.kt Maven / Gradle / Ivy

Go to download
package ru.tinkoff.plugins.buildmetrics.gradle.metrics.internal

import org.gradle.api.internal.tasks.RealizeTaskBuildOperationType
import org.gradle.api.internal.tasks.RegisterTaskBuildOperationType
import ru.tinkoff.plugins.buildmetrics.api.builds.internal.BuildOperationData
import ru.tinkoff.plugins.buildmetrics.api.builds.internal.BuildOperationDataListener
import ru.tinkoff.plugins.buildmetrics.api.factories.Factory
import ru.tinkoff.plugins.buildmetrics.api.metrics.Metric
import ru.tinkoff.plugins.buildmetrics.gradle.internal.utils.ConfigurationCacheData
import ru.tinkoff.plugins.buildmetrics.gradle.internal.utils.TasksData

/**
 * Metrics:
 * - gradle_total_tasks_count;
 * - gradle_run_tasks_count;
 * - gradle_executed_tasks_count;
 * - gradle_from_cache_tasks_count;
 * - gradle_up_to_date_tasks_count;
 * - gradle_skipped_tasks_count;
 * - gradle_no_source_tasks_count;
 * - gradle_lifecycle_tasks_count;
 * - gradle_requested_from_cache_tasks_count;
 * - gradle_created_immediately_tasks_count;
 * - gradle_from_cache_tasks_execution_time_serial_diff_ms;
 * - gradle_up_to_date_tasks_execution_time_serial_diff_ms;
 */
class BuildTasksMetricsFactory : Factory.Metrics, BuildOperationDataListener {

    private class FactoryData(
        private val tasksDataBuilder: TasksData.Builder = TasksData.Builder(),
        private val configurationCacheDataBuilder: ConfigurationCacheData.Builder = ConfigurationCacheData.Builder(),
    ) {

        val registerTasks: MutableSet = mutableSetOf()

        val realizeTasks: MutableSet = mutableSetOf()

        fun onBuildOperationData(data: BuildOperationData) {
            when (val details = data.details) {
                is RegisterTaskBuildOperationType.Details -> {
                    registerTasks.add(details.taskId)
                }

                is RealizeTaskBuildOperationType.Details -> {
                    realizeTasks.add(details.taskId)
                }
            }
            tasksDataBuilder.onBuildOperationData(data = data)
            configurationCacheDataBuilder.onBuildOperationData(data = data)
        }

        fun totalTasksCount(): Int = registerTasks.plus(realizeTasks).size

        fun createTasksCountWithoutRegister(): Int = realizeTasks.minus(registerTasks).size

        fun tasksData(): TasksData = tasksDataBuilder.build()

        fun configurationCacheData(): ConfigurationCacheData = configurationCacheDataBuilder.build()
    }

    @Transient
    private var factoryData: FactoryData = FactoryData()

    override fun reinitialize() {
        factoryData = FactoryData()
    }

    override fun onBuildOperationData(data: BuildOperationData) {
        factoryData.onBuildOperationData(data = data)
    }

    @Synchronized
    override fun create(): List> {
        val tasksData = factoryData.tasksData()
        val configurationCacheData = factoryData.configurationCacheData()
        return buildList {
            add(Metric(name = "gradle_total_tasks_count", value = factoryData.totalTasksCount()))
            add(Metric(name = "gradle_run_tasks_count", value = tasksData.runTasksCount))
            add(Metric(name = "gradle_executed_tasks_count", value = tasksData.executedTasksCount))
            add(Metric(name = "gradle_from_cache_tasks_count", value = tasksData.fromCacheTasksCount))
            add(Metric(name = "gradle_up_to_date_tasks_count", value = tasksData.upToDateTasksCount))
            add(Metric(name = "gradle_skipped_tasks_count", value = tasksData.skippedTasksCount))
            add(Metric(name = "gradle_no_source_tasks_count", value = tasksData.noSourceTasksCount))
            add(Metric(name = "gradle_lifecycle_tasks_count", value = tasksData.lifecycleTasksCount))
            add(
                Metric(
                    name = "gradle_requested_from_cache_tasks_count",
                    value = tasksData.requestedFromCacheTasksCount,
                )
            )
            if (configurationCacheData.reused.not()) {
                add(
                    Metric(
                        name = "gradle_created_immediately_tasks_count",
                        value = factoryData.createTasksCountWithoutRegister(),
                    )
                )
            }
            tasksData.fromCacheTasksOriginExecutionTimeSerialSum.let { originTimeSum ->
                if (originTimeSum > 0L) {
                    add(
                        Metric(
                            name = "gradle_from_cache_tasks_execution_time_serial_diff_ms",
                            value = originTimeSum - tasksData.fromCacheTasksExecutionTimeSerialSum,
                        )
                    )
                }
            }
            tasksData.upToDateTasksOriginExecutionTimeSerialSum.let { originTimeSum ->
                if (originTimeSum > 0L) {
                    add(
                        Metric(
                            name = "gradle_up_to_date_tasks_execution_time_serial_diff_ms",
                            value = originTimeSum - tasksData.upToDateTasksExecutionTimeSerialSum,
                        )
                    )
                }
            }
        }
    }
}