Add some basic tests for metrics_daemon.

src/platform/metrics/metrics_daemon.cc

 // Copyright (c) 2010 The Chromium OS 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 "metrics_daemon.h"
 #include "metrics_library.h"
 
 #include <dbus/dbus-glib-lowlevel.h>
 #include <sys/file.h>
 
@@ skipping 19 matching lines @@
 
 // The daily use monitor is scheduled to a 1-minute interval after
 // initial user activity and then it's exponentially backed off to
 // 10-minute intervals. Although not required, the back off is
 // implemented because the histogram buckets are spaced exponentially
 // anyway and to avoid too frequent metrics daemon process wake-ups
 // and file I/O.
 static const int kUseMonitorIntervalInit = 1 * kSecondsPerMinute;
 static const int kUseMonitorIntervalMax = 10 * kSecondsPerMinute;
 
+// static metrics parameters.
+const char MetricsDaemon::kMetricDailyUseTimeName[] =
+    "Logging.DailyUseTime";
+const int MetricsDaemon::kMetricDailyUseTimeMin = 1;
+const int MetricsDaemon::kMetricDailyUseTimeMax = kMinutesPerDay;
+const int MetricsDaemon::kMetricDailyUseTimeBuckets = 50;
+
+const char MetricsDaemon::kMetricTimeToNetworkDropName[] =
+    "Network.TimeToDrop";
+const int MetricsDaemon::kMetricTimeToNetworkDropMin = 1;
+const int MetricsDaemon::kMetricTimeToNetworkDropMax =
+    8 /* hours */ * kMinutesPerHour * kSecondsPerMinute;
+const int MetricsDaemon::kMetricTimeToNetworkDropBuckets = 50;
+
 // static
 const char* MetricsDaemon::kDBusMatches_[] = {
   "type='signal',"
   "sender='org.moblin.connman',"
   "interface='" DBUS_IFACE_CONNMAN_MANAGER "',"
   "path='/',"
   "member='StateChanged'",
 
   "type='signal',"
   "interface='" DBUS_IFACE_POWER_MANAGER "',"
@@ skipping 29 matching lines @@
 #define STATE(name, capname) #name,
 #include "screensaver_states.h"
 };
 
 // static
 const char* MetricsDaemon::kSessionStates_[] = {
 #define STATE(name, capname) #name,
 #include "session_states.h"
 };
 
