FUS: extract all dynamic values from event id in run-configuration and file type collectors (FUS-470)

GitOrigin-RevId: 36c17ef2dbfe8379094bcff2caccbc8bb1fcc659

platform/lang-impl/src/com/intellij/execution/impl/statistics/RunConfigurationTypeUsagesCollector.java

@@ -29,7 +29,8 @@ import java.util.Objects;
 import java.util.Set;
 
 public class RunConfigurationTypeUsagesCollector extends ProjectUsagesCollector {
-  public static final String FACTORY_FIELD = "factory";
+  private static final String ID_FIELD = "id";
+  private static final String FACTORY_FIELD = "factory";
 
   @NotNull
   @Override
@@ -39,7 +40,7 @@ public class RunConfigurationTypeUsagesCollector extends ProjectUsagesCollector
 
   @Override
   public int getVersion() {
-    return 4;
+    return 5;
   }
 
   @NotNull
@@ -58,13 +59,9 @@ public class RunConfigurationTypeUsagesCollector extends ProjectUsagesCollector
         }
 
         final ConfigurationType configurationType = configurationFactory.getType();
-        final String eventId = toConfigurationId(configurationType);
-        final FeatureUsageData data = createData(settings, runConfiguration);
-        if (configurationType.getConfigurationFactories().length > 1) {
-          data.addData(FACTORY_FIELD, configurationFactory.getId());
-        }
-
-        final Template template = new Template(eventId, data);
+        final FeatureUsageData data = newFeatureUsageData(configurationType, configurationFactory);
+        fillSettings(data, settings, runConfiguration);
+        final Template template = new Template("configured.in.project", data);
         if (templates.containsKey(template)) {
           templates.increment(template);
         }
@@ -80,14 +77,19 @@ public class RunConfigurationTypeUsagesCollector extends ProjectUsagesCollector
   }
 
   @NotNull
