Measure and report time between user-space process crashes.

metrics_daemon.h

 // 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.
 
 #ifndef METRICS_DAEMON_H_
 #define METRICS_DAEMON_H_
 
 #include <dbus/dbus.h>
 #include <glib.h>
 
@@ skipping 22 matching lines @@
   friend class MetricsDaemonTest;
   FRIEND_TEST(MetricsDaemonTest, DailyUseReporter);
   FRIEND_TEST(MetricsDaemonTest, LookupNetworkState);
   FRIEND_TEST(MetricsDaemonTest, LookupPowerState);
   FRIEND_TEST(MetricsDaemonTest, LookupScreenSaverState);
   FRIEND_TEST(MetricsDaemonTest, LookupSessionState);
   FRIEND_TEST(MetricsDaemonTest, MessageFilter);
   FRIEND_TEST(MetricsDaemonTest, NetStateChangedSimpleDrop);
   FRIEND_TEST(MetricsDaemonTest, NetStateChangedSuspend);
   FRIEND_TEST(MetricsDaemonTest, PowerStateChanged);
+  FRIEND_TEST(MetricsDaemonTest, ProcessUserCrash);
   FRIEND_TEST(MetricsDaemonTest, ScreenSaverStateChanged);
   FRIEND_TEST(MetricsDaemonTest, SendMetric);
   FRIEND_TEST(MetricsDaemonTest, SessionStateChanged);
   FRIEND_TEST(MetricsDaemonTest, SetUserActiveState);
   FRIEND_TEST(MetricsDaemonTest, SetUserActiveStateTimeJump);
+  FRIEND_TEST(MetricsDaemonTest, UserCrashIntervalReporter);
 
   // The network states (see network_states.h).
   enum NetworkState {
     kUnknownNetworkState = -1, // Initial/unknown network state.
 #define STATE(name, capname) kNetworkState ## capname,
 #include "network_states.h"
     kNumberNetworkStates
   };
 
   // The power states (see power_states.h).
@@ skipping 22 matching lines @@
 
   // Metric parameters.
   static const char kMetricDailyUseTimeName[];
   static const int kMetricDailyUseTimeMin;
   static const int kMetricDailyUseTimeMax;
   static const int kMetricDailyUseTimeBuckets;
   static const char kMetricTimeToNetworkDropName[];
   static const int kMetricTimeToNetworkDropMin;
   static const int kMetricTimeToNetworkDropMax;
   static const int kMetricTimeToNetworkDropBuckets;
+  static const char kMetricUserCrashIntervalName[];
+  static const int kMetricUserCrashIntervalMin;
+  static const int kMetricUserCrashIntervalMax;
+  static const int kMetricUserCrashIntervalBuckets;
 
   // D-Bus message match strings.
   static const char* kDBusMatches_[];
 
   // Array of network states.
   static const char* kNetworkStates_[kNumberNetworkStates];
 
   // Array of power states.
   static const char* kPowerStates_[kNumberPowerStates];
 
@@ skipping 35 matching lines @@
   // discarded.
   void SetUserActiveState(bool active, base::Time now);
 
   // Updates the daily usage file, if necessary, by adding |seconds|
   // of active use to the |day| since Epoch. If there's usage data for
   // day in the past in the usage file, that data is sent to UMA and
   // removed from the file. If there's already usage data for |day| in
   // the usage file, the |seconds| are accumulated.
   void LogDailyUseRecord(int day, int seconds);
 
+  // Updates the active use time and logs time between user-space
+  // process crashes.
+  void ProcessUserCrash();
+
   // Callbacks for the daily use monitor. The daily use monitor uses
   // LogDailyUseRecord to aggregate current usage data and send it to
   // UMA, if necessary. It also reschedules itself using an
   // exponentially bigger interval (up to a certain maximum) -- so
   // usage is monitored less frequently with longer active use.
   static gboolean UseMonitorStatic(gpointer data);
   bool UseMonitor();
 
   // Schedules or reschedules a daily use monitor for |interval|
   // seconds from now. |backoff| mode is used by the use monitor to
   // reschedule itself. If there's a monitor scheduled already and
   // |backoff| is false, unschedules it first. Doesn't schedule a
   // monitor for more than kUseMonitorIntervalMax seconds in the
   // future (see metrics_daemon.cc). Returns true if a new use monitor
   // was scheduled, false otherwise (note that if |backoff| is false a
   // new use monitor will always be scheduled).
   bool ScheduleUseMonitor(int interval, bool backoff);
 
   // Unschedules a scheduled use monitor, if any.
   void UnscheduleUseMonitor();
 
   // Sends a regular (exponential) histogram sample to Chrome for
   // transport to UMA. See MetricsLibrary::SendToUMA in
   // metrics_library.h for a description of the arguments.
   void SendMetric(const std::string& name, int sample,
                   int min, int max, int nbuckets);
 
+  // TaggedCounter callback to process aggregated daily usage data and
+  // send to UMA.
   static void DailyUseReporter(void* data, int tag, int count);
 
+  // TaggedCounter callback to process time between user-space process
+  // crashes and send to UMA.
+  static void UserCrashIntervalReporter(void* data, int tag, int count);
+
   // Test mode.
   bool testing_;
 
   // The metrics library handle.
   MetricsLibraryInterface* metrics_lib_;
 
   // Current network state.
   NetworkState network_state_;
 
   // Timestamps last network state update.  This timestamp is used to
   // sample the time from the network going online to going offline so
   // TimeTicks ensures a monotonically increasing TimeDelta.
   base::TimeTicks network_state_last_;
 
   // Current power state.
   PowerState power_state_;
 
   // Current user session state.
   SessionState session_state_;
 
   // Is the user currently active: power is on, user session has
   // started, screen is not locked.
   bool user_active_;
 
-  // Timestamps last user active update.  Active use time is
-  // aggregated each day before sending to UMA so using time since the
-  // epoch as the timestamp.
+  // Timestamps last user active update. Active use time is aggregated
+  // each day before sending to UMA so using time since the epoch as
+  // the timestamp.
   base::Time user_active_last_;
 
+  // Daily active use time in seconds.
   scoped_ptr<chromeos_metrics::TaggedCounterInterface> daily_use_;
 
+  // Active use time between user-space process crashes.
+  scoped_ptr<chromeos_metrics::TaggedCounterInterface> user_crash_interval_;
+
   // Sleep period until the next daily usage aggregation performed by
   // the daily use monitor (see ScheduleUseMonitor).
   int usemon_interval_;
 
   // Scheduled daily use monitor source (see ScheduleUseMonitor).
   GSource* usemon_source_;
 };
 
 #endif  // METRICS_DAEMON_H_