Add weekly crash counters, refactor metrics_daemon, respect opt-in in library.

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>
+#include <map>
 
+#include <base/file_path.h>
 #include <base/scoped_ptr.h>
 #include <base/time.h>
 #include <gtest/gtest_prod.h>  // for FRIEND_TEST
 
 #include "metrics_library.h"
 
 namespace chromeos_metrics {
 class FrequencyCounter;
-class TaggedCounterInterface;
+class TaggedCounter;
+class TaggedCounterReporter;
 }
 
 class MetricsDaemon {
 
  public:
   MetricsDaemon();
   ~MetricsDaemon();
 
   // Initializes.
   void Init(bool testing, MetricsLibraryInterface* metrics_lib);
 
   // Does all the work. If |run_as_daemon| is true, daemonizes by
   // forking.
   void Run(bool run_as_daemon);
 
  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, 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, ProcessKernelCrash);
   FRIEND_TEST(MetricsDaemonTest, ProcessUncleanShutdown);
@@ skipping 34 matching lines @@
   };
 
   // Data record for aggregating daily usage.
   class UseRecord {
    public:
     UseRecord() : day_(0), seconds_(0) {}
     int day_;
     int seconds_;
   };
 
+  typedef std::map<std::string, chromeos_metrics::FrequencyCounter*>
+    FrequencyCounters;
+
   // Metric parameters.
   static const char kMetricAnyCrashesDailyName[];
-  static const char kMetricCrashesDailyBuckets;
-  static const char kMetricCrashesDailyMax;
-  static const char kMetricCrashesDailyMin;
+  static const char kMetricAnyCrashesWeeklyName[];
+  static const char kMetricCrashFrequencyBuckets;
+  static const char kMetricCrashFrequencyMax;
+  static const char kMetricCrashFrequencyMin;
   static const int  kMetricCrashIntervalBuckets;
   static const int  kMetricCrashIntervalMax;
   static const int  kMetricCrashIntervalMin;
   static const int  kMetricDailyUseTimeBuckets;
   static const int  kMetricDailyUseTimeMax;
   static const int  kMetricDailyUseTimeMin;
   static const char kMetricDailyUseTimeName[];
   static const char kMetricKernelCrashesDailyName[];
+  static const char kMetricKernelCrashesWeeklyName[];
   static const char kMetricKernelCrashIntervalName[];
+  static const char kMetricsPath[];
   static const int  kMetricTimeToNetworkDropBuckets;
   static const int  kMetricTimeToNetworkDropMax;
   static const int  kMetricTimeToNetworkDropMin;
   static const char kMetricTimeToNetworkDropName[];
   static const char kMetricUncleanShutdownIntervalName[];
   static const char kMetricUncleanShutdownsDailyName[];
+  static const char kMetricUncleanShutdownsWeeklyName[];
   static const char kMetricUserCrashesDailyName[];
+  static const char kMetricUserCrashesWeeklyName[];
   static const char kMetricUserCrashIntervalName[];
 
   // 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];
 
   // Array of user session states.
   static const char* kSessionStates_[kNumberSessionStates];
 
+  // Clears and deletes the data contained in frequency_counters_.
+  void DeleteFrequencyCounters();
+
+  // Configures the given crash interval reporter.
+  void ConfigureCrashIntervalReporter(
+      const char* histogram_name,
+      scoped_ptr<chromeos_metrics::TaggedCounterReporter>* reporter);
+
+  // Configures the given frequency counter reporter.
+  void ConfigureCrashFrequencyReporter(const char* histogram_name);
+
+  // Returns file path to persistent file for generating given histogram.
+  FilePath GetHistogramPath(const char* histogram_name);
+
   // Creates the event loop and enters it.
   void Loop();
 
   // D-Bus filter callback.
   static DBusHandlerResult MessageFilter(DBusConnection* connection,
                                          DBusMessage* message,
                                          void* user_data);
 
   // Processes network state change.
   void NetStateChanged(const char* state_name, base::TimeTicks ticks);
@@ skipping 59 matching lines @@
   // |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();
 
+  // Report daily use through UMA.
+  static void ReportDailyUse(void* handle, int tag, int count);
+
   // 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 ReportDailyUse(void* data, int tag, int count);
-
-  // Helper to report a crash interval to UMA.
-  static void ReportCrashInterval(const char* histogram_name,
-                                  void* handle, int count);
-
-  // TaggedCounter callback to process time between user-space process
-  // crashes and send to UMA.
-  static void ReportUserCrashInterval(void* data, int tag, int count);
-
-  // TaggedCounter callback to process time between kernel crashes and
-  // send to UMA.
-  static void ReportKernelCrashInterval(void* data, int tag, int count);
-
-  // TaggedCounter callback to process time between unclean shutdowns and
-  // send to UMA.
-  static void ReportUncleanShutdownInterval(void* data, int tag, int count);
-
-  // Helper to report a daily crash frequency to UMA.
-  static void ReportCrashesDailyFrequency(const char* histogram_name,
-                                          void* handle, int count);
-
-  // TaggedCounter callback to report daily crash frequency to UMA.
-  static void ReportUserCrashesDaily(void* handle, int tag, int count);
-
-  // TaggedCounter callback to report kernel crash frequency to UMA.
-  static void ReportKernelCrashesDaily(void* handle, int tag, int count);
-
-  // TaggedCounter callback to report unclean shutdown frequency to UMA.
-  static void ReportUncleanShutdownsDaily(void* handle, int tag, int count);
-
-  // TaggedCounter callback to report frequency of any crashes to UMA.
-  static void ReportAnyCrashesDaily(void* handle, 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
@@ skipping 10 matching lines @@
   // 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.
   base::Time user_active_last_;
 
   // Daily active use time in seconds.
-  scoped_ptr<chromeos_metrics::TaggedCounterInterface> daily_use_;
+  scoped_ptr<chromeos_metrics::TaggedCounter> daily_use_;
 
   // Active use time between user-space process crashes.
-  scoped_ptr<chromeos_metrics::TaggedCounterInterface> user_crash_interval_;
+  scoped_ptr<chromeos_metrics::TaggedCounterReporter> user_crash_interval_;
 
   // Active use time between kernel crashes.
-  scoped_ptr<chromeos_metrics::TaggedCounterInterface> kernel_crash_interval_;
+  scoped_ptr<chromeos_metrics::TaggedCounterReporter> kernel_crash_interval_;
 
   // Active use time between unclean shutdowns crashes.
-  scoped_ptr<chromeos_metrics::TaggedCounterInterface>
+  scoped_ptr<chromeos_metrics::TaggedCounterReporter>
       unclean_shutdown_interval_;
 
-  // Daily count of user-space process crashes.
-  scoped_ptr<chromeos_metrics::FrequencyCounter> user_crashes_daily_;
-
-  // Daily count of kernel crashes.
-  scoped_ptr<chromeos_metrics::FrequencyCounter> kernel_crashes_daily_;
-
-  // Daily count of unclean shutdowns.
-  scoped_ptr<chromeos_metrics::FrequencyCounter> unclean_shutdowns_daily_;
-
-  // Daily count of any crashes (user-space processes, kernel, or
-  // unclean shutdowns).
-  scoped_ptr<chromeos_metrics::FrequencyCounter> any_crashes_daily_;
+  // Map of all frequency counters, to simplify flushing them.
+  FrequencyCounters frequency_counters_;
 
   // 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_