-  public static String toConfigurationId(@NotNull ConfigurationType configurationType) {
-    return configurationType instanceof UnknownConfigurationType ? "unknown" : configurationType.getId();
+  public static FeatureUsageData newFeatureUsageData(@NotNull ConfigurationType configuration, @NotNull ConfigurationFactory factory) {
+    final String id = configuration instanceof UnknownConfigurationType ? "unknown" : configuration.getId();
+    final FeatureUsageData data = new FeatureUsageData().addData(ID_FIELD, id);
+    if (configuration.getConfigurationFactories().length > 1) {
+      data.addData(FACTORY_FIELD, factory.getId());
+    }
+    return data;
   }
 
-  private static FeatureUsageData createData(@NotNull RunnerAndConfigurationSettings settings,
-                                             @NotNull RunConfiguration runConfiguration) {
-    return new FeatureUsageData().
-      addData("shared", settings.isShared()).
+  private static void fillSettings(@NotNull FeatureUsageData data,
+                                   @NotNull RunnerAndConfigurationSettings settings,
+                                   @NotNull RunConfiguration runConfiguration) {
+    data.addData("shared", settings.isShared()).
       addData("edit_before_run", settings.isEditBeforeRun()).
       addData("activate_before_run", settings.isActivateToolWindowBeforeRun()).
       addData("parallel", runConfiguration.isAllowRunningInParallel()).
@@ -126,7 +128,7 @@ public class RunConfigurationTypeUsagesCollector extends ProjectUsagesCollector
   public static class RunConfigurationUtilValidator extends CustomWhiteListRule {
     @Override
     public boolean acceptRuleId(@Nullable String ruleId) {
-      return "run_config".equals(ruleId) || "run_config_factory".equals(ruleId);
+      return "run_config_id".equals(ruleId) || "run_config_factory".equals(ruleId);
     }
 
     @NotNull
@@ -134,8 +136,12 @@ public class RunConfigurationTypeUsagesCollector extends ProjectUsagesCollector
     protected ValidationResultType doValidate(@NotNull String data, @NotNull EventContext context) {
       if (isThirdPartyValue(data) || "unknown".equals(data)) return ValidationResultType.ACCEPTED;
 
-      final String configurationId = context.eventId;
-      final String factoryId = context.eventData.containsKey(FACTORY_FIELD) ? context.eventData.get(FACTORY_FIELD).toString() : null;
+      final String configurationId = getDataField(context, ID_FIELD);
+      final String factoryId = getDataField(context, FACTORY_FIELD);
+      if (configurationId == null) {
+        return ValidationResultType.REJECTED;
+      }
+
       if (StringUtil.equals(data, configurationId) || StringUtil.equals(data, factoryId)) {
         final Pair<ConfigurationType, ConfigurationFactory> configurationAndFactory =
           findConfigurationAndFactory(configurationId, factoryId);
@@ -144,15 +150,18 @@ public class RunConfigurationTypeUsagesCollector extends ProjectUsagesCollector
         final ConfigurationFactory factory = configurationAndFactory.getSecond();
         if (configuration != null && (StringUtil.isEmpty(factoryId) || factory != null)) {
           final PluginInfo info = PluginInfoDetectorKt.getPluginInfo(configuration.getClass());
-          if (StringUtil.equals(data, context.eventId)) {
-            context.setPluginInfo(info);
-          }
+          context.setPluginInfo(info);
           return info.isDevelopedByJetBrains() ? ValidationResultType.ACCEPTED : ValidationResultType.THIRD_PARTY;
         }
       }
       return ValidationResultType.REJECTED;
     }
 
+    @Nullable
+    private static String getDataField(@NotNull EventContext context, @NotNull String fieldName) {
+      return context.eventData.containsKey(fieldName) ? context.eventData.get(fieldName).toString() : null;
+    }
+
     @NotNull
     private static Pair<ConfigurationType, ConfigurationFactory> findConfigurationAndFactory(@NotNull String configurationId,
                                                                                              @Nullable String factoryId) {

platform/lang-impl/src/com/intellij/execution/impl/statistics/RunConfigurationUsageTriggerCollector.java

@@ -16,18 +16,14 @@ import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import static com.intellij.execution.impl.statistics.RunConfigurationTypeUsagesCollector.FACTORY_FIELD;
+import static com.intellij.execution.impl.statistics.RunConfigurationTypeUsagesCollector.newFeatureUsageData;
 
 public class RunConfigurationUsageTriggerCollector {
 
   public static void trigger(@NotNull Project project, @NotNull ConfigurationFactory factory, @NotNull Executor executor) {
     final ConfigurationType configurationType = factory.getType();
-    final String eventId = RunConfigurationTypeUsagesCollector.toConfigurationId(configurationType);
-    final FeatureUsageData data = new FeatureUsageData().addProject(project).addExecutor(executor);
-    if (configurationType.getConfigurationFactories().length > 1) {
-      data.addData(FACTORY_FIELD, factory.getId());
-    }
-    FUCounterUsageLogger.getInstance().logEvent(project, "run.configuration.exec", eventId, data);
+    final FeatureUsageData data = newFeatureUsageData(configurationType, factory).addExecutor(executor);
+    FUCounterUsageLogger.getInstance().logEvent(project, "run.configuration.exec", "executed", data);
   }
 
   public static class RunConfigurationExecutorUtilValidator extends CustomWhiteListRule {

platform/lang-impl/testSources/com/intellij/execution/impl/statistics/RunConfigurationUsageCollectorTest.java

@@ -64,8 +64,8 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, false, false, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     doTest(configurations, expected, true);
   }
@@ -79,8 +79,8 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 3,
-      create(false, false, false, false))
+      "configured.in.project", 3,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     doTest(configurations, expected, true);
   }
@@ -92,8 +92,8 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(true, false, false, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", true, false, false, false))
     );
     doTest(configurations, expected, false);
   }
@@ -105,8 +105,8 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, true, false, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, true, false, false))
     );
     doTest(configurations, expected, true);
   }
