FUS-407 Build Tools: extract dynamic parts from event id to event data and merge small collector together

GitOrigin-RevId: 0d365787bb5dfa756b089284f662c46330bcdfb0

java/compiler/impl/src/com/intellij/compiler/CompilerSettingsCollector.kt

@@ -1,26 +1,26 @@
 // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.intellij.compiler
 
-import com.intellij.internal.statistic.beans.UsageDescriptor
+import com.intellij.internal.statistic.beans.MetricEvent
+import com.intellij.internal.statistic.beans.newBooleanMetric
 import com.intellij.internal.statistic.service.fus.collectors.ProjectUsagesCollector
-import com.intellij.internal.statistic.utils.getBooleanUsage
 import com.intellij.openapi.project.Project
 
 class CompilerSettingsCollector : ProjectUsagesCollector() {
   override fun getGroupId() = "java.compiler.settings.project"
 
-  override fun getUsages(project: Project): Set<UsageDescriptor> {
-    val usages = mutableSetOf<UsageDescriptor>()
+  override fun getMetrics(project: Project): MutableSet<MetricEvent> {
+    val usages = mutableSetOf<MetricEvent>()
 
     val config = CompilerWorkspaceConfiguration.getInstance(project)
 
-    usages.add(getBooleanUsage("AUTO_SHOW_ERRORS_IN_EDITOR", config.AUTO_SHOW_ERRORS_IN_EDITOR))
-    usages.add(getBooleanUsage("DISPLAY_NOTIFICATION_POPUP", config.DISPLAY_NOTIFICATION_POPUP))
-    usages.add(getBooleanUsage("CLEAR_OUTPUT_DIRECTORY", config.CLEAR_OUTPUT_DIRECTORY))
-    usages.add(getBooleanUsage("MAKE_PROJECT_ON_SAVE", config.MAKE_PROJECT_ON_SAVE))
-    usages.add(getBooleanUsage("PARALLEL_COMPILATION", config.PARALLEL_COMPILATION))
-    usages.add(getBooleanUsage("REBUILD_ON_DEPENDENCY_CHANGE", config.REBUILD_ON_DEPENDENCY_CHANGE))
-    usages.add(getBooleanUsage("COMPILE_AFFECTED_UNLOADED_MODULES_BEFORE_COMMIT", config.COMPILE_AFFECTED_UNLOADED_MODULES_BEFORE_COMMIT))
+    usages.add(newBooleanMetric("AUTO_SHOW_ERRORS_IN_EDITOR", config.AUTO_SHOW_ERRORS_IN_EDITOR))
+    usages.add(newBooleanMetric("DISPLAY_NOTIFICATION_POPUP", config.DISPLAY_NOTIFICATION_POPUP))
+    usages.add(newBooleanMetric("CLEAR_OUTPUT_DIRECTORY", config.CLEAR_OUTPUT_DIRECTORY))
+    usages.add(newBooleanMetric("MAKE_PROJECT_ON_SAVE", config.MAKE_PROJECT_ON_SAVE))
+    usages.add(newBooleanMetric("PARALLEL_COMPILATION", config.PARALLEL_COMPILATION))
+    usages.add(newBooleanMetric("REBUILD_ON_DEPENDENCY_CHANGE", config.REBUILD_ON_DEPENDENCY_CHANGE))
+    usages.add(newBooleanMetric("COMPILE_AFFECTED_UNLOADED_MODULES_BEFORE_COMMIT", config.COMPILE_AFFECTED_UNLOADED_MODULES_BEFORE_COMMIT))
 
     return usages
   }

platform/external-system-impl/src/com/intellij/openapi/externalSystem/statistics/ExternalSystemSettingsCollector.kt

@@ -1,34 +1,34 @@
 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.intellij.openapi.externalSystem.statistics
 
-import com.intellij.internal.statistic.beans.UsageDescriptor
+import com.intellij.internal.statistic.beans.MetricEvent
+import com.intellij.internal.statistic.beans.newBooleanMetric
+import com.intellij.internal.statistic.beans.newCounterMetric
 import com.intellij.internal.statistic.service.fus.collectors.ProjectUsagesCollector
-import com.intellij.internal.statistic.utils.getBooleanUsage
-import com.intellij.internal.statistic.utils.getCountingUsage
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
 import com.intellij.openapi.project.Project
 
 class ExternalSystemSettingsCollector : ProjectUsagesCollector() {
   override fun getGroupId() = "build.tools.state"
 
-  override fun getUsages(project: Project): Set<UsageDescriptor> {
-    val usages = mutableSetOf<UsageDescriptor>()
+  override fun getMetrics(project: Project): Set<MetricEvent> {
+    val usages = mutableSetOf<MetricEvent>()
 
     for (manager in ExternalSystemApiUtil.getAllManagers()) {
       val systemId = getAnonymizedSystemId(manager.getSystemId())
-      fun addWithSystemId(desc: UsageDescriptor) {
+      fun addWithSystemId(desc: MetricEvent) {
         desc.data.addData("externalSystemId", systemId)
         usages.add(desc)
       }
 
       val projects = manager.getSettingsProvider().`fun`(project).getLinkedProjectsSettings()
 
-      addWithSystemId(getCountingUsage("numberOfLinkedProject", projects.size))
+      addWithSystemId(newCounterMetric("numberOfLinkedProject", projects.size))
 
       for (projectsSetting in projects) {
-        addWithSystemId(getBooleanUsage("autoImport", projectsSetting.isUseAutoImport))
-        addWithSystemId(getBooleanUsage("useQualifiedModuleNames", projectsSetting.isUseQualifiedModuleNames))
-        addWithSystemId(getCountingUsage("modules.count", projectsSetting.modules.size))
+        addWithSystemId(newBooleanMetric("autoImport", projectsSetting.isUseAutoImport))
+        addWithSystemId(newBooleanMetric("useQualifiedModuleNames", projectsSetting.isUseQualifiedModuleNames))
+        addWithSystemId(newCounterMetric("modules.count", projectsSetting.modules.size))
       }
     }
 

platform/external-system-impl/src/com/intellij/openapi/externalSystem/statistics/ExternalSystemUsagesCollector.kt

@@ -1,7 +1,8 @@
 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.intellij.openapi.externalSystem.statistics
 
-import com.intellij.internal.statistic.beans.UsageDescriptor
+import com.intellij.internal.statistic.beans.MetricEvent
+import com.intellij.internal.statistic.beans.newMetric
 import com.intellij.internal.statistic.service.fus.collectors.ProjectUsagesCollector
 import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager
 import com.intellij.openapi.externalSystem.service.execution.ExternalSystemJdkUtil
@@ -13,22 +14,22 @@ import com.intellij.openapi.util.Version
 class ExternalSystemUsagesCollector : ProjectUsagesCollector() {
   override fun getGroupId() = "build.tools"
 
-  override fun getUsages(project: Project): Set<UsageDescriptor> {
-    val usages = mutableSetOf<UsageDescriptor>()
+  override fun getMetrics(project: Project): Set<MetricEvent> {
+    val usages = mutableSetOf<MetricEvent>()
     for (manager in ExternalSystemApiUtil.getAllManagers()) {
       if (!manager.getSettingsProvider().`fun`(project).getLinkedProjectsSettings().isEmpty()) {
-        usages.add(UsageDescriptor(getAnonymizedSystemId(manager.getSystemId())))
+        usages.add(newMetric("externalSystemId", getAnonymizedSystemId(manager.getSystemId())))
       }
     }
 
     ModuleManager.getInstance(project).modules.find { ExternalSystemModulePropertyManager.getInstance(it).isMavenized() }?.let {
-      usages.add(UsageDescriptor("Maven"))
+      usages.add(newMetric("externalSystemId", "Maven"))
     }
     return usages
   }
 
   companion object {
-    fun getJRETypeUsage(key: String, jreName: String?): UsageDescriptor {
+    fun getJRETypeUsage(key: String, jreName: String?): MetricEvent {
       val anonymizedName = when {
         jreName.isNullOrBlank() -> "empty"
         jreName in listOf(ExternalSystemJdkUtil.USE_INTERNAL_JAVA,
@@ -36,16 +37,16 @@ class ExternalSystemUsagesCollector : ProjectUsagesCollector() {
                           ExternalSystemJdkUtil.USE_JAVA_HOME) -> jreName
         else -> "custom"
       }
-      return UsageDescriptor("$key.$anonymizedName", 1)
+      return newMetric(key, anonymizedName)
     }
 
-    fun getJREVersionUsage(project: Project, key: String, jreName: String?): UsageDescriptor {
+    fun getJREVersionUsage(project: Project, key: String, jreName: String?): MetricEvent {
       val jdk = ExternalSystemJdkUtil.getJdk(project, jreName)
       val versionString =
         jdk?.versionString?.let { Version.parseVersion(it)?.let { parsed -> "${parsed.major}.${parsed.minor}" } }
         ?: "unknown"
 
-      return UsageDescriptor("$key.$versionString", 1)
+      return newMetric(key, versionString)
     }
   }
 }

plugins/ant/src/com/intellij/lang/ant/AntUsagesCollectors.kt

@@ -1,11 +1,11 @@
 // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.intellij.lang.ant
 
-import com.intellij.internal.statistic.beans.UsageDescriptor
+import com.intellij.internal.statistic.beans.MetricEvent
+import com.intellij.internal.statistic.beans.newBooleanMetric
 import com.intellij.internal.statistic.collectors.fus.actions.persistence.ActionsCollectorImpl
 import com.intellij.internal.statistic.service.fus.collectors.FUCounterUsageLogger
 import com.intellij.internal.statistic.service.fus.collectors.ProjectUsagesCollector
-import com.intellij.internal.statistic.utils.getBooleanUsage
 import com.intellij.lang.ant.config.AntConfiguration
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
@@ -14,20 +14,20 @@ import com.intellij.openapi.project.Project
 class AntSettingsCollector : ProjectUsagesCollector() {
   override fun getGroupId() = "build.ant.state"
 
-  override fun getUsages(project: Project): Set<UsageDescriptor> {
+  override fun getMetrics(project: Project): Set<MetricEvent> {
     val buildFiles = AntConfiguration.getInstance(project).buildFileList
     if (buildFiles.isEmpty()) return emptySet()
 
-    val usages = mutableSetOf<UsageDescriptor>()
+    val usages = mutableSetOf<MetricEvent>()
 
     // to have a total users base line to calculate pertentages of settings
-    usages.add(getBooleanUsage("hasAntProjects", true))
+    usages.add(newBooleanMetric("hasAntProjects", true))
 
     for (each in buildFiles) {
-      usages.add(getBooleanUsage("isRunInBackground", each.isRunInBackground))
-      usages.add(getBooleanUsage("isColoredOutputMessages", each.isColoredOutputMessages))
-      usages.add(getBooleanUsage("isViewClosedWhenNoErrors", each.isViewClosedWhenNoErrors))
-      usages.add(getBooleanUsage("isCollapseFinishedTargets", each.isCollapseFinishedTargets))
+      usages.add(newBooleanMetric("isRunInBackground", each.isRunInBackground))
+      usages.add(newBooleanMetric("isColoredOutputMessages", each.isColoredOutputMessages))
+      usages.add(newBooleanMetric("isViewClosedWhenNoErrors", each.isViewClosedWhenNoErrors))
+      usages.add(newBooleanMetric("isCollapseFinishedTargets", each.isCollapseFinishedTargets))
     }
 
     return usages

plugins/gradle/src/org/jetbrains/plugins/gradle/statistics/GradleSettingsCollector.kt

@@ -1,10 +1,10 @@
 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package org.jetbrains.plugins.gradle.statistics
 
-import com.intellij.internal.statistic.beans.UsageDescriptor
+import com.intellij.internal.statistic.beans.MetricEvent
+import com.intellij.internal.statistic.beans.newBooleanMetric
+import com.intellij.internal.statistic.beans.newMetric
 import com.intellij.internal.statistic.service.fus.collectors.ProjectUsagesCollector
-import com.intellij.internal.statistic.utils.getBooleanUsage
-import com.intellij.internal.statistic.utils.getEnumUsage
 import com.intellij.openapi.externalSystem.statistics.ExternalSystemUsagesCollector
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Version
@@ -15,48 +15,46 @@ import org.jetbrains.plugins.gradle.settings.GradleSettings
 class GradleSettingsCollector : ProjectUsagesCollector() {
   override fun getGroupId() = "build.gradle.state"
 
-  override fun getUsages(project: Project): Set<UsageDescriptor> {
+  override fun getMetrics(project: Project): Set<MetricEvent> {
     val gradleSettings = GradleSettings.getInstance(project)
     val projectsSettings = gradleSettings.linkedProjectsSettings
     if (projectsSettings.isEmpty()) {
       return emptySet()
     }
-    val usages = mutableSetOf<UsageDescriptor>()
+    val usages = mutableSetOf<MetricEvent>()
 
     // to have a total users base line to calculate pertentages of settings
-    usages.add(getBooleanUsage("hasGradleProject", true))
+    usages.add(newBooleanMetric("hasGradleProject", true))
 
     // global settings
-    usages.add(getBooleanUsage("offlineWork", gradleSettings.isOfflineWork))
-    usages.add(getBooleanUsage("hasCustomServiceDirectoryPath", !gradleSettings.serviceDirectoryPath.isNullOrBlank()))
-    usages.add(getBooleanUsage("hasCustomGradleVmOptions", !gradleSettings.gradleVmOptions.isNullOrBlank()))
-    usages.add(getBooleanUsage("showSelectiveImportDialogOnInitialImport", gradleSettings.showSelectiveImportDialogOnInitialImport()))
-    usages.add(getBooleanUsage("storeProjectFilesExternally", gradleSettings.storeProjectFilesExternally))
+    usages.add(newBooleanMetric("offlineWork", gradleSettings.isOfflineWork))
+    usages.add(newBooleanMetric("hasCustomServiceDirectoryPath", !gradleSettings.serviceDirectoryPath.isNullOrBlank()))
+    usages.add(newBooleanMetric("hasCustomGradleVmOptions", !gradleSettings.gradleVmOptions.isNullOrBlank()))
+    usages.add(newBooleanMetric("showSelectiveImportDialogOnInitialImport", gradleSettings.showSelectiveImportDialogOnInitialImport()))
+    usages.add(newBooleanMetric("storeProjectFilesExternally", gradleSettings.storeProjectFilesExternally))
 
     // project settings
     for (setting in gradleSettings.linkedProjectsSettings) {
       val projectPath = setting.externalProjectPath
-      usages.add(getBooleanUsage("isUseQualifiedModuleNames", setting.isUseQualifiedModuleNames))
-      usages.add(getBooleanUsage("createModulePerSourceSet", setting.isResolveModulePerSourceSet))
-      usages.add(getEnumUsage("distributionType", setting.distributionType))
+      usages.add(newBooleanMetric("isUseQualifiedModuleNames", setting.isUseQualifiedModuleNames))
+      usages.add(newBooleanMetric("createModulePerSourceSet", setting.isResolveModulePerSourceSet))
+      usages.add(newMetric("distributionType", setting.distributionType))
 
-      usages.add(getYesNoUsage("isCompositeBuilds", setting.compositeBuild != null))
-      usages.add(getBooleanUsage("disableWrapperSourceDistributionNotification", setting.isDisableWrapperSourceDistributionNotification))
+      usages.add(newBooleanMetric("isCompositeBuilds", setting.compositeBuild != null))
+      usages.add(newBooleanMetric("disableWrapperSourceDistributionNotification", setting.isDisableWrapperSourceDistributionNotification))
 
       usages.add(ExternalSystemUsagesCollector.getJRETypeUsage("gradleJvmType", setting.gradleJvm))
       usages.add(ExternalSystemUsagesCollector.getJREVersionUsage(project, "gradleJvmVersion", setting.gradleJvm))
 
       val gradleVersion = setting.resolveGradleVersion()
       if(gradleVersion.isSnapshot) {
-        usages.add(UsageDescriptor("gradleVersion." + anonymizeGradleVersion(gradleVersion.baseVersion) + ".SNAPSHOT", 1))
+        usages.add(newMetric("gradleVersion", anonymizeGradleVersion(gradleVersion.baseVersion) + ".SNAPSHOT"))
       } else {
-        usages.add(UsageDescriptor("gradleVersion." + anonymizeGradleVersion(gradleVersion), 1))
+        usages.add(newMetric("gradleVersion", anonymizeGradleVersion(gradleVersion)))
       }
 
-      usages.add(getBooleanUsage("delegateBuildRun",
-                                 GradleProjectSettings.isDelegatedBuildEnabled(project, projectPath)))
-      usages.add(getEnumUsage("preferredTestRunner",
-                              GradleProjectSettings.getTestRunner(project, projectPath)))
+      usages.add(newBooleanMetric("delegateBuildRun", GradleProjectSettings.isDelegatedBuildEnabled(project, projectPath)))
+      usages.add(newMetric("preferredTestRunner", GradleProjectSettings.getTestRunner(project, projectPath)))
     }
     return usages
   }
@@ -64,8 +62,4 @@ class GradleSettingsCollector : ProjectUsagesCollector() {
   private fun anonymizeGradleVersion(version : GradleVersion) : String {
     return Version.parseVersion(version.version)?.toCompactString() ?: "unknown"
   }
-
-  private fun getYesNoUsage(key: String, value: Boolean): UsageDescriptor {
-    return UsageDescriptor(key + if (value) ".yes" else ".no", 1)
-  }
 }

plugins/maven/src/main/java/org/jetbrains/idea/maven/statistics/MavenSettingsCollector.kt

@@ -1,10 +1,10 @@
 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package org.jetbrains.idea.maven.statistics
 
-import com.intellij.internal.statistic.beans.UsageDescriptor
+import com.intellij.internal.statistic.beans.MetricEvent
+import com.intellij.internal.statistic.beans.newBooleanMetric
+import com.intellij.internal.statistic.beans.newMetric
 import com.intellij.internal.statistic.service.fus.collectors.ProjectUsagesCollector
-import com.intellij.internal.statistic.utils.getBooleanUsage
-import com.intellij.internal.statistic.utils.getEnumUsage
 import com.intellij.openapi.externalSystem.statistics.ExternalSystemUsagesCollector
 import com.intellij.openapi.project.ExternalStorageConfigurationManager
 import com.intellij.openapi.project.Project
@@ -18,79 +18,80 @@ import org.jetbrains.idea.maven.utils.MavenUtil
 class MavenSettingsCollector : ProjectUsagesCollector() {
   override fun getGroupId() = "build.maven.state"
 
-  override fun getUsages(project: Project): Set<UsageDescriptor> {
+  override fun getMetrics(project: Project): Set<MetricEvent> {
     val manager = MavenProjectsManager.getInstance(project)
     if (!manager.isMavenizedProject) return emptySet()
 
-    val usages = mutableSetOf<UsageDescriptor>()
+    val usages = mutableSetOf<MetricEvent>()
 
     // to have a total users base line to calculate pertentages of settings
-    usages.add(getBooleanUsage("hasMavenProject", true))
+    usages.add(newBooleanMetric("hasMavenProject", true))
 
     // Main page
     val generalSettings = manager.generalSettings
-    usages.add(getEnumUsage("checksumPolicy", generalSettings.checksumPolicy))
-    usages.add(getEnumUsage("failureBehavior", generalSettings.failureBehavior))
-    usages.add(getBooleanUsage("alwaysUpdateSnapshots", generalSettings.isAlwaysUpdateSnapshots))
-    usages.add(getBooleanUsage("nonRecursive", generalSettings.isNonRecursive))
-    usages.add(getBooleanUsage("printErrorStackTraces", generalSettings.isPrintErrorStackTraces))
-    usages.add(getBooleanUsage("usePluginRegistry", generalSettings.isUsePluginRegistry))
-    usages.add(getBooleanUsage("workOffline", generalSettings.isWorkOffline))
-    usages.add(getEnumUsage("outputLevel", generalSettings.outputLevel))
-    usages.add(getEnumUsage("pluginUpdatePolicy", generalSettings.pluginUpdatePolicy))
-    usages.add(getEnumUsage("loggingLevel", generalSettings.loggingLevel))
+    usages.add(newMetric("checksumPolicy", generalSettings.checksumPolicy))
+    usages.add(newMetric("failureBehavior", generalSettings.failureBehavior))
+    usages.add(newBooleanMetric("alwaysUpdateSnapshots", generalSettings.isAlwaysUpdateSnapshots))
+    usages.add(newBooleanMetric("nonRecursive", generalSettings.isNonRecursive))
+    usages.add(newBooleanMetric("printErrorStackTraces", generalSettings.isPrintErrorStackTraces))
+    usages.add(newBooleanMetric("usePluginRegistry", generalSettings.isUsePluginRegistry))
+    usages.add(newBooleanMetric("workOffline", generalSettings.isWorkOffline))
+    usages.add(newMetric("outputLevel", generalSettings.outputLevel))
+    usages.add(newMetric("pluginUpdatePolicy", generalSettings.pluginUpdatePolicy))
+    @Suppress("DEPRECATION")
+    usages.add(newMetric("loggingLevel", generalSettings.loggingLevel))
     try {
       var mavenVersion = MavenUtil.getMavenVersion(resolveMavenHome(generalSettings, project, null))
       mavenVersion = mavenVersion?.let { Version.parseVersion(it)?.toCompactString() } ?: "unknown"
-      usages.add(UsageDescriptor("mavenVersion.$mavenVersion"))
+      usages.add(newMetric("mavenVersion", mavenVersion))
     }
     catch (ignore: Exception) {
       // ignore invalid maven home configuration
     }
-    usages.add(getBooleanUsage("localRepository", generalSettings.localRepository.isNotBlank()))
-    usages.add(getBooleanUsage("userSettingsFile", generalSettings.userSettingsFile.isNotBlank()))
+    usages.add(newBooleanMetric("localRepository", generalSettings.localRepository.isNotBlank()))
+    usages.add(newBooleanMetric("userSettingsFile", generalSettings.userSettingsFile.isNotBlank()))
 
     // Importing page
     val importingSettings = manager.importingSettings
-    usages.add(getBooleanUsage("lookForNested", importingSettings.isLookForNested))
+    usages.add(newBooleanMetric("lookForNested", importingSettings.isLookForNested))
 
-    usages.add(getBooleanUsage("dedicatedModuleDir", importingSettings.dedicatedModuleDir.isNotBlank()))
-    usages.add(getBooleanUsage("storeProjectFilesExternally", ExternalStorageConfigurationManager.getInstance(project).isEnabled))
-    usages.add(getBooleanUsage("importAutomatically", importingSettings.isImportAutomatically))
-    usages.add(getBooleanUsage("autoDetectCompiler", importingSettings.isAutoDetectCompiler))
-    usages.add(getBooleanUsage("createModulesForAggregators", importingSettings.isCreateModulesForAggregators))
-    usages.add(getBooleanUsage("createModuleGroups", importingSettings.isCreateModuleGroups))
-    usages.add(getBooleanUsage("keepSourceFolders", importingSettings.isKeepSourceFolders))
-    usages.add(getBooleanUsage("excludeTargetFolder", importingSettings.isExcludeTargetFolder))
-    usages.add(getBooleanUsage("useMavenOutput", importingSettings.isUseMavenOutput))
+    usages.add(newBooleanMetric("dedicatedModuleDir", importingSettings.dedicatedModuleDir.isNotBlank()))
+    usages.add(newBooleanMetric("storeProjectFilesExternally", ExternalStorageConfigurationManager.getInstance(project).isEnabled))
+    usages.add(newBooleanMetric("importAutomatically", importingSettings.isImportAutomatically))
+    usages.add(newBooleanMetric("autoDetectCompiler", importingSettings.isAutoDetectCompiler))
+    usages.add(newBooleanMetric("createModulesForAggregators", importingSettings.isCreateModulesForAggregators))
+    usages.add(newBooleanMetric("createModuleGroups", importingSettings.isCreateModuleGroups))
+    usages.add(newBooleanMetric("keepSourceFolders", importingSettings.isKeepSourceFolders))
+    usages.add(newBooleanMetric("excludeTargetFolder", importingSettings.isExcludeTargetFolder))
+    usages.add(newBooleanMetric("useMavenOutput", importingSettings.isUseMavenOutput))
 
-    usages.add(getEnumUsage("generatedSourcesFolder", importingSettings.generatedSourcesFolder))
-    usages.add(UsageDescriptor("updateFoldersOnImportPhase." + importingSettings.updateFoldersOnImportPhase))
+    usages.add(newMetric("generatedSourcesFolder", importingSettings.generatedSourcesFolder))
+    usages.add(newMetric("updateFoldersOnImportPhase", importingSettings.updateFoldersOnImportPhase))
 
-    usages.add(getBooleanUsage("downloadDocsAutomatically", importingSettings.isDownloadDocsAutomatically))
-    usages.add(getBooleanUsage("downloadSourcesAutomatically", importingSettings.isDownloadSourcesAutomatically))
-    usages.add(getBooleanUsage("customDependencyTypes",
+    usages.add(newBooleanMetric("downloadDocsAutomatically", importingSettings.isDownloadDocsAutomatically))
+    usages.add(newBooleanMetric("downloadSourcesAutomatically", importingSettings.isDownloadSourcesAutomatically))
+    usages.add(newBooleanMetric("customDependencyTypes",
                                MavenImportingSettings.DEFAULT_DEPENDENCY_TYPES != importingSettings.dependencyTypes))
 
     usages.add(ExternalSystemUsagesCollector.getJRETypeUsage("jdkTypeForImporter", importingSettings.jdkForImporter))
     usages.add(ExternalSystemUsagesCollector.getJREVersionUsage(project, "jdkVersionForImporter", importingSettings.jdkForImporter))
-    usages.add(getBooleanUsage("hasVmOptionsForImporter", importingSettings.vmOptionsForImporter.isNotBlank()))
+    usages.add(newBooleanMetric("hasVmOptionsForImporter", importingSettings.vmOptionsForImporter.isNotBlank()))
 
     // Ignored Files page
-    usages.add(getBooleanUsage("hasIgnoredFiles", manager.ignoredFilesPaths.isNotEmpty()))
-    usages.add(getBooleanUsage("hasIgnoredPatterns", manager.ignoredFilesPatterns.isNotEmpty()))
+    usages.add(newBooleanMetric("hasIgnoredFiles", manager.ignoredFilesPaths.isNotEmpty()))
+    usages.add(newBooleanMetric("hasIgnoredPatterns", manager.ignoredFilesPatterns.isNotEmpty()))
 
     // Runner page
     val runnerSettings = MavenRunner.getInstance(project).settings
-    usages.add(getBooleanUsage("delegateBuildRun", runnerSettings.isDelegateBuildToMaven));
-    usages.add(getBooleanUsage("runMavenInBackground", runnerSettings.isRunMavenInBackground));
-    usages.add(ExternalSystemUsagesCollector.getJRETypeUsage("runnerJreType", runnerSettings.jreName));
-    usages.add(ExternalSystemUsagesCollector.getJREVersionUsage(project, "runnerJreVersion", runnerSettings.jreName));
-    usages.add(getBooleanUsage("hasRunnerVmOptions", runnerSettings.vmOptions.isNotBlank()));
-    usages.add(getBooleanUsage("hasRunnerEnvVariables", !runnerSettings.environmentProperties.isNullOrEmpty()));
-    usages.add(getBooleanUsage("passParentEnv", runnerSettings.isPassParentEnv));
-    usages.add(getBooleanUsage("skipTests", runnerSettings.isSkipTests));
-    usages.add(getBooleanUsage("hasRunnerMavenProperties", !runnerSettings.mavenProperties.isNullOrEmpty()));
+    usages.add(newBooleanMetric("delegateBuildRun", runnerSettings.isDelegateBuildToMaven))
+    usages.add(newBooleanMetric("runMavenInBackground", runnerSettings.isRunMavenInBackground))
+    usages.add(ExternalSystemUsagesCollector.getJRETypeUsage("runnerJreType", runnerSettings.jreName))
+    usages.add(ExternalSystemUsagesCollector.getJREVersionUsage(project, "runnerJreVersion", runnerSettings.jreName))
+    usages.add(newBooleanMetric("hasRunnerVmOptions", runnerSettings.vmOptions.isNotBlank()))
+    usages.add(newBooleanMetric("hasRunnerEnvVariables", !runnerSettings.environmentProperties.isNullOrEmpty()))
+    usages.add(newBooleanMetric("passParentEnv", runnerSettings.isPassParentEnv))
+    usages.add(newBooleanMetric("skipTests", runnerSettings.isSkipTests))
+    usages.add(newBooleanMetric("hasRunnerMavenProperties", !runnerSettings.mavenProperties.isNullOrEmpty()))
     return usages
   }
 }