Measure and report time between user-space process crashes.

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 <dbus/dbus-glib-lowlevel.h>
 
 #include <base/logging.h>
 
 #include "counter.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 #define SAFE_MESSAGE(e) (e.message ? e.message : "unknown error")
+#define DBUS_IFACE_CRASH_REPORTER "org.chromium.CrashReporter"
 #define DBUS_IFACE_FLIMFLAM_MANAGER "org.chromium.flimflam.Manager"
 #define DBUS_IFACE_POWER_MANAGER "org.chromium.PowerManager"
 #define DBUS_IFACE_SESSION_MANAGER "org.chromium.SessionManagerInterface"
 
 // File to aggregate daily usage before sending to UMA.
 // TODO(petkov): This file should probably live in a user-specific stateful
 // location, e.g., /home/chronos/user.
 static const char kDailyUseRecordFile[] = "/var/log/metrics/daily-usage";
+static const char kUserCrashIntervalRecordFile[] =
+    "/var/log/metrics/user-crash-interval";
 
 static const int kSecondsPerMinute = 60;
 static const int kMinutesPerHour = 60;
 static const int kHoursPerDay = 24;
 static const int kMinutesPerDay = kHoursPerDay * kMinutesPerHour;
+static const int kSecondsPerDay = kSecondsPerMinute * kMinutesPerDay;
+static const int kDaysPerWeek = 7;
+static const int kSecondsPerWeek = kSecondsPerDay * kDaysPerWeek;
 
 // 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;
 
+const char MetricsDaemon::kMetricUserCrashIntervalName[] =
+    "Logging.UserCrashInterval";
+const int MetricsDaemon::kMetricUserCrashIntervalMin = 1;
+const int MetricsDaemon::kMetricUserCrashIntervalMax = 4 * kSecondsPerWeek;
+const int MetricsDaemon::kMetricUserCrashIntervalBuckets = 50;
+
 // static
 const char* MetricsDaemon::kDBusMatches_[] = {
   "type='signal',"
+  "interface='" DBUS_IFACE_CRASH_REPORTER "',"
+  "path='/',"
+  "member='UserCrash'",
+
+  "type='signal',"
   "sender='org.chromium.flimflam',"
   "interface='" DBUS_IFACE_FLIMFLAM_MANAGER "',"
   "path='/',"
   "member='StateChanged'",
 
   "type='signal',"
   "interface='" DBUS_IFACE_POWER_MANAGER "',"
   "path='/'",
 
   "type='signal',"
@@ skipping 36 matching lines @@
     Loop();
   }
 }
 
 void MetricsDaemon::Init(bool testing, MetricsLibraryInterface* metrics_lib) {
   testing_ = testing;
   DCHECK(metrics_lib != NULL);
   metrics_lib_ = metrics_lib;
   daily_use_.reset(new chromeos_metrics::TaggedCounter());
   daily_use_->Init(kDailyUseRecordFile, &DailyUseReporter, this);
+  user_crash_interval_.reset(new chromeos_metrics::TaggedCounter());
+  user_crash_interval_->Init(kUserCrashIntervalRecordFile,
+                             &UserCrashIntervalReporter, this);
 
   // 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)) <<
       "No D-Bus connection: " << SAFE_MESSAGE(error);
 
   dbus_connection_setup_with_g_main(connection, NULL);
 
   // Registers D-Bus matches for the signals we would like to catch.
-  for (unsigned int m = 0; m < sizeof(kDBusMatches_) / sizeof(char*); m++) {
+  for (unsigned int m = 0; m < arraysize(kDBusMatches_); m++) {
     const char* match = kDBusMatches_[m];
     DLOG(INFO) << "adding dbus match: " << match;
     dbus_bus_add_match(connection, match, &error);
     LOG_IF(FATAL, dbus_error_is_set(&error)) <<
         "unable to add a match: " << SAFE_MESSAGE(error);
   }
 
   // Adds the D-Bus filter routine to be called back whenever one of
   // the registered D-Bus matches is successful. The daemon is not
   // activated for D-Bus messages that don't match.
@@ skipping 20 matching lines @@
   }
 
   // Signal messages always have interfaces.
   const char* interface = dbus_message_get_interface(message);
   CHECK(interface != NULL);
 
   MetricsDaemon* daemon = static_cast<MetricsDaemon*>(user_data);
 
   DBusMessageIter iter;
   dbus_message_iter_init(message, &iter);
-  if (strcmp(interface, DBUS_IFACE_FLIMFLAM_MANAGER) == 0) {
+  if (strcmp(interface, DBUS_IFACE_CRASH_REPORTER) == 0) {
+    CHECK(strcmp(dbus_message_get_member(message),
+                 "UserCrash") == 0);
+    daemon->ProcessUserCrash();
+  } else if (strcmp(interface, DBUS_IFACE_FLIMFLAM_MANAGER) == 0) {
     CHECK(strcmp(dbus_message_get_member(message),
                  "StateChanged") == 0);
 
     char* state_name;
     dbus_message_iter_get_basic(&iter, &state_name);
     daemon->NetStateChanged(state_name, ticks);
   } else if (strcmp(interface, DBUS_IFACE_POWER_MANAGER) == 0) {
     const char* member = dbus_message_get_member(message);
     if (strcmp(member, "ScreenIsLocked") == 0) {
       daemon->SetUserActiveState(false, now);
@@ skipping 103 matching lines @@
   if (user_active_ && now > user_active_last_) {
     TimeDelta since_active = now - user_active_last_;
     if (since_active < TimeDelta::FromSeconds(
             kUseMonitorIntervalMax + kSecondsPerMinute)) {
       seconds = static_cast<int>(since_active.InSeconds());
     }
   }
   TimeDelta since_epoch = now - Time();
   int day = since_epoch.InDays();
   daily_use_->Update(day, seconds);
+  user_crash_interval_->Update(0, seconds);
 
   // Schedules a use monitor on inactive->active transitions and
   // unschedules it on active->inactive transitions.
   if (!user_active_ && active)
     ScheduleUseMonitor(kUseMonitorIntervalInit, /* backoff */ false);
   else if (user_active_ && !active)
     UnscheduleUseMonitor();
 
   // Remembers the current active state and the time of the last
   // activity update.
   user_active_ = active;
   user_active_last_ = now;
 }
 
+void MetricsDaemon::ProcessUserCrash() {
+  // Counts the active use time up to now.
+  SetUserActiveState(user_active_, Time::Now());
+
+  // Reports the active use time since the last crash and resets it.
+  user_crash_interval_->Flush();
+}
+
 // static
 gboolean MetricsDaemon::UseMonitorStatic(gpointer data) {
   return static_cast<MetricsDaemon*>(data)->UseMonitor() ? TRUE : FALSE;
 }
 
 bool MetricsDaemon::UseMonitor() {
   SetUserActiveState(user_active_, Time::Now());
 
   // If a new monitor source/instance is scheduled, returns false to
   // tell GLib to destroy this monitor source/instance. Returns true
@@ skipping 42 matching lines @@
     return;
 
   DLOG(INFO) << "destroying use monitor";
   g_source_destroy(usemon_source_);
   usemon_source_ = NULL;
   usemon_interval_ = 0;
 }
 
 // static
 void MetricsDaemon::DailyUseReporter(void* handle, int tag, int count) {
+  if (count <= 0)
+    return;
+
   MetricsDaemon* daemon = static_cast<MetricsDaemon*>(handle);
   int minutes = (count + kSecondsPerMinute / 2) / kSecondsPerMinute;
   daemon->SendMetric(kMetricDailyUseTimeName, minutes,
                      kMetricDailyUseTimeMin,
                      kMetricDailyUseTimeMax,
                      kMetricDailyUseTimeBuckets);
 }
 
+// static
+void MetricsDaemon::UserCrashIntervalReporter(void* handle,
+                                              int tag, int count) {
+  MetricsDaemon* daemon = static_cast<MetricsDaemon*>(handle);
+  daemon->SendMetric(kMetricUserCrashIntervalName, count,
+                     kMetricUserCrashIntervalMin,
+                     kMetricUserCrashIntervalMax,
+                     kMetricUserCrashIntervalBuckets);
+}
+
 void MetricsDaemon::SendMetric(const std::string& name, int sample,
                                int min, int max, int nbuckets) {
   DLOG(INFO) << "received metric: " << name << " " << sample << " "
              << min << " " << max << " " << nbuckets;
   metrics_lib_->SendToUMA(name, sample, min, max, nbuckets);
 }