blob: 314200d8f07231accc9e84d733c92070b15c20b4 [file] [log] [blame]
// Copyright 2014 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 "components/metrics/metrics_log.h"
#include <algorithm>
#include <string>
#include <vector>
#include "base/base64.h"
#include "base/basictypes.h"
#include "base/cpu.h"
#include "base/memory/scoped_ptr.h"
#include "base/metrics/histogram.h"
#include "base/metrics/histogram_samples.h"
#include "base/prefs/pref_registry_simple.h"
#include "base/prefs/pref_service.h"
#include "base/sha1.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/sys_info.h"
#include "base/time/time.h"
#include "components/metrics/metrics_hashes.h"
#include "components/metrics/metrics_pref_names.h"
#include "components/metrics/metrics_provider.h"
#include "components/metrics/metrics_service_client.h"
#include "components/metrics/proto/histogram_event.pb.h"
#include "components/metrics/proto/system_profile.pb.h"
#include "components/metrics/proto/user_action_event.pb.h"
#include "components/variations/active_field_trials.h"
#if defined(OS_ANDROID)
#include "base/android/build_info.h"
#endif
#if defined(OS_WIN)
#include "base/win/metro.h"
// http://blogs.msdn.com/oldnewthing/archive/2004/10/25/247180.aspx
extern "C" IMAGE_DOS_HEADER __ImageBase;
#endif
using base::SampleCountIterator;
typedef variations::ActiveGroupId ActiveGroupId;
namespace metrics {
namespace {
// Any id less than 16 bytes is considered to be a testing id.
bool IsTestingID(const std::string& id) {
return id.size() < 16;
}
// Returns the date at which the current metrics client ID was created as
// a string containing seconds since the epoch, or "0" if none was found.
std::string GetMetricsEnabledDate(PrefService* pref) {
if (!pref) {
NOTREACHED();
return "0";
}
return pref->GetString(metrics::prefs::kMetricsReportingEnabledTimestamp);
}
// Computes a SHA-1 hash of |data| and returns it as a hex string.
std::string ComputeSHA1(const std::string& data) {
const std::string sha1 = base::SHA1HashString(data);
return base::HexEncode(sha1.data(), sha1.size());
}
void WriteFieldTrials(const std::vector<ActiveGroupId>& field_trial_ids,
SystemProfileProto* system_profile) {
for (std::vector<ActiveGroupId>::const_iterator it =
field_trial_ids.begin(); it != field_trial_ids.end(); ++it) {
SystemProfileProto::FieldTrial* field_trial =
system_profile->add_field_trial();
field_trial->set_name_id(it->name);
field_trial->set_group_id(it->group);
}
}
// Round a timestamp measured in seconds since epoch to one with a granularity
// of an hour. This can be used before uploaded potentially sensitive
// timestamps.
int64 RoundSecondsToHour(int64 time_in_seconds) {
return 3600 * (time_in_seconds / 3600);
}
} // namespace
MetricsLog::MetricsLog(const std::string& client_id,
int session_id,
LogType log_type,
metrics::MetricsServiceClient* client,
PrefService* local_state)
: closed_(false),
log_type_(log_type),
client_(client),
creation_time_(base::TimeTicks::Now()),
local_state_(local_state) {
if (IsTestingID(client_id))
uma_proto_.set_client_id(0);
else
uma_proto_.set_client_id(Hash(client_id));
uma_proto_.set_session_id(session_id);
SystemProfileProto* system_profile = uma_proto_.mutable_system_profile();
system_profile->set_build_timestamp(GetBuildTime());
system_profile->set_app_version(client_->GetVersionString());
system_profile->set_channel(client_->GetChannel());
}
MetricsLog::~MetricsLog() {
}
// static
void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) {
registry->RegisterIntegerPref(metrics::prefs::kStabilityLaunchCount, 0);
registry->RegisterIntegerPref(metrics::prefs::kStabilityCrashCount, 0);
registry->RegisterIntegerPref(
metrics::prefs::kStabilityIncompleteSessionEndCount, 0);
registry->RegisterIntegerPref(
metrics::prefs::kStabilityBreakpadRegistrationFail, 0);
registry->RegisterIntegerPref(
metrics::prefs::kStabilityBreakpadRegistrationSuccess, 0);
registry->RegisterIntegerPref(metrics::prefs::kStabilityDebuggerPresent, 0);
registry->RegisterIntegerPref(metrics::prefs::kStabilityDebuggerNotPresent,
0);
registry->RegisterStringPref(metrics::prefs::kStabilitySavedSystemProfile,
std::string());
registry->RegisterStringPref(metrics::prefs::kStabilitySavedSystemProfileHash,
std::string());
}
// static
uint64 MetricsLog::Hash(const std::string& value) {
uint64 hash = metrics::HashMetricName(value);
// The following log is VERY helpful when folks add some named histogram into
// the code, but forgot to update the descriptive list of histograms. When
// that happens, all we get to see (server side) is a hash of the histogram
// name. We can then use this logging to find out what histogram name was
// being hashed to a given MD5 value by just running the version of Chromium
// in question with --enable-logging.
DVLOG(1) << "Metrics: Hash numeric [" << value << "]=[" << hash << "]";
return hash;
}
// static
int64 MetricsLog::GetBuildTime() {
static int64 integral_build_time = 0;
if (!integral_build_time) {
base::Time time;
static const char kDateTime[] = __DATE__ " " __TIME__ " GMT";
bool result = base::Time::FromString(kDateTime, &time);
DCHECK(result);
integral_build_time = static_cast<int64>(time.ToTimeT());
}
return integral_build_time;
}
// static
int64 MetricsLog::GetCurrentTime() {
return (base::TimeTicks::Now() - base::TimeTicks()).InSeconds();
}
void MetricsLog::RecordUserAction(const std::string& key) {
DCHECK(!closed_);
UserActionEventProto* user_action = uma_proto_.add_user_action_event();
user_action->set_name_hash(Hash(key));
user_action->set_time(GetCurrentTime());
}
void MetricsLog::RecordHistogramDelta(const std::string& histogram_name,
const base::HistogramSamples& snapshot) {
DCHECK(!closed_);
DCHECK_NE(0, snapshot.TotalCount());
// We will ignore the MAX_INT/infinite value in the last element of range[].
HistogramEventProto* histogram_proto = uma_proto_.add_histogram_event();
histogram_proto->set_name_hash(Hash(histogram_name));
histogram_proto->set_sum(snapshot.sum());
for (scoped_ptr<SampleCountIterator> it = snapshot.Iterator(); !it->Done();
it->Next()) {
base::Histogram::Sample min;
base::Histogram::Sample max;
base::Histogram::Count count;
it->Get(&min, &max, &count);
HistogramEventProto::Bucket* bucket = histogram_proto->add_bucket();
bucket->set_min(min);
bucket->set_max(max);
bucket->set_count(count);
}
// Omit fields to save space (see rules in histogram_event.proto comments).
for (int i = 0; i < histogram_proto->bucket_size(); ++i) {
HistogramEventProto::Bucket* bucket = histogram_proto->mutable_bucket(i);
if (i + 1 < histogram_proto->bucket_size() &&
bucket->max() == histogram_proto->bucket(i + 1).min()) {
bucket->clear_max();
} else if (bucket->max() == bucket->min() + 1) {
bucket->clear_min();
}
}
}
void MetricsLog::RecordStabilityMetrics(
const std::vector<metrics::MetricsProvider*>& metrics_providers,
base::TimeDelta incremental_uptime,
base::TimeDelta uptime) {
DCHECK(!closed_);
DCHECK(HasEnvironment());
DCHECK(!HasStabilityMetrics());
PrefService* pref = local_state_;
DCHECK(pref);
// Get stability attributes out of Local State, zeroing out stored values.
// NOTE: This could lead to some data loss if this report isn't successfully
// sent, but that's true for all the metrics.
WriteRequiredStabilityAttributes(pref);
// Record recent delta for critical stability metrics. We can't wait for a
// restart to gather these, as that delay biases our observation away from
// users that run happily for a looooong time. We send increments with each
// uma log upload, just as we send histogram data.
WriteRealtimeStabilityAttributes(pref, incremental_uptime, uptime);
SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
for (size_t i = 0; i < metrics_providers.size(); ++i)
metrics_providers[i]->ProvideStabilityMetrics(system_profile);
// Omit some stats unless this is the initial stability log.
if (log_type() != INITIAL_STABILITY_LOG)
return;
int incomplete_shutdown_count =
pref->GetInteger(metrics::prefs::kStabilityIncompleteSessionEndCount);
pref->SetInteger(metrics::prefs::kStabilityIncompleteSessionEndCount, 0);
int breakpad_registration_success_count =
pref->GetInteger(metrics::prefs::kStabilityBreakpadRegistrationSuccess);
pref->SetInteger(metrics::prefs::kStabilityBreakpadRegistrationSuccess, 0);
int breakpad_registration_failure_count =
pref->GetInteger(metrics::prefs::kStabilityBreakpadRegistrationFail);
pref->SetInteger(metrics::prefs::kStabilityBreakpadRegistrationFail, 0);
int debugger_present_count =
pref->GetInteger(metrics::prefs::kStabilityDebuggerPresent);
pref->SetInteger(metrics::prefs::kStabilityDebuggerPresent, 0);
int debugger_not_present_count =
pref->GetInteger(metrics::prefs::kStabilityDebuggerNotPresent);
pref->SetInteger(metrics::prefs::kStabilityDebuggerNotPresent, 0);
// TODO(jar): The following are all optional, so we *could* optimize them for
// values of zero (and not include them).
SystemProfileProto::Stability* stability =
system_profile->mutable_stability();
stability->set_incomplete_shutdown_count(incomplete_shutdown_count);
stability->set_breakpad_registration_success_count(
breakpad_registration_success_count);
stability->set_breakpad_registration_failure_count(
breakpad_registration_failure_count);
stability->set_debugger_present_count(debugger_present_count);
stability->set_debugger_not_present_count(debugger_not_present_count);
}
void MetricsLog::RecordGeneralMetrics(
const std::vector<metrics::MetricsProvider*>& metrics_providers) {
for (size_t i = 0; i < metrics_providers.size(); ++i)
metrics_providers[i]->ProvideGeneralMetrics(uma_proto());
}
void MetricsLog::GetFieldTrialIds(
std::vector<ActiveGroupId>* field_trial_ids) const {
variations::GetFieldTrialActiveGroupIds(field_trial_ids);
}
bool MetricsLog::HasEnvironment() const {
return uma_proto()->system_profile().has_uma_enabled_date();
}
bool MetricsLog::HasStabilityMetrics() const {
return uma_proto()->system_profile().stability().has_launch_count();
}
// The server refuses data that doesn't have certain values. crashcount and
// launchcount are currently "required" in the "stability" group.
// TODO(isherman): Stop writing these attributes specially once the migration to
// protobufs is complete.
void MetricsLog::WriteRequiredStabilityAttributes(PrefService* pref) {
int launch_count = pref->GetInteger(metrics::prefs::kStabilityLaunchCount);
pref->SetInteger(metrics::prefs::kStabilityLaunchCount, 0);
int crash_count = pref->GetInteger(metrics::prefs::kStabilityCrashCount);
pref->SetInteger(metrics::prefs::kStabilityCrashCount, 0);
SystemProfileProto::Stability* stability =
uma_proto()->mutable_system_profile()->mutable_stability();
stability->set_launch_count(launch_count);
stability->set_crash_count(crash_count);
}
void MetricsLog::WriteRealtimeStabilityAttributes(
PrefService* pref,
base::TimeDelta incremental_uptime,
base::TimeDelta uptime) {
// Update the stats which are critical for real-time stability monitoring.
// Since these are "optional," only list ones that are non-zero, as the counts
// are aggregated (summed) server side.
SystemProfileProto::Stability* stability =
uma_proto()->mutable_system_profile()->mutable_stability();
const uint64 incremental_uptime_sec = incremental_uptime.InSeconds();
if (incremental_uptime_sec)
stability->set_incremental_uptime_sec(incremental_uptime_sec);
const uint64 uptime_sec = uptime.InSeconds();
if (uptime_sec)
stability->set_uptime_sec(uptime_sec);
}
void MetricsLog::RecordEnvironment(
const std::vector<metrics::MetricsProvider*>& metrics_providers,
const std::vector<variations::ActiveGroupId>& synthetic_trials,
int64 install_date) {
DCHECK(!HasEnvironment());
SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
std::string brand_code;
if (client_->GetBrand(&brand_code))
system_profile->set_brand_code(brand_code);
int enabled_date;
bool success =
base::StringToInt(GetMetricsEnabledDate(local_state_), &enabled_date);
DCHECK(success);
// Reduce granularity of the enabled_date field to nearest hour.
system_profile->set_uma_enabled_date(RoundSecondsToHour(enabled_date));
// Reduce granularity of the install_date field to nearest hour.
system_profile->set_install_date(RoundSecondsToHour(install_date));
system_profile->set_application_locale(client_->GetApplicationLocale());
SystemProfileProto::Hardware* hardware = system_profile->mutable_hardware();
// By default, the hardware class is empty (i.e., unknown).
hardware->set_hardware_class(std::string());
hardware->set_cpu_architecture(base::SysInfo::OperatingSystemArchitecture());
hardware->set_system_ram_mb(base::SysInfo::AmountOfPhysicalMemoryMB());
#if defined(OS_WIN)
hardware->set_dll_base(reinterpret_cast<uint64>(&__ImageBase));
#endif
SystemProfileProto::OS* os = system_profile->mutable_os();
std::string os_name = base::SysInfo::OperatingSystemName();
#if defined(OS_WIN)
// TODO(mad): This only checks whether the main process is a Metro process at
// upload time; not whether the collected metrics were all gathered from
// Metro. This is ok as an approximation for now, since users will rarely be
// switching from Metro to Desktop mode; but we should re-evaluate whether we
// can distinguish metrics more cleanly in the future: http://crbug.com/140568
if (base::win::IsMetroProcess())
os_name += " (Metro)";
#endif
os->set_name(os_name);
os->set_version(base::SysInfo::OperatingSystemVersion());
#if defined(OS_ANDROID)
os->set_fingerprint(
base::android::BuildInfo::GetInstance()->android_build_fp());
#endif
base::CPU cpu_info;
SystemProfileProto::Hardware::CPU* cpu = hardware->mutable_cpu();
cpu->set_vendor_name(cpu_info.vendor_name());
cpu->set_signature(cpu_info.signature());
std::vector<ActiveGroupId> field_trial_ids;
GetFieldTrialIds(&field_trial_ids);
WriteFieldTrials(field_trial_ids, system_profile);
WriteFieldTrials(synthetic_trials, system_profile);
for (size_t i = 0; i < metrics_providers.size(); ++i)
metrics_providers[i]->ProvideSystemProfileMetrics(system_profile);
std::string serialied_system_profile;
std::string base64_system_profile;
if (system_profile->SerializeToString(&serialied_system_profile)) {
base::Base64Encode(serialied_system_profile, &base64_system_profile);
PrefService* local_state = local_state_;
local_state->SetString(metrics::prefs::kStabilitySavedSystemProfile,
base64_system_profile);
local_state->SetString(metrics::prefs::kStabilitySavedSystemProfileHash,
ComputeSHA1(serialied_system_profile));
}
}
bool MetricsLog::LoadSavedEnvironmentFromPrefs() {
PrefService* local_state = local_state_;
const std::string base64_system_profile =
local_state->GetString(metrics::prefs::kStabilitySavedSystemProfile);
if (base64_system_profile.empty())
return false;
const std::string system_profile_hash =
local_state->GetString(metrics::prefs::kStabilitySavedSystemProfileHash);
local_state->ClearPref(metrics::prefs::kStabilitySavedSystemProfile);
local_state->ClearPref(metrics::prefs::kStabilitySavedSystemProfileHash);
SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
std::string serialied_system_profile;
return base::Base64Decode(base64_system_profile, &serialied_system_profile) &&
ComputeSHA1(serialied_system_profile) == system_profile_hash &&
system_profile->ParseFromString(serialied_system_profile);
}
void MetricsLog::CloseLog() {
DCHECK(!closed_);
closed_ = true;
}
void MetricsLog::GetEncodedLog(std::string* encoded_log) {
DCHECK(closed_);
uma_proto_.SerializeToString(encoded_log);
}
} // namespace metrics