Quantify initial stability report edge cases.

components/metrics/metrics_log.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/metrics/metrics_log.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 99 matching lines @@
 #if defined(SYZYASAN)
   system_profile->set_is_asan_build(true);
 #endif
 }
 
 MetricsLog::~MetricsLog() {
 }
 
 // static
 void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) {
-  registry->RegisterIntegerPref(prefs::kStabilityLaunchCount, 0);
   registry->RegisterIntegerPref(prefs::kStabilityCrashCount, 0);
   registry->RegisterIntegerPref(prefs::kStabilityIncompleteSessionEndCount, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityLaunchCount, 0);
   registry->RegisterIntegerPref(prefs::kStabilityBreakpadRegistrationFail, 0);
   registry->RegisterIntegerPref(
       prefs::kStabilityBreakpadRegistrationSuccess, 0);
   registry->RegisterIntegerPref(prefs::kStabilityDebuggerPresent, 0);
   registry->RegisterIntegerPref(prefs::kStabilityDebuggerNotPresent, 0);
   registry->RegisterStringPref(prefs::kStabilitySavedSystemProfile,
                                std::string());
   registry->RegisterStringPref(prefs::kStabilitySavedSystemProfileHash,
                                std::string());
+  registry->RegisterIntegerPref(prefs::kStabilityDeferredCount, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityDiscardCount, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityVersionMismatchCount, 0);
 }
 
 // static
 uint64_t MetricsLog::Hash(const std::string& value) {
   uint64_t hash = base::HashMetricName(value);
 
   // The following log is VERY helpful when folks add some named histogram into
   // the code, but forgot to update the descriptive list of histograms.  When
   // that happens, all we get to see (server side) is a hash of the histogram
   // name.  We can then use this logging to find out what histogram name was
@@ skipping 93 matching lines @@
     pref->SetInteger(prefs::kStabilityDebuggerPresent, 0);
     stability->set_debugger_present_count(debugger_present_count);
   }
 
   int debugger_not_present_count =
       pref->GetInteger(prefs::kStabilityDebuggerNotPresent);
   if (debugger_not_present_count) {
     pref->SetInteger(prefs::kStabilityDebuggerNotPresent, 0);
     stability->set_debugger_not_present_count(debugger_not_present_count);
   }
+
+  // Note: only logging the following histograms for non-zero values.
+
+  int deferred_count = pref->GetInteger(prefs::kStabilityDeferredCount);
+  if (deferred_count) {
+    local_state_->SetInteger(prefs::kStabilityDeferredCount, 0);
+    UMA_HISTOGRAM_COUNTS_100("Stability.InitialStabilityLog.DeferredCount",

[Alexei Svitkine (slow), 2016/09/02 17:57:49]

If you want these to be logged in the initial stability log, they need to be
logged with the Stability flag. This flag makes it so such histograms are added
to the initial stability log (as it ignores all other histograms).

We have UMA_STABILITY_HISTOGRAM_ENUMERATION() macro, but don't have
UMA_STABILITY_HISTOGRAM_COUNTS_100(). Feel free to add one.

[manzagop (departed), 2016/09/02 21:00:05]

Oh, good to know! Done.

+                             deferred_count);
+  }
+
+  int discard_count = local_state_->GetInteger(prefs::kStabilityDiscardCount);
+  if (discard_count) {
+    local_state_->SetInteger(prefs::kStabilityDiscardCount, 0);
+    UMA_HISTOGRAM_COUNTS_100("Stability.InitialStabilityLog.DiscardCount",

[Alexei Svitkine (slow), 2016/09/02 17:57:49]

Will these always be logged just in the initial stability log? What guarantees
that? (i.e. I don't see a check for f (log_type() == INITIAL_STABILITY_LOG)).

[manzagop (departed), 2016/09/02 21:00:05]

No, they might be logged with any log. My thinking is if there is no initial
log, this enables faster reporting.

The discard count is special in that it's not cleared on upgrade, so a given
version's data will also include discards of past versions, but I think that's
better if we want an idea of how much is lost. If we cared, we could have a
second histogram that is version specific, and gets cleared on upgrade.

[Alexei Svitkine (slow), 2016/09/08 18:41:12]

Ah, I see - the InitialStabilityLog refers to "what" they're talking about, not
where they're logged.

+                             discard_count);
+  }
+
+  int version_mismatch_count =
+      local_state_->GetInteger(prefs::kStabilityVersionMismatchCount);
+  if (version_mismatch_count) {
+    local_state_->SetInteger(prefs::kStabilityVersionMismatchCount, 0);
+    UMA_HISTOGRAM_COUNTS_100(
+        "Stability.InitialStabilityLog.VersionMismatchCount",
+        version_mismatch_count);
+  }
 }
 
 void MetricsLog::RecordGeneralMetrics(
     const std::vector<MetricsProvider*>& metrics_providers) {
   for (size_t i = 0; i < metrics_providers.size(); ++i)
     metrics_providers[i]->ProvideGeneralMetrics(uma_proto());
 }
 
 void MetricsLog::GetFieldTrialIds(
     std::vector<ActiveGroupId>* field_trial_ids) const {
@@ skipping 139 matching lines @@
   if (system_profile->SerializeToString(&serialized_system_profile)) {
     base::Base64Encode(serialized_system_profile, &base64_system_profile);
     PrefService* local_state = local_state_;
     local_state->SetString(prefs::kStabilitySavedSystemProfile,
                            base64_system_profile);
     local_state->SetString(prefs::kStabilitySavedSystemProfileHash,
                            ComputeSHA1(serialized_system_profile));
   }
 }
 
-bool MetricsLog::LoadSavedEnvironmentFromPrefs() {
+bool MetricsLog::LoadSavedEnvironmentFromPrefs(std::string* app_version) {
+  DCHECK(app_version);
+  app_version->clear();
+
   PrefService* local_state = local_state_;
   const std::string base64_system_profile =
       local_state->GetString(prefs::kStabilitySavedSystemProfile);
   if (base64_system_profile.empty())
     return false;
 
   const std::string system_profile_hash =
       local_state->GetString(prefs::kStabilitySavedSystemProfileHash);
   local_state->ClearPref(prefs::kStabilitySavedSystemProfile);
   local_state->ClearPref(prefs::kStabilitySavedSystemProfileHash);
 
   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
   std::string serialized_system_profile;
-  return base::Base64Decode(base64_system_profile,
-                            &serialized_system_profile) &&
-         ComputeSHA1(serialized_system_profile) == system_profile_hash &&
-         system_profile->ParseFromString(serialized_system_profile);
+
+  bool success =
+      base::Base64Decode(base64_system_profile, &serialized_system_profile) &&
+      ComputeSHA1(serialized_system_profile) == system_profile_hash &&
+      system_profile->ParseFromString(serialized_system_profile);
+  if (success)
+    *app_version = system_profile->app_version();
+  return success;
 }
 
 void MetricsLog::CloseLog() {
   DCHECK(!closed_);
   closed_ = true;
 }
 
 void MetricsLog::GetEncodedLog(std::string* encoded_log) {
   DCHECK(closed_);
   uma_proto_.SerializeToString(encoded_log);
 }
 
 }  // namespace metrics