@@ -118,8 +118,8 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, false, true, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, false, true, false))
     );
     doTest(configurations, expected, true);
   }
@@ -131,8 +131,8 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, false, false, true))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, false, false, true))
     );
     doTest(configurations, expected, true);
   }
@@ -145,12 +145,12 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, false, false, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "SecondTestRunConfigurationType", 1,
-      create(false, false, false, false))
+      "configured.in.project", 1,
+      create("SecondTestRunConfigurationType", false, false, false, false))
     );
     doTest(configurations, expected, true);
   }
@@ -164,12 +164,12 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, false, false, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 2,
-      create(true, false, false, false))
+      "configured.in.project", 2,
+      create("FirstTestRunConfigurationType", true, false, false, false))
     );
     doTest(configurations, expected, false);
   }
@@ -185,12 +185,12 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 3,
-      create(false, true, false, false))
+      "configured.in.project", 3,
+      create("FirstTestRunConfigurationType", false, true, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 2,
-      create(false, false, false, false))
+      "configured.in.project", 2,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     doTest(configurations, expected, true);
   }
@@ -204,12 +204,12 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, false, true, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, false, true, false))
     );
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 2,
-      create(false, false, false, false))
+      "configured.in.project", 2,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     doTest(configurations, expected, false);
   }
@@ -223,12 +223,12 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, false, false, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 2,
-      create(false, false, false, true))
+      "configured.in.project", 2,
+      create("FirstTestRunConfigurationType", false, false, false, true))
     );
     doTest(configurations, expected, false);
   }
@@ -244,12 +244,12 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 2,
-      create(false, false, false, false))
+      "configured.in.project", 2,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "SecondTestRunConfigurationType", 3,
-      create(false, false, false, false))
+      "configured.in.project", 3,
+      create("SecondTestRunConfigurationType", false, false, false, false))
     );
     doTest(configurations, expected, true);
   }
@@ -269,32 +269,32 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(true, false, false, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", true, false, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(false, false, false, false))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", false, false, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 2,
-      create(true, true, false, false))
+      "configured.in.project", 2,
+      create("FirstTestRunConfigurationType", true, true, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 1,
-      create(true, true, true, true))
+      "configured.in.project", 1,
+      create("FirstTestRunConfigurationType", true, true, true, true))
     );
     expected.add(new TestUsageDescriptor(
-      "SecondTestRunConfigurationType", 1,
-      create(true, false, false, false))
+      "configured.in.project", 1,
+      create("SecondTestRunConfigurationType", true, false, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "SecondTestRunConfigurationType", 2,
-      create(false, false, true, false))
+      "configured.in.project", 2,
+      create("SecondTestRunConfigurationType", false, false, true, false))
     );
     expected.add(new TestUsageDescriptor(
-      "SecondTestRunConfigurationType", 1,
-      create(false, false, false, false))
+      "configured.in.project", 1,
+      create("SecondTestRunConfigurationType", false, false, false, false))
     );
     doTest(configurations, expected, false);
   }
@@ -311,20 +311,20 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "FirstTestRunConfigurationType", 2,
-      create(false, false, false, true))
+      "configured.in.project", 2,
+      create("FirstTestRunConfigurationType", false, false, false, true))
     );
     expected.add(new TestUsageDescriptor(
-      "SecondTestRunConfigurationType", 1,
-      create(false, false, false, true))
+      "configured.in.project", 1,
+      create("SecondTestRunConfigurationType", false, false, false, true))
     );
     expected.add(new TestUsageDescriptor(
-      "SecondTestRunConfigurationType", 2,
-      create(false, true, false, false))
+      "configured.in.project", 2,
+      create("SecondTestRunConfigurationType", false, true, false, false))
     );
     expected.add(new TestUsageDescriptor(
-      "SecondTestRunConfigurationType", 1,
-      create(false, true, true, true))
+      "configured.in.project", 1,
+      create("SecondTestRunConfigurationType", false, true, true, true))
     );
     doTest(configurations, expected, true);
   }
@@ -337,8 +337,8 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "MultiFactoryTestRunConfigurationType", 1,
-      create(false, false, false, true).addData("factory", "Local"))
+      "configured.in.project", 1,
+      create("MultiFactoryTestRunConfigurationType", false, false, false, true).addData("factory", "Local"))
     );
     doTest(configurations, expected, true);
   }
@@ -351,15 +351,16 @@ public class RunConfigurationUsageCollectorTest extends LightPlatformTestCase {
 
     final Set<TestUsageDescriptor> expected = new HashSet<>();
     expected.add(new TestUsageDescriptor(
-      "MultiFactoryTestRunConfigurationType", 1,
-      create(false, false, false, true).addData("factory", "Remote"))
+      "configured.in.project", 1,
+      create("MultiFactoryTestRunConfigurationType", false, false, false, true).addData("factory", "Remote"))
     );
     doTest(configurations, expected, true);
   }
 
   @NotNull
-  private static FeatureUsageData create(boolean isShared, boolean isEditBeforeRun, boolean isActivate, boolean isParallel) {
+  private static FeatureUsageData create(@NotNull String id, boolean isShared, boolean isEditBeforeRun, boolean isActivate, boolean isParallel) {
     return new FeatureUsageData().
+      addData("id", id).
       addData("edit_before_run", isEditBeforeRun).
       addData("activate_before_run", isActivate).
       addData("shared", isShared).

platform/lang-impl/testSources/com/intellij/execution/impl/statistics/RunConfigurationValidatorTest.java

@@ -35,17 +35,18 @@ public class RunConfigurationValidatorTest extends LightPlatformTestCase {
     }
   }
 
-  private static void doValidateEventId(@NotNull String eventId, @NotNull FeatureUsageData eventData) {
-    final RunConfigurationUtilValidator validator = new RunConfigurationUtilValidator();
-    final EventContext context = EventContext.create(eventId, eventData.build());
-    doTest(ValidationResultType.ACCEPTED, validator, eventId, context);
+  private static void doValidateFactory(@NotNull FeatureUsageData eventData) {
+    doValidateData(eventData, "factory");
   }
 
-  @SuppressWarnings("SameParameterValue")
-  private static void doValidateFactoryData(@NotNull String eventId, @NotNull FeatureUsageData eventData) {
+  private static void doValidateConfigId(@NotNull FeatureUsageData eventData) {
+    doValidateData(eventData, "id");
+  }
+
+  private static void doValidateData(@NotNull FeatureUsageData eventData, @NotNull String field) {
     final RunConfigurationUtilValidator validator = new RunConfigurationUtilValidator();
-    final EventContext context = EventContext.create(eventId, eventData.build());
-    final Object data = eventData.build().get("factory");
+    final EventContext context = EventContext.create("configured.in.project", eventData.build());
+    final Object data = eventData.build().get(field);
     assertTrue(data instanceof String);
     doTest(ValidationResultType.ACCEPTED, validator, (String)data, context);
   }
@@ -56,53 +57,68 @@ public class RunConfigurationValidatorTest extends LightPlatformTestCase {
     doTest(ValidationResultType.REJECTED, validator, eventId, context);
   }
 
-  @SuppressWarnings("SameParameterValue")
-  private static void doRejectFactoryData(@NotNull String eventId, @NotNull FeatureUsageData eventData) {
+  private static void doRejectConfigId(@NotNull FeatureUsageData eventData) {
+    doRejectData(eventData, "id");
+  }
+
+  private static void doRejectFactory(@NotNull FeatureUsageData eventData) {
+    doRejectData(eventData, "factory");
+  }
+
+  private static void doRejectData(@NotNull FeatureUsageData eventData, @NotNull String field) {
     final RunConfigurationUtilValidator validator = new RunConfigurationUtilValidator();
-    final EventContext context = EventContext.create(eventId, eventData.build());
-    final Object data = eventData.build().get("factory");
+    final EventContext context = EventContext.create("configured.in.project", eventData.build());
+    final Object data = eventData.build().get(field);
     assertTrue(data instanceof String);
     doTest(ValidationResultType.REJECTED, validator, (String)data, context);
   }
 
   public void testRunConfigurationWithOneFactory() {
-    doValidateEventId("FirstTestRunConfigurationType", newFeatureUsageData());
+    doValidateConfigId(newFeatureUsageData().addData("id", "FirstTestRunConfigurationType"));
   }
 
   public void testAnotherRunConfigurationWithOneFactory() {
-    doValidateEventId("SecondTestRunConfigurationType", newFeatureUsageData());
+    doValidateConfigId(newFeatureUsageData().addData("id", "SecondTestRunConfigurationType"));
   }
 
   public void testAnotherRunConfigurationWithEmptyName() {
-    doValidateEventId("SecondTestRunConfigurationType", newFeatureUsageData());
+    doValidateConfigId(newFeatureUsageData().addData("id", "SecondTestRunConfigurationType"));
   }
 
   public void testThirdPartyRunConfigurationWithOneFactory() {
-    doValidateEventId("third.party", newFeatureUsageData());
+    doValidateConfigId(newFeatureUsageData().addData("id", "third.party"));
   }
 
   public void testRejectUnknownRunConfiguration() {
-    doRejectEventId("UnknownTestRunConfigurationType", newFeatureUsageData());
+    doRejectConfigId(newFeatureUsageData().addData("id", "UnknownTestRunConfigurationType"));
   }
 
   public void testRejectEmptyRunConfiguration() {
-    doRejectEventId("", newFeatureUsageData());
+    doRejectConfigId(newFeatureUsageData().addData("id", ""));
+  }
+
+  public void testRejectNoEmptyRunConfiguration() {
+    doRejectFactory(newFeatureUsageData().addData("factory", "Local"));
   }
 
   public void testRunConfigurationWithIncorrectFactory() {
-    doRejectEventId("FirstTestRunConfigurationType/Local", newFeatureUsageData());
+    doRejectConfigId(newFeatureUsageData().addData("id", "FirstTestRunConfigurationType/Local"));
   }
 
   public void testRunConfigurationWithLocalFactory() {
-    final FeatureUsageData data = newFeatureUsageData().addData("factory", "Local");
-    doValidateEventId("MultiFactoryTestRunConfigurationType", data);
-    doValidateFactoryData("MultiFactoryTestRunConfigurationType", data);
+    final FeatureUsageData data = newFeatureUsageData().
+      addData("factory", "Local").
+      addData("id", "MultiFactoryTestRunConfigurationType");
+    doValidateConfigId(data);
+    doValidateFactory(data);
   }
 
   public void testRunConfigurationWithRemoteFactory() {
-    final FeatureUsageData data = newFeatureUsageData().addData("factory", "Remote");
-    doValidateEventId("MultiFactoryTestRunConfigurationType", data);
-    doValidateFactoryData("MultiFactoryTestRunConfigurationType", data);
+    final FeatureUsageData data = newFeatureUsageData().
+      addData("factory", "Remote").
+      addData("id", "MultiFactoryTestRunConfigurationType");
+    doValidateConfigId(data);
+    doValidateFactory(data);
   }
 
   public void testRunConfigurationWithEmptyFactory() {
@@ -110,21 +126,23 @@ public class RunConfigurationValidatorTest extends LightPlatformTestCase {
   }
 
   public void testRejectRunConfigurationWithUnknownFactory() {
-    final FeatureUsageData data = newFeatureUsageData().addData("factory", "Unknown");
-    doRejectEventId("MultiFactoryTestRunConfigurationType", data);
-    doRejectFactoryData("MultiFactoryTestRunConfigurationType", data);
+    final FeatureUsageData data = newFeatureUsageData().
+      addData("factory", "Unknown").
+      addData("id", "MultiFactoryTestRunConfigurationType");
+    doRejectConfigId(data);
+    doRejectFactory(data);
   }
 
   public void testRejectRunConfigurationWithEmptyName() {
-    doRejectEventId("/Remote", newFeatureUsageData());
+    doRejectConfigId(newFeatureUsageData().addData("id", "/Remote"));
   }
 
   public void testRejectRunConfigurationWithEmptyNameAndFactory() {
-    doRejectEventId("/", newFeatureUsageData());
+    doRejectEventId("/", newFeatureUsageData().addData("id", "/"));
   }
 
   public void testRejectRunConfigurationWithTwoMuchValues() {
-    doRejectEventId("RunConfigName/Factory/AnotherValue", newFeatureUsageData());
+    doRejectEventId("RunConfigName/Factory/AnotherValue", newFeatureUsageData().addData("id", "RunConfigName/Factory/AnotherValue"));
   }
 
   @NotNull

platform/platform-impl/src/com/intellij/internal/statistic/collectors/fus/fileTypes/FileTypeUsageCounterCollector.java

@@ -7,7 +7,6 @@ import com.intellij.internal.statistic.utils.StatisticsUtilKt;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.extensions.AbstractExtensionPointBean;
 import com.intellij.openapi.extensions.ExtensionPointName;
-import com.intellij.openapi.fileTypes.FileType;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.LazyInstance;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -31,10 +30,8 @@ public class FileTypeUsageCounterCollector {
 
   private static void trigger(@NotNull Project project,
                               @NotNull VirtualFile file,
-                              @NotNull String type) {
-    final FeatureUsageData data = new FeatureUsageData().addData("type", type);
-    FileType fileType = file.getFileType();
-
+                              @NotNull String event) {
+    final FeatureUsageData data = FileTypeUsagesCollector.newFeatureUsageData(file.getFileType());
     for (FileTypeUsageSchemaDescriptorEP<FileTypeUsageSchemaDescriptor> ext : EP.getExtensionList()) {
       FileTypeUsageSchemaDescriptor instance = ext.getInstance();
       if (ext.schema == null) {
@@ -48,8 +45,7 @@ public class FileTypeUsageCounterCollector {
       }
     }
 
-    final String id = FileTypeUsagesCollector.toReportedId(fileType, data);
-    FUCounterUsageLogger.getInstance().logEvent(project, "file.types.usage", id, data);
+    FUCounterUsageLogger.getInstance().logEvent(project, "file.types.usage", event, data);
   }
 
   public static class FileTypeUsageSchemaDescriptorEP<T> extends AbstractExtensionPointBean implements KeyedLazyInstance<T> {

platform/platform-impl/src/com/intellij/internal/statistic/collectors/fus/fileTypes/FileTypeUsagesCollector.java

@@ -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 com.intellij.internal.statistic.collectors.fus.fileTypes;
 
-import com.intellij.internal.statistic.beans.UsageDescriptor;
+import com.intellij.internal.statistic.beans.MetricEvent;
 import com.intellij.internal.statistic.eventLog.FeatureUsageData;
-import com.intellij.internal.statistic.eventLog.validator.rules.EventContext;
 import com.intellij.internal.statistic.eventLog.validator.ValidationResultType;
+import com.intellij.internal.statistic.eventLog.validator.rules.EventContext;
 import com.intellij.internal.statistic.eventLog.validator.rules.impl.CustomWhiteListRule;
 import com.intellij.internal.statistic.service.fus.collectors.ProjectUsagesCollector;
 import com.intellij.internal.statistic.utils.PluginInfo;
@@ -33,15 +33,20 @@ public class FileTypeUsagesCollector extends ProjectUsagesCollector {
     return "file.types";
   }
 
+  @Override
+  public int getVersion() {
+    return 2;
+  }
+
   @NotNull
   @Override
-  public Set<UsageDescriptor> getUsages(@NotNull final Project project) {
+  public Set<MetricEvent> getMetrics(@NotNull Project project) {
     return getDescriptors(project);
   }
 
   @NotNull
-  public static Set<UsageDescriptor> getDescriptors(@NotNull Project project) {
-    final Set<UsageDescriptor> descriptors = new HashSet<>();
+  public static Set<MetricEvent> getDescriptors(@NotNull Project project) {
+    final Set<MetricEvent> events = new HashSet<>();
     final FileTypeManager fileTypeManager = FileTypeManager.getInstance();
     if (fileTypeManager == null) {
       return Collections.emptySet();
@@ -52,27 +57,27 @@ public class FileTypeUsagesCollector extends ProjectUsagesCollector {
         return Collections.emptySet();
       }
 
-      final FeatureUsageData data = new FeatureUsageData();
-      final String id = toReportedId(fileType, data);
       ApplicationManager.getApplication().runReadAction(() -> {
         FileTypeIndex.processFiles(fileType, file -> {
           //skip files from .idea directory otherwise 99% of projects would have XML and PLAIN_TEXT file types
           if (!ProjectKt.getStateStore(project).isProjectFile(file)) {
-            descriptors.add(new UsageDescriptor(id, 1, data));
+            events.add(new MetricEvent("file.in.project", newFeatureUsageData(fileType)));
             return false;
           }
           return true;
         }, GlobalSearchScope.projectScope(project));
       });
     }
-    return descriptors;
+    return events;
   }
 
   @NotNull
-  public static String toReportedId(@NotNull FileType type, @NotNull FeatureUsageData data) {
+  public static FeatureUsageData newFeatureUsageData(@NotNull FileType type) {
+    final FeatureUsageData data = new FeatureUsageData();
     final PluginInfo info = PluginInfoDetectorKt.getPluginInfo(type.getClass());
     data.addPluginInfo(info);
-    return info.isDevelopedByJetBrains() ? type.getName() : DEFAULT_ID;
+    data.addData("file_type", info.isDevelopedByJetBrains() ? type.getName() : DEFAULT_ID);
+    return data;
   }
 
   public static class ValidationRule extends CustomWhiteListRule {
@@ -84,12 +89,15 @@ public class FileTypeUsagesCollector extends ProjectUsagesCollector {
     @NotNull
     @Override
     protected ValidationResultType doValidate(@NotNull String data, @NotNull EventContext context) {
-      FileType fileType = FileTypeManager.getInstance().findFileTypeByName(data);
-      if (fileType != null && StringUtil.equals(fileType.getName(), data) &&
-          PluginInfoDetectorKt.getPluginInfo(fileType.getClass()).isDevelopedByJetBrains()) {
-        return ValidationResultType.ACCEPTED;
+      if (isThirdPartyValue(data)) return ValidationResultType.ACCEPTED;
+
+      final FileType fileType = FileTypeManager.getInstance().findFileTypeByName(data);
+      if (fileType == null || !StringUtil.equals(fileType.getName(), data)) {
+        return ValidationResultType.REJECTED;
       }
-      return ValidationResultType.REJECTED;
+
+      final boolean isDevelopedByJB = PluginInfoDetectorKt.getPluginInfo(fileType.getClass()).isDevelopedByJetBrains();
+      return isDevelopedByJB ? ValidationResultType.ACCEPTED : ValidationResultType.THIRD_PARTY;
     }
   }
 }

platform/platform-impl/src/com/intellij/internal/statistic/eventLog/fus/FeatureUsageEventLoggerProvider.kt

@@ -6,7 +6,7 @@ import com.intellij.internal.statistic.utils.StatisticsUploadAssistant
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.util.registry.Registry
 
-class FeatureUsageEventLoggerProvider : StatisticsEventLoggerProvider("FUS", 22) {
+class FeatureUsageEventLoggerProvider : StatisticsEventLoggerProvider("FUS", 23) {
   override fun isRecordEnabled(): Boolean {
     return !ApplicationManager.getApplication().isUnitTestMode &&
            Registry.`is`("feature.usage.event.log.collect.and.upload") &&