openkylin
/
platform_system_core
mirror of https://gitee.com/openkylin/platform_system_core.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge "metricsd: Split into two daemons."

This commit is contained in:
Bertrand Simonnet 2015-11-18 19:53:44 +00:00 committed by Gerrit Code Review
parent 08251c3646 608e428006
commit f3f2c63adb
14 changed files with 352 additions and 305 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
metricsd/Android.mk
View File

@ -25,11 +25,14 @@ libmetrics_sources := \
metrics_client_sources := \
metrics_client.cc
metrics_daemon_common := \
metrics_collector_common := \
collectors/averaged_statistics_collector.cc \
collectors/cpu_usage_collector.cc \
collectors/disk_usage_collector.cc \
metrics_daemon.cc \
metrics_collector.cc \
persistent_integer.cc \
metricsd_common := \
persistent_integer.cc \
serialization/metric_sample.cc \
serialization/serialization_utils.cc \
@ -40,14 +43,16 @@ metrics_daemon_common := \
uploader/system_profile_cache.cc \
uploader/upload_service.cc \
metrics_tests_sources := \
metrics_collector_tests_sources := \
collectors/averaged_statistics_collector_test.cc \
collectors/cpu_usage_collector_test.cc \
metrics_daemon_test.cc \
metrics_collector_test.cc \
metrics_library_test.cc \
persistent_integer_test.cc \
serialization/serialization_utils_unittest.cc \
timer_test.cc \
metricsd_tests_sources := \
uploader/metrics_hashes_unittest.cc \
uploader/metrics_log_base_unittest.cc \
uploader/mock/sender_mock.cc \
@ -56,7 +61,6 @@ metrics_tests_sources := \
metrics_CFLAGS := -Wall \
-Wno-char-subscripts \
-Wno-missing-field-initializers \
-Wno-unused-function \
-Wno-unused-parameter \
-Werror \
-fvisibility=default
@ -67,17 +71,22 @@ metrics_CPPFLAGS := -Wno-non-virtual-dtor \
metrics_includes := external/gtest/include \
$(LOCAL_PATH)/include
libmetrics_shared_libraries := libchrome libbrillo
metrics_daemon_shared_libraries := $(libmetrics_shared_libraries) \
libbrillo-http \
metrics_collector_shared_libraries := $(libmetrics_shared_libraries) \
libbrillo-dbus \
libbrillo-http \
libchrome-dbus \
libdbus \
libmetrics \
libprotobuf-cpp-lite \
librootdev \
libupdate_engine_client \
libweaved \
metricsd_shared_libraries := \
libbrillo \
libbrillo-http \
libchrome \
libprotobuf-cpp-lite \
libupdate_engine_client \
# Shared library for metrics.
# ========================================================
include $(CLEAR_VARS)
@ -107,10 +116,10 @@ LOCAL_SHARED_LIBRARIES := $(libmetrics_shared_libraries) \
LOCAL_SRC_FILES := $(metrics_client_sources)
include $(BUILD_EXECUTABLE)
# Protobuf library for metrics_daemon.
# Protobuf library for metricsd.
# ========================================================
include $(CLEAR_VARS)
LOCAL_MODULE := metrics_daemon_protos
LOCAL_MODULE := metricsd_protos
LOCAL_MODULE_CLASS := STATIC_LIBRARIES
generated_sources_dir := $(call local-generated-sources-dir)
LOCAL_EXPORT_C_INCLUDE_DIRS += \
@ -118,40 +127,71 @@ LOCAL_EXPORT_C_INCLUDE_DIRS += \
LOCAL_SRC_FILES := $(call all-proto-files-under,uploader/proto)
include $(BUILD_STATIC_LIBRARY)
# metrics daemon.
# metrics_collector daemon.
# ========================================================
include $(CLEAR_VARS)
LOCAL_MODULE := metrics_daemon
LOCAL_MODULE := metrics_collector
LOCAL_C_INCLUDES := $(metrics_includes)
LOCAL_CFLAGS := $(metrics_CFLAGS)
LOCAL_CLANG := true
LOCAL_CPP_EXTENSION := $(metrics_cpp_extension)
LOCAL_CPPFLAGS := $(metrics_CPPFLAGS)
LOCAL_INIT_RC := metrics_daemon.rc
LOCAL_INIT_RC := metrics_collector.rc
LOCAL_REQUIRED_MODULES := \
metrics.json \
metrics.schema.json \
metrics.schema.json
LOCAL_RTTI_FLAG := -frtti
LOCAL_SHARED_LIBRARIES := $(metrics_daemon_shared_libraries)
LOCAL_CLANG := true
LOCAL_SRC_FILES := $(metrics_daemon_common) \
metrics_daemon_main.cc
LOCAL_STATIC_LIBRARIES := metrics_daemon_protos
LOCAL_SHARED_LIBRARIES := $(metrics_collector_shared_libraries)
LOCAL_SRC_FILES := $(metrics_collector_common) \
metrics_collector_main.cc
include $(BUILD_EXECUTABLE)
# Unit tests for metrics.
# metricsd daemon.
# ========================================================
include $(CLEAR_VARS)
LOCAL_MODULE := metrics_tests
LOCAL_CLANG := true
LOCAL_MODULE := metricsd
LOCAL_C_INCLUDES := $(metrics_includes)
LOCAL_CFLAGS := $(metrics_CFLAGS)
LOCAL_CLANG := true
LOCAL_CPP_EXTENSION := $(metrics_cpp_extension)
LOCAL_CPPFLAGS := $(metrics_CPPFLAGS)
LOCAL_INIT_RC := metricsd.rc
LOCAL_REQUIRED_MODULES := \
metrics_collector
LOCAL_RTTI_FLAG := -frtti
LOCAL_SHARED_LIBRARIES := $(metricsd_shared_libraries)
LOCAL_STATIC_LIBRARIES := metricsd_protos
LOCAL_SRC_FILES := $(metricsd_common) \
metricsd_main.cc
include $(BUILD_EXECUTABLE)
# Unit tests for metricsd.
# ========================================================
include $(CLEAR_VARS)
LOCAL_MODULE := metricsd_tests
LOCAL_CFLAGS := $(metrics_CFLAGS)
LOCAL_CLANG := true
LOCAL_CPP_EXTENSION := $(metrics_cpp_extension)
LOCAL_CPPFLAGS := $(metrics_CPPFLAGS) -Wno-sign-compare
LOCAL_RTTI_FLAG := -frtti
LOCAL_SHARED_LIBRARIES := $(metrics_daemon_shared_libraries)
LOCAL_SRC_FILES := $(metrics_tests_sources) $(metrics_daemon_common)
LOCAL_STATIC_LIBRARIES := libBionicGtestMain libgmock metrics_daemon_protos
LOCAL_SHARED_LIBRARIES := $(metricsd_shared_libraries) libmetrics
LOCAL_SRC_FILES := $(metricsd_tests_sources) $(metricsd_common)
LOCAL_STATIC_LIBRARIES := libBionicGtestMain libgmock metricsd_protos
include $(BUILD_NATIVE_TEST)
# Unit tests for metrics_collector.
# ========================================================
include $(CLEAR_VARS)
LOCAL_MODULE := metrics_collector_tests
LOCAL_CFLAGS := $(metrics_CFLAGS)
LOCAL_CLANG := true
LOCAL_CPP_EXTENSION := $(metrics_cpp_extension)
LOCAL_CPPFLAGS := $(metrics_CPPFLAGS) -Wno-sign-compare
LOCAL_RTTI_FLAG := -frtti
LOCAL_SHARED_LIBRARIES := $(metrics_collector_shared_libraries)
LOCAL_SRC_FILES := $(metrics_collector_tests_sources) \
$(metrics_collector_common)
LOCAL_STATIC_LIBRARIES := libBionicGtestMain libgmock
include $(BUILD_NATIVE_TEST)
# Weave schema files

