Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 608e4280 authored by Bertrand SIMONNET's avatar Bertrand SIMONNET
Browse files

metricsd: Split into two daemons. 

This CL splits metrics_daemon into two independent daemons: metricsd and
metrics_collector.

* metricsd will be responsible for reading the metrics from disk and
  periodically uploading them to the server.
* metrics_collector will be responsible for gathering generic metrics
  from the system and managing the weave state for metrics.

This refactoring is necessary to prepare the migration of metricsd to
log over binder.

Bug: 25670908
Test: Unit tests.
Test: manual: both daemons run. Metrics are logged, uploaded and the
      weave interaction works.

Change-Id: Ib00e1772bb7eec87cbcdcd912c30b555d79d7074
parent 39a1b773

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