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 35 matching lines @@
     return false;
 
   const TypedValue& value = it->second;
   if (value.value_case() != TypedValue::kSignedValue)
     return false;
 
   *time = base::Time::FromInternalValue(value.signed_value());
   return true;
 }
 
+void LogCollectionStatus(CollectionStatus status) {
+  UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.Status", status,
+                            COLLECTION_STATUS_MAX);
+}
+
 }  // namespace
 
 PostmortemReportCollector::PostmortemReportCollector(
     const std::string& product_name,
     const std::string& version_number,
     const std::string& channel_name,
     SystemSessionAnalyzer* analyzer)
     : product_name_(product_name),
       version_number_(version_number),
       channel_name_(channel_name),
@@ skipping 18 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);
-    // TODO(manzagop): consider making this a stability metric.
-    UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.Status", status,
-                              COLLECTION_STATUS_MAX);
-    if (status == SUCCESS)
-      ++success_cnt;
+    bool system_unclean = false;
+    if (CollectAndSubmitOneReport(client_id, file, report_database,
+                                  &system_unclean)) {
+      ++unclean_cnt;
+      if (system_unclean)
+        ++unclean_system_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(
+bool PostmortemReportCollector::CollectAndSubmitOneReport(
     const crashpad::UUID& client_id,
     const FilePath& file,
-    crashpad::CrashReportDatabase* report_database) {
+    crashpad::CrashReportDatabase* report_database,
+    bool* system_unclean) {
   DCHECK_NE(nullptr, report_database);
+  DCHECK_NE(nullptr, system_unclean);
+  *system_unclean = false;
 
   // 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
     // logging happens within the Collect function.
     if (!base::DeleteFile(file, false))
       DLOG(ERROR) << "Failed to delete " << file.value();
-    return status;
+    LogCollectionStatus(status);
+    return false;
   }
 
   // Prepare a crashpad report.
   CrashReportDatabase::NewReport* new_report = nullptr;
   CrashReportDatabase::OperationStatus database_status =
       report_database->PrepareNewCrashReport(&new_report);
   if (database_status != CrashReportDatabase::kNoError) {
     // Assume this is recoverable: not deleting the file.
     DLOG(ERROR) << "PrepareNewCrashReport failed";
-    return PREPARE_NEW_CRASH_REPORT_FAILED;
+    LogCollectionStatus(PREPARE_NEW_CRASH_REPORT_FAILED);
+    return false;
   }
   CrashReportDatabase::CallErrorWritingCrashReport
       call_error_writing_crash_report(report_database, new_report);
 
   // Write the report to a minidump.
   if (!WriteReportToMinidump(&report_proto, client_id, new_report->uuid,
                              reinterpret_cast<FILE*>(new_report->handle))) {
     // Assume this is not recoverable and delete the file.
     if (!base::DeleteFile(file, false))
       DLOG(ERROR) << "Failed to delete " << file.value();
-    return WRITE_TO_MINIDUMP_FAILED;
+    LogCollectionStatus(WRITE_TO_MINIDUMP_FAILED);
+    return false;
   }
 
   // If the file cannot be deleted, do not report its contents. Note this can
   // lead to under reporting and retries. However, under reporting is
   // preferable to the over reporting that would happen with a file that
   // cannot be deleted.
   // TODO(manzagop): metrics for the number of non-deletable files.
   if (!base::DeleteFile(file, false)) {
     DLOG(ERROR) << "Failed to delete " << file.value();
-    return DEBUG_FILE_DELETION_FAILED;
+    LogCollectionStatus(DEBUG_FILE_DELETION_FAILED);
+    return false;
   }
 
   // Finalize the report wrt the report database. Note that this doesn't trigger
   // an immediate upload, but Crashpad will eventually upload the report (as of
   // 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;
+    LogCollectionStatus(FINISHED_WRITING_CRASH_REPORT_FAILED);
+    return false;
   }
 
-  return SUCCESS;
+  // Report collection is successful. We may increment |unclean_system_cnt|.
+  if (report_proto.system_state().session_state() == SystemState::UNCLEAN)
+    *system_unclean = true;
+
+  return true;
 }
 
 CollectionStatus PostmortemReportCollector::CollectOneReport(
     const base::FilePath& file,
     StabilityReport* report) {
   DCHECK(report);
 
   CollectionStatus status = Extract(file, report);
   if (status != SUCCESS)
     return status;
@@ skipping 70 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