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