Quantify instability according to the stability instrumentation

components/browser_watcher/postmortem_report_collector.cc

 // Copyright 2016 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/postmortem_report_collector.h"
 
 #include <utility>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
@@ skipping 73 matching lines @@
 
   // Determine the crashpad client id.
   crashpad::UUID client_id;
   crashpad::Settings* settings = report_database->GetSettings();
   if (settings) {
     // If GetSettings() or GetClientID() fails client_id will be left at its
     // default value, all zeroes, which is appropriate.
     settings->GetClientID(&client_id);
   }
 
+  // Number of unclean shutdowns based on successful collection of stability
+  // reports.
+  int unclean_cnt = 0;
+  // Number of unclean shutdowns that may be attributable to system instability
+  // based on successful collection of stability reports. This number should be
+  // smaller or equal to |unclean_cnt|.
+  int unclean_system_cnt = 0;
+
   // Process each stability file.
-  int success_cnt = 0;
   for (const FilePath& file : debug_files) {
-    CollectionStatus status =
-        CollectAndSubmitOneReport(client_id, file, report_database);
+    CollectionStatus status = CollectAndSubmitOneReport(
+        client_id, file, report_database, &unclean_system_cnt);
     // TODO(manzagop): consider making this a stability metric.
     UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.Status", status,
                               COLLECTION_STATUS_MAX);
     if (status == SUCCESS)

[Sigurður Ásgeirsson, 2017/05/18 12:45:03]

yups, if the CollectOne function reports a bool, then your counting all comes to
this point.

[manzagop (departed), 2017/05/18 14:52:12]

Done.

-      ++success_cnt;
+      ++unclean_cnt;
   }
 
-  return success_cnt;
+  UMA_STABILITY_HISTOGRAM_COUNTS_100(
+      "ActivityTracker.Collect.UncleanShutdownCount", unclean_cnt);
+  UMA_STABILITY_HISTOGRAM_COUNTS_100(
+      "ActivityTracker.Collect.UncleanSystemCount", unclean_system_cnt);
+
+  return unclean_cnt;
 }
 
 std::vector<FilePath> PostmortemReportCollector::GetDebugStateFilePaths(
     const FilePath& debug_info_dir,
     const FilePath::StringType& debug_file_pattern,
     const std::set<FilePath>& excluded_debug_files) {
   DCHECK_NE(true, debug_info_dir.empty());
   DCHECK_NE(true, debug_file_pattern.empty());
 
   std::vector<FilePath> paths;
   base::FileEnumerator enumerator(debug_info_dir, false /* recursive */,
                                   base::FileEnumerator::FILES,
                                   debug_file_pattern);
   FilePath path;
   for (path = enumerator.Next(); !path.empty(); path = enumerator.Next()) {
     if (excluded_debug_files.find(path) == excluded_debug_files.end())
       paths.push_back(path);
   }
   return paths;
 }
 
 CollectionStatus PostmortemReportCollector::CollectAndSubmitOneReport(
     const crashpad::UUID& client_id,
     const FilePath& file,
-    crashpad::CrashReportDatabase* report_database) {
+    crashpad::CrashReportDatabase* report_database,
+    int* unclean_system_cnt) {
   DCHECK_NE(nullptr, report_database);
+  DCHECK_NE(nullptr, unclean_system_cnt);
 
   // Note: the code below involves two notions of report: chrome internal state
   // reports and the crashpad reports they get wrapped into.
 
   // Collect the data from the debug file to a proto. Note: a non-empty report
   // is interpreted here as an unclean exit.
   StabilityReport report_proto;
   CollectionStatus status = CollectOneReport(file, &report_proto);
   if (status != SUCCESS) {
     // The file was empty, or there was an error collecting the data. Detailed
@@ skipping 39 matching lines @@
   // writing, the delay is on the order of up to 15 minutes).
   call_error_writing_crash_report.Disarm();
   crashpad::UUID unused_report_id;
   database_status = report_database->FinishedWritingCrashReport(
       new_report, &unused_report_id);
   if (database_status != CrashReportDatabase::kNoError) {
     DLOG(ERROR) << "FinishedWritingCrashReport failed";
     return FINISHED_WRITING_CRASH_REPORT_FAILED;
   }
 
+  // Report collection is successful. We may increment |unclean_system_cnt|.
+  if (report_proto.system_state().session_state() == SystemState::UNCLEAN)
+    (*unclean_system_cnt)++;
+
   return SUCCESS;
 }
 
 CollectionStatus PostmortemReportCollector::CollectOneReport(
     const base::FilePath& file,
     StabilityReport* report) {
   DCHECK(report);
 
   CollectionStatus status = Extract(file, report);
   if (status != SUCCESS)
@@ skipping 71 matching lines @@
     StabilityReport* report,
     const crashpad::UUID& client_id,
     const crashpad::UUID& report_id,
     base::PlatformFile minidump_file) {
   DCHECK(report);
 
   return WritePostmortemDump(minidump_file, client_id, report_id, report);
 }
 
 }  // namespace browser_watcher