Updated device reporting code to report multiple samples of free RAM

chrome/browser/chromeos/policy/device_status_collector.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 
 #include <stdint.h>
 #include <limits>
 #include <sys/statvfs.h>
 
@@ skipping 335 matching lines @@
     std::string day_key = base::Int64ToString(TimestampToDayKey(start));
     int previous_activity = 0;
     activity_times->GetInteger(day_key, &previous_activity);
     activity_times->SetInteger(day_key, previous_activity + activity);
     start = midnight;
   }
 }
 
 void DeviceStatusCollector::ClearCachedHardwareStatus() {
   volume_info_.clear();
-  cpu_usage_percent_.clear();
+  resource_usage_.clear();
 }
 
 void DeviceStatusCollector::IdleStateCallback(ui::IdleState state) {
   // Do nothing if device activity reporting is disabled.
   if (!report_activity_times_)
     return;
 
   Time now = GetCurrentTime();
 
   if (state == ui::IDLE_STATE_ACTIVE) {
@@ skipping 28 matching lines @@
   }
 
   // Call out to the blocking pool to measure disk usage.
   base::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(volume_info_fetcher_, mount_points),
       base::Bind(&DeviceStatusCollector::ReceiveVolumeInfo,
                  weak_factory_.GetWeakPtr()));
 
-  SampleCPUUsage();
+  SampleResourceUsage();
 }
 
-void DeviceStatusCollector::SampleCPUUsage() {
+void DeviceStatusCollector::SampleResourceUsage() {
   // Walk the process list and measure CPU utilization.
   double total_usage = 0;
   std::vector<double> per_process_usage = GetPerProcessCPUUsage();
   for (double cpu_usage : per_process_usage) {
     total_usage += cpu_usage;
   }
-  cpu_usage_percent_.push_back(total_usage);
+
+  ResourceUsage usage = { total_usage,
+                          base::SysInfo::AmountOfAvailablePhysicalMemory() };
+
+  resource_usage_.push_back(usage);
 
   // If our cache of samples is full, throw out old samples to make room for new
   // sample.
-  if (cpu_usage_percent_.size() > kMaxCPUSamples)
-    cpu_usage_percent_.pop_front();
+  if (resource_usage_.size() > kMaxResourceUsageSamples)
+    resource_usage_.pop_front();

[Mattias Nissler (ping if slow), 2015/01/29 08:19:41]

Hm, this seems odd from a reporting perspective. There are no timestamps
attached to the samples, so the server doesn't know when these samples were
collected. Also, depending on the reporting frequency, samples may be reported
multiple times to the server or never. Is this intentional?

[Andrew T Wilson (Slow), 2015/01/29 09:02:58]

Yes, the goal isn't to give a smooth set of discrete datapoints to the server
(for example, two simultaneous status uploads will upload overlapping data, and
if the status upload period is very long, you won't get samples for the entire
period between uploads because we cap the # samples).

Basically, the genesis of this is Matt's desire for us to upload an "average" of
CPU usage. Rather than compute that average on the client, we decided to send
the CPU usage samples to the server and let them do what they want with it
(compute average, maybe compute min/max).

Then Bin noticed that we weren't sending up samples for RAM, and wanted to know
why not - it might be useful to be able to display high/low water marks for RAM,
etc, similar to what we do for CPU. Most likely they'll just do something really
simple with the RAM samples (like display average).

The goal here is explicitly *not* to provide timestamps so the user can 
historically look at the data and say "Oh, there was a CPU spike at 1AM last
night".

If it ends up being useful in the future, timestamps are something we can add.

 }
 
 std::vector<double> DeviceStatusCollector::GetPerProcessCPUUsage() {
   std::vector<double> cpu_usage;
   base::ProcessIterator process_iter(nullptr);
 
   const int num_processors = base::SysInfo::NumberOfProcessors();
   while (const base::ProcessEntry* process_entry =
          process_iter.NextProcessEntry()) {
     base::ProcessHandle process;
@@ skipping 216 matching lines @@
 }
 
 void DeviceStatusCollector::GetHardwareStatus(
     em::DeviceStatusReportRequest* status) {
   // Add volume info.
   status->clear_volume_info();
   for (const em::VolumeInfo& info : volume_info_) {
     *status->add_volume_info() = info;
   }
 
-  status->set_system_ram_free(base::SysInfo::AmountOfAvailablePhysicalMemory());
   status->set_system_ram_total(base::SysInfo::AmountOfPhysicalMemory());
-
+  status->clear_system_ram_free();
   status->clear_cpu_utilization_pct();
-  for (const int cpu_usage : cpu_usage_percent_) {
-    status->add_cpu_utilization_pct(cpu_usage);
+  for (const ResourceUsage& usage : resource_usage_) {
+    status->add_cpu_utilization_pct(usage.cpu_usage_percent);
+    status->add_system_ram_free(usage.bytes_of_ram_free);
   }
 }
 
 bool DeviceStatusCollector::GetDeviceStatus(
     em::DeviceStatusReportRequest* status) {
   if (report_activity_times_)
     GetActivityTimes(status);
 
   if (report_version_info_)
     GetVersionInfo(status);
@@ skipping 93 matching lines @@
   ScheduleGeolocationUpdateRequest();
 }
 
 void DeviceStatusCollector::ReceiveVolumeInfo(
     const std::vector<em::VolumeInfo>& info) {
   if (report_hardware_status_)
     volume_info_ = info;
 }
 
 }  // namespace policy