Support "shared" histograms between processes.

components/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It is
@@ skipping 115 matching lines @@
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/histogram_persistence.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 92 matching lines @@
 
   int probability;
   // In case specified sampling rate is invalid.
   if (!base::StringToInt(probability_str, &probability))
     return true;
   return base::RandInt(1, 100) <= probability;
 }
 
 }  // namespace
 
+MetricsService::PersistentHistogramIterator::PersistentHistogramIterator(
+    AllocatorSet& allocators,
+    AllocatorSet::iterator pos)
+    : allocators_(allocators),
+      allocator_iter_(pos) {
+  if (pos != allocators_.end()) {
+    (*allocator_iter_)->CreateIterator(&histogram_iter_);
+    // Have to call ++ to advance iterator to the first persistent histogram.
+    operator++();
+  }
+}
+
+MetricsService::PersistentHistogramIterator&
+MetricsService::PersistentHistogramIterator::operator++() {
+  if (allocator_iter_ != allocators_.end()) {
+    for (;;) {
+      base::HistogramBase* h = base::GetNextPersistentHistogram(
+          *allocator_iter_, &histogram_iter_);
+      if (h) {
+        current_histogram_ = new HistogramPointer(h);
+        break;
+      }
+      allocator_iter_++;
+      if (allocator_iter_ == allocators_.end()) {
+        histogram_iter_.clear();  // Clear so it matches end() iterator.
+        current_histogram_ = nullptr;
+        break;
+      }
+      (*allocator_iter_)->CreateIterator(&histogram_iter_);
+    }
+  }
+  return *this;
+}
+
 // static
 MetricsService::ShutdownCleanliness MetricsService::clean_shutdown_status_ =
     MetricsService::CLEANLY_SHUTDOWN;
 
 MetricsService::ExecutionPhase MetricsService::execution_phase_ =
     MetricsService::UNINITIALIZED_PHASE;
 
 // static
 void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
   DCHECK(IsSingleThreaded());
@@ skipping 276 matching lines @@
                            UNINITIALIZED_PHASE);
   local_state_->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
   local_state_->SetInteger(prefs::kStabilityLaunchCount, 0);
   local_state_->SetBoolean(prefs::kStabilitySessionEndCompleted, true);
 }
 
 void MetricsService::PushExternalLog(const std::string& log) {
   log_manager_.StoreLog(log, MetricsLog::ONGOING_LOG);
 }
 
