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

metrics_daemon_test.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 <utime.h>
+
 #include <base/file_util.h>
 #include <gtest/gtest.h>
 
 #include "counter_mock.h"
 #include "metrics_daemon.h"
 #include "metrics_library_mock.h"
 
 using base::Time;
 using base::TimeTicks;
+using chromeos_metrics::FrequencyCounter;
 using chromeos_metrics::FrequencyCounterMock;
 using chromeos_metrics::TaggedCounterMock;
+using chromeos_metrics::TaggedCounterReporter;
+using chromeos_metrics::TaggedCounterReporterMock;
 using ::testing::_;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 static const int kSecondsPerDay = 24 * 60 * 60;
 
+static const char kTestDir[] = "test";
+static const char kLastFile[] = "test/last";
+static const char kCurrentFile[] = "test/current";
+
 // This class allows a TimeTicks object to be initialized with seconds
 // (rather than microseconds) through the protected TimeTicks(int64)
 // constructor.
 class TestTicks : public TimeTicks {
  public:
   TestTicks(int64 seconds)
       : TimeTicks(seconds * Time::kMicrosecondsPerSecond) {}
 };
 
 // Overloaded for test failure printing purposes.
 static std::ostream& operator<<(std::ostream& o, const TimeTicks& ticks) {
   o << ticks.ToInternalValue() << "us";
   return o;
 };
 
 // Overloaded for test failure printing purposes.
 static std::ostream& operator<<(std::ostream& o, const Time& time) {
   o << time.ToInternalValue() << "us";
   return o;
 };
 
 class MetricsDaemonTest : public testing::Test {
  protected:
   virtual void SetUp() {
     EXPECT_EQ(NULL, daemon_.daily_use_.get());
     EXPECT_EQ(NULL, daemon_.kernel_crash_interval_.get());
     EXPECT_EQ(NULL, daemon_.user_crash_interval_.get());
     daemon_.Init(true, &metrics_lib_);
 
+    // Check configuration of a few histograms.
+    FrequencyCounter* frequency_counter =
+        daemon_.frequency_counters_[MetricsDaemon::kMetricAnyCrashesDailyName];
+    const TaggedCounterReporter* reporter = GetReporter(frequency_counter);
+    EXPECT_EQ(MetricsDaemon::kMetricAnyCrashesDailyName,
+              reporter->histogram_name());
+    EXPECT_EQ(chromeos_metrics::kSecondsPerDay,
+              frequency_counter->cycle_duration());
+    EXPECT_EQ(MetricsDaemon::kMetricCrashFrequencyMin, reporter->min());
+    EXPECT_EQ(MetricsDaemon::kMetricCrashFrequencyMax, reporter->max());
+    EXPECT_EQ(MetricsDaemon::kMetricCrashFrequencyBuckets, reporter->buckets());
+
+    frequency_counter =
+        daemon_.frequency_counters_[MetricsDaemon::kMetricAnyCrashesWeeklyName];
+    reporter = GetReporter(frequency_counter);
+    EXPECT_EQ(MetricsDaemon::kMetricAnyCrashesWeeklyName,
+              reporter->histogram_name());
+    EXPECT_EQ(chromeos_metrics::kSecondsPerWeek,
+              frequency_counter->cycle_duration());
+
+    EXPECT_EQ(MetricsDaemon::kMetricKernelCrashIntervalName,
+              daemon_.kernel_crash_interval_->histogram_name());
+    EXPECT_EQ(MetricsDaemon::kMetricCrashIntervalMin,
+              daemon_.kernel_crash_interval_->min());
+    EXPECT_EQ(MetricsDaemon::kMetricCrashIntervalMax,
+              daemon_.kernel_crash_interval_->max());
+    EXPECT_EQ(MetricsDaemon::kMetricCrashIntervalBuckets,
+              daemon_.kernel_crash_interval_->buckets());
+
+    EXPECT_EQ(MetricsDaemon::kMetricUncleanShutdownIntervalName,
+              daemon_.unclean_shutdown_interval_->histogram_name());
+
     // Tests constructor initialization. Switches to mock counters.
     EXPECT_TRUE(NULL != daemon_.daily_use_.get());
     EXPECT_TRUE(NULL != daemon_.kernel_crash_interval_.get());
     EXPECT_TRUE(NULL != daemon_.user_crash_interval_.get());
 
     // Allocates mock counter and transfers ownership.
     daily_use_ = new StrictMock<TaggedCounterMock>();
     daemon_.daily_use_.reset(daily_use_);
-    kernel_crash_interval_ = new StrictMock<TaggedCounterMock>();
+    kernel_crash_interval_ = new StrictMock<TaggedCounterReporterMock>();
     daemon_.kernel_crash_interval_.reset(kernel_crash_interval_);
-    user_crash_interval_ = new StrictMock<TaggedCounterMock>();
+    user_crash_interval_ = new StrictMock<TaggedCounterReporterMock>();
     daemon_.user_crash_interval_.reset(user_crash_interval_);
-    unclean_shutdown_interval_ = new StrictMock<TaggedCounterMock>();
+    unclean_shutdown_interval_ = new StrictMock<TaggedCounterReporterMock>();
     daemon_.unclean_shutdown_interval_.reset(unclean_shutdown_interval_);
-    kernel_crashes_daily_ = new StrictMock<FrequencyCounterMock>();
-    daemon_.kernel_crashes_daily_.reset(kernel_crashes_daily_);
-    user_crashes_daily_ = new StrictMock<FrequencyCounterMock>();
-    daemon_.user_crashes_daily_.reset(user_crashes_daily_);
-    unclean_shutdowns_daily_ = new StrictMock<FrequencyCounterMock>();
-    daemon_.unclean_shutdowns_daily_.reset(unclean_shutdowns_daily_);
-    any_crashes_daily_ = new StrictMock<FrequencyCounterMock>();
-    daemon_.any_crashes_daily_.reset(any_crashes_daily_);
+
+    // Reset all frequency counter reporters to mocks for further testing.
+    MetricsDaemon::FrequencyCounters::iterator i;
+    for (i = daemon_.frequency_counters_.begin();
+         i != daemon_.frequency_counters_.end(); ++i) {
+      delete i->second;
+      i->second = new StrictMock<FrequencyCounterMock>();
+    }
 
     EXPECT_FALSE(daemon_.user_active_);
     EXPECT_TRUE(daemon_.user_active_last_.is_null());
     EXPECT_EQ(MetricsDaemon::kUnknownNetworkState, daemon_.network_state_);
     EXPECT_TRUE(daemon_.network_state_last_.is_null());
     EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_);
     EXPECT_EQ(MetricsDaemon::kUnknownSessionState, daemon_.session_state_);
+
+    file_util::Delete(FilePath(kTestDir), true);
+    file_util::CreateDirectory(FilePath(kTestDir));
   }
 
   virtual void TearDown() {}
 
