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