Metrics for feature engagement tracker.

components/feature_engagement_tracker/internal/chrome_variations_configuration.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/feature_engagement_tracker/internal/chrome_variations_configuration.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/feature_engagement_tracker/internal/configuration.h"
+#include "components/feature_engagement_tracker/internal/stats.h"
 #include "components/feature_engagement_tracker/public/feature_list.h"
 
 namespace {
 
 const char kComparatorTypeAny[] = "any";
 const char kComparatorTypeLessThan[] = "<";
 const char kComparatorTypeGreaterThan[] = ">";
 const char kComparatorTypeLessThanOrEqual[] = "<=";
 const char kComparatorTypeGreaterThanOrEqual[] = ">=";
 const char kComparatorTypeEqual[] = "==";
@@ skipping 173 matching lines @@
   DCHECK(feature);
   DCHECK(configs_.find(feature) == configs_.end());
 
   // Initially all new configurations are considered invalid.
   FeatureConfig& config = configs_[feature];
   config.valid = false;
   uint32_t parse_errors = 0;
 
   std::map<std::string, std::string> params;
   bool result = base::GetFieldTrialParamsByFeature(*feature, &params);
-  if (!result)
+  if (!result) {
+    stats::RecordConfigParsingEvent(
+        stats::ConfigParsingEvent::FAILURE_NO_FIELD_TRIAL);
+    // Returns early. If no field trial, ConfigParsingEvent::FAILURE will not be
+    // recorded.
     return;
+  }
 
   for (const auto& it : params) {
     const std::string& key = it.first;
     if (key == kEventConfigUsedKey) {
       EventConfig event_config;
       if (!ParseEventConfig(params[key], &event_config)) {
         ++parse_errors;
+        stats::RecordConfigParsingEvent(
+            stats::ConfigParsingEvent::FAILURE_USED_EVENT_PARSE);
         continue;
       }
       config.used = event_config;
     } else if (key == kEventConfigTriggerKey) {
       EventConfig event_config;
       if (!ParseEventConfig(params[key], &event_config)) {
+        stats::RecordConfigParsingEvent(
+            stats::ConfigParsingEvent::FAILURE_TRIGGER_EVENT_PARSE);
         ++parse_errors;
         continue;
       }
       config.trigger = event_config;
     } else if (key == kSessionRateKey) {
       Comparator comparator;
       if (!ParseComparator(params[key], &comparator)) {
+        stats::RecordConfigParsingEvent(
+            stats::ConfigParsingEvent::FAILURE_SESSION_RATE_PARSE);
         ++parse_errors;
         continue;
       }
       config.session_rate = comparator;
     } else if (key == kAvailabilityKey) {
       Comparator comparator;
       if (!ParseComparator(params[key], &comparator)) {
+        stats::RecordConfigParsingEvent(
+            stats::ConfigParsingEvent::FAILURE_AVAILABILITY_PARSE);
         ++parse_errors;
         continue;
       }
       config.availability = comparator;
     } else if (base::StartsWith(key, kEventConfigKeyPrefix,
                                 base::CompareCase::INSENSITIVE_ASCII)) {
       EventConfig event_config;
       if (!ParseEventConfig(params[key], &event_config)) {
+        stats::RecordConfigParsingEvent(
+            stats::ConfigParsingEvent::FAILURE_OTHER_EVENT_PARSE);
         ++parse_errors;
         continue;
       }
       config.event_configs.insert(event_config);
     } else {
       DVLOG(1) << "Ignoring unknown key when parsing config for feature "
                << feature->name << ": " << key;
+      stats::RecordConfigParsingEvent(
+          stats::ConfigParsingEvent::FAILURE_UNKNOWN_KEY);
     }
   }
 
   // The |used| and |trigger| members are required, so should not be the
   // default values.
-  config.valid = config.used != EventConfig() &&
-                 config.trigger != EventConfig() && parse_errors == 0;
+  bool has_used_event = config.used != EventConfig();
+  bool has_trigger_event = config.trigger != EventConfig();
+  config.valid = has_used_event && has_trigger_event && parse_errors == 0;
+
+  if (config.valid) {
+    stats::RecordConfigParsingEvent(stats::ConfigParsingEvent::SUCCESS);
+  } else {
+    stats::RecordConfigParsingEvent(stats::ConfigParsingEvent::FAILURE);
+  }
+
+  // Notice parse errors for used and trigger events will also cause the
+  // following histograms being recorded.
+  if (!has_used_event) {
+    stats::RecordConfigParsingEvent(
+        stats::ConfigParsingEvent::FAILURE_USED_EVENT_MISSING);
+  }
+  if (!has_trigger_event) {
+    stats::RecordConfigParsingEvent(
+        stats::ConfigParsingEvent::FAILURE_TRIGGER_EVENT_MISSING);
+  }
 }
 
 const FeatureConfig& ChromeVariationsConfiguration::GetFeatureConfig(
     const base::Feature& feature) const {
   auto it = configs_.find(&feature);
   DCHECK(it != configs_.end());
   return it->second;
 }
 
+const Configuration::ConfigMap&
+ChromeVariationsConfiguration::GetRegisteredFeatures() const {
+  return configs_;
+}
+
 }  // namespace feature_engagement_tracker