+  const TaggedCounterReporter*
+  GetReporter(FrequencyCounter* frequency_counter) const {
+    return static_cast<const TaggedCounterReporter*>(
+        &frequency_counter->tagged_counter());
+  }
+
+  void ExpectFrequencyFlushCalls() {
+    MetricsDaemon::FrequencyCounters::iterator i;
+    for (i = daemon_.frequency_counters_.begin();
+         i != daemon_.frequency_counters_.end(); ++i) {
+      FrequencyCounterMock* mock =
+          static_cast<FrequencyCounterMock*>(i->second);
+      EXPECT_CALL(*mock, FlushFinishedCycles());
+    }
+  }
+
   // Adds active use aggregation counters update expectations that the
   // specified tag/count update will be generated.
   void ExpectActiveUseUpdate(int daily_tag, int count) {
     EXPECT_CALL(*daily_use_, Update(daily_tag, count))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*kernel_crash_interval_, Update(0, count))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*user_crash_interval_, Update(0, count))
         .Times(1)
         .RetiresOnSaturation();
+    ExpectFrequencyFlushCalls();
   }
 
   // Adds active use aggregation counters update expectations that
   // ignore the update arguments.
   void IgnoreActiveUseUpdate() {
     EXPECT_CALL(*daily_use_, Update(_, _))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*kernel_crash_interval_, Update(_, _))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*user_crash_interval_, Update(_, _))
         .Times(1)
         .RetiresOnSaturation();
+    ExpectFrequencyFlushCalls();
   }
 
   // Adds a metrics library mock expectation that the specified metric
   // will be generated.
   void ExpectMetric(const std::string& name, int sample,
                     int min, int max, int buckets) {
     EXPECT_CALL(metrics_lib_, SendToUMA(name, sample, min, max, buckets))
         .Times(1)
         .WillOnce(Return(true))
         .RetiresOnSaturation();
@@ skipping 43 matching lines @@
     dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &arg_value_c);
     return msg;
   }
 
   // Deallocates the DBus message |msg| previously allocated through
   // dbus_message_new*.
   void DeleteDBusMessage(DBusMessage* msg) {
     dbus_message_unref(msg);
   }
 