+void MetricsService::AddPersistentMemorySegment(
+    base::PersistentMemoryAllocator* allocator) {
+  DCHECK(allocators_.find(allocator) == allocators_.end());
+  allocators_.insert(allocator);
+}
+
+void MetricsService::RemovePersistentMemorySegment(
+    base::PersistentMemoryAllocator* allocator) {
+  DCHECK(allocators_.find(allocator) != allocators_.end());
+  allocators_.erase(allocator);
+}
+
 //------------------------------------------------------------------------------
 // private methods
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
 // Initialization methods
 
 void MetricsService::InitializeMetricsState() {
   const int64_t buildtime = MetricsLog::GetBuildTime();
@@ skipping 179 matching lines @@
 
   // TODO(jar): Integrate bounds on log recording more consistently, so that we
   // can stop recording logs that are too big much sooner.
   if (log_manager_.current_log()->num_events() > kEventLimit) {
     UMA_HISTOGRAM_COUNTS("UMA.Discarded Log Events",
                          log_manager_.current_log()->num_events());
     log_manager_.DiscardCurrentLog();
     OpenNewLog();  // Start trivial log to hold our histograms.
   }
 
+  base::PersistentMemoryAllocator* allocator =

[Alexei Svitkine (slow), 2016/01/14 16:43:14]

Add a comment about this block, as it's not clear what it's for.

[bcwhite, 2016/01/14 19:20:26]

Done.

+      base::GetPersistentHistogramMemoryAllocator();
+  if (allocator)
+    allocator->UpdateStaticHistograms();
+
   // Put incremental data (histogram deltas, and realtime stats deltas) at the
   // end of all log transmissions (initial log handles this separately).
   // RecordIncrementalStabilityElements only exists on the derived
   // MetricsLog class.
   MetricsLog* current_log = log_manager_.current_log();
   DCHECK(current_log);
   RecordCurrentEnvironment(current_log);
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
   GetUptimes(local_state_, &incremental_uptime, &uptime);
@@ skipping 340 matching lines @@
 void MetricsService::RecordCurrentEnvironment(MetricsLog* log) {
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetSyntheticFieldTrialsOlderThan(log->creation_time(), &synthetic_trials);
   log->RecordEnvironment(metrics_providers_.get(), synthetic_trials,
                          GetInstallDate(), GetMetricsReportingEnabledDate());
 }
 
 void MetricsService::RecordCurrentHistograms() {
   DCHECK(log_manager_.current_log());
   histogram_snapshot_manager_.PrepareDeltas(
+      base::StatisticsRecorder::begin(true), base::StatisticsRecorder::end(),
+      base::Histogram::kNoFlags, base::Histogram::kUmaTargetedHistogramFlag);
+  histogram_snapshot_manager_.PrepareDeltas(

[Alexei Svitkine (slow), 2016/01/14 16:43:14]

Can the metrics service changes be in a separate CL?

Correct me if I'm wrong, but it doesn't seem like anything is being hooked up to
metrics service here anyway - even if the trial is on, we're not going to get
AddPersistentMemorySegment() called yet until we have something coming from a
different source than the browser process. In which case, I suggest including
those changes with the first CL that starts using this - for example the CL that
adds the collection to setup.exe.

(In which case, probably all the iterator changes can also be part of that CL.)

[bcwhite, 2016/01/14 19:20:26]

It could be moved but it seems to be more "in context" here since this whole CL
is about adding persistent support.

[Alexei Svitkine (slow), 2016/01/14 21:53:41]

I disagree. Given that this CL is not adding any external persistent histograms,
I think it's cleaner to have this set of changes with the CL that does.

[bcwhite, 2016/01/15 15:24:38]

I understand the point but pushing this to the setup-metrics CL is going to
complicate the CL between it and this one (the "merge histograms" CL) since it
expands on this somewhat.  It's also going to cost me a day of time to do yet
another split and fix my CL chain in git.

[Alexei Svitkine (slow), 2016/01/15 15:43:47]

APII'm not fully sold on the iterator changes and would like to not have that
discussion block landing this CL, so would like these changes to move to a
follow-up CL - preferably the one that also adds external persistent metrics so
I can reviewer the new API in the same CL that it's used. I'm hoping we can
agree on the remaining parts on this CL and land it early next week and start
experimenting - while in parallel discussing this other part on a separate CL.

[bcwhite, 2016/01/15 19:23:41]

Done.

+      persistent_begin(), persistent_end(),
       base::Histogram::kNoFlags, base::Histogram::kUmaTargetedHistogramFlag);
 }
 
 void MetricsService::RecordCurrentStabilityHistograms() {
   DCHECK(log_manager_.current_log());
   histogram_snapshot_manager_.PrepareDeltas(
+      base::StatisticsRecorder::begin(true), base::StatisticsRecorder::end(),
       base::Histogram::kNoFlags, base::Histogram::kUmaStabilityHistogramFlag);
 }
 
 void MetricsService::LogCleanShutdown() {
   // Redundant setting to assure that we always reset this value at shutdown
   // (and that we don't use some alternate path, and not call LogCleanShutdown).
   clean_shutdown_status_ = CLEANLY_SHUTDOWN;
 
   clean_exit_beacon_.WriteBeaconValue(true);
   RecordCurrentState(local_state_);
@@ skipping 18 matching lines @@
   pref->SetInt64(prefs::kStabilityLastTimestampSec,
                  base::Time::Now().ToTimeT());
 }
 
 void MetricsService::SkipAndDiscardUpload() {
   log_manager_.DiscardStagedLog();
   scheduler_->UploadCancelled();
   log_upload_in_progress_ = false;
 }
 
+MetricsService::PersistentHistogramIterator MetricsService::persistent_begin() {
+  return PersistentHistogramIterator(allocators_, allocators_.begin());
+}
+
+MetricsService::PersistentHistogramIterator MetricsService::persistent_end() {
+  return PersistentHistogramIterator(allocators_, allocators_.end());
+}
+
 }  // namespace metrics