Added more policy UMA metrics.

components/policy/core/browser/browser_policy_connector.cc

 // Copyright 2014 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/policy/core/browser/browser_policy_connector.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
 #include "components/policy/core/common/cloud/device_management_service.h"
 #include "components/policy/core/common/configuration_policy_provider.h"
 #include "components/policy/core/common/policy_namespace.h"
 #include "components/policy/core/common/policy_pref_names.h"
 #include "components/policy/core/common/policy_service_impl.h"
 #include "components/policy/core/common/policy_statistics_collector.h"
 #include "components/policy/core/common/policy_switches.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "policy/policy_constants.h"
 #include "third_party/icu/source/i18n/unicode/regex.h"
 
 namespace policy {
 
 namespace {
 
 // The URL for the device management server.
 const char kDefaultDeviceManagementServerUrl[] =
     "https://m.google.com/devicemanagement/data/api";
 
 // Used in BrowserPolicyConnector::SetPolicyProviderForTesting.
 bool g_created_policy_service = false;
 ConfigurationPolicyProvider* g_testing_provider = NULL;
 
+void ReportRegexSuccessMetric(bool success) {
+  UMA_HISTOGRAM_BOOLEAN("Enterprise.DomainWhitelistRegexSuccess", success);
+}
+
+

[Ilya Sherman, 2014/07/24 17:29:32]

nit: Spurious newline

[Andrew T Wilson (Slow), 2014/07/25 07:39:01]

Done.

+// Regexes that match many of the larger public email providers as we know
+// these users are not from hosted enterprise domains. Keep this list in sync
+// with the EnterpriseDomainRegex enum in histograms.xml.
+const wchar_t* kNonManagedDomainPatterns[] = {

[Ilya Sherman, 2014/07/24 17:29:33]

nit: Can this be more const?

[Andrew T Wilson (Slow), 2014/07/25 07:39:01]

Done.

+  L"aol\\.com",
+  L"googlemail\\.com",
+  L"gmail\\.com",
+  L"hotmail(\\.co|\\.com|)\\.[^.]+", // hotmail.com, hotmail.it, hotmail.co.uk

[Ilya Sherman, 2014/07/24 17:29:33]

Hmm, this is a slightly strange regex -- why specify the ".co" suffix
explicitly, if you then allow any suffix later on?

[Andrew T Wilson (Slow), 2014/07/24 19:49:53]

Agreed, I can fix this in a separate CL (this isn't new code - I just moved it
up here so I could access arraysize(kNonManagedDomainPatterns) from here.

+  L"live\\.com",
+  L"mail\\.ru",
+  L"msn\\.com",
+  L"qq\\.com",
+  L"yahoo(\\.co|\\.com|)\\.[^.]+", // yahoo.com, yahoo.co.uk, yahoo.com.tw
+  L"yandex\\.ru",
+};
+
 // Returns true if |domain| matches the regex |pattern|.
-bool MatchDomain(const base::string16& domain, const base::string16& pattern) {
+bool MatchDomain(const base::string16& domain, const base::string16& pattern,
+                 size_t index) {
   UErrorCode status = U_ZERO_ERROR;
   const icu::UnicodeString icu_pattern(pattern.data(), pattern.length());
   icu::RegexMatcher matcher(icu_pattern, UREGEX_CASE_INSENSITIVE, status);
   if (!U_SUCCESS(status)) {
     // http://crbug.com/365351 - if for some reason the matcher creation fails
     // just return that the pattern doesn't match the domain. This is safe
     // because the calling method (IsNonEnterpriseUser()) is just used to enable
     // an optimization for non-enterprise users - better to skip the
     // optimization than crash.
     DLOG(ERROR) << "Possible invalid domain pattern: " << pattern
                 << " - Error: " << status;
+    ReportRegexSuccessMetric(false);
+    UMA_HISTOGRAM_ENUMERATION("Enterprise.DomainWhitelistRegexFailureIndex",
+                              index, arraysize(kNonManagedDomainPatterns));

[Ilya Sherman, 2014/07/24 17:29:33]

Note that as you have this set up, the only valid change to the array is to
append at the end; otherwise, changes to the array will confuse the metrics. 
I'd recommend having a function that explicitly maps from strings to enum
constants instead.

[Andrew T Wilson (Slow), 2014/07/24 19:49:53]

Yes. My goal isn't to have this be a long-term UMA, but rather to try to gather
information about a crash.

+    UMA_HISTOGRAM_SPARSE_SLOWLY("Enterprise.DomainWhitelistRegexFailureStatus",
+                                status);
     return false;
   }
+  ReportRegexSuccessMetric(true);
   icu::UnicodeString icu_input(domain.data(), domain.length());
   matcher.reset(icu_input);
   status = U_ZERO_ERROR;
   UBool match = matcher.matches(status);
   DCHECK(U_SUCCESS(status));
   return !!match;  // !! == convert from UBool to bool.
 }
 
 }  // namespace
 
@@ skipping 118 matching lines @@
 
 // static
 bool BrowserPolicyConnector::IsNonEnterpriseUser(const std::string& username) {
   if (username.empty() || username.find('@') == std::string::npos) {
     // An empty username means incognito user in case of ChromiumOS and
     // no logged-in user in case of Chromium (SigninService). Many tests use
     // nonsense email addresses (e.g. 'test') so treat those as non-enterprise
     // users.
     return true;
   }
-
-  // Exclude many of the larger public email providers as we know these users
-  // are not from hosted enterprise domains.
-  static const wchar_t* kNonManagedDomainPatterns[] = {
-    L"aol\\.com",
-    L"googlemail\\.com",
-    L"gmail\\.com",
-    L"hotmail(\\.co|\\.com|)\\.[^.]+", // hotmail.com, hotmail.it, hotmail.co.uk
-    L"live\\.com",
-    L"mail\\.ru",
-    L"msn\\.com",
-    L"qq\\.com",
-    L"yahoo(\\.co|\\.com|)\\.[^.]+", // yahoo.com, yahoo.co.uk, yahoo.com.tw
-    L"yandex\\.ru",
-  };
   const base::string16 domain = base::UTF8ToUTF16(
       gaia::ExtractDomainName(gaia::CanonicalizeEmail(username)));
   for (size_t i = 0; i < arraysize(kNonManagedDomainPatterns); i++) {
     base::string16 pattern = base::WideToUTF16(kNonManagedDomainPatterns[i]);
-    if (MatchDomain(domain, pattern))
+    if (MatchDomain(domain, pattern, i))
       return true;
   }
   return false;
 }
 
 // static
 std::string BrowserPolicyConnector::GetDeviceManagementUrl() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDeviceManagementUrl))
     return command_line->GetSwitchValueASCII(switches::kDeviceManagementUrl);
@@ skipping 14 matching lines @@
 }
 
 void BrowserPolicyConnector::SetPlatformPolicyProvider(
     scoped_ptr<ConfigurationPolicyProvider> provider) {
   CHECK(!platform_policy_provider_);
   platform_policy_provider_ = provider.get();
   AddPolicyProvider(provider.Pass());
 }
 
 }  // namespace policy