Merge "metricsd: Split into two daemons." (f3f2c63a) · Commits · e / os / android_system_core

metricsd/Android.mk

+66 −26

Original line number	Diff line number	Diff line
		@@ -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_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

metricsd/collectors/averaged_statistics_collector.cc

+3 −3

Original line number	Diff line number	Diff line
		@@ -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);

metricsd/metrics_daemon.cc→metricsd/metrics_collector.cc

+84 −111

Original line number	Diff line number	Diff line
		@@ -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,7 +217,6 @@ int MetricsDaemon::OnInit() {
		if (testing_)
		return EX_OK;

		if (dbus_enabled_) {
		bus_->AssertOnDBusThread();
		CHECK(bus_->SetUpAsyncOperations());

		@@ -247,7 +226,7 @@ int MetricsDaemon::OnInit() {
		kCrashReporterInterface,
		kCrashReporterUserCrashSignal);

		bus_->AddFilterFunction(&MetricsDaemon::MessageFilter, this);
		bus_->AddFilterFunction(&MetricsCollector::MessageFilter, this);

		DBusError error;
		dbus_error_init(&error);
		@@ -265,38 +244,31 @@ int MetricsDaemon::OnInit() {

		device_ = weaved::Device::CreateInstance(
		bus_,
		base::Bind(&MetricsDaemon::UpdateWeaveState, base::Unretained(this)));
		base::Bind(&MetricsCollector::UpdateWeaveState, base::Unretained(this)));
		device_->AddCommandHandler(
		"_metrics._enableAnalyticsReporting",
		base::Bind(&MetricsDaemon::OnEnableMetrics, base::Unretained(this)));
		base::Bind(&MetricsCollector::OnEnableMetrics, base::Unretained(this)));
		device_->AddCommandHandler(
		"_metrics._disableAnalyticsReporting",
		base::Bind(&MetricsDaemon::OnDisableMetrics, base::Unretained(this)));
		}
		base::Bind(&MetricsCollector::OnDisableMetrics, base::Unretained(this)));

		latest_cpu_use_microseconds_ = cpu_usage_collector_->GetCumulativeCpuUse();
		base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
		base::Bind(&MetricsDaemon::HandleUpdateStatsTimeout,
		base::Bind(&MetricsCollector::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()) {
		void MetricsCollector::OnShutdown(int* return_code) {
		if (!testing_ && bus_->is_connected()) {
		const std::string match_rule =
		base::StringPrintf(kCrashReporterMatchRule,
		kCrashReporterInterface,
		kCrashReporterUserCrashSignal);

		bus_->RemoveFilterFunction(&MetricsDaemon::MessageFilter, this);
		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,7 +333,7 @@ void MetricsDaemon::UpdateWeaveState() {
		}

		// static
		DBusHandlerResult MetricsDaemon::MessageFilter(DBusConnection* connection,
		DBusHandlerResult MetricsCollector::MessageFilter(DBusConnection* connection,
		DBusMessage* message,
		void* user_data) {
		int message_type = dbus_message_get_type(message);
		@@ -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,14 +446,14 @@ 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,
		bool MetricsCollector::ReadFileToUint64(const base::FilePath& path,
		uint64_t* value) {
		std::string content;
		if (!base::ReadFileToString(path, &content)) {
		@@ -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,7 +577,7 @@ bool MetricsDaemon::ProcessMeminfo(const string& meminfo_raw) {
		return true;
		}

		bool MetricsDaemon::FillMeminfo(const string& meminfo_raw,
		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,
		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,7 +752,7 @@ void MetricsDaemon::SendAndResetCrashFrequencySample(
		50); // number of buckets
		}

		void MetricsDaemon::SendLinearSample(const string& name, int sample,
		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.
		@@ -787,7 +760,7 @@ void MetricsDaemon::SendLinearSample(const string& name, int sample,
		metrics_lib_->SendEnumToUMA(name, sample, max);
		}

		void MetricsDaemon::UpdateStats(TimeTicks now_ticks,
		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);
		@@ -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));
		}

metricsd/metrics_daemon.h→metricsd/metrics_collector.h

+24 −43

Original line number	Diff line number	Diff line
		@@ -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_

metricsd/metrics_collector.rc

0 → 100644

+4 −0

Original line number	Diff line number	Diff line
		service metricscollector /system/bin/metrics_collector --foreground --logtosyslog
		class late_start
		user system
		group system dbus