components/metrics/metrics_service_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/metrics/metrics_service.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/metrics/statistics_recorder.h"
  13 #include "base/prefs/testing_pref_service.h"
  14 #include "base/threading/platform_thread.h"
  15 #include "components/metrics/client_info.h"
  16 #include "components/metrics/compression_utils.h"
  17 #include "components/metrics/metrics_hashes.h"
  18 #include "components/metrics/metrics_log.h"
  19 #include "components/metrics/metrics_pref_names.h"
  20 #include "components/metrics/metrics_state_manager.h"
  21 #include "components/metrics/test_metrics_service_client.h"
  22 #include "components/variations/metrics_util.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 namespace metrics {
  26
  27 namespace {
  28
  29 void StoreNoClientInfoBackup(const ClientInfo& /* client_info */) {
  30 }
  31
  32 scoped_ptr<ClientInfo> ReturnNoBackup() {
  33   return scoped_ptr<ClientInfo>();
  34 }
  35
  36 class TestMetricsProvider : public MetricsProvider {
  37  public:
  38   explicit TestMetricsProvider(bool has_stability_metrics) :
  39       has_stability_metrics_(has_stability_metrics),
  40       provide_stability_metrics_called_(false) {
  41   }
  42
  43   bool HasStabilityMetrics() override { return has_stability_metrics_; }
  44   void ProvideStabilityMetrics(
  45       SystemProfileProto* system_profile_proto) override {
  46     UMA_STABILITY_HISTOGRAM_ENUMERATION("TestMetricsProvider.Metric", 1, 2);
  47     provide_stability_metrics_called_ = true;
  48   }
  49
  50   bool provide_stability_metrics_called() const {
  51     return provide_stability_metrics_called_;
  52   }
  53
  54  private:
  55   bool has_stability_metrics_;
  56   bool provide_stability_metrics_called_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(TestMetricsProvider);
  59 };
  60
  61 class TestMetricsService : public MetricsService {
  62  public:
  63   TestMetricsService(MetricsStateManager* state_manager,
  64                      MetricsServiceClient* client,
  65                      PrefService* local_state)
  66       : MetricsService(state_manager, client, local_state) {}
  67   ~TestMetricsService() override {}
  68
  69   using MetricsService::log_manager;
  70
  71  private:
  72   DISALLOW_COPY_AND_ASSIGN(TestMetricsService);
  73 };
  74
  75 class TestMetricsLog : public MetricsLog {
  76  public:
  77   TestMetricsLog(const std::string& client_id,
  78                  int session_id,
  79                  MetricsServiceClient* client,
  80                  PrefService* local_state)
  81       : MetricsLog(client_id,
  82                    session_id,
  83                    MetricsLog::ONGOING_LOG,
  84                    client,
  85                    local_state) {}
  86
  87   ~TestMetricsLog() override {}
  88
  89  private:
  90   DISALLOW_COPY_AND_ASSIGN(TestMetricsLog);
  91 };
  92
  93 class MetricsServiceTest : public testing::Test {
  94  public:
  95   MetricsServiceTest() : is_metrics_reporting_enabled_(false) {
  96     MetricsService::RegisterPrefs(testing_local_state_.registry());
  97     metrics_state_manager_ = MetricsStateManager::Create(
  98         GetLocalState(),
  99         base::Bind(&MetricsServiceTest::is_metrics_reporting_enabled,
 100                    base::Unretained(this)),
 101         base::Bind(&StoreNoClientInfoBackup),
 102         base::Bind(&ReturnNoBackup));
 103   }
 104
 105   ~MetricsServiceTest() override {
 106     MetricsService::SetExecutionPhase(MetricsService::UNINITIALIZED_PHASE,
 107                                       GetLocalState());
 108   }
 109
 110   MetricsStateManager* GetMetricsStateManager() {
 111     return metrics_state_manager_.get();
 112   }
 113
 114   PrefService* GetLocalState() { return &testing_local_state_; }
 115
 116   // Sets metrics reporting as enabled for testing.
 117   void EnableMetricsReporting() {
 118     is_metrics_reporting_enabled_ = true;
 119   }
 120
 121   // Waits until base::TimeTicks::Now() no longer equals |value|. This should
 122   // take between 1-15ms per the documented resolution of base::TimeTicks.
 123   void WaitUntilTimeChanges(const base::TimeTicks& value) {
 124     while (base::TimeTicks::Now() == value) {
 125       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
 126     }
 127   }
 128
 129   // Returns true if there is a synthetic trial in the given vector that matches
 130   // the given trial name and trial group; returns false otherwise.
 131   bool HasSyntheticTrial(
 132       const std::vector<variations::ActiveGroupId>& synthetic_trials,
 133       const std::string& trial_name,
 134       const std::string& trial_group) {
 135     uint32 trial_name_hash = HashName(trial_name);
 136     uint32 trial_group_hash = HashName(trial_group);
 137     for (const variations::ActiveGroupId& trial : synthetic_trials) {
 138       if (trial.name == trial_name_hash && trial.group == trial_group_hash)
 139         return true;
 140     }
 141     return false;
 142   }
 143
 144   // Finds a histogram with the specified |name_hash| in |histograms|.
 145   const base::HistogramBase* FindHistogram(
 146       const base::StatisticsRecorder::Histograms& histograms,
 147       uint64 name_hash) {
 148     for (const base::HistogramBase* histogram : histograms) {
 149       if (name_hash == HashMetricName(histogram->histogram_name()))
 150         return histogram;
 151     }
 152     return nullptr;
 153   }
 154
 155   // Checks whether |uma_log| contains any histograms that are not flagged
 156   // with kUmaStabilityHistogramFlag. Stability logs should only contain such
 157   // histograms.
 158   void CheckForNonStabilityHistograms(
 159       const ChromeUserMetricsExtension& uma_log) {
 160     const int kStabilityFlags = base::HistogramBase::kUmaStabilityHistogramFlag;
 161     base::StatisticsRecorder::Histograms histograms;
 162     base::StatisticsRecorder::GetHistograms(&histograms);
 163     for (int i = 0; i < uma_log.histogram_event_size(); ++i) {
 164       const uint64 hash = uma_log.histogram_event(i).name_hash();
 165
 166       const base::HistogramBase* histogram = FindHistogram(histograms, hash);
 167       EXPECT_TRUE(histogram) << hash;
 168
 169       EXPECT_EQ(kStabilityFlags, histogram->flags() & kStabilityFlags) << hash;
 170     }
 171   }
 172
 173  private:
 174   bool is_metrics_reporting_enabled() const {
 175     return is_metrics_reporting_enabled_;
 176   }
 177
 178   bool is_metrics_reporting_enabled_;
 179   TestingPrefServiceSimple testing_local_state_;
 180   scoped_ptr<MetricsStateManager> metrics_state_manager_;
 181   base::MessageLoop message_loop;
 182
 183   DISALLOW_COPY_AND_ASSIGN(MetricsServiceTest);
 184 };
 185
 186 }  // namespace
 187
 188 TEST_F(MetricsServiceTest, InitialStabilityLogAfterCleanShutDown) {
 189   EnableMetricsReporting();
 190   GetLocalState()->SetBoolean(prefs::kStabilityExitedCleanly, true);
 191
 192   TestMetricsServiceClient client;
 193   TestMetricsService service(
 194       GetMetricsStateManager(), &client, GetLocalState());
 195
 196   TestMetricsProvider* test_provider = new TestMetricsProvider(false);
 197   service.RegisterMetricsProvider(scoped_ptr<MetricsProvider>(test_provider));
 198
 199   service.InitializeMetricsRecordingState();
 200   // No initial stability log should be generated.
 201   EXPECT_FALSE(service.log_manager()->has_unsent_logs());
 202   EXPECT_FALSE(service.log_manager()->has_staged_log());
 203
 204   // The test provider should not have been called upon to provide stability
 205   // metrics.
 206   EXPECT_FALSE(test_provider->provide_stability_metrics_called());
 207 }
 208
 209 TEST_F(MetricsServiceTest, InitialStabilityLogAtProviderRequest) {
 210   EnableMetricsReporting();
 211
 212   // Save an existing system profile to prefs, to correspond to what would be
 213   // saved from a previous session.
 214   TestMetricsServiceClient client;
 215   TestMetricsLog log("client", 1, &client, GetLocalState());
 216   log.RecordEnvironment(std::vector<MetricsProvider*>(),
 217                         std::vector<variations::ActiveGroupId>(),
 218                         0);
 219
 220   // Record stability build time and version from previous session, so that
 221   // stability metrics (including exited cleanly flag) won't be cleared.
 222   GetLocalState()->SetInt64(prefs::kStabilityStatsBuildTime,
 223                             MetricsLog::GetBuildTime());
 224   GetLocalState()->SetString(prefs::kStabilityStatsVersion,
 225                              client.GetVersionString());
 226
 227   // Set the clean exit flag, as that will otherwise cause a stabilty
 228   // log to be produced, irrespective provider requests.
 229   GetLocalState()->SetBoolean(prefs::kStabilityExitedCleanly, true);
 230
 231   TestMetricsService service(
 232       GetMetricsStateManager(), &client, GetLocalState());
 233   // Add a metrics provider that requests a stability log.
 234   TestMetricsProvider* test_provider = new TestMetricsProvider(true);
 235   service.RegisterMetricsProvider(
 236       scoped_ptr<MetricsProvider>(test_provider));
 237
 238   service.InitializeMetricsRecordingState();
 239
 240   // The initial stability log should be generated and persisted in unsent logs.
 241   MetricsLogManager* log_manager = service.log_manager();
 242   EXPECT_TRUE(log_manager->has_unsent_logs());
 243   EXPECT_FALSE(log_manager->has_staged_log());
 244
 245   // The test provider should have been called upon to provide stability
 246   // metrics.
 247   EXPECT_TRUE(test_provider->provide_stability_metrics_called());
 248
 249   // Stage the log and retrieve it.
 250   log_manager->StageNextLogForUpload();
 251   EXPECT_TRUE(log_manager->has_staged_log());
 252
 253   std::string uncompressed_log;
 254   EXPECT_TRUE(GzipUncompress(log_manager->staged_log(), &uncompressed_log));
 255
 256   ChromeUserMetricsExtension uma_log;
 257   EXPECT_TRUE(uma_log.ParseFromString(uncompressed_log));
 258
 259   EXPECT_TRUE(uma_log.has_client_id());
 260   EXPECT_TRUE(uma_log.has_session_id());
 261   EXPECT_TRUE(uma_log.has_system_profile());
 262   EXPECT_EQ(0, uma_log.user_action_event_size());
 263   EXPECT_EQ(0, uma_log.omnibox_event_size());
 264   EXPECT_EQ(0, uma_log.profiler_event_size());
 265   EXPECT_EQ(0, uma_log.perf_data_size());
 266   CheckForNonStabilityHistograms(uma_log);
 267
 268   // As there wasn't an unclean shutdown, this log has zero crash count.
 269   EXPECT_EQ(0, uma_log.system_profile().stability().crash_count());
 270 }
 271
 272 TEST_F(MetricsServiceTest, InitialStabilityLogAfterCrash) {
 273   EnableMetricsReporting();
 274   GetLocalState()->ClearPref(prefs::kStabilityExitedCleanly);
 275
 276   // Set up prefs to simulate restarting after a crash.
 277
 278   // Save an existing system profile to prefs, to correspond to what would be
 279   // saved from a previous session.
 280   TestMetricsServiceClient client;
 281   TestMetricsLog log("client", 1, &client, GetLocalState());
 282   log.RecordEnvironment(std::vector<MetricsProvider*>(),
 283                         std::vector<variations::ActiveGroupId>(),
 284                         0);
 285
 286   // Record stability build time and version from previous session, so that
 287   // stability metrics (including exited cleanly flag) won't be cleared.
 288   GetLocalState()->SetInt64(prefs::kStabilityStatsBuildTime,
 289                             MetricsLog::GetBuildTime());
 290   GetLocalState()->SetString(prefs::kStabilityStatsVersion,
 291                              client.GetVersionString());
 292
 293   GetLocalState()->SetBoolean(prefs::kStabilityExitedCleanly, false);
 294
 295   TestMetricsService service(
 296       GetMetricsStateManager(), &client, GetLocalState());
 297   service.InitializeMetricsRecordingState();
 298
 299   // The initial stability log should be generated and persisted in unsent logs.
 300   MetricsLogManager* log_manager = service.log_manager();
 301   EXPECT_TRUE(log_manager->has_unsent_logs());
 302   EXPECT_FALSE(log_manager->has_staged_log());
 303
 304   // Stage the log and retrieve it.
 305   log_manager->StageNextLogForUpload();
 306   EXPECT_TRUE(log_manager->has_staged_log());
 307
 308   std::string uncompressed_log;
 309   EXPECT_TRUE(GzipUncompress(log_manager->staged_log(), &uncompressed_log));
 310
 311   ChromeUserMetricsExtension uma_log;
 312   EXPECT_TRUE(uma_log.ParseFromString(uncompressed_log));
 313
 314   EXPECT_TRUE(uma_log.has_client_id());
 315   EXPECT_TRUE(uma_log.has_session_id());
 316   EXPECT_TRUE(uma_log.has_system_profile());
 317   EXPECT_EQ(0, uma_log.user_action_event_size());
 318   EXPECT_EQ(0, uma_log.omnibox_event_size());
 319   EXPECT_EQ(0, uma_log.profiler_event_size());
 320   EXPECT_EQ(0, uma_log.perf_data_size());
 321   CheckForNonStabilityHistograms(uma_log);
 322
 323   EXPECT_EQ(1, uma_log.system_profile().stability().crash_count());
 324 }
 325
 326 TEST_F(MetricsServiceTest, RegisterSyntheticTrial) {
 327   TestMetricsServiceClient client;
 328   MetricsService service(GetMetricsStateManager(), &client, GetLocalState());
 329
 330   // Add two synthetic trials and confirm that they show up in the list.
 331   SyntheticTrialGroup trial1(HashName("TestTrial1"), HashName("Group1"));
 332   service.RegisterSyntheticFieldTrial(trial1);
 333
 334   SyntheticTrialGroup trial2(HashName("TestTrial2"), HashName("Group2"));
 335   service.RegisterSyntheticFieldTrial(trial2);
 336   // Ensure that time has advanced by at least a tick before proceeding.
 337   WaitUntilTimeChanges(base::TimeTicks::Now());
 338
 339   service.log_manager_.BeginLoggingWithLog(scoped_ptr<MetricsLog>(
 340       new MetricsLog("clientID",
 341                      1,
 342                      MetricsLog::INITIAL_STABILITY_LOG,
 343                      &client,
 344                      GetLocalState())));
 345   // Save the time when the log was started (it's okay for this to be greater
 346   // than the time recorded by the above call since it's used to ensure the
 347   // value changes).
 348   const base::TimeTicks begin_log_time = base::TimeTicks::Now();
 349
 350   std::vector<variations::ActiveGroupId> synthetic_trials;
 351   service.GetCurrentSyntheticFieldTrials(&synthetic_trials);
 352   EXPECT_EQ(2U, synthetic_trials.size());
 353   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial1", "Group1"));
 354   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial2", "Group2"));
 355
 356   // Ensure that time has advanced by at least a tick before proceeding.
 357   WaitUntilTimeChanges(begin_log_time);
 358
 359   // Change the group for the first trial after the log started.
 360   SyntheticTrialGroup trial3(HashName("TestTrial1"), HashName("Group2"));
 361   service.RegisterSyntheticFieldTrial(trial3);
 362   service.GetCurrentSyntheticFieldTrials(&synthetic_trials);
 363   EXPECT_EQ(1U, synthetic_trials.size());
 364   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial2", "Group2"));
 365
 366   // Add a new trial after the log started and confirm that it doesn't show up.
 367   SyntheticTrialGroup trial4(HashName("TestTrial3"), HashName("Group3"));
 368   service.RegisterSyntheticFieldTrial(trial4);
 369   service.GetCurrentSyntheticFieldTrials(&synthetic_trials);
 370   EXPECT_EQ(1U, synthetic_trials.size());
 371   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial2", "Group2"));
 372
 373   // Ensure that time has advanced by at least a tick before proceeding.
 374   WaitUntilTimeChanges(base::TimeTicks::Now());
 375
 376   // Start a new log and ensure all three trials appear in it.
 377   service.log_manager_.FinishCurrentLog();
 378   service.log_manager_.BeginLoggingWithLog(
 379       scoped_ptr<MetricsLog>(new MetricsLog(
 380           "clientID", 1, MetricsLog::ONGOING_LOG, &client, GetLocalState())));
 381   service.GetCurrentSyntheticFieldTrials(&synthetic_trials);
 382   EXPECT_EQ(3U, synthetic_trials.size());
 383   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial1", "Group2"));
 384   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial2", "Group2"));
 385   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial3", "Group3"));
 386   service.log_manager_.FinishCurrentLog();
 387 }
 388
 389 }  // namespace metrics