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 45 matching lines @@
 }  // 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),
-      system_session_analyzer_(analyzer) {}
+      system_session_analyzer_(analyzer),
+      unclean_system_cnt_(0) {}
 
 PostmortemReportCollector::~PostmortemReportCollector() {}
 
 int PostmortemReportCollector::CollectAndSubmitAllPendingReports(
     const base::FilePath& debug_info_dir,
     const base::FilePath::StringType& debug_file_pattern,
     const std::set<base::FilePath>& excluded_debug_files,
     crashpad::CrashReportDatabase* report_database) {
   DCHECK_NE(true, debug_info_dir.empty());
   DCHECK_NE(true, debug_file_pattern.empty());
   DCHECK_NE(nullptr, report_database);
+  unclean_system_cnt_ = 0;

[Sigurður Ásgeirsson, 2017/05/15 20:18:04]

looks like rather than a member variable, you want a local that's passed into
CollectAndSubmitOneReport?

[manzagop (departed), 2017/05/17 22:31:56]

Yes! Done.

 
   // Collect the list of files to harvest.
   std::vector<FilePath> debug_files = GetDebugStateFilePaths(
       debug_info_dir, debug_file_pattern, excluded_debug_files);
   UMA_HISTOGRAM_COUNTS_100("ActivityTracker.Collect.StabilityFileCount",
                            debug_files.size());
 
   // 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);
   }
 
   // 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;
   }
 
+  UMA_STABILITY_HISTOGRAM_COUNTS_100(
+      "ActivityTracker.Collect.UncleanShutdownCount", success_cnt);
+  UMA_STABILITY_HISTOGRAM_COUNTS_100(

[Sigurður Ásgeirsson, 2017/05/15 20:18:04]

is it possible to test these metrics - it'd be pretty sweet to have metrics we
can rely on ;).

[manzagop (departed), 2017/05/17 22:31:56]

I've added some histogram testing.

+      "ActivityTracker.Collect.UncleanSystemCount", unclean_system_cnt_);
+
   return success_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());
 
@@ skipping 133 matching lines @@
         system_session_analyzer_->IsSessionUnclean(time);
     switch (analyzer_status) {
       case SystemSessionAnalyzer::FAILED:
         status = SYSTEM_SESSION_ANALYSIS_FAILED;
         break;
       case SystemSessionAnalyzer::CLEAN:
         session_state = SystemState::CLEAN;
         break;
       case SystemSessionAnalyzer::UNCLEAN:
         session_state = SystemState::UNCLEAN;
+        unclean_system_cnt_++;
         break;
       case SystemSessionAnalyzer::OUTSIDE_RANGE:
         status = SYSTEM_SESSION_ANALYSIS_OUTSIDE_RANGE;
         break;
     }
   }
 
   report->mutable_system_state()->set_session_state(session_state);
   UMA_HISTOGRAM_ENUMERATION(
       "ActivityTracker.Collect.SystemSessionAnalysisStatus", status,
       SYSTEM_SESSION_ANALYSIS_STATUS_MAX);
 }
 
 bool PostmortemReportCollector::WriteReportToMinidump(
     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