6
metricsd/collectors/averaged_statistics_collector.cc
View File

@ -21,7 +21,7 @@
#include <base/strings/string_number_conversions.h>
#include <base/strings/string_split.h>
#include "metrics_daemon.h"
#include "metrics_collector.h"
namespace {
@ -90,7 +90,7 @@ void AveragedStatisticsCollector::CollectCallback() {
}
void AveragedStatisticsCollector::ReadInitialValues() {
stats_start_time_ = MetricsDaemon::GetActiveTime();
stats_start_time_ = MetricsCollector::GetActiveTime();
DiskStatsReadStats(&read_sectors_, &write_sectors_);
VmStatsReadStats(&vmstats_);
}
@ -168,7 +168,7 @@ bool AveragedStatisticsCollector::VmStatsReadStats(struct VmstatRecord* stats) {
void AveragedStatisticsCollector::Collect() {
uint64_t read_sectors_now, write_sectors_now;
struct VmstatRecord vmstats_now;
double time_now = MetricsDaemon::GetActiveTime();
double time_now = MetricsCollector::GetActiveTime();
double delta_time = time_now - stats_start_time_;
bool diskstats_success = DiskStatsReadStats(&read_sectors_now,
&write_sectors_now);

223
metricsd/metrics_daemon.cc → metricsd/metrics_collector.cc
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
#include "metrics_daemon.h"
#include "metrics_collector.h"
#include <sysexits.h>
#include <time.h>
@ -33,7 +33,6 @@
#include <dbus/message.h>
#include "constants.h"
#include "uploader/upload_service.h"
using base::FilePath;
using base::StringPrintf;
@ -78,9 +77,9 @@ const char kVmStatFileName[] = "/proc/vmstat";
// Zram sysfs entries.
const char MetricsDaemon::kComprDataSizeName[] = "compr_data_size";
const char MetricsDaemon::kOrigDataSizeName[] = "orig_data_size";
const char MetricsDaemon::kZeroPagesName[] = "zero_pages";
const char MetricsCollector::kComprDataSizeName[] = "compr_data_size";
const char MetricsCollector::kOrigDataSizeName[] = "orig_data_size";
const char MetricsCollector::kZeroPagesName[] = "zero_pages";
// Memory use stats collection intervals. We collect some memory use interval
// at these intervals after boot, and we stop collecting after the last one,
@ -94,15 +93,15 @@ static const int kMemuseIntervals[] = {
600 * kSecondsPerMinute, // 12.5 hour mark
};
MetricsDaemon::MetricsDaemon()
MetricsCollector::MetricsCollector()
: memuse_final_time_(0),
memuse_interval_index_(0) {}
MetricsDaemon::~MetricsDaemon() {
MetricsCollector::~MetricsCollector() {
}
// static
double MetricsDaemon::GetActiveTime() {
double MetricsCollector::GetActiveTime() {
struct timespec ts;
int r = clock_gettime(CLOCK_MONOTONIC, &ts);
if (r < 0) {
@ -113,7 +112,7 @@ double MetricsDaemon::GetActiveTime() {
}
}
int MetricsDaemon::Run() {
int MetricsCollector::Run() {
if (CheckSystemCrash(kKernelCrashDetectedFile)) {
ProcessKernelCrash();
}
@ -134,16 +133,7 @@ int MetricsDaemon::Run() {
return brillo::DBusDaemon::Run();
}
void MetricsDaemon::RunUploaderTest() {
upload_service_.reset(new UploadService(
new SystemProfileCache(true, metrics_directory_),
metrics_lib_,
server_));
upload_service_->Init(upload_interval_, metrics_directory_);
upload_service_->UploadEvent();
}
uint32_t MetricsDaemon::GetOsVersionHash() {
uint32_t MetricsCollector::GetOsVersionHash() {
brillo::OsReleaseReader reader;
reader.Load();
string version;
@ -159,24 +149,15 @@ uint32_t MetricsDaemon::GetOsVersionHash() {
return version_hash;
}
void MetricsDaemon::Init(bool testing,
bool uploader_active,
bool dbus_enabled,
void MetricsCollector::Init(bool testing,
MetricsLibraryInterface* metrics_lib,
const string& diskstats_path,
const base::TimeDelta& upload_interval,
const string& server,
const base::FilePath& metrics_directory) {
CHECK(metrics_lib);
testing_ = testing;
uploader_active_ = uploader_active;
dbus_enabled_ = dbus_enabled;
metrics_directory_ = metrics_directory;
metrics_lib_ = metrics_lib;
upload_interval_ = upload_interval;
server_ = server;
daily_active_use_.reset(
new PersistentInteger("Platform.UseTime.PerDay"));
version_cumulative_active_use_.reset(
@ -221,9 +202,8 @@ void MetricsDaemon::Init(bool testing,
cpu_usage_collector_.reset(new CpuUsageCollector(metrics_lib_));
}
int MetricsDaemon::OnInit() {
int return_code = dbus_enabled_ ? brillo::DBusDaemon::OnInit() :
brillo::Daemon::OnInit();
int MetricsCollector::OnInit() {
int return_code = brillo::DBusDaemon::OnInit();
if (return_code != EX_OK)
return return_code;
@ -237,66 +217,58 @@ int MetricsDaemon::OnInit() {
if (testing_)
return EX_OK;
if (dbus_enabled_) {
bus_->AssertOnDBusThread();
CHECK(bus_->SetUpAsyncOperations());
bus_->AssertOnDBusThread();
CHECK(bus_->SetUpAsyncOperations());
if (bus_->is_connected()) {
const std::string match_rule =
base::StringPrintf(kCrashReporterMatchRule,
kCrashReporterInterface,
kCrashReporterUserCrashSignal);
bus_->AddFilterFunction(&MetricsDaemon::MessageFilter, this);
DBusError error;
dbus_error_init(&error);
bus_->AddMatch(match_rule, &error);
if (dbus_error_is_set(&error)) {
LOG(ERROR) << "Failed to add match rule \"" << match_rule << "\". Got "
<< error.name << ": " << error.message;
return EX_SOFTWARE;
}
} else {
LOG(ERROR) << "DBus isn't connected.";
return EX_UNAVAILABLE;
}
device_ = weaved::Device::CreateInstance(
bus_,
base::Bind(&MetricsDaemon::UpdateWeaveState, base::Unretained(this)));
device_->AddCommandHandler(
"_metrics._enableAnalyticsReporting",
base::Bind(&MetricsDaemon::OnEnableMetrics, base::Unretained(this)));
device_->AddCommandHandler(
"_metrics._disableAnalyticsReporting",
base::Bind(&MetricsDaemon::OnDisableMetrics, base::Unretained(this)));
}
latest_cpu_use_microseconds_ = cpu_usage_collector_->GetCumulativeCpuUse();
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&MetricsDaemon::HandleUpdateStatsTimeout,
base::Unretained(this)),
base::TimeDelta::FromMilliseconds(kUpdateStatsIntervalMs));
if (uploader_active_) {
upload_service_.reset(
new UploadService(new SystemProfileCache(), metrics_lib_, server_));
upload_service_->Init(upload_interval_, metrics_directory_);
}
return EX_OK;
}
void MetricsDaemon::OnShutdown(int* return_code) {
if (!testing_ && dbus_enabled_ && bus_->is_connected()) {
if (bus_->is_connected()) {
const std::string match_rule =
base::StringPrintf(kCrashReporterMatchRule,
kCrashReporterInterface,
kCrashReporterUserCrashSignal);
bus_->RemoveFilterFunction(&MetricsDaemon::MessageFilter, this);
bus_->AddFilterFunction(&MetricsCollector::MessageFilter, this);
DBusError error;
dbus_error_init(&error);
bus_->AddMatch(match_rule, &error);
if (dbus_error_is_set(&error)) {
LOG(ERROR) << "Failed to add match rule \"" << match_rule << "\". Got "
<< error.name << ": " << error.message;
return EX_SOFTWARE;
}
} else {
LOG(ERROR) << "DBus isn't connected.";
return EX_UNAVAILABLE;
}
device_ = weaved::Device::CreateInstance(
bus_,
base::Bind(&MetricsCollector::UpdateWeaveState, base::Unretained(this)));
device_->AddCommandHandler(
"_metrics._enableAnalyticsReporting",
base::Bind(&MetricsCollector::OnEnableMetrics, base::Unretained(this)));
device_->AddCommandHandler(
"_metrics._disableAnalyticsReporting",
base::Bind(&MetricsCollector::OnDisableMetrics, base::Unretained(this)));
latest_cpu_use_microseconds_ = cpu_usage_collector_->GetCumulativeCpuUse();
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&MetricsCollector::HandleUpdateStatsTimeout,
base::Unretained(this)),
base::TimeDelta::FromMilliseconds(kUpdateStatsIntervalMs));
return EX_OK;
}
void MetricsCollector::OnShutdown(int* return_code) {
if (!testing_ && bus_->is_connected()) {
const std::string match_rule =
base::StringPrintf(kCrashReporterMatchRule,
kCrashReporterInterface,
kCrashReporterUserCrashSignal);
bus_->RemoveFilterFunction(&MetricsCollector::MessageFilter, this);
DBusError error;
dbus_error_init(&error);
@ -310,7 +282,8 @@ void MetricsDaemon::OnShutdown(int* return_code) {
brillo::DBusDaemon::OnShutdown(return_code);
}
void MetricsDaemon::OnEnableMetrics(const std::weak_ptr<weaved::Command>& cmd) {
void MetricsCollector::OnEnableMetrics(
const std::weak_ptr<weaved::Command>& cmd) {
auto command = cmd.lock();
if (!command)
return;
@ -327,7 +300,7 @@ void MetricsDaemon::OnEnableMetrics(const std::weak_ptr<weaved::Command>& cmd) {
command->Complete({}, nullptr);
}
void MetricsDaemon::OnDisableMetrics(
void MetricsCollector::OnDisableMetrics(
const std::weak_ptr<weaved::Command>& cmd) {
auto command = cmd.lock();
if (!command)
@ -345,7 +318,7 @@ void MetricsDaemon::OnDisableMetrics(
command->Complete({}, nullptr);
}
void MetricsDaemon::UpdateWeaveState() {
void MetricsCollector::UpdateWeaveState() {
if (!device_)
return;
@ -360,9 +333,9 @@ void MetricsDaemon::UpdateWeaveState() {
}
// static
DBusHandlerResult MetricsDaemon::MessageFilter(DBusConnection* connection,
DBusMessage* message,
void* user_data) {
DBusHandlerResult MetricsCollector::MessageFilter(DBusConnection* connection,
DBusMessage* message,
void* user_data) {
int message_type = dbus_message_get_type(message);
if (message_type != DBUS_MESSAGE_TYPE_SIGNAL) {
DLOG(WARNING) << "unexpected message type " << message_type;
@ -374,7 +347,7 @@ DBusHandlerResult MetricsDaemon::MessageFilter(DBusConnection* connection,
const std::string member(dbus_message_get_member(message));
DLOG(INFO) << "Got " << interface << "." << member << " D-Bus signal";
MetricsDaemon* daemon = static_cast<MetricsDaemon*>(user_data);
MetricsCollector* daemon = static_cast<MetricsCollector*>(user_data);
DBusMessageIter iter;
dbus_message_iter_init(message, &iter);
@ -389,7 +362,7 @@ DBusHandlerResult MetricsDaemon::MessageFilter(DBusConnection* connection,
return DBUS_HANDLER_RESULT_HANDLED;
}
void MetricsDaemon::ProcessUserCrash() {
void MetricsCollector::ProcessUserCrash() {
// Counts the active time up to now.
UpdateStats(TimeTicks::Now(), Time::Now());
@ -402,7 +375,7 @@ void MetricsDaemon::ProcessUserCrash() {
user_crashes_weekly_count_->Add(1);
}
void MetricsDaemon::ProcessKernelCrash() {
void MetricsCollector::ProcessKernelCrash() {
// Counts the active time up to now.
UpdateStats(TimeTicks::Now(), Time::Now());
@ -417,7 +390,7 @@ void MetricsDaemon::ProcessKernelCrash() {
kernel_crashes_version_count_->Add(1);
}
void MetricsDaemon::ProcessUncleanShutdown() {
void MetricsCollector::ProcessUncleanShutdown() {
// Counts the active time up to now.
UpdateStats(TimeTicks::Now(), Time::Now());
@ -430,7 +403,7 @@ void MetricsDaemon::ProcessUncleanShutdown() {
any_crashes_weekly_count_->Add(1);
}
bool MetricsDaemon::CheckSystemCrash(const string& crash_file) {
bool MetricsCollector::CheckSystemCrash(const string& crash_file) {
FilePath crash_detected(crash_file);
if (!base::PathExists(crash_detected))
return false;
@ -441,7 +414,7 @@ bool MetricsDaemon::CheckSystemCrash(const string& crash_file) {
return true;
}
void MetricsDaemon::StatsReporterInit() {
void MetricsCollector::StatsReporterInit() {
disk_usage_collector_->Schedule();
cpu_usage_collector_->Init();
@ -452,18 +425,18 @@ void MetricsDaemon::StatsReporterInit() {
averaged_stats_collector_->ScheduleWait();
}
void MetricsDaemon::ScheduleMeminfoCallback(int wait) {
void MetricsCollector::ScheduleMeminfoCallback(int wait) {
if (testing_) {
return;
}
base::TimeDelta waitDelta = base::TimeDelta::FromSeconds(wait);
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&MetricsDaemon::MeminfoCallback, base::Unretained(this),
base::Bind(&MetricsCollector::MeminfoCallback, base::Unretained(this),
waitDelta),
waitDelta);
}
void MetricsDaemon::MeminfoCallback(base::TimeDelta wait) {
void MetricsCollector::MeminfoCallback(base::TimeDelta wait) {
string meminfo_raw;
const FilePath meminfo_path(kMeminfoFileName);
if (!base::ReadFileToString(meminfo_path, &meminfo_raw)) {
@ -473,15 +446,15 @@ void MetricsDaemon::MeminfoCallback(base::TimeDelta wait) {
// Make both calls even if the first one fails.
if (ProcessMeminfo(meminfo_raw)) {
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&MetricsDaemon::MeminfoCallback, base::Unretained(this),
base::Bind(&MetricsCollector::MeminfoCallback, base::Unretained(this),
wait),
wait);
}
}
// static
bool MetricsDaemon::ReadFileToUint64(const base::FilePath& path,
uint64_t* value) {
bool MetricsCollector::ReadFileToUint64(const base::FilePath& path,
uint64_t* value) {
std::string content;
if (!base::ReadFileToString(path, &content)) {
PLOG(WARNING) << "cannot read " << path.MaybeAsASCII();
@ -496,7 +469,7 @@ bool MetricsDaemon::ReadFileToUint64(const base::FilePath& path,
return true;
}
bool MetricsDaemon::ReportZram(const base::FilePath& zram_dir) {
bool MetricsCollector::ReportZram(const base::FilePath& zram_dir) {
// Data sizes are in bytes. |zero_pages| is in number of pages.
uint64_t compr_data_size, orig_data_size, zero_pages;
const size_t page_size = 4096;
@ -533,7 +506,7 @@ bool MetricsDaemon::ReportZram(const base::FilePath& zram_dir) {
return true;
}
bool MetricsDaemon::ProcessMeminfo(const string& meminfo_raw) {
bool MetricsCollector::ProcessMeminfo(const string& meminfo_raw) {
static const MeminfoRecord fields_array[] = {
{ "MemTotal", "MemTotal" }, // SPECIAL CASE: total system memory
{ "MemFree", "MemFree" },
@ -604,8 +577,8 @@ bool MetricsDaemon::ProcessMeminfo(const string& meminfo_raw) {
return true;
}
bool MetricsDaemon::FillMeminfo(const string& meminfo_raw,
vector<MeminfoRecord>* fields) {
bool MetricsCollector::FillMeminfo(const string& meminfo_raw,
vector<MeminfoRecord>* fields) {
vector<string> lines;
unsigned int nlines = Tokenize(meminfo_raw, "\n", &lines);
@ -636,16 +609,16 @@ bool MetricsDaemon::FillMeminfo(const string& meminfo_raw,
return true;
}
void MetricsDaemon::ScheduleMemuseCallback(double interval) {
void MetricsCollector::ScheduleMemuseCallback(double interval) {
if (testing_) {
return;
}
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&MetricsDaemon::MemuseCallback, base::Unretained(this)),
base::Bind(&MetricsCollector::MemuseCallback, base::Unretained(this)),
base::TimeDelta::FromSeconds(interval));
}
void MetricsDaemon::MemuseCallback() {
void MetricsCollector::MemuseCallback() {
// Since we only care about active time (i.e. uptime minus sleep time) but
// the callbacks are driven by real time (uptime), we check if we should
// reschedule this callback due to intervening sleep periods.
@ -666,7 +639,7 @@ void MetricsDaemon::MemuseCallback() {
}
}
bool MetricsDaemon::MemuseCallbackWork() {
bool MetricsCollector::MemuseCallbackWork() {
string meminfo_raw;
const FilePath meminfo_path(kMeminfoFileName);
if (!base::ReadFileToString(meminfo_path, &meminfo_raw)) {
@ -676,7 +649,7 @@ bool MetricsDaemon::MemuseCallbackWork() {
return ProcessMemuse(meminfo_raw);
}
bool MetricsDaemon::ProcessMemuse(const string& meminfo_raw) {
bool MetricsCollector::ProcessMemuse(const string& meminfo_raw) {
static const MeminfoRecord fields_array[] = {
{ "MemTotal", "MemTotal" }, // SPECIAL CASE: total system memory
{ "ActiveAnon", "Active(anon)" },
@ -702,12 +675,12 @@ bool MetricsDaemon::ProcessMemuse(const string& meminfo_raw) {
return true;
}
void MetricsDaemon::SendSample(const string& name, int sample,
int min, int max, int nbuckets) {
void MetricsCollector::SendSample(const string& name, int sample,
int min, int max, int nbuckets) {
metrics_lib_->SendToUMA(name, sample, min, max, nbuckets);
}
void MetricsDaemon::SendKernelCrashesCumulativeCountStats() {
void MetricsCollector::SendKernelCrashesCumulativeCountStats() {
// Report the number of crashes for this OS version, but don't clear the
// counter. It is cleared elsewhere on version change.
int64_t crashes_count = kernel_crashes_version_count_->Get();
@ -752,7 +725,7 @@ void MetricsDaemon::SendKernelCrashesCumulativeCountStats() {
}
}
void MetricsDaemon::SendAndResetDailyUseSample(
void MetricsCollector::SendAndResetDailyUseSample(
const scoped_ptr<PersistentInteger>& use) {
SendSample(use->Name(),
use->GetAndClear(),
@ -761,7 +734,7 @@ void MetricsDaemon::SendAndResetDailyUseSample(
50); // number of buckets
}
void MetricsDaemon::SendAndResetCrashIntervalSample(
void MetricsCollector::SendAndResetCrashIntervalSample(
const scoped_ptr<PersistentInteger>& interval) {
SendSample(interval->Name(),
interval->GetAndClear(),
@ -770,7 +743,7 @@ void MetricsDaemon::SendAndResetCrashIntervalSample(
50); // number of buckets
}
void MetricsDaemon::SendAndResetCrashFrequencySample(
void MetricsCollector::SendAndResetCrashFrequencySample(
const scoped_ptr<PersistentInteger>& frequency) {
SendSample(frequency->Name(),
frequency->GetAndClear(),
@ -779,16 +752,16 @@ void MetricsDaemon::SendAndResetCrashFrequencySample(
50); // number of buckets
}
void MetricsDaemon::SendLinearSample(const string& name, int sample,
int max, int nbuckets) {
void MetricsCollector::SendLinearSample(const string& name, int sample,
int max, int nbuckets) {
// TODO(semenzato): add a proper linear histogram to the Chrome external
// metrics API.
LOG_IF(FATAL, nbuckets != max + 1) << "unsupported histogram scale";
metrics_lib_->SendEnumToUMA(name, sample, max);
}
void MetricsDaemon::UpdateStats(TimeTicks now_ticks,
Time now_wall_time) {
void MetricsCollector::UpdateStats(TimeTicks now_ticks,
Time now_wall_time) {
const int elapsed_seconds = (now_ticks - last_update_stats_time_).InSeconds();
daily_active_use_->Add(elapsed_seconds);
version_cumulative_active_use_->Add(elapsed_seconds);
@ -823,10 +796,10 @@ void MetricsDaemon::UpdateStats(TimeTicks now_ticks,
}
}
void MetricsDaemon::HandleUpdateStatsTimeout() {
void MetricsCollector::HandleUpdateStatsTimeout() {
UpdateStats(TimeTicks::Now(), Time::Now());
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&MetricsDaemon::HandleUpdateStatsTimeout,
base::Bind(&MetricsCollector::HandleUpdateStatsTimeout,
base::Unretained(this)),
base::TimeDelta::FromMilliseconds(kUpdateStatsIntervalMs));
}

67
metricsd/metrics_daemon.h → metricsd/metrics_collector.h
View File

@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef METRICS_METRICS_DAEMON_H_
#define METRICS_METRICS_DAEMON_H_
#ifndef METRICS_METRICS_COLLECTOR_H_
#define METRICS_METRICS_COLLECTOR_H_
#include <stdint.h>
@ -36,23 +36,18 @@
#include "collectors/disk_usage_collector.h"
#include "metrics/metrics_library.h"
#include "persistent_integer.h"
#include "uploader/upload_service.h"
using chromeos_metrics::PersistentInteger;
class MetricsDaemon : public brillo::DBusDaemon {
class MetricsCollector : public brillo::DBusDaemon {
public:
MetricsDaemon();
~MetricsDaemon();
MetricsCollector();
~MetricsCollector();
// Initializes metrics class variables.
void Init(bool testing,
bool uploader_active,
bool dbus_enabled,
MetricsLibraryInterface* metrics_lib,
const std::string& diskstats_path,
const base::TimeDelta& upload_interval,
const std::string& server,
const base::FilePath& metrics_directory);
// Initializes DBus and MessageLoop variables before running the MessageLoop.
@ -64,9 +59,6 @@ class MetricsDaemon : public brillo::DBusDaemon {
// Does all the work.
int Run() override;
// Triggers an upload event and exit. (Used to test UploadService)
void RunUploaderTest();
// Returns the active time since boot (uptime minus sleep time) in seconds.
static double GetActiveTime();
@ -77,24 +69,24 @@ class MetricsDaemon : public brillo::DBusDaemon {
static const char kZeroPagesName[];
private:
friend class MetricsDaemonTest;
FRIEND_TEST(MetricsDaemonTest, CheckSystemCrash);
FRIEND_TEST(MetricsDaemonTest, ComputeEpochNoCurrent);
FRIEND_TEST(MetricsDaemonTest, ComputeEpochNoLast);
FRIEND_TEST(MetricsDaemonTest, GetHistogramPath);
FRIEND_TEST(MetricsDaemonTest, IsNewEpoch);
FRIEND_TEST(MetricsDaemonTest, MessageFilter);
FRIEND_TEST(MetricsDaemonTest, ProcessKernelCrash);
FRIEND_TEST(MetricsDaemonTest, ProcessMeminfo);
FRIEND_TEST(MetricsDaemonTest, ProcessMeminfo2);
FRIEND_TEST(MetricsDaemonTest, ProcessUncleanShutdown);
FRIEND_TEST(MetricsDaemonTest, ProcessUserCrash);
FRIEND_TEST(MetricsDaemonTest, ReportCrashesDailyFrequency);
FRIEND_TEST(MetricsDaemonTest, ReportKernelCrashInterval);
FRIEND_TEST(MetricsDaemonTest, ReportUncleanShutdownInterval);
FRIEND_TEST(MetricsDaemonTest, ReportUserCrashInterval);
FRIEND_TEST(MetricsDaemonTest, SendSample);
FRIEND_TEST(MetricsDaemonTest, SendZramMetrics);
friend class MetricsCollectorTest;
FRIEND_TEST(MetricsCollectorTest, CheckSystemCrash);
FRIEND_TEST(MetricsCollectorTest, ComputeEpochNoCurrent);
FRIEND_TEST(MetricsCollectorTest, ComputeEpochNoLast);
FRIEND_TEST(MetricsCollectorTest, GetHistogramPath);
FRIEND_TEST(MetricsCollectorTest, IsNewEpoch);
FRIEND_TEST(MetricsCollectorTest, MessageFilter);
FRIEND_TEST(MetricsCollectorTest, ProcessKernelCrash);
FRIEND_TEST(MetricsCollectorTest, ProcessMeminfo);
FRIEND_TEST(MetricsCollectorTest, ProcessMeminfo2);
FRIEND_TEST(MetricsCollectorTest, ProcessUncleanShutdown);
FRIEND_TEST(MetricsCollectorTest, ProcessUserCrash);
FRIEND_TEST(MetricsCollectorTest, ReportCrashesDailyFrequency);
FRIEND_TEST(MetricsCollectorTest, ReportKernelCrashInterval);
FRIEND_TEST(MetricsCollectorTest, ReportUncleanShutdownInterval);
FRIEND_TEST(MetricsCollectorTest, ReportUserCrashInterval);
FRIEND_TEST(MetricsCollectorTest, SendSample);
FRIEND_TEST(MetricsCollectorTest, SendZramMetrics);
// Type of scale to use for meminfo histograms. For most of them we use
// percent of total RAM, but for some we use absolute numbers, usually in
@ -233,13 +225,6 @@ class MetricsDaemon : public brillo::DBusDaemon {
// Test mode.
bool testing_;
// Whether the uploader is enabled or disabled.
bool uploader_active_;
// Whether or not dbus should be used.
// If disabled, we will not collect the frequency of crashes.
bool dbus_enabled_;
// Root of the configuration files to use.
base::FilePath metrics_directory_;
@ -291,11 +276,7 @@ class MetricsDaemon : public brillo::DBusDaemon {
scoped_ptr<DiskUsageCollector> disk_usage_collector_;
scoped_ptr<AveragedStatisticsCollector> averaged_stats_collector_;
base::TimeDelta upload_interval_;
std::string server_;
scoped_ptr<UploadService> upload_service_;
std::unique_ptr<weaved::Device> device_;
};
#endif // METRICS_METRICS_DAEMON_H_
#endif // METRICS_METRICS_COLLECTOR_H_

4
metricsd/metrics_collector.rc Normal file
View File

@ -0,0 +1,4 @@
service metricscollector /system/bin/metrics_collector --foreground --logtosyslog
class late_start
user system
group system dbus

35
metricsd/metrics_daemon_main.cc → metricsd/metrics_collector_main.cc
View File

@ -23,7 +23,7 @@
#include <rootdev.h>
#include "constants.h"
#include "metrics_daemon.h"
#include "metrics_collector.h"
// Returns the path to the disk stats in the sysfs. Returns the null string if
@ -51,26 +51,6 @@ const std::string MetricsMainDiskStatsPath() {
int main(int argc, char** argv) {
DEFINE_bool(foreground, false, "Don't daemonize");
// The uploader is disabled by default on ChromeOS as Chrome is responsible
// for sending the metrics.
DEFINE_bool(uploader, false, "activate the uploader");
// Upload the metrics once and exit. (used for testing)
DEFINE_bool(uploader_test,
false,
"run the uploader once and exit");
// Enable dbus.
DEFINE_bool(withdbus, true, "Enable dbus");
// Upload Service flags.
DEFINE_int32(upload_interval_secs,
1800,
"Interval at which metrics_daemon sends the metrics. (needs "
"-uploader)");
DEFINE_string(server,
metrics::kMetricsServer,
"Server to upload the metrics to. (needs -uploader)");
DEFINE_string(metrics_directory,
metrics::kMetricsDirectory,
"Root of the configuration files (testing only)");
@ -102,20 +82,11 @@ int main(int argc, char** argv) {
MetricsLibrary metrics_lib;
metrics_lib.InitWithNoCaching();
MetricsDaemon daemon;
daemon.Init(FLAGS_uploader_test,
FLAGS_uploader | FLAGS_uploader_test,
FLAGS_withdbus,
MetricsCollector daemon;
daemon.Init(false,
&metrics_lib,
MetricsMainDiskStatsPath(),
base::TimeDelta::FromSeconds(FLAGS_upload_interval_secs),
FLAGS_server,
base::FilePath(FLAGS_metrics_directory));
if (FLAGS_uploader_test) {
daemon.RunUploaderTest();
return 0;
}
daemon.Run();
}

39
metricsd/metrics_daemon_test.cc → metricsd/metrics_collector_test.cc
View File

@ -24,7 +24,7 @@
#include <gtest/gtest.h>
#include "constants.h"
#include "metrics_daemon.h"
#include "metrics_collector.h"
#include "metrics/metrics_library_mock.h"
#include "persistent_integer_mock.h"
@ -40,7 +40,7 @@ using ::testing::StrictMock;
using chromeos_metrics::PersistentIntegerMock;
class MetricsDaemonTest : public testing::Test {
class MetricsCollectorTest : public testing::Test {
protected:
virtual void SetUp() {
brillo::FlagHelper::Init(0, nullptr, "");
@ -48,14 +48,7 @@ class MetricsDaemonTest : public testing::Test {
chromeos_metrics::PersistentInteger::SetMetricsDirectory(
temp_dir_.path().value());
daemon_.Init(true,
false,
true,
&metrics_lib_,
"",
base::TimeDelta::FromMinutes(30),
metrics::kMetricsServer,
temp_dir_.path());
daemon_.Init(true, &metrics_lib_, "", temp_dir_.path());
}
// Adds a metrics library mock expectation that the specified metric
@ -107,8 +100,8 @@ class MetricsDaemonTest : public testing::Test {
value_string.length()));
}
// The MetricsDaemon under test.
MetricsDaemon daemon_;
// The MetricsCollector under test.
MetricsCollector daemon_;
// Temporary directory used for tests.
base::ScopedTempDir temp_dir_;
@ -118,13 +111,13 @@ class MetricsDaemonTest : public testing::Test {
StrictMock<MetricsLibraryMock> metrics_lib_;
};
TEST_F(MetricsDaemonTest, MessageFilter) {
TEST_F(MetricsCollectorTest, MessageFilter) {
// Ignore calls to SendToUMA.
EXPECT_CALL(metrics_lib_, SendToUMA(_, _, _, _, _)).Times(AnyNumber());
DBusMessage* msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
DBusHandlerResult res =
MetricsDaemon::MessageFilter(/* connection */ nullptr, msg, &daemon_);
MetricsCollector::MessageFilter(/* connection */ nullptr, msg, &daemon_);
EXPECT_EQ(DBUS_HANDLER_RESULT_NOT_YET_HANDLED, res);
DeleteDBusMessage(msg);
@ -133,7 +126,7 @@ TEST_F(MetricsDaemonTest, MessageFilter) {
"org.chromium.CrashReporter",
"UserCrash",
signal_args);
res = MetricsDaemon::MessageFilter(/* connection */ nullptr, msg, &daemon_);
res = MetricsCollector::MessageFilter(/* connection */ nullptr, msg, &daemon_);
EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
DeleteDBusMessage(msg);
@ -144,18 +137,18 @@ TEST_F(MetricsDaemonTest, MessageFilter) {
"org.chromium.UnknownService.Manager",
"StateChanged",
signal_args);
res = MetricsDaemon::MessageFilter(/* connection */ nullptr, msg, &daemon_);
res = MetricsCollector::MessageFilter(/* connection */ nullptr, msg, &daemon_);
EXPECT_EQ(DBUS_HANDLER_RESULT_NOT_YET_HANDLED, res);
DeleteDBusMessage(msg);
}
TEST_F(MetricsDaemonTest, SendSample) {
TEST_F(MetricsCollectorTest, SendSample) {
ExpectSample("Dummy.Metric", 3);
daemon_.SendSample("Dummy.Metric", /* sample */ 3,
/* min */ 1, /* max */ 100, /* buckets */ 50);
}
TEST_F(MetricsDaemonTest, ProcessMeminfo) {
TEST_F(MetricsCollectorTest, ProcessMeminfo) {
string meminfo =
"MemTotal: 2000000 kB\nMemFree: 500000 kB\n"
"Buffers: 1000000 kB\nCached: 213652 kB\n"
@ -192,13 +185,13 @@ TEST_F(MetricsDaemonTest, ProcessMeminfo) {
EXPECT_TRUE(daemon_.ProcessMeminfo(meminfo));
}
TEST_F(MetricsDaemonTest, ProcessMeminfo2) {
TEST_F(MetricsCollectorTest, ProcessMeminfo2) {
string meminfo = "MemTotal: 2000000 kB\nMemFree: 1000000 kB\n";
// Not enough fields.
EXPECT_FALSE(daemon_.ProcessMeminfo(meminfo));
}
TEST_F(MetricsDaemonTest, SendZramMetrics) {
TEST_F(MetricsCollectorTest, SendZramMetrics) {
EXPECT_TRUE(daemon_.testing_);
// |compr_data_size| is the size in bytes of compressed data.
@ -210,13 +203,13 @@ TEST_F(MetricsDaemonTest, SendZramMetrics) {
const uint64_t zero_pages = 10 * 1000 * 1000 / page_size;
CreateUint64ValueFile(
temp_dir_.path().Append(MetricsDaemon::kComprDataSizeName),
temp_dir_.path().Append(MetricsCollector::kComprDataSizeName),
compr_data_size);
CreateUint64ValueFile(
temp_dir_.path().Append(MetricsDaemon::kOrigDataSizeName),
temp_dir_.path().Append(MetricsCollector::kOrigDataSizeName),
orig_data_size);
CreateUint64ValueFile(
temp_dir_.path().Append(MetricsDaemon::kZeroPagesName), zero_pages);
temp_dir_.path().Append(MetricsCollector::kZeroPagesName), zero_pages);
const uint64_t real_orig_size = orig_data_size + zero_pages * page_size;
const uint64_t zero_ratio_percent =

2
metricsd/metrics_daemon.rc → metricsd/metricsd.rc
View File

@ -1,7 +1,7 @@
on post-fs-data
mkdir /data/misc/metrics 0770 system system
service metrics_daemon /system/bin/metrics_daemon --uploader --foreground --logtosyslog
service metricsd /system/bin/metricsd --foreground --logtosyslog
class late_start
user system
group system dbus inet

80
metricsd/metricsd_main.cc Normal file
View File

@ -0,0 +1,80 @@
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <base/at_exit.h>
#include <base/command_line.h>
#include <base/files/file_path.h>
#include <base/logging.h>
#include <base/strings/string_util.h>
#include <base/time/time.h>
#include <brillo/flag_helper.h>
#include <brillo/syslog_logging.h>
#include "constants.h"
#include "uploader/upload_service.h"
int main(int argc, char** argv) {
DEFINE_bool(foreground, false, "Don't daemonize");
// Upload the metrics once and exit. (used for testing)
DEFINE_bool(uploader_test,
false,
"run the uploader once and exit");
// Upload Service flags.
DEFINE_int32(upload_interval_secs,
1800,
"Interval at which metrics_daemon sends the metrics. (needs "
"-uploader)");
DEFINE_string(server,
metrics::kMetricsServer,
"Server to upload the metrics to. (needs -uploader)");
DEFINE_string(metrics_directory,
metrics::kMetricsDirectory,
"Root of the configuration files (testing only)");
DEFINE_bool(logtostderr, false, "Log to standard error");
DEFINE_bool(logtosyslog, false, "Log to syslog");
brillo::FlagHelper::Init(argc, argv, "Brillo metrics daemon.");
int logging_location = (FLAGS_foreground ? brillo::kLogToStderr
: brillo::kLogToSyslog);
if (FLAGS_logtosyslog)
logging_location = brillo::kLogToSyslog;
if (FLAGS_logtostderr)
logging_location = brillo::kLogToStderr;
// Also log to stderr when not running as daemon.
brillo::InitLog(logging_location | brillo::kLogHeader);
if (FLAGS_logtostderr && FLAGS_logtosyslog) {
LOG(ERROR) << "only one of --logtosyslog and --logtostderr can be set";
return 1;
}
if (!FLAGS_foreground && daemon(0, 0) != 0) {
return errno;
}
UploadService service(FLAGS_server,
base::TimeDelta::FromSeconds(FLAGS_upload_interval_secs),
base::FilePath(FLAGS_metrics_directory));
service.Run();
}

1
metricsd/persistent_integer.cc
View File

@ -22,7 +22,6 @@
#include <base/posix/eintr_wrapper.h>
#include "constants.h"
#include "metrics/metrics_library.h"
namespace chromeos_metrics {

1
metricsd/uploader/system_profile_cache.cc
View File

@ -84,6 +84,7 @@ bool SystemProfileCache::Initialize() {
auto client = update_engine::UpdateEngineClient::CreateInstance();
if (!client->GetChannel(&channel)) {
LOG(ERROR) << "failed to read the current channel from update engine.";
return false;
}
}

59
metricsd/uploader/upload_service.cc
View File

@ -16,6 +16,8 @@
#include "uploader/upload_service.h"
#include <sysexits.h>
#include <string>
#include <base/bind.h>
@ -39,38 +41,34 @@
const int UploadService::kMaxFailedUpload = 10;
UploadService::UploadService(SystemProfileSetter* setter,
MetricsLibraryInterface* metrics_lib,
const std::string& server)
: system_profile_setter_(setter),
metrics_lib_(metrics_lib),
histogram_snapshot_manager_(this),
UploadService::UploadService(const std::string& server,
const base::TimeDelta& upload_interval,
const base::FilePath& metrics_directory)
: histogram_snapshot_manager_(this),
sender_(new HttpSender(server)),
failed_upload_count_(metrics::kFailedUploadCountName),
testing_(false) {
}
UploadService::UploadService(SystemProfileSetter* setter,
MetricsLibraryInterface* metrics_lib,
const std::string& server,
bool testing)
: UploadService(setter, metrics_lib, server) {
testing_ = testing;
}
void UploadService::Init(const base::TimeDelta& upload_interval,
const base::FilePath& metrics_directory) {
base::StatisticsRecorder::Initialize();
upload_interval_(upload_interval) {
metrics_file_ = metrics_directory.Append(metrics::kMetricsEventsFileName);
staged_log_path_ = metrics_directory.Append(metrics::kStagedLogName);
consent_file_ = metrics_directory.Append(metrics::kConsentFileName);
}
if (!testing_) {
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&UploadService::UploadEventCallback,
base::Unretained(this),
upload_interval),
upload_interval);
}
int UploadService::OnInit() {
base::StatisticsRecorder::Initialize();
system_profile_setter_.reset(new SystemProfileCache());
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&UploadService::UploadEventCallback,
base::Unretained(this),
upload_interval_),
upload_interval_);
return EX_OK;
}
void UploadService::InitForTest(SystemProfileSetter* setter) {
base::StatisticsRecorder::Initialize();
system_profile_setter_.reset(setter);
}
void UploadService::StartNewLog() {
@ -114,7 +112,7 @@ void UploadService::UploadEvent() {
void UploadService::SendStagedLog() {
// If metrics are not enabled, discard the log and exit.
if (!metrics_lib_->AreMetricsEnabled()) {
if (!AreMetricsEnabled()) {
LOG(INFO) << "Metrics disabled. Don't upload metrics samples.";
base::DeleteFile(staged_log_path_, false);
return;
@ -263,3 +261,8 @@ void UploadService::RemoveFailedLog() {
failed_upload_count_.Set(0);
}
}
bool UploadService::AreMetricsEnabled() {
return base::PathExists(consent_file_);
}

34
metricsd/uploader/upload_service.h
View File

@ -19,11 +19,11 @@
#include <string>
#include "base/metrics/histogram_base.h"
#include "base/metrics/histogram_flattener.h"
#include "base/metrics/histogram_snapshot_manager.h"
#include <base/metrics/histogram_base.h>
#include <base/metrics/histogram_flattener.h>
#include <base/metrics/histogram_snapshot_manager.h>
#include <brillo/daemons/daemon.h>
#include "metrics/metrics_library.h"
#include "persistent_integer.h"
#include "uploader/metrics_log.h"
#include "uploader/sender.h"
@ -67,14 +67,14 @@ class SystemProfileSetter;
// - if the upload fails, we keep the staged log in memory to retry
// uploading later.
//
class UploadService : public base::HistogramFlattener {
class UploadService : public base::HistogramFlattener, public brillo::Daemon {
public:
explicit UploadService(SystemProfileSetter* setter,
MetricsLibraryInterface* metrics_lib,
const std::string& server);
UploadService(const std::string& server,
const base::TimeDelta& upload_interval,
const base::FilePath& metrics_directory);
void Init(const base::TimeDelta& upload_interval,
const base::FilePath& metrics_directory);
// Initializes the upload service.
int OnInit();
// Starts a new log. The log needs to be regenerated after each successful
// launch as it is destroyed when staging the log.
@ -114,11 +114,8 @@ class UploadService : public base::HistogramFlattener {
FRIEND_TEST(UploadServiceTest, UnknownCrashIgnored);
FRIEND_TEST(UploadServiceTest, ValuesInConfigFileAreSent);
// Private constructor for use in unit testing.
UploadService(SystemProfileSetter* setter,
MetricsLibraryInterface* metrics_lib,
const std::string& server,
bool testing);
// Initializes the upload service for testing.
void InitForTest(SystemProfileSetter* setter);
// If a staged log fails to upload more than kMaxFailedUpload times, it
// will be discarded.
@ -136,6 +133,9 @@ class UploadService : public base::HistogramFlattener {
// Adds a crash to the current log.
void AddCrash(const std::string& crash_name);
// Returns true iff metrics reporting is enabled.
bool AreMetricsEnabled();
// Aggregates all histogram available in memory and store them in the current
// log.
void GatherHistograms();
@ -158,12 +158,14 @@ class UploadService : public base::HistogramFlattener {
MetricsLog* GetOrCreateCurrentLog();
scoped_ptr<SystemProfileSetter> system_profile_setter_;
MetricsLibraryInterface* metrics_lib_;
base::HistogramSnapshotManager histogram_snapshot_manager_;
scoped_ptr<Sender> sender_;
chromeos_metrics::PersistentInteger failed_upload_count_;
scoped_ptr<MetricsLog> current_log_;
base::TimeDelta upload_interval_;
base::FilePath consent_file_;
base::FilePath metrics_file_;
base::FilePath staged_log_path_;

12
metricsd/uploader/upload_service_test.cc
View File

@ -44,11 +44,11 @@ class UploadServiceTest : public testing::Test {
metrics_lib_.InitForTest(dir_.path());
ASSERT_EQ(0, base::WriteFile(
dir_.path().Append(metrics::kConsentFileName), "", 0));
upload_service_.reset(new UploadService(new MockSystemProfileSetter(),
&metrics_lib_, "", true));
upload_service_.reset(new UploadService("", base::TimeDelta(),
dir_.path()));
upload_service_->sender_.reset(new SenderMock);
upload_service_->Init(base::TimeDelta::FromMinutes(30), dir_.path());
upload_service_->InitForTest(new MockSystemProfileSetter);
upload_service_->GatherHistograms();
upload_service_->Reset();
}
@ -58,7 +58,8 @@ class UploadServiceTest : public testing::Test {
}
void SetTestingProperty(const std::string& name, const std::string& value) {
base::FilePath filepath = dir_.path().Append("etc/os-release.d").Append(name);
base::FilePath filepath =
dir_.path().Append("etc/os-release.d").Append(name);
ASSERT_TRUE(base::CreateDirectory(filepath.DirName()));
ASSERT_EQ(
value.size(),
@ -159,8 +160,7 @@ TEST_F(UploadServiceTest, EmptyLogsAreNotSent) {
}
TEST_F(UploadServiceTest, LogEmptyByDefault) {
UploadService upload_service(new MockSystemProfileSetter(), &metrics_lib_,
"");
UploadService upload_service("", base::TimeDelta(), dir_.path());
// current_log_ should be initialized later as it needs AtExitManager to exit
// in order to gather system information from SysInfo.