Add ExitFunnel to prepare for instrumenting browser exits.

components/browser_watcher/watcher_metrics_provider_win.cc

 // Copyright (c) 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/browser_watcher/watcher_metrics_provider_win.h"
 
+#include <limits>
 #include <vector>
 
 #include "base/metrics/sparse_histogram.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 
 namespace browser_watcher {
 
 namespace {
 
 void CompileAsserts() {
   // Process ID APIs on Windows talk in DWORDs, whereas for string formatting
   // and parsing, this code uses int. In practice there are no process IDs with
   // the high bit set on Windows, so there's no danger of overflow if this is
@@ skipping 30 matching lines @@
   if (base::OpenProcessHandle(static_cast<base::ProcessId>(pid), &process)) {
     base::CloseProcessHandle(process);
 
     // The fact that it was possible to open the process says it's live.
     return false;
   }
 
   return true;
 }
 
+void RecordExitCodes(const base::string16& registry_path) {
+  base::win::RegKey regkey(HKEY_CURRENT_USER,
+                           registry_path.c_str(),
+                           KEY_QUERY_VALUE | KEY_SET_VALUE);
+  if (!regkey.Valid())
+    return;
+
+  size_t num = regkey.GetValueCount();
+  if (num == 0)
+    return;
+  std::vector<base::string16> to_delete;
+
+  // Record the exit codes in a sparse stability histogram, as the range of
+  // values used to report failures is large.
+  base::HistogramBase* exit_code_histogram =
+      base::SparseHistogram::FactoryGet(
+          WatcherMetricsProviderWin::kBrowserExitCodeHistogramName,
+          base::HistogramBase::kUmaStabilityHistogramFlag);
+
+  for (size_t i = 0; i < num; ++i) {
+    base::string16 name;
+    if (regkey.GetValueNameAt(static_cast<int>(i), &name) == ERROR_SUCCESS) {
+      DWORD exit_code = 0;
+      if (regkey.ReadValueDW(name.c_str(), &exit_code) == ERROR_SUCCESS) {
+        // Do not report exit codes for processes that are still live,
+        // notably for our own process.
+        if (exit_code != STILL_ACTIVE || IsDeadProcess(name)) {
+          to_delete.push_back(name);
+          exit_code_histogram->Add(exit_code);
+        }
+      }
+    }
+  }
+
+  // Delete the values reported above.
+  for (size_t i = 0; i < to_delete.size(); ++i)
+    regkey.DeleteValue(to_delete[i].c_str());
+}
+
+void ReadSingleExitFunnel(
+    base::win::RegKey* parent_key, const base::char16* name,
+    std::vector<std::pair<base::string16, int64>>* events_out) {
+  DCHECK(parent_key);
+  DCHECK(name);
+  DCHECK(events_out);
+
+  base::win::RegKey regkey(parent_key->Handle(), name, KEY_READ | KEY_WRITE);
+  if (!regkey.Valid())
+    return;
+
+  // Exit early if no work to do.
+  size_t num = regkey.GetValueCount();
+  if (num == 0)
+    return;
+
+  // Enumerate the recorded events for this process for processing.
+  std::vector<std::pair<base::string16, int64>> events;
+  for (size_t i = 0; i < num; ++i) {
+    base::string16 event_name;
+    LONG res = regkey.GetValueNameAt(static_cast<int>(i), &event_name);
+    if (res == ERROR_SUCCESS) {
+      int64 event_time = 0;
+      res = regkey.ReadInt64(event_name.c_str(), &event_time);
+      if (res == ERROR_SUCCESS)
+        events.push_back(std::make_pair(event_name, event_time));
+    }
+  }
+
+  // Attempt to delete the values before reporting anything.
+  // Exit if this fails to make sure there is no double-reporting on e.g.
+  // permission problems or other corruption.
+  for (size_t i = 0; i < events.size(); ++i) {

[erikwright (departed), 2014/12/12 16:58:29]

Since you are recording the duration from the first event, deleting an earlier
event will change how you report later events, which could corrupt data if
something systematic prevented deletion of some keys.

It would be more technically correct to sort the keys in order of time and
delete in descending order.

[erikwright (departed), 2014/12/12 17:17:19]

This is optional, FYI. Up to you to decide if it compromises your data gathering
enough to warrant addressing.

[Sigurður Ásgeirsson, 2014/12/12 20:25:13]

Thanks - I figure failure to delete a value will be persistent, so it's gonna
come out in the wash...

[Sigurður Ásgeirsson, 2014/12/12 20:25:13]

Acknowledged.

+    const base::string16& event_name = events[i].first;
+    LONG res = regkey.DeleteValue(event_name.c_str());
+    if (res != ERROR_SUCCESS) {
+      LOG(ERROR) << "Failed to delete value " << event_name;
+      return;
+    }
+  }
+
+  events_out->swap(events);
+}
+
+void RecordSingleExitFunnel(base::win::RegKey* parent_key,
+                            const base::char16* name) {
+  std::vector<std::pair<base::string16, int64>> events;
+  ReadSingleExitFunnel(parent_key, name, &events);
+
+  // Find the earliest event time.
+  int64 min_time = std::numeric_limits<int64>::max();
+  for (size_t i = 0; i < events.size(); ++i)
+    min_time = std::min(min_time, events[i].second);
+
+  // Record the exit funnel event times in a sparse stability histogram.
+  for (size_t i = 0; i < events.size(); ++i) {
+    std::string histogram_name(
+        WatcherMetricsProviderWin::kExitFunnelHistogramPrefix);
+    histogram_name.append(base::WideToUTF8(events[i].first));
+    base::TimeDelta event_time =
+        base::Time::FromInternalValue(events[i].second) -
+            base::Time::FromInternalValue(min_time);
+    base::HistogramBase* histogram =
+        base::SparseHistogram::FactoryGet(
+            histogram_name.c_str(),
+            base::HistogramBase::kUmaStabilityHistogramFlag);
+
+    // Record the time rounded up to the nearest millisecond.
+    histogram->Add(event_time.InMillisecondsRoundedUp());
+  }
+}
+
+void RecordExitFunnels(const base::string16& registry_path) {
+  base::win::RegistryKeyIterator it(HKEY_CURRENT_USER, registry_path.c_str());
+  if (!it.Valid())
+    return;
+
+  // Exit early if no work to do.
+  if (it.SubkeyCount() == 0)
+    return;
+
+  // Open the key we use for deletion preemptively to prevent reporting
+  // multiple times on permission problems.
+  base::win::RegKey key(HKEY_CURRENT_USER,
+                        registry_path.c_str(),
+                        KEY_QUERY_VALUE);
+  if (!key.Valid()) {
+    LOG(ERROR) << "Failed to open " << registry_path << " for writing.";
+    return;
+  }
+
+  std::vector<base::string16> to_delete;
+  for (; it.Valid(); ++it) {
+    RecordSingleExitFunnel(&key, it.Name());
+    to_delete.push_back(it.Name());
+  }
+
+  for (size_t i = 0; i < to_delete.size(); ++i) {
+    LONG res = key.DeleteEmptyKey(to_delete[i].c_str());
+    if (res != ERROR_SUCCESS)
+      LOG(ERROR) << "Failed to delete key " << to_delete[i];
+  }
+}
+
 }  // namespace
 
 const char WatcherMetricsProviderWin::kBrowserExitCodeHistogramName[] =
     "Stability.BrowserExitCodes";
+const char WatcherMetricsProviderWin::kExitFunnelHistogramPrefix[] =
+    "Stability.ExitFunnel.";
 
 WatcherMetricsProviderWin::WatcherMetricsProviderWin(
     const base::char16* registry_path) : registry_path_(registry_path) {
 }
 
 WatcherMetricsProviderWin::~WatcherMetricsProviderWin() {
 }
 
 void WatcherMetricsProviderWin::ProvideStabilityMetrics(
     metrics::SystemProfileProto* /* system_profile_proto */) {
   // Note that if there are multiple instances of Chrome running in the same
   // user account, there's a small race that will double-report the exit codes
   // from both/multiple instances. This ought to be vanishingly rare and will
   // only manifest as low-level "random" noise. To work around this it would be
   // necessary to implement some form of global locking, which is not worth it
   // here.
-  base::win::RegKey regkey(HKEY_CURRENT_USER,
-                           registry_path_.c_str(),
-                           KEY_QUERY_VALUE | KEY_SET_VALUE);
-
-  size_t num = regkey.GetValueCount();
-  if (num != 0) {
-    std::vector<base::string16> to_delete;
-
-    // Record the exit codes in a sparse stability histogram, as the range of
-    // values used to report failures is large.
-    base::HistogramBase* exit_code_histogram =
-        base::SparseHistogram::FactoryGet(kBrowserExitCodeHistogramName,
-            base::HistogramBase::kUmaStabilityHistogramFlag);
-
-    for (size_t i = 0; i < num; ++i) {
-      base::string16 name;
-      if (regkey.GetValueNameAt(static_cast<int>(i), &name) == ERROR_SUCCESS) {
-        DWORD exit_code = 0;
-        if (regkey.ReadValueDW(name.c_str(), &exit_code) == ERROR_SUCCESS) {
-          // Do not report exit codes for processes that are still live,
-          // notably for our own process.
-          if (exit_code != STILL_ACTIVE || IsDeadProcess(name)) {
-            to_delete.push_back(name);
-            exit_code_histogram->Add(exit_code);
-          }
-        }
-      }
-    }
-
-    // Delete the values reported above.
-    for (size_t i = 0; i < to_delete.size(); ++i)
-      regkey.DeleteValue(to_delete[i].c_str());
-  }
+  RecordExitCodes(registry_path_);
+  RecordExitFunnels(registry_path_);
 }
 
 }  // namespace browser_watcher