-void MetricsDaemon::Run(bool run_as_daemon, bool testing) {
-  Init(testing);
+void MetricsDaemon::Run(bool run_as_daemon) {
+  Init(false);
   if (!run_as_daemon || daemon(0, 0) == 0) {
     Loop();
   }
 }
 
 void MetricsDaemon::Init(bool testing) {
   testing_ = testing;
+  daily_use_record_file_ = kDailyUseRecordFile;
+
+  // Don't setup D-Bus and GLib in test mode.
+  if (testing)
+    return;
 
   g_thread_init(NULL);
   g_type_init();
   dbus_g_thread_init();
 
   DBusError error;
   dbus_error_init(&error);
 
   DBusConnection *connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
   LOG_IF(FATAL, dbus_error_is_set(&error)) <<
@@ skipping 77 matching lines @@
 
   return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 void MetricsDaemon::NetStateChanged(const char* state_name, time_t now) {
   DLOG(INFO) << "network state: " << state_name;
 
   NetworkState state = LookupNetworkState(state_name);
 
   // Logs the time in seconds between the network going online to
-  // going offline in order to measure the mean time to network
-  // dropping. Going offline as part of suspend-to-RAM is not logged
-  // as network drop -- the assumption is that the message for
-  // suspend-to-RAM comes before the network offline message which
-  // seems to and should be the case.
-  if (state == kNetworkStateOffline &&
+  // going offline (or, more precisely, going not online) in order to
+  // measure the mean time to network dropping. Going offline as part
+  // of suspend-to-RAM is not logged as network drop -- the assumption
+  // is that the message for suspend-to-RAM comes before the network
+  // offline message which seems to and should be the case.
+  if (state != kNetworkStateOnline &&
       network_state_ == kNetworkStateOnline &&
       power_state_ != kPowerStateMem) {
     int online_time = static_cast<int>(now - network_state_last_);
-    PublishMetric("Network.TimeToDrop", online_time,
-                  1, 8 /* hours */ * 60 * 60, 50);
+    PublishMetric(kMetricTimeToNetworkDropName, online_time,
+                  kMetricTimeToNetworkDropMin,
+                  kMetricTimeToNetworkDropMax,
+                  kMetricTimeToNetworkDropBuckets);
   }
 
   network_state_ = state;
   network_state_last_ = now;
 }
 
 MetricsDaemon::NetworkState
 MetricsDaemon::LookupNetworkState(const char* state_name) {
   for (int i = 0; i < kNumberNetworkStates; i++) {
     if (strcmp(state_name, kNetworkStates_[i]) == 0) {
@@ skipping 81 matching lines @@
   user_active_last_ = now;
 }
 
 void MetricsDaemon::LogDailyUseRecord(int day, int seconds) {
   // If there's no new active use today and the last record in the
   // usage aggregation file is today, there's nothing to do.
   if (seconds == 0 && day == daily_use_day_last_)
     return;
 
   DLOG(INFO) << "day: " << day << " usage: " << seconds << " seconds";
-  int fd = HANDLE_EINTR(open(kDailyUseRecordFile,
+  int fd = HANDLE_EINTR(open(daily_use_record_file_,
                              O_RDWR | O_CREAT,
                              S_IRUSR | S_IWUSR));
   if (fd < 0) {
-    DLOG(WARNING) << "Unable to open the daily use file.";
+    PLOG(WARNING) << "Unable to open the daily use file";
     return;
   }
 
   bool same_day = false;
   UseRecord record;
   if (HANDLE_EINTR(read(fd, &record, sizeof(record))) == sizeof(record)) {
     if (record.day_ == day) {
       // If there's an existing record for today, aggregates the usage
       // time.
       same_day = true;
       record.seconds_ += seconds;
     } else {
       // If there's an existing record for a day in the past, rounds
       // the usage to the nearest minute and sends it to UMA.
       int minutes =
           (record.seconds_ + kSecondsPerMinute / 2) / kSecondsPerMinute;
-      PublishMetric("Logging.DailyUseTime",
-                    minutes, 1, kMinutesPerDay, 50);
+      PublishMetric(kMetricDailyUseTimeName, minutes,
+                    kMetricDailyUseTimeMin,
+                    kMetricDailyUseTimeMax,
+                    kMetricDailyUseTimeBuckets);
 
       // Truncates the usage file to ensure that no duplicate usage is
       // sent to UMA.
-      LOG_IF(WARNING, HANDLE_EINTR(ftruncate(fd, 0)) != 0);
+      PLOG_IF(WARNING, HANDLE_EINTR(ftruncate(fd, 0)) != 0);
     }
   }
 
   // Updates the use record in the daily usage file if there's new
   // usage today.
   if (seconds > 0) {
     if (!same_day) {
       record.day_ = day;
       record.seconds_ = seconds;
     }
     // else an already existing record for the same day will be
     // overwritten with updated usage below.
 
-    LOG_IF(WARNING, HANDLE_EINTR(lseek(fd, 0, SEEK_SET)) != 0);
-    LOG_IF(WARNING,
-           HANDLE_EINTR(write(fd, &record, sizeof(record))) != sizeof(record));
+    PLOG_IF(WARNING, HANDLE_EINTR(lseek(fd, 0, SEEK_SET)) != 0);
+    PLOG_IF(WARNING,
+            HANDLE_EINTR(write(fd, &record, sizeof(record))) !=
+            sizeof(record));
   }
 
   HANDLE_EINTR(close(fd));
 
   // Remembers the day of the use record in the usage aggregation file
   // to reduce file I/O. This is not really useful now but potentially
   // allows frequent LogDailyUseRecord calls with no unnecessary I/O
   // overhead.
   daily_use_day_last_ = day;
 }
 
 // static
 gboolean MetricsDaemon::UseMonitorStatic(gpointer data) {
   return static_cast<MetricsDaemon*>(data)->UseMonitor() ? TRUE : FALSE;
 }
 
 bool MetricsDaemon::UseMonitor() {
   SetUserActiveState(user_active_, time(NULL));
 
   // If a new monitor source/instance is scheduled, returns false to
   // tell GLib to destroy this monitor source/instance. Returns true
   // otherwise to keep calling back this monitor.
   return !ScheduleUseMonitor(usemon_interval_ * 2, /* backoff */ true);
 }
 
 bool MetricsDaemon::ScheduleUseMonitor(int interval, bool backoff)
 {
+  if (testing_)

[kmixter1, 2010/05/10 19:06:31]

Ideally you'd want to make this function available through a fake/mock object.

+    return false;
+
   // Caps the interval -- the bigger the interval, the more active use
   // time will be potentially dropped on system shutdown.
   if (interval > kUseMonitorIntervalMax)
     interval = kUseMonitorIntervalMax;
 
   if (backoff) {
     // Back-off mode is used by the use monitor to reschedule itself
     // with exponential back-off in time. This mode doesn't create a
     // new timeout source if the new interval is the same as the old
     // one. Also, if a new timeout source is created, the old one is
@@ skipping 23 matching lines @@
     return;
 
   DLOG(INFO) << "destroying use monitor";
   g_source_destroy(usemon_source_);
   usemon_source_ = NULL;
   usemon_interval_ = 0;
 }
 
 void MetricsDaemon::PublishMetric(const char* name, int sample,
                                   int min, int max, int nbuckets) {
-  DLOG(INFO) << "received metric: " << name << " " << sample << " "
-             << min << " " << max << " " << nbuckets;
+  LOG(INFO) << "received metric: " << name << " " << sample << " "
+            << min << " " << max << " " << nbuckets;
   if (!testing_) {
     MetricsLibrary::SendToChrome(name, sample, min, max, nbuckets);
   }
 }