+  // Get the frequency counter for the given name.
+  FrequencyCounterMock& GetFrequencyMock(const char* histogram_name) {
+    return *static_cast<FrequencyCounterMock*>(
+        daemon_.frequency_counters_[histogram_name]);
+  }
+
   // The MetricsDaemon under test.
   MetricsDaemon daemon_;
 
   // Metrics library mock. It's a strict mock so that all unexpected
   // metric generation calls are marked as failures.
   StrictMock<MetricsLibraryMock> metrics_lib_;
 
   // Counter mocks. They are strict mocks so that all unexpected
   // update calls are marked as failures. They are pointers so that
   // they can replace the scoped_ptr's allocated by the daemon.
   StrictMock<TaggedCounterMock>* daily_use_;
-  StrictMock<TaggedCounterMock>* kernel_crash_interval_;
-  StrictMock<TaggedCounterMock>* user_crash_interval_;
-  StrictMock<TaggedCounterMock>* unclean_shutdown_interval_;
-
-  StrictMock<FrequencyCounterMock>* kernel_crashes_daily_;
-  StrictMock<FrequencyCounterMock>* user_crashes_daily_;
-  StrictMock<FrequencyCounterMock>* unclean_shutdowns_daily_;
-  StrictMock<FrequencyCounterMock>* any_crashes_daily_;
+  StrictMock<TaggedCounterReporterMock>* kernel_crash_interval_;
+  StrictMock<TaggedCounterReporterMock>* user_crash_interval_;
+  StrictMock<TaggedCounterReporterMock>* unclean_shutdown_interval_;
 };
 
 TEST_F(MetricsDaemonTest, CheckSystemCrash) {
   static const char kKernelCrashDetected[] = "test-kernel-crash-detected";
   EXPECT_FALSE(daemon_.CheckSystemCrash(kKernelCrashDetected));
 
   FilePath crash_detected(kKernelCrashDetected);
   file_util::WriteFile(crash_detected, "", 0);
   EXPECT_TRUE(file_util::PathExists(crash_detected));
   EXPECT_TRUE(daemon_.CheckSystemCrash(kKernelCrashDetected));
   EXPECT_FALSE(file_util::PathExists(crash_detected));
   EXPECT_FALSE(daemon_.CheckSystemCrash(kKernelCrashDetected));
   EXPECT_FALSE(file_util::PathExists(crash_detected));
   file_util::Delete(crash_detected, false);
 }
 
 TEST_F(MetricsDaemonTest, ReportDailyUse) {
   ExpectDailyUseTimeMetric(/* sample */ 2);
   MetricsDaemon::ReportDailyUse(&daemon_, /* tag */ 20, /* count */ 90);
 
   ExpectDailyUseTimeMetric(/* sample */ 1);
   MetricsDaemon::ReportDailyUse(&daemon_, /* tag */ 23, /* count */ 89);
 
   // There should be no metrics generated for the calls below.
   MetricsDaemon::ReportDailyUse(&daemon_, /* tag */ 50, /* count */ 0);
   MetricsDaemon::ReportDailyUse(&daemon_, /* tag */ 60, /* count */ -5);
 }
 
-TEST_F(MetricsDaemonTest, ReportKernelCrashInterval) {
-  ExpectMetric(MetricsDaemon::kMetricKernelCrashIntervalName, 50,
-               MetricsDaemon::kMetricCrashIntervalMin,
-               MetricsDaemon::kMetricCrashIntervalMax,
-               MetricsDaemon::kMetricCrashIntervalBuckets);
-  MetricsDaemon::ReportKernelCrashInterval(&daemon_, 0, 50);
-}
-
-TEST_F(MetricsDaemonTest, ReportUncleanShutdownInterval) {
-  ExpectMetric(MetricsDaemon::kMetricUncleanShutdownIntervalName, 50,
-               MetricsDaemon::kMetricCrashIntervalMin,
-               MetricsDaemon::kMetricCrashIntervalMax,
-               MetricsDaemon::kMetricCrashIntervalBuckets);
-  MetricsDaemon::ReportUncleanShutdownInterval(&daemon_, 0, 50);
-}
-
 TEST_F(MetricsDaemonTest, LookupNetworkState) {
   EXPECT_EQ(MetricsDaemon::kNetworkStateOnline,
             daemon_.LookupNetworkState("online"));
   EXPECT_EQ(MetricsDaemon::kNetworkStateOffline,
             daemon_.LookupNetworkState("offline"));
   EXPECT_EQ(MetricsDaemon::kUnknownNetworkState,
             daemon_.LookupNetworkState("somestate"));
 }
 
 TEST_F(MetricsDaemonTest, LookupPowerState) {
@@ skipping 15 matching lines @@
 }
 
 TEST_F(MetricsDaemonTest, MessageFilter) {
   DBusMessage* msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
   DBusHandlerResult res =
       MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_NOT_YET_HANDLED, res);
   DeleteDBusMessage(msg);
 
   IgnoreActiveUseUpdate();
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricAnyCrashesDailyName),
+      Update(1))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricAnyCrashesWeeklyName),
+      Update(1))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricUserCrashesDailyName),
+      Update(1))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricUserCrashesWeeklyName),
+      Update(1))
+      .Times(1)
+      .RetiresOnSaturation();
   EXPECT_CALL(*user_crash_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*user_crashes_daily_, Update(1))
-      .Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*any_crashes_daily_, Update(1))
-      .Times(1)
-      .RetiresOnSaturation();
   msg = NewDBusSignalString("/",
                             "org.chromium.CrashReporter",
                             "UserCrash",
                             "");
   res = MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
   DeleteDBusMessage(msg);
 
   msg = NewDBusSignalString("/",
                             "org.chromium.flimflam.Manager",
@@ skipping 113 matching lines @@
   EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_);
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(7 * kSecondsPerDay + 185), daemon_.user_active_last_);
 }
 
 TEST_F(MetricsDaemonTest, ProcessKernelCrash) {
   IgnoreActiveUseUpdate();
   EXPECT_CALL(*kernel_crash_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*kernel_crashes_daily_, Update(1));
-  EXPECT_CALL(*any_crashes_daily_, Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricAnyCrashesDailyName),
+              Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricAnyCrashesWeeklyName),
+              Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricKernelCrashesDailyName),
+              Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricKernelCrashesWeeklyName),
+              Update(1));
   daemon_.ProcessKernelCrash();
 }
 
 TEST_F(MetricsDaemonTest, ProcessUncleanShutdown) {
   IgnoreActiveUseUpdate();
   EXPECT_CALL(*unclean_shutdown_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*unclean_shutdowns_daily_, Update(1));
-  EXPECT_CALL(*any_crashes_daily_, Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricAnyCrashesDailyName),
+              Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricAnyCrashesWeeklyName),
+              Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricUncleanShutdownsDailyName),
+              Update(1));
+  EXPECT_CALL(
+      GetFrequencyMock(MetricsDaemon::kMetricUncleanShutdownsWeeklyName),
+      Update(1));
   daemon_.ProcessUncleanShutdown();
 }
 
 TEST_F(MetricsDaemonTest, ProcessUserCrash) {
   IgnoreActiveUseUpdate();
   EXPECT_CALL(*user_crash_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
-  EXPECT_CALL(*user_crashes_daily_, Update(1));
-  EXPECT_CALL(*any_crashes_daily_, Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricAnyCrashesDailyName),
+              Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricAnyCrashesWeeklyName),
+              Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricUserCrashesDailyName),
+              Update(1));
+  EXPECT_CALL(GetFrequencyMock(MetricsDaemon::kMetricUserCrashesWeeklyName),
+              Update(1));
   daemon_.ProcessUserCrash();
 }
 
 TEST_F(MetricsDaemonTest, SendMetric) {
   ExpectMetric("Dummy.Metric", 3, 1, 100, 50);
   daemon_.SendMetric("Dummy.Metric", /* sample */ 3,
                      /* min */ 1, /* max */ 100, /* buckets */ 50);
 }
 
 TEST_F(MetricsDaemonTest, SessionStateChanged) {
@@ skipping 62 matching lines @@
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(10 * kSecondsPerDay + 300), daemon_.user_active_last_);
 
   ExpectActiveUseUpdate(10, 0);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(10 * kSecondsPerDay + 1000));
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(10 * kSecondsPerDay + 1000), daemon_.user_active_last_);
 }
 
-TEST_F(MetricsDaemonTest, ReportUserCrashInterval) {
-  ExpectMetric(MetricsDaemon::kMetricUserCrashIntervalName, 50,
-               MetricsDaemon::kMetricCrashIntervalMin,
-               MetricsDaemon::kMetricCrashIntervalMax,
-               MetricsDaemon::kMetricCrashIntervalBuckets);
-  MetricsDaemon::ReportUserCrashInterval(&daemon_, 0, 50);
-}
-
-TEST_F(MetricsDaemonTest, ReportCrashesDailyFrequency) {
-  ExpectMetric("foobar", 50,
-               MetricsDaemon::kMetricCrashesDailyMin,
-               MetricsDaemon::kMetricCrashesDailyMax,
-               MetricsDaemon::kMetricCrashesDailyBuckets);
-  MetricsDaemon::ReportCrashesDailyFrequency("foobar", &daemon_, 50);
+TEST_F(MetricsDaemonTest, GetHistogramPath) {
+  EXPECT_EQ("/var/log/metrics/Logging.AnyCrashesDaily",
+            daemon_.GetHistogramPath(
+                MetricsDaemon::kMetricAnyCrashesDailyName).value());
 }
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }