Support experiment to store persistent metrics in memory-mapped file.

chrome/browser/chrome_browser_field_trials.cc

 // Copyright (c) 2012 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 "chrome/browser/chrome_browser_field_trials.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
+#include "base/files/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/persistent_histogram_allocator.h"
+#include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/metrics/chrome_metrics_service_client.h"
 #include "chrome/browser/tracing/background_tracing_field_trial.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/metrics/metrics_pref_names.h"
+#include "components/variations/variations_associated_data.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/chrome_browser_field_trials_mobile.h"
 #else
 #include "chrome/browser/chrome_browser_field_trials_desktop.h"
 #endif
 
 namespace {
 
 // Check for feature enabling the use of persistent histogram storage and
 // enable the global allocator if so.
 void InstantiatePersistentHistograms() {

[Alexei Svitkine (slow), 2016/06/28 15:08:00]

Both this code and corresponding code in chrome_metrics_service_client.cc is
getting pretty involved now.

I suggest moving things to a new file (e.g.
persistent_metrics_initialization.cc) where both this code and
CreateInstallerFileMetricsProvider() can live. This way,
ChromeMetricsServiceClient::kBrowserMetricsName can be made local to that file
and you can make a helper function for generating the metrics file name that you
can share instead of duplicating code.

I'm OK with doing all of the above in a separate follow-up CL - so you can just
add a TODO here for now that you can address in a follow-up CL. Thanks!

[bcwhite, 2016/06/29 03:17:03]

Acknowledged.

-  if (base::FeatureList::IsEnabled(base::kPersistentHistogramsFeature)) {
-    // Create persistent/shared memory and allow histograms to be stored in
-    // it. Memory that is not actualy used won't be physically mapped by the
-    // system. BrowserMetrics usage, as reported in UMA, peaked around 1.9MiB
-    // as of 2016-02-20.
+  base::FilePath metrics_dir;
+  if (!base::PathService::Get(chrome::DIR_USER_DATA, &metrics_dir))
+    return;
+
+  base::FilePath metrics_file =
+      metrics_dir
+          .AppendASCII(ChromeMetricsServiceClient::kBrowserMetricsName)
+          .AddExtension(base::PersistentMemoryAllocator::kFileExtension);
+  base::FilePath active_file =
+      metrics_dir
+          .AppendASCII(
+              std::string(ChromeMetricsServiceClient::kBrowserMetricsName) +
+              "-active")
+          .AddExtension(base::PersistentMemoryAllocator::kFileExtension);
+
+  // Move any existing "active" file to the final name from which it will be
+  // read when reporting initial stability metrics. If there is no file to

[Alexei Svitkine (slow), 2016/06/28 15:08:00]

I'm not sure this behavior makes sense.

The initial stability metrics report (that uses the "saved" system profile from
the previous session) will only report histograms that are marked as "uma
stability histograms". So, assuming that file is opened and its contents are
merged into the global statistics recorder, then what happens is that only
stability metrics will be picked up and reported correctly (with the old system
profile), but the other metrics won't be and will persist and get reported by
this browser's next upload, which uses a system profile that doesn't correspond
to last session.

I don't think we want the above behavior since it will cause confusing metrics.

[bcwhite, 2016/06/29 03:17:03]

The FileMetricsProvider, when doing RecordInitialHistogramSnapshots() that is
called because it is tagged ASSOCIATE_PREVIOUS_RUN will send all non-zero
metrics regardless of what flags it may have.  None of the metrics from it will
get merged into the SR.

+  // move, remove any old, existing file from before the previous session.
+  if (!base::ReplaceFile(active_file, metrics_file, nullptr))
+    base::DeleteFile(metrics_file, /*recursive=*/false);
+
+  // Create persistent/shared memory and allow histograms to be stored in
+  // it. Memory that is not actualy used won't be physically mapped by the
+  // system. BrowserMetrics usage, as reported in UMA, peaked around 1.9MiB
+  // as of 2016-02-20.
+  const size_t kAllocSize = 3 << 20;     // 3 MiB
+  const uint32_t kAllocId = 0x935DDD43;  // SHA1(BrowserMetrics)
+  std::string storage = variations::GetVariationParamValue(

[Alexei Svitkine (slow), 2016/06/28 15:08:00]

Use GetVariationParamValueByFeature().

[bcwhite, 2016/06/29 03:17:03]

Done.

+      base::kPersistentHistogramsFeature.name, "storage");
+  if (storage == "MappedFile") {
+    // Create global allocator with the "active" file.
+    base::GlobalHistogramAllocator::CreateWithFile(
+        active_file, kAllocSize, kAllocId,
+        ChromeMetricsServiceClient::kBrowserMetricsName);
+  } else if (storage == "LocalMemory") {
+    // Use local memory for storage even though it will not persist across
+    // an unclean shutdown.
     base::GlobalHistogramAllocator::CreateWithLocalMemory(
-        3 << 20,     // 3 MiB
-        0x935DDD43,  // SHA1(BrowserMetrics)
-        ChromeMetricsServiceClient::kBrowserMetricsName);
-    base::GlobalHistogramAllocator* allocator =
-        base::GlobalHistogramAllocator::Get();
-    allocator->CreateTrackingHistograms(
-        ChromeMetricsServiceClient::kBrowserMetricsName);
+        kAllocSize, kAllocId, ChromeMetricsServiceClient::kBrowserMetricsName);
+  } else {
+    // Persistent metric storage is disabled.
+    return;
   }
+
+  base::GlobalHistogramAllocator* allocator =
+      base::GlobalHistogramAllocator::Get();
+  allocator->CreateTrackingHistograms(
+      ChromeMetricsServiceClient::kBrowserMetricsName);
+  allocator->SetPersistentLocation(active_file);
 }
 
 }  // namespace
 
 ChromeBrowserFieldTrials::ChromeBrowserFieldTrials(
     const base::CommandLine& parsed_command_line)
     : parsed_command_line_(parsed_command_line) {
 }
 
 ChromeBrowserFieldTrials::~ChromeBrowserFieldTrials() {
 }
 
 void ChromeBrowserFieldTrials::SetupFieldTrials() {
   // Field trials that are shared by all platforms.
   InstantiateDynamicTrials();
 
 #if defined(OS_ANDROID)
   chrome::SetupMobileFieldTrials(parsed_command_line_);
 #else
   chrome::SetupDesktopFieldTrials(parsed_command_line_);
 #endif
 }
 
 void ChromeBrowserFieldTrials::InstantiateDynamicTrials() {
   // Persistent histograms must be enabled as soon as possible.
   InstantiatePersistentHistograms();
   tracing::SetupBackgroundTracingFieldTrial();
 }