components/metrics/metrics_log.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_log.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/base64.h"
  12 #include "base/basictypes.h"
  13 #include "base/build_time.h"
  14 #include "base/cpu.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/metrics/histogram.h"
  17 #include "base/metrics/histogram_samples.h"
  18 #include "base/prefs/pref_registry_simple.h"
  19 #include "base/prefs/pref_service.h"
  20 #include "base/sha1.h"
  21 #include "base/strings/string_number_conversions.h"
  22 #include "base/strings/string_util.h"
  23 #include "base/strings/utf_string_conversions.h"
  24 #include "base/sys_info.h"
  25 #include "base/time/time.h"
  26 #include "components/metrics/histogram_encoder.h"
  27 #include "components/metrics/metrics_hashes.h"
  28 #include "components/metrics/metrics_pref_names.h"
  29 #include "components/metrics/metrics_provider.h"
  30 #include "components/metrics/metrics_service_client.h"
  31 #include "components/metrics/proto/histogram_event.pb.h"
  32 #include "components/metrics/proto/system_profile.pb.h"
  33 #include "components/metrics/proto/user_action_event.pb.h"
  34 #include "components/variations/active_field_trials.h"
  35
  36 #if defined(OS_ANDROID)
  37 #include "base/android/build_info.h"
  38 #endif
  39
  40 #if defined(OS_WIN)
  41 #include "base/win/metro.h"
  42
  43 // http://blogs.msdn.com/oldnewthing/archive/2004/10/25/247180.aspx
  44 extern "C" IMAGE_DOS_HEADER __ImageBase;
  45 #endif
  46
  47 using base::SampleCountIterator;
  48 typedef variations::ActiveGroupId ActiveGroupId;
  49
  50 namespace metrics {
  51
  52 namespace {
  53
  54 // Any id less than 16 bytes is considered to be a testing id.
  55 bool IsTestingID(const std::string& id) {
  56   return id.size() < 16;
  57 }
  58
  59 // Computes a SHA-1 hash of |data| and returns it as a hex string.
  60 std::string ComputeSHA1(const std::string& data) {
  61   const std::string sha1 = base::SHA1HashString(data);
  62   return base::HexEncode(sha1.data(), sha1.size());
  63 }
  64
  65 void WriteFieldTrials(const std::vector<ActiveGroupId>& field_trial_ids,
  66                       SystemProfileProto* system_profile) {
  67   for (std::vector<ActiveGroupId>::const_iterator it =
  68        field_trial_ids.begin(); it != field_trial_ids.end(); ++it) {
  69     SystemProfileProto::FieldTrial* field_trial =
  70         system_profile->add_field_trial();
  71     field_trial->set_name_id(it->name);
  72     field_trial->set_group_id(it->group);
  73   }
  74 }
  75
  76 // Round a timestamp measured in seconds since epoch to one with a granularity
  77 // of an hour. This can be used before uploaded potentially sensitive
  78 // timestamps.
  79 int64 RoundSecondsToHour(int64 time_in_seconds) {
  80   return 3600 * (time_in_seconds / 3600);
  81 }
  82
  83 }  // namespace
  84
  85 MetricsLog::MetricsLog(const std::string& client_id,
  86                        int session_id,
  87                        LogType log_type,
  88                        MetricsServiceClient* client,
  89                        PrefService* local_state)
  90     : closed_(false),
  91       log_type_(log_type),
  92       client_(client),
  93       creation_time_(base::TimeTicks::Now()),
  94       local_state_(local_state) {
  95   if (IsTestingID(client_id))
  96     uma_proto_.set_client_id(0);
  97   else
  98     uma_proto_.set_client_id(Hash(client_id));
  99
 100   uma_proto_.set_session_id(session_id);
 101
 102   const int32 product = client_->GetProduct();
 103   // Only set the product if it differs from the default value.
 104   if (product != uma_proto_.product())
 105     uma_proto_.set_product(product);
 106
 107   SystemProfileProto* system_profile = uma_proto_.mutable_system_profile();
 108   system_profile->set_build_timestamp(GetBuildTime());
 109   system_profile->set_app_version(client_->GetVersionString());
 110   system_profile->set_channel(client_->GetChannel());
 111 #if defined(SYZYASAN)
 112   system_profile->set_is_asan_build(true);
 113 #endif
 114 }
 115
 116 MetricsLog::~MetricsLog() {
 117 }
 118
 119 // static
 120 void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) {
 121   registry->RegisterIntegerPref(prefs::kStabilityLaunchCount, 0);
 122   registry->RegisterIntegerPref(prefs::kStabilityCrashCount, 0);
 123   registry->RegisterIntegerPref(prefs::kStabilityIncompleteSessionEndCount, 0);
 124   registry->RegisterIntegerPref(prefs::kStabilityBreakpadRegistrationFail, 0);
 125   registry->RegisterIntegerPref(
 126       prefs::kStabilityBreakpadRegistrationSuccess, 0);
 127   registry->RegisterIntegerPref(prefs::kStabilityDebuggerPresent, 0);
 128   registry->RegisterIntegerPref(prefs::kStabilityDebuggerNotPresent, 0);
 129   registry->RegisterStringPref(prefs::kStabilitySavedSystemProfile,
 130                                std::string());
 131   registry->RegisterStringPref(prefs::kStabilitySavedSystemProfileHash,
 132                                std::string());
 133 }
 134
 135 // static
 136 uint64 MetricsLog::Hash(const std::string& value) {
 137   uint64 hash = HashMetricName(value);
 138
 139   // The following log is VERY helpful when folks add some named histogram into
 140   // the code, but forgot to update the descriptive list of histograms.  When
 141   // that happens, all we get to see (server side) is a hash of the histogram
 142   // name.  We can then use this logging to find out what histogram name was
 143   // being hashed to a given MD5 value by just running the version of Chromium
 144   // in question with --enable-logging.
 145   DVLOG(1) << "Metrics: Hash numeric [" << value << "]=[" << hash << "]";
 146
 147   return hash;
 148 }
 149
 150 // static
 151 int64 MetricsLog::GetBuildTime() {
 152   static int64 integral_build_time = 0;
 153   if (!integral_build_time)
 154     integral_build_time = static_cast<int64>(base::GetBuildTime().ToTimeT());
 155   return integral_build_time;
 156 }
 157
 158 // static
 159 int64 MetricsLog::GetCurrentTime() {
 160   return (base::TimeTicks::Now() - base::TimeTicks()).InSeconds();
 161 }
 162
 163 void MetricsLog::RecordUserAction(const std::string& key) {
 164   DCHECK(!closed_);
 165
 166   UserActionEventProto* user_action = uma_proto_.add_user_action_event();
 167   user_action->set_name_hash(Hash(key));
 168   user_action->set_time(GetCurrentTime());
 169 }
 170
 171 void MetricsLog::RecordHistogramDelta(const std::string& histogram_name,
 172                                       const base::HistogramSamples& snapshot) {
 173   DCHECK(!closed_);
 174   EncodeHistogramDelta(histogram_name, snapshot, &uma_proto_);
 175 }
 176
 177 void MetricsLog::RecordStabilityMetrics(
 178     const std::vector<MetricsProvider*>& metrics_providers,
 179     base::TimeDelta incremental_uptime,
 180     base::TimeDelta uptime) {
 181   DCHECK(!closed_);
 182   DCHECK(HasEnvironment());
 183   DCHECK(!HasStabilityMetrics());
 184
 185   PrefService* pref = local_state_;
 186   DCHECK(pref);
 187
 188   // Get stability attributes out of Local State, zeroing out stored values.
 189   // NOTE: This could lead to some data loss if this report isn't successfully
 190   //       sent, but that's true for all the metrics.
 191
 192   WriteRequiredStabilityAttributes(pref);
 193
 194   // Record recent delta for critical stability metrics.  We can't wait for a
 195   // restart to gather these, as that delay biases our observation away from
 196   // users that run happily for a looooong time.  We send increments with each
 197   // uma log upload, just as we send histogram data.
 198   WriteRealtimeStabilityAttributes(pref, incremental_uptime, uptime);
 199
 200   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
 201   for (size_t i = 0; i < metrics_providers.size(); ++i) {
 202     if (log_type() == INITIAL_STABILITY_LOG)
 203       metrics_providers[i]->ProvideInitialStabilityMetrics(system_profile);
 204     metrics_providers[i]->ProvideStabilityMetrics(system_profile);
 205   }
 206
 207   // Omit some stats unless this is the initial stability log.
 208   if (log_type() != INITIAL_STABILITY_LOG)
 209     return;
 210
 211   int incomplete_shutdown_count =
 212       pref->GetInteger(prefs::kStabilityIncompleteSessionEndCount);
 213   pref->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
 214   int breakpad_registration_success_count =
 215       pref->GetInteger(prefs::kStabilityBreakpadRegistrationSuccess);
 216   pref->SetInteger(prefs::kStabilityBreakpadRegistrationSuccess, 0);
 217   int breakpad_registration_failure_count =
 218       pref->GetInteger(prefs::kStabilityBreakpadRegistrationFail);
 219   pref->SetInteger(prefs::kStabilityBreakpadRegistrationFail, 0);
 220   int debugger_present_count =
 221       pref->GetInteger(prefs::kStabilityDebuggerPresent);
 222   pref->SetInteger(prefs::kStabilityDebuggerPresent, 0);
 223   int debugger_not_present_count =
 224       pref->GetInteger(prefs::kStabilityDebuggerNotPresent);
 225   pref->SetInteger(prefs::kStabilityDebuggerNotPresent, 0);
 226
 227   // TODO(jar): The following are all optional, so we *could* optimize them for
 228   // values of zero (and not include them).
 229   SystemProfileProto::Stability* stability =
 230       system_profile->mutable_stability();
 231   stability->set_incomplete_shutdown_count(incomplete_shutdown_count);
 232   stability->set_breakpad_registration_success_count(
 233       breakpad_registration_success_count);
 234   stability->set_breakpad_registration_failure_count(
 235       breakpad_registration_failure_count);
 236   stability->set_debugger_present_count(debugger_present_count);
 237   stability->set_debugger_not_present_count(debugger_not_present_count);
 238 }
 239
 240 void MetricsLog::RecordGeneralMetrics(
 241     const std::vector<MetricsProvider*>& metrics_providers) {
 242   for (size_t i = 0; i < metrics_providers.size(); ++i)
 243     metrics_providers[i]->ProvideGeneralMetrics(uma_proto());
 244 }
 245
 246 void MetricsLog::GetFieldTrialIds(
 247     std::vector<ActiveGroupId>* field_trial_ids) const {
 248   variations::GetFieldTrialActiveGroupIds(field_trial_ids);
 249 }
 250
 251 bool MetricsLog::HasEnvironment() const {
 252   return uma_proto()->system_profile().has_uma_enabled_date();
 253 }
 254
 255 bool MetricsLog::HasStabilityMetrics() const {
 256   return uma_proto()->system_profile().stability().has_launch_count();
 257 }
 258
 259 // The server refuses data that doesn't have certain values.  crashcount and
 260 // launchcount are currently "required" in the "stability" group.
 261 // TODO(isherman): Stop writing these attributes specially once the migration to
 262 // protobufs is complete.
 263 void MetricsLog::WriteRequiredStabilityAttributes(PrefService* pref) {
 264   int launch_count = pref->GetInteger(prefs::kStabilityLaunchCount);
 265   pref->SetInteger(prefs::kStabilityLaunchCount, 0);
 266   int crash_count = pref->GetInteger(prefs::kStabilityCrashCount);
 267   pref->SetInteger(prefs::kStabilityCrashCount, 0);
 268
 269   SystemProfileProto::Stability* stability =
 270       uma_proto()->mutable_system_profile()->mutable_stability();
 271   stability->set_launch_count(launch_count);
 272   stability->set_crash_count(crash_count);
 273 }
 274
 275 void MetricsLog::WriteRealtimeStabilityAttributes(
 276     PrefService* pref,
 277     base::TimeDelta incremental_uptime,
 278     base::TimeDelta uptime) {
 279   // Update the stats which are critical for real-time stability monitoring.
 280   // Since these are "optional," only list ones that are non-zero, as the counts
 281   // are aggregated (summed) server side.
 282
 283   SystemProfileProto::Stability* stability =
 284       uma_proto()->mutable_system_profile()->mutable_stability();
 285
 286   const uint64 incremental_uptime_sec = incremental_uptime.InSeconds();
 287   if (incremental_uptime_sec)
 288     stability->set_incremental_uptime_sec(incremental_uptime_sec);
 289   const uint64 uptime_sec = uptime.InSeconds();
 290   if (uptime_sec)
 291     stability->set_uptime_sec(uptime_sec);
 292 }
 293
 294 void MetricsLog::RecordEnvironment(
 295     const std::vector<MetricsProvider*>& metrics_providers,
 296     const std::vector<variations::ActiveGroupId>& synthetic_trials,
 297     int64 install_date,
 298     int64 metrics_reporting_enabled_date) {
 299   DCHECK(!HasEnvironment());
 300
 301   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
 302
 303   std::string brand_code;
 304   if (client_->GetBrand(&brand_code))
 305     system_profile->set_brand_code(brand_code);
 306
 307   // Reduce granularity of the enabled_date field to nearest hour.
 308   system_profile->set_uma_enabled_date(
 309       RoundSecondsToHour(metrics_reporting_enabled_date));
 310
 311   // Reduce granularity of the install_date field to nearest hour.
 312   system_profile->set_install_date(RoundSecondsToHour(install_date));
 313
 314   system_profile->set_application_locale(client_->GetApplicationLocale());
 315
 316   SystemProfileProto::Hardware* hardware = system_profile->mutable_hardware();
 317
 318   // HardwareModelName() will return an empty string on platforms where it's
 319   // not implemented or if an error occured.
 320   hardware->set_hardware_class(base::SysInfo::HardwareModelName());
 321
 322   hardware->set_cpu_architecture(base::SysInfo::OperatingSystemArchitecture());
 323   hardware->set_system_ram_mb(base::SysInfo::AmountOfPhysicalMemoryMB());
 324 #if defined(OS_WIN)
 325   hardware->set_dll_base(reinterpret_cast<uint64>(&__ImageBase));
 326 #endif
 327
 328   SystemProfileProto::OS* os = system_profile->mutable_os();
 329   std::string os_name = base::SysInfo::OperatingSystemName();
 330 #if defined(OS_WIN)
 331   // TODO(mad): This only checks whether the main process is a Metro process at
 332   // upload time; not whether the collected metrics were all gathered from
 333   // Metro.  This is ok as an approximation for now, since users will rarely be
 334   // switching from Metro to Desktop mode; but we should re-evaluate whether we
 335   // can distinguish metrics more cleanly in the future: http://crbug.com/140568
 336   if (base::win::IsMetroProcess())
 337     os_name += " (Metro)";
 338 #endif
 339   os->set_name(os_name);
 340   os->set_version(base::SysInfo::OperatingSystemVersion());
 341 #if defined(OS_ANDROID)
 342   os->set_fingerprint(
 343       base::android::BuildInfo::GetInstance()->android_build_fp());
 344 #endif
 345
 346   base::CPU cpu_info;
 347   SystemProfileProto::Hardware::CPU* cpu = hardware->mutable_cpu();
 348   cpu->set_vendor_name(cpu_info.vendor_name());
 349   cpu->set_signature(cpu_info.signature());
 350   cpu->set_num_cores(base::SysInfo::NumberOfProcessors());
 351
 352   std::vector<ActiveGroupId> field_trial_ids;
 353   GetFieldTrialIds(&field_trial_ids);
 354   WriteFieldTrials(field_trial_ids, system_profile);
 355   WriteFieldTrials(synthetic_trials, system_profile);
 356
 357   for (size_t i = 0; i < metrics_providers.size(); ++i)
 358     metrics_providers[i]->ProvideSystemProfileMetrics(system_profile);
 359
 360   std::string serialied_system_profile;
 361   std::string base64_system_profile;
 362   if (system_profile->SerializeToString(&serialied_system_profile)) {
 363     base::Base64Encode(serialied_system_profile, &base64_system_profile);
 364     PrefService* local_state = local_state_;
 365     local_state->SetString(prefs::kStabilitySavedSystemProfile,
 366                            base64_system_profile);
 367     local_state->SetString(prefs::kStabilitySavedSystemProfileHash,
 368                            ComputeSHA1(serialied_system_profile));
 369   }
 370 }
 371
 372 bool MetricsLog::LoadSavedEnvironmentFromPrefs() {
 373   PrefService* local_state = local_state_;
 374   const std::string base64_system_profile =
 375       local_state->GetString(prefs::kStabilitySavedSystemProfile);
 376   if (base64_system_profile.empty())
 377     return false;
 378
 379   const std::string system_profile_hash =
 380       local_state->GetString(prefs::kStabilitySavedSystemProfileHash);
 381   local_state->ClearPref(prefs::kStabilitySavedSystemProfile);
 382   local_state->ClearPref(prefs::kStabilitySavedSystemProfileHash);
 383
 384   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
 385   std::string serialied_system_profile;
 386   return base::Base64Decode(base64_system_profile, &serialied_system_profile) &&
 387          ComputeSHA1(serialied_system_profile) == system_profile_hash &&
 388          system_profile->ParseFromString(serialied_system_profile);
 389 }
 390
 391 void MetricsLog::CloseLog() {
 392   DCHECK(!closed_);
 393   closed_ = true;
 394 }
 395
 396 void MetricsLog::GetEncodedLog(std::string* encoded_log) {
 397   DCHECK(closed_);
 398   uma_proto_.SerializeToString(encoded_log);
 399 }
 400
 401 }  // namespace metrics