Add weekly crash counters, refactor metrics_daemon, respect opt-in in library.
BUG=5340,5814
Change-Id: I2c207055f1ebe48051193395e2dbe38d9140b025
Review URL: http://codereview.chromium.org/3171023
diff --git a/metrics/c_metrics_library.cc b/metrics/c_metrics_library.cc
index 91e9ca6..e97f9ac 100644
--- a/metrics/c_metrics_library.cc
+++ b/metrics/c_metrics_library.cc
@@ -26,8 +26,8 @@
}
extern "C" int CMetricsLibrarySendToUMA(CMetricsLibrary handle,
- const char* name, int sample,
- int min, int max, int nbuckets) {
+ const char* name, int sample,
+ int min, int max, int nbuckets) {
MetricsLibrary* lib = reinterpret_cast<MetricsLibrary*>(handle);
if (lib == NULL)
return 0;
@@ -35,10 +35,17 @@
}
extern "C" int CMetricsLibrarySendEnumToUMA(CMetricsLibrary handle,
- const char* name, int sample,
- int max) {
+ const char* name, int sample,
+ int max) {
MetricsLibrary* lib = reinterpret_cast<MetricsLibrary*>(handle);
if (lib == NULL)
return 0;
return lib->SendEnumToUMA(std::string(name), sample, max);
}
+
+extern "C" int CMetricsLibraryAreMetricsEnabled(CMetricsLibrary handle) {
+ MetricsLibrary* lib = reinterpret_cast<MetricsLibrary*>(handle);
+ if (lib == NULL)
+ return 0;
+ return lib->AreMetricsEnabled();
+}
diff --git a/metrics/c_metrics_library.h b/metrics/c_metrics_library.h
index 6d1e6f9..e691ad6 100644
--- a/metrics/c_metrics_library.h
+++ b/metrics/c_metrics_library.h
@@ -21,13 +21,17 @@
// C wrapper for MetricsLibrary::SendToUMA.
int CMetricsLibrarySendToUMA(CMetricsLibrary handle,
- const char* name, int sample,
- int min, int max, int nbuckets);
+ const char* name, int sample,
+ int min, int max, int nbuckets);
// C wrapper for MetricsLibrary::SendEnumToUMA.
int CMetricsLibrarySendEnumToUMA(CMetricsLibrary handle,
- const char* name, int sample, int max);
+ const char* name, int sample, int max);
+
+// C wrapper for MetricsLibrary::AreMetricsEnabled.
+int CMetricsLibraryAreMetricsEnabled(CMetricsLibrary handle);
+
#if defined(__cplusplus)
}
#endif
-#endif // C_METRICS_LIBRARY_H_
+#endif // C_METRICS_LIBRARY_H_
diff --git a/metrics/counter.cc b/metrics/counter.cc
index 4de1db1..95d1faf 100644
--- a/metrics/counter.cc
+++ b/metrics/counter.cc
@@ -8,6 +8,7 @@
#include <base/eintr_wrapper.h>
#include <base/logging.h>
+#include "metrics_library.h"
namespace chromeos_metrics {
@@ -31,8 +32,7 @@
// TaggedCounter implementation.
TaggedCounter::TaggedCounter()
- : filename_(NULL),
- reporter_(NULL),
+ : reporter_(NULL),
reporter_handle_(NULL),
record_state_(kRecordInvalid) {}
@@ -72,12 +72,13 @@
}
DLOG(INFO) << "tag: " << tag << " count: " << count << " flush: " << flush;
- DCHECK(filename_);
+ DCHECK(!filename_.empty());
// NOTE: The assumption is that this TaggedCounter object is the
// sole owner of the persistent storage file so no locking is
// necessary.
- int fd = HANDLE_EINTR(open(filename_, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR));
+ int fd = HANDLE_EINTR(open(filename_.c_str(),
+ O_RDWR | O_CREAT, S_IRUSR | S_IWUSR));
if (fd < 0) {
PLOG(WARNING) << "Unable to open the persistent counter file";
return;
@@ -183,21 +184,57 @@
}
}
+MetricsLibraryInterface* TaggedCounterReporter::metrics_lib_ = NULL;
+
+TaggedCounterReporter::TaggedCounterReporter()
+ : tagged_counter_(new TaggedCounter()),
+ min_(0),
+ max_(0),
+ buckets_(0) {
+}
+
+TaggedCounterReporter::~TaggedCounterReporter() {
+}
+
+void TaggedCounterReporter::Init(const char* filename,
+ const char* histogram_name,
+ int min,
+ int max,
+ int buckets) {
+ tagged_counter_->Init(filename, Report, this);
+ histogram_name_ = histogram_name;
+ min_ = min;
+ max_ = max;
+ buckets_ = buckets;
+ CHECK(min_ >= 0);
+ CHECK(max_ > min_);
+ CHECK(buckets_ > 0);
+}
+
+void TaggedCounterReporter::Report(void* handle, int32 tag, int32 count) {
+ TaggedCounterReporter* this_reporter =
+ reinterpret_cast<TaggedCounterReporter*>(handle);
+ DLOG(INFO) << "received metric: " << this_reporter->histogram_name_
+ << " " << count << " " << this_reporter->min_ << " "
+ << this_reporter->max_ << " " << this_reporter->buckets_;
+ CHECK(metrics_lib_ != NULL);
+ CHECK(this_reporter->buckets_ > 0);
+ metrics_lib_->SendToUMA(this_reporter->histogram_name_,
+ count,
+ this_reporter->min_,
+ this_reporter->max_,
+ this_reporter->buckets_);
+}
+
FrequencyCounter::FrequencyCounter() : cycle_duration_(1) {
}
FrequencyCounter::~FrequencyCounter() {
}
-void FrequencyCounter::Init(const char* filename,
- TaggedCounterInterface::Reporter reporter,
- void* reporter_handle,
+void FrequencyCounter::Init(TaggedCounterInterface* tagged_counter,
time_t cycle_duration) {
- // Allow tests to inject tagged_counter_ dependency.
- if (tagged_counter_.get() == NULL) {
- tagged_counter_.reset(new TaggedCounter());
- }
- tagged_counter_->Init(filename, reporter, reporter_handle);
+ tagged_counter_.reset(tagged_counter);
DCHECK(cycle_duration > 0);
cycle_duration_ = cycle_duration;
}
diff --git a/metrics/counter.h b/metrics/counter.h
index a5e5302..e55cded 100644
--- a/metrics/counter.h
+++ b/metrics/counter.h
@@ -5,12 +5,15 @@
#ifndef METRICS_COUNTER_H_
#define METRICS_COUNTER_H_
+#include <string>
#include <time.h>
#include <base/basictypes.h>
#include <base/scoped_ptr.h>
#include <gtest/gtest_prod.h> // for FRIEND_TEST
+class MetricsLibraryInterface;
+
namespace chromeos_metrics {
// Constants useful for frequency statistics.
@@ -44,16 +47,6 @@
virtual ~TaggedCounterInterface() {}
- // Initializes the counter by providing the persistent storage
- // location |filename| and a |reporter| callback for reporting
- // aggregated counts. |reporter_handle| is sent to the |reporter|
- // along with the aggregated counts.
- //
- // NOTE: The assumption is that this object is the sole owner of the
- // persistent storage file so no locking is currently implemented.
- virtual void Init(const char* filename,
- Reporter reporter, void* reporter_handle) = 0;
-
// Adds |count| of events for the given |tag|. If there's an
// existing aggregated count for a different tag, it's reported
// through the reporter callback and discarded.
@@ -67,12 +60,21 @@
class TaggedCounter : public TaggedCounterInterface {
public:
TaggedCounter();
- ~TaggedCounter();
+ virtual ~TaggedCounter();
+
+ // Initializes the counter by providing the persistent storage
+ // location |filename| and a |reporter| callback for reporting
+ // aggregated counts. |reporter_handle| is sent to the |reporter|
+ // along with the aggregated counts.
+ //
+ // NOTE: The assumption is that this object is the sole owner of the
+ // persistent storage file so no locking is currently implemented.
+ virtual void Init(const char* filename,
+ Reporter reporter, void* reporter_handle);
// Implementation of interface methods.
- void Init(const char* filename, Reporter reporter, void* reporter_handle);
- void Update(int32 tag, int32 count);
- void Flush();
+ virtual void Update(int32 tag, int32 count);
+ virtual void Flush();
private:
friend class RecordTest;
@@ -146,7 +148,7 @@
void WriteRecord(int fd);
// Persistent storage file path.
- const char* filename_;
+ std::string filename_;
// Aggregated data reporter callback and handle to pass-through.
Reporter reporter_;
@@ -159,6 +161,71 @@
RecordState record_state_;
};
+// TaggedCounterReporter provides a TaggedCounterInterface which both
+// counts tagged events and reports them up through the metrics
+// library to UMA.
+class TaggedCounterReporter : public TaggedCounterInterface {
+ public:
+ TaggedCounterReporter();
+ virtual ~TaggedCounterReporter();
+
+ // Set the metrics library used by all TaggedCounterReporter
+ // instances. We assume there is only one metrics library
+ // shared amongst all reporters.
+ static void SetMetricsLibraryInterface(MetricsLibraryInterface* metrics_lib) {
+ metrics_lib_ = metrics_lib;
+ }
+
+ // Initializes the counter by providing the persistent storage
+ // location |filename|, a |histogram_name| (a linear histogram) to
+ // report to with |min|, |max|, and |buckets| attributes for the
+ // histogram.
+ virtual void Init(const char* filename,
+ const char* histogram_name,
+ int min,
+ int max,
+ int buckets);
+
+ // Implementation of interface method.
+ virtual void Update(int32 tag, int32 count) {
+ tagged_counter_->Update(tag, count);
+ }
+ // Implementation of interface method.
+ virtual void Flush() {
+ tagged_counter_->Flush();
+ }
+
+ // Accessor functions.
+ const std::string& histogram_name() const {
+ return histogram_name_;
+ }
+
+ int min() const {
+ return min_;
+ }
+
+ int max() const {
+ return max_;
+ }
+
+ int buckets() const {
+ return buckets_;
+ }
+
+ protected:
+ friend class TaggedCounterReporterTest;
+ FRIEND_TEST(TaggedCounterReporterTest, Report);
+
+ static void Report(void* handle, int32 tag, int32 count);
+
+ static MetricsLibraryInterface* metrics_lib_;
+ scoped_ptr<TaggedCounter> tagged_counter_;
+ std::string histogram_name_;
+ int min_;
+ int max_;
+ int buckets_;
+};
+
// FrequencyCounter uses TaggedCounter to maintain a persistent
// storage of the number of events that occur in a given cycle
// duration (in other words, a frequency count). For example, to
@@ -172,13 +239,11 @@
FrequencyCounter();
virtual ~FrequencyCounter();
- // Initialize a frequency counter, which is necessary before first use.
- // |filename|, |reporter|, and |reporter_handle| are used as in
- // TaggedCounter::Init. |cycle_duration| is the number of seconds
- // in a cycle.
- virtual void Init(const char* filename,
- TaggedCounterInterface::Reporter reporter,
- void* reporter_handle,
+ // Initialize a frequency counter, which is necessary before first
+ // use. |tagged_counter| is used to store the counts, its memory
+ // will be managed by this FrequencyCounter. |cycle_duration| is
+ // the number of seconds in a cycle.
+ virtual void Init(TaggedCounterInterface* tagged_counter,
time_t cycle_duration);
// Record that an event occurred. |count| is the number of concurrent
// events that have occurred. The time is implicitly assumed to be the
@@ -187,9 +252,29 @@
UpdateInternal(count, time(NULL));
}
+ // Update the frequency counter based on the current time. If a
+ // cycle has finished, this will have the effect of flushing the
+ // cycle's count, without first requiring another update to the
+ // frequency counter. The more often this is called, the lower the
+ // latency to have a new sample submitted.
+ virtual void FlushFinishedCycles() {
+ Update(0);
+ }
+
+ // Accessor function.
+ const TaggedCounterInterface& tagged_counter() const {
+ return *tagged_counter_;
+ }
+
+ time_t cycle_duration() const {
+ return cycle_duration_;
+ }
+
private:
friend class FrequencyCounterTest;
FRIEND_TEST(FrequencyCounterTest, UpdateInternal);
+ FRIEND_TEST(FrequencyCounterTest, GetCycleNumberForWeek);
+ FRIEND_TEST(FrequencyCounterTest, GetCycleNumberForDay);
void UpdateInternal(int32 count, time_t now);
int32 GetCycleNumber(time_t now);
diff --git a/metrics/counter_mock.h b/metrics/counter_mock.h
index 701cce4..cf2a486 100644
--- a/metrics/counter_mock.h
+++ b/metrics/counter_mock.h
@@ -13,7 +13,7 @@
namespace chromeos_metrics {
-class TaggedCounterMock : public TaggedCounterInterface {
+class TaggedCounterMock : public TaggedCounter {
public:
MOCK_METHOD3(Init, void(const char* filename,
Reporter reporter, void* reporter_handle));
@@ -21,6 +21,17 @@
MOCK_METHOD0(Flush, void());
};
+class TaggedCounterReporterMock : public TaggedCounterReporter {
+ public:
+ MOCK_METHOD5(Init, void(const char* filename,
+ const char* histogram_name,
+ int min,
+ int max,
+ int nbuckets));
+ MOCK_METHOD2(Update, void(int32 tag, int32 count));
+ MOCK_METHOD0(Flush, void());
+};
+
class FrequencyCounterMock : public FrequencyCounter {
public:
MOCK_METHOD4(Init, void(const char* filename,
@@ -28,6 +39,7 @@
void* reporter_handle,
time_t cycle_duration));
MOCK_METHOD1(Update, void(int32 count));
+ MOCK_METHOD0(FlushFinishedCycles, void());
};
} // namespace chromeos_metrics
diff --git a/metrics/counter_test.cc b/metrics/counter_test.cc
index eb68b2a..3580516 100644
--- a/metrics/counter_test.cc
+++ b/metrics/counter_test.cc
@@ -13,6 +13,7 @@
#include "counter.h"
#include "counter_mock.h" // For TaggedCounterMock.
+#include "metrics_library_mock.h"
using ::testing::_;
using ::testing::MockFunction;
@@ -37,7 +38,7 @@
class TaggedCounterTest : public testing::Test {
protected:
virtual void SetUp() {
- EXPECT_EQ(NULL, counter_.filename_);
+ EXPECT_TRUE(counter_.filename_.empty());
EXPECT_TRUE(NULL == counter_.reporter_);
EXPECT_EQ(NULL, counter_.reporter_handle_);
EXPECT_EQ(TaggedCounter::kRecordInvalid, counter_.record_state_);
@@ -256,14 +257,85 @@
EXPECT_EQ(TaggedCounter::kRecordValid, counter_.record_state_);
}
+static const char kTestFilename[] = "test_filename";
+static const char kTestHistogram[] = "test_histogram";
+const int kHistogramMin = 15;
+const int kHistogramMax = 1024;
+const int kHistogramBuckets = 23;
+
+class TaggedCounterReporterTest : public testing::Test {
+ protected:
+ virtual void SetUp() {
+ tagged_counter_ = new StrictMock<TaggedCounterMock>();
+ reporter_.tagged_counter_.reset(tagged_counter_);
+ metrics_lib_.reset(new StrictMock<MetricsLibraryMock>);
+ reporter_.SetMetricsLibraryInterface(metrics_lib_.get());
+ ASSERT_TRUE(metrics_lib_.get() == reporter_.metrics_lib_);
+ }
+ virtual void TearDown() {
+ reporter_.SetMetricsLibraryInterface(NULL);
+ }
+
+ void DoInit();
+ StrictMock<TaggedCounterMock>* tagged_counter_;
+ TaggedCounterReporter reporter_;
+ scoped_ptr<MetricsLibraryMock> metrics_lib_;
+};
+
+void TaggedCounterReporterTest::DoInit() {
+ EXPECT_CALL(*tagged_counter_,
+ Init(kTestFilename,
+ TaggedCounterReporter::Report,
+ &reporter_))
+ .Times(1)
+ .RetiresOnSaturation();
+ reporter_.Init(kTestFilename,
+ kTestHistogram,
+ kHistogramMin,
+ kHistogramMax,
+ kHistogramBuckets);
+ EXPECT_EQ(kTestHistogram, reporter_.histogram_name_);
+ EXPECT_EQ(kHistogramBuckets, reporter_.buckets_);
+ EXPECT_EQ(kHistogramMax, reporter_.max_);
+ EXPECT_EQ(kHistogramMin, reporter_.min_);
+}
+
+TEST_F(TaggedCounterReporterTest, Init) {
+ DoInit();
+}
+
+TEST_F(TaggedCounterReporterTest, Update) {
+ DoInit();
+ EXPECT_CALL(*tagged_counter_, Update(1, 2))
+ .Times(1)
+ .RetiresOnSaturation();
+ reporter_.Update(1, 2);
+}
+
+TEST_F(TaggedCounterReporterTest, Flush) {
+ DoInit();
+ EXPECT_CALL(*tagged_counter_, Flush())
+ .Times(1)
+ .RetiresOnSaturation();
+ reporter_.Flush();
+}
+
+TEST_F(TaggedCounterReporterTest, Report) {
+ DoInit();
+ EXPECT_CALL(*metrics_lib_, SendToUMA(kTestHistogram,
+ 301,
+ kHistogramMin,
+ kHistogramMax,
+ kHistogramBuckets))
+ .Times(1)
+ .RetiresOnSaturation();
+ reporter_.Report(&reporter_, 127, 301);
+}
+
class FrequencyCounterTest : public testing::Test {
protected:
virtual void SetUp() {
- tagged_counter_ = new StrictMock<TaggedCounterMock>;
- frequency_counter_.tagged_counter_.reset(tagged_counter_);
- }
-
- static void FakeReporter(void *, int32, int32) {
+ tagged_counter_ = NULL;
}
void CheckInit(int32 cycle_duration);
@@ -276,14 +348,10 @@
};
void FrequencyCounterTest::CheckInit(int32 cycle_duration) {
- EXPECT_CALL(*tagged_counter_, Init(kTestRecordFile, FakeReporter, this))
- .Times(1)
- .RetiresOnSaturation();
- frequency_counter_.Init(kTestRecordFile,
- FakeReporter,
- this,
- cycle_duration);
+ tagged_counter_ = new StrictMock<TaggedCounterMock>;
+ frequency_counter_.Init(tagged_counter_, cycle_duration);
EXPECT_EQ(cycle_duration, frequency_counter_.cycle_duration_);
+ EXPECT_EQ(tagged_counter_, frequency_counter_.tagged_counter_.get());
}
TEST_F(FrequencyCounterTest, Init) {
@@ -292,10 +360,12 @@
void FrequencyCounterTest::CheckCycleNumber(int32 cycle_duration) {
CheckInit(cycle_duration);
- EXPECT_EQ(150, frequency_counter_.GetCycleNumber(cycle_duration * 150));
- EXPECT_EQ(150, frequency_counter_.GetCycleNumber(cycle_duration * 150 +
- cycle_duration - 1));
- EXPECT_EQ(151, frequency_counter_.GetCycleNumber(cycle_duration * 151 + 1));
+ EXPECT_EQ(150, frequency_counter_.GetCycleNumber(
+ cycle_duration * 150));
+ EXPECT_EQ(150, frequency_counter_.GetCycleNumber(
+ cycle_duration * 150 + cycle_duration - 1));
+ EXPECT_EQ(151, frequency_counter_.GetCycleNumber(
+ cycle_duration * 151 + 1));
EXPECT_EQ(0, frequency_counter_.GetCycleNumber(0));
}
@@ -310,7 +380,9 @@
TEST_F(FrequencyCounterTest, UpdateInternal) {
CheckInit(kSecondsPerWeek);
- EXPECT_CALL(*tagged_counter_, Update(150, 2));
+ EXPECT_CALL(*tagged_counter_, Update(150, 2))
+ .Times(1)
+ .RetiresOnSaturation();
frequency_counter_.UpdateInternal(2, kSecondsPerWeek * 150);
}
diff --git a/metrics/metrics_daemon.cc b/metrics/metrics_daemon.cc
index 0171fde..4d50cb5 100644
--- a/metrics/metrics_daemon.cc
+++ b/metrics/metrics_daemon.cc
@@ -4,10 +4,11 @@
#include "metrics_daemon.h"
-#include <dbus/dbus-glib-lowlevel.h>
+#include <string.h>
#include <base/file_util.h>
#include <base/logging.h>
+#include <dbus/dbus-glib-lowlevel.h>
#include "counter.h"
@@ -43,7 +44,7 @@
static const char kUncleanShutdownDetectedFile[] =
"/tmp/unclean-shutdown-detected";
-// static metrics parameters.
+// static metrics parameters
const char MetricsDaemon::kMetricDailyUseTimeName[] =
"Logging.DailyUseTime";
const int MetricsDaemon::kMetricDailyUseTimeMin = 1;
@@ -73,16 +74,26 @@
// crash frequency metrics
const char MetricsDaemon::kMetricAnyCrashesDailyName[] =
"Logging.AnyCrashesDaily";
+const char MetricsDaemon::kMetricAnyCrashesWeeklyName[] =
+ "Logging.AnyCrashesWeekly";
const char MetricsDaemon::kMetricKernelCrashesDailyName[] =
"Logging.KernelCrashesDaily";
+const char MetricsDaemon::kMetricKernelCrashesWeeklyName[] =
+ "Logging.KernelCrashesWeekly";
const char MetricsDaemon::kMetricUncleanShutdownsDailyName[] =
"Logging.UncleanShutdownsDaily";
+const char MetricsDaemon::kMetricUncleanShutdownsWeeklyName[] =
+ "Logging.UncleanShutdownsWeekly";
const char MetricsDaemon::kMetricUserCrashesDailyName[] =
"Logging.UserCrashesDaily";
-const char MetricsDaemon::kMetricCrashesDailyMin = 1;
-const char MetricsDaemon::kMetricCrashesDailyMax = 100;
-const char MetricsDaemon::kMetricCrashesDailyBuckets = 50;
+const char MetricsDaemon::kMetricUserCrashesWeeklyName[] =
+ "Logging.UserCrashesWeekly";
+const char MetricsDaemon::kMetricCrashFrequencyMin = 1;
+const char MetricsDaemon::kMetricCrashFrequencyMax = 100;
+const char MetricsDaemon::kMetricCrashFrequencyBuckets = 50;
+// persistent metrics path
+const char MetricsDaemon::kMetricsPath[] = "/var/log/metrics";
// static
@@ -182,7 +193,17 @@
usemon_interval_(0),
usemon_source_(NULL) {}
-MetricsDaemon::~MetricsDaemon() {}
+MetricsDaemon::~MetricsDaemon() {
+ DeleteFrequencyCounters();
+}
+
+void MetricsDaemon::DeleteFrequencyCounters() {
+ for (FrequencyCounters::iterator i = frequency_counters_.begin();
+ i != frequency_counters_.end(); ++i) {
+ delete i->second;
+ i->second = NULL;
+ }
+}
void MetricsDaemon::Run(bool run_as_daemon) {
if (run_as_daemon && daemon(0, 0) != 0)
@@ -199,64 +220,72 @@
Loop();
}
+FilePath MetricsDaemon::GetHistogramPath(const char* histogram_name) {
+ return FilePath(kMetricsPath).Append(histogram_name);
+}
+
+void MetricsDaemon::ConfigureCrashIntervalReporter(
+ const char* histogram_name,
+ scoped_ptr<chromeos_metrics::TaggedCounterReporter>* reporter) {
+ reporter->reset(new chromeos_metrics::TaggedCounterReporter());
+ FilePath file_path = GetHistogramPath(histogram_name);
+ (*reporter)->Init(file_path.value().c_str(),
+ histogram_name,
+ kMetricCrashIntervalMin,
+ kMetricCrashIntervalMax,
+ kMetricCrashIntervalBuckets);
+}
+
+void MetricsDaemon::ConfigureCrashFrequencyReporter(
+ const char* histogram_name) {
+ scoped_ptr<chromeos_metrics::TaggedCounterReporter> reporter(
+ new chromeos_metrics::TaggedCounterReporter());
+ FilePath file_path = GetHistogramPath(histogram_name);
+ reporter->Init(file_path.value().c_str(),
+ histogram_name,
+ kMetricCrashFrequencyMin,
+ kMetricCrashFrequencyMax,
+ kMetricCrashFrequencyBuckets);
+ scoped_ptr<chromeos_metrics::FrequencyCounter> new_counter(
+ new chromeos_metrics::FrequencyCounter());
+ time_t cycle_duration = strstr(histogram_name, "Weekly") != NULL ?
+ chromeos_metrics::kSecondsPerWeek :
+ chromeos_metrics::kSecondsPerDay;
+ new_counter->Init(
+ static_cast<chromeos_metrics::TaggedCounterInterface*>(
+ reporter.release()),
+ cycle_duration);
+ frequency_counters_[histogram_name] = new_counter.release();
+}
+
void MetricsDaemon::Init(bool testing, MetricsLibraryInterface* metrics_lib) {
testing_ = testing;
DCHECK(metrics_lib != NULL);
metrics_lib_ = metrics_lib;
+ chromeos_metrics::TaggedCounterReporter::
+ SetMetricsLibraryInterface(metrics_lib);
static const char kDailyUseRecordFile[] = "/var/log/metrics/daily-usage";
daily_use_.reset(new chromeos_metrics::TaggedCounter());
daily_use_->Init(kDailyUseRecordFile, &ReportDailyUse, this);
- static const char kUserCrashIntervalRecordFile[] =
- "/var/log/metrics/user-crash-interval";
- user_crash_interval_.reset(new chromeos_metrics::TaggedCounter());
- user_crash_interval_->Init(kUserCrashIntervalRecordFile,
- &ReportUserCrashInterval, this);
+ ConfigureCrashIntervalReporter(kMetricKernelCrashIntervalName,
+ &kernel_crash_interval_);
+ ConfigureCrashIntervalReporter(kMetricUncleanShutdownIntervalName,
+ &unclean_shutdown_interval_);
+ ConfigureCrashIntervalReporter(kMetricUserCrashIntervalName,
+ &user_crash_interval_);
- static const char kKernelCrashIntervalRecordFile[] =
- "/var/log/metrics/kernel-crash-interval";
- kernel_crash_interval_.reset(new chromeos_metrics::TaggedCounter());
- kernel_crash_interval_->Init(kKernelCrashIntervalRecordFile,
- &ReportKernelCrashInterval, this);
-
- static const char kUncleanShutdownDetectedFile[] =
- "/var/log/metrics/unclean-shutdown-interval";
- unclean_shutdown_interval_.reset(new chromeos_metrics::TaggedCounter());
- unclean_shutdown_interval_->Init(kUncleanShutdownDetectedFile,
- &ReportUncleanShutdownInterval, this);
-
- static const char kUserCrashesDailyRecordFile[] =
- "/var/log/metrics/user-crashes-daily";
- user_crashes_daily_.reset(new chromeos_metrics::FrequencyCounter());
- user_crashes_daily_->Init(kUserCrashesDailyRecordFile,
- &ReportUserCrashesDaily,
- this,
- chromeos_metrics::kSecondsPerDay);
-
- static const char kKernelCrashesDailyRecordFile[] =
- "/var/log/metrics/kernel-crashes-daily";
- kernel_crashes_daily_.reset(new chromeos_metrics::FrequencyCounter());
- kernel_crashes_daily_->Init(kKernelCrashesDailyRecordFile,
- &ReportKernelCrashesDaily,
- this,
- chromeos_metrics::kSecondsPerDay);
-
- static const char kUncleanShutdownsDailyRecordFile[] =
- "/var/log/metrics/unclean-shutdowns-daily";
- unclean_shutdowns_daily_.reset(new chromeos_metrics::FrequencyCounter());
- unclean_shutdowns_daily_->Init(kUncleanShutdownsDailyRecordFile,
- &ReportUncleanShutdownsDaily,
- this,
- chromeos_metrics::kSecondsPerDay);
-
- static const char kAnyCrashesUserCrashDailyRecordFile[] =
- "/var/log/metrics/any-crashes-daily";
- any_crashes_daily_.reset(new chromeos_metrics::FrequencyCounter());
- any_crashes_daily_->Init(kAnyCrashesUserCrashDailyRecordFile,
- &ReportAnyCrashesDaily,
- this,
- chromeos_metrics::kSecondsPerDay);
+ DeleteFrequencyCounters();
+ ConfigureCrashFrequencyReporter(kMetricAnyCrashesDailyName);
+ ConfigureCrashFrequencyReporter(kMetricAnyCrashesDailyName);
+ ConfigureCrashFrequencyReporter(kMetricAnyCrashesWeeklyName);
+ ConfigureCrashFrequencyReporter(kMetricKernelCrashesDailyName);
+ ConfigureCrashFrequencyReporter(kMetricKernelCrashesWeeklyName);
+ ConfigureCrashFrequencyReporter(kMetricUncleanShutdownsDailyName);
+ ConfigureCrashFrequencyReporter(kMetricUncleanShutdownsWeeklyName);
+ ConfigureCrashFrequencyReporter(kMetricUserCrashesDailyName);
+ ConfigureCrashFrequencyReporter(kMetricUserCrashesWeeklyName);
// Don't setup D-Bus and GLib in test mode.
if (testing)
@@ -453,6 +482,12 @@
user_crash_interval_->Update(0, seconds);
kernel_crash_interval_->Update(0, seconds);
+ // Flush finished cycles of all frequency counters.
+ for (FrequencyCounters::iterator i = frequency_counters_.begin();
+ i != frequency_counters_.end(); ++i) {
+ i->second->FlushFinishedCycles();
+ }
+
// Schedules a use monitor on inactive->active transitions and
// unschedules it on active->inactive transitions.
if (!user_active_ && active)
@@ -473,8 +508,10 @@
// Reports the active use time since the last crash and resets it.
user_crash_interval_->Flush();
- user_crashes_daily_->Update(1);
- any_crashes_daily_->Update(1);
+ frequency_counters_[kMetricUserCrashesDailyName]->Update(1);
+ frequency_counters_[kMetricUserCrashesWeeklyName]->Update(1);
+ frequency_counters_[kMetricAnyCrashesDailyName]->Update(1);
+ frequency_counters_[kMetricAnyCrashesWeeklyName]->Update(1);
}
void MetricsDaemon::ProcessKernelCrash() {
@@ -484,8 +521,10 @@
// Reports the active use time since the last crash and resets it.
kernel_crash_interval_->Flush();
- kernel_crashes_daily_->Update(1);
- any_crashes_daily_->Update(1);
+ frequency_counters_[kMetricKernelCrashesDailyName]->Update(1);
+ frequency_counters_[kMetricKernelCrashesWeeklyName]->Update(1);
+ frequency_counters_[kMetricAnyCrashesDailyName]->Update(1);
+ frequency_counters_[kMetricAnyCrashesWeeklyName]->Update(1);
}
void MetricsDaemon::ProcessUncleanShutdown() {
@@ -495,8 +534,10 @@
// Reports the active use time since the last crash and resets it.
unclean_shutdown_interval_->Flush();
- unclean_shutdowns_daily_->Update(1);
- any_crashes_daily_->Update(1);
+ frequency_counters_[kMetricUncleanShutdownsDailyName]->Update(1);
+ frequency_counters_[kMetricUncleanShutdownsWeeklyName]->Update(1);
+ frequency_counters_[kMetricAnyCrashesDailyName]->Update(1);
+ frequency_counters_[kMetricAnyCrashesWeeklyName]->Update(1);
}
bool MetricsDaemon::CheckSystemCrash(const std::string& crash_file) {
@@ -584,69 +625,6 @@
kMetricDailyUseTimeBuckets);
}
-// static
-void MetricsDaemon::ReportCrashInterval(const char* histogram_name,
- void* handle, int count) {
- MetricsDaemon* daemon = static_cast<MetricsDaemon*>(handle);
- daemon->SendMetric(histogram_name, count,
- kMetricCrashIntervalMin,
- kMetricCrashIntervalMax,
- kMetricCrashIntervalBuckets);
-}
-
-// static
-void MetricsDaemon::ReportUserCrashInterval(void* handle,
- int tag, int count) {
- ReportCrashInterval(kMetricUserCrashIntervalName, handle, count);
-}
-
-// static
-void MetricsDaemon::ReportKernelCrashInterval(void* handle,
- int tag, int count) {
- ReportCrashInterval(kMetricKernelCrashIntervalName, handle, count);
-}
-
-// static
-void MetricsDaemon::ReportUncleanShutdownInterval(void* handle,
- int tag, int count) {
- ReportCrashInterval(kMetricUncleanShutdownIntervalName, handle, count);
-}
-
-// static
-void MetricsDaemon::ReportCrashesDailyFrequency(const char* histogram_name,
- void* handle,
- int count) {
- MetricsDaemon* daemon = static_cast<MetricsDaemon*>(handle);
- daemon->SendMetric(histogram_name, count,
- kMetricCrashesDailyMin,
- kMetricCrashesDailyMax,
- kMetricCrashesDailyBuckets);
-}
-
-// static
-void MetricsDaemon::ReportUserCrashesDaily(void* handle,
- int tag, int count) {
- ReportCrashesDailyFrequency(kMetricUserCrashesDailyName, handle, count);
-}
-
-// static
-void MetricsDaemon::ReportKernelCrashesDaily(void* handle,
- int tag, int count) {
- ReportCrashesDailyFrequency(kMetricKernelCrashesDailyName, handle, count);
-}
-
-// static
-void MetricsDaemon::ReportUncleanShutdownsDaily(void* handle,
- int tag, int count) {
- ReportCrashesDailyFrequency(kMetricUncleanShutdownsDailyName, handle, count);
-}
-
-// static
-void MetricsDaemon::ReportAnyCrashesDaily(void* handle, int tag, int count) {
- ReportCrashesDailyFrequency(kMetricAnyCrashesDailyName, handle, count);
-}
-
-
void MetricsDaemon::SendMetric(const string& name, int sample,
int min, int max, int nbuckets) {
DLOG(INFO) << "received metric: " << name << " " << sample << " "
diff --git a/metrics/metrics_daemon.h b/metrics/metrics_daemon.h
index f98c34c..d400bf0 100644
--- a/metrics/metrics_daemon.h
+++ b/metrics/metrics_daemon.h
@@ -7,7 +7,9 @@
#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
@@ -16,7 +18,8 @@
namespace chromeos_metrics {
class FrequencyCounter;
-class TaggedCounterInterface;
+class TaggedCounter;
+class TaggedCounterReporter;
}
class MetricsDaemon {
@@ -35,6 +38,10 @@
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);
@@ -89,11 +96,15 @@
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;
@@ -102,14 +113,18 @@
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.
@@ -124,6 +139,20 @@
// 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();
@@ -203,48 +232,15 @@
// 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_;
@@ -275,30 +271,20 @@
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).
diff --git a/metrics/metrics_daemon_test.cc b/metrics/metrics_daemon_test.cc
index e551cf9..9ba63e8 100644
--- a/metrics/metrics_daemon_test.cc
+++ b/metrics/metrics_daemon_test.cc
@@ -2,6 +2,8 @@
// 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>
@@ -11,14 +13,21 @@
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.
@@ -48,6 +57,38 @@
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());
@@ -56,20 +97,20 @@
// 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());
@@ -77,10 +118,29 @@
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) {
@@ -93,6 +153,7 @@
EXPECT_CALL(*user_crash_interval_, Update(0, count))
.Times(1)
.RetiresOnSaturation();
+ ExpectFrequencyFlushCalls();
}
// Adds active use aggregation counters update expectations that
@@ -107,6 +168,7 @@
EXPECT_CALL(*user_crash_interval_, Update(_, _))
.Times(1)
.RetiresOnSaturation();
+ ExpectFrequencyFlushCalls();
}
// Adds a metrics library mock expectation that the specified metric
@@ -170,6 +232,12 @@
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_;
@@ -181,14 +249,9 @@
// 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) {
@@ -217,22 +280,6 @@
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"));
@@ -268,15 +315,25 @@
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",
@@ -410,8 +467,14 @@
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();
}
@@ -420,8 +483,15 @@
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();
}
@@ -430,8 +500,14 @@
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();
}
@@ -514,20 +590,10 @@
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) {
diff --git a/metrics/metrics_library.cc b/metrics/metrics_library.cc
index e4087ef..3e3987d 100644
--- a/metrics/metrics_library.cc
+++ b/metrics/metrics_library.cc
@@ -6,6 +6,7 @@
#include <errno.h>
#include <sys/file.h>
+#include <sys/stat.h>
#include <cstdarg>
#include <cstdio>
@@ -14,12 +15,14 @@
#define READ_WRITE_ALL_FILE_FLAGS \
(S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
-static const char kAutotestPath[] =
- "/var/log/metrics/autotest-events";
-static const char kUMAEventsPath[] =
- "/var/log/metrics/uma-events";
+static const char kAutotestPath[] = "/var/log/metrics/autotest-events";
+static const char kUMAEventsPath[] = "/var/log/metrics/uma-events";
+static const char kConsentFile[] = "/home/chronos/Consent To Send Stats";
static const int32_t kBufferSize = 1024;
+time_t MetricsLibrary::cached_enabled_time_ = 0;
+bool MetricsLibrary::cached_enabled_ = false;
+
using std::string;
// TODO(sosa@chromium.org) - use Chromium logger instead of stderr
@@ -38,9 +41,24 @@
}
MetricsLibrary::MetricsLibrary()
- : uma_events_file_(NULL) {}
+ : uma_events_file_(NULL),
+ consent_file_(kConsentFile) {}
+
+bool MetricsLibrary::AreMetricsEnabled() {
+ static struct stat stat_buffer;
+ time_t this_check_time = time(NULL);
+
+ if (this_check_time != cached_enabled_time_) {
+ cached_enabled_time_ = this_check_time;
+ cached_enabled_ = (stat(consent_file_, &stat_buffer) >= 0);
+ }
+ return cached_enabled_;
+}
bool MetricsLibrary::SendMessageToChrome(int32_t length, const char* message) {
+ if (!AreMetricsEnabled())
+ return true;
+
int chrome_fd = open(uma_events_file_,
O_WRONLY | O_APPEND | O_CREAT,
READ_WRITE_ALL_FILE_FLAGS);
diff --git a/metrics/metrics_library.h b/metrics/metrics_library.h
index 76fa451..52da94d 100644
--- a/metrics/metrics_library.h
+++ b/metrics/metrics_library.h
@@ -27,6 +27,9 @@
// Initializes the library.
void Init();
+ // Returns whether or not metrics collection is enabled.
+ bool AreMetricsEnabled();
+
// Sends histogram data to Chrome for transport to UMA and returns
// true on success. This method results in the equivalent of an
// asynchronous non-blocking RPC to UMA_HISTOGRAM_CUSTOM_COUNTS
@@ -69,6 +72,7 @@
private:
friend class CMetricsLibraryTest;
friend class MetricsLibraryTest;
+ FRIEND_TEST(MetricsLibraryTest, AreMetricsEnabled);
FRIEND_TEST(MetricsLibraryTest, FormatChromeMessage);
FRIEND_TEST(MetricsLibraryTest, FormatChromeMessageTooLong);
FRIEND_TEST(MetricsLibraryTest, SendMessageToChrome);
@@ -89,7 +93,14 @@
int32_t FormatChromeMessage(int32_t buffer_size, char* buffer,
const char* format, ...);
+ // Time at which we last checked if metrics were enabled.
+ static time_t cached_enabled_time_;
+
+ // Cached state of whether or not metrics were enabled.
+ static bool cached_enabled_;
+
const char* uma_events_file_;
+ const char* consent_file_;
};
#endif // METRICS_LIBRARY_H_
diff --git a/metrics/metrics_library_test.cc b/metrics/metrics_library_test.cc
index 596abd3..cbf4cce 100644
--- a/metrics/metrics_library_test.cc
+++ b/metrics/metrics_library_test.cc
@@ -12,6 +12,15 @@
static const FilePath kTestUMAEventsFile("test-uma-events");
+static const char kTestConsent[] = "test-consent";
+
+static void SetMetricsEnabled(bool enabled) {
+ if (enabled)
+ ASSERT_EQ(1, file_util::WriteFile(FilePath(kTestConsent) , "0", 1));
+ else
+ file_util::Delete(FilePath(kTestConsent), false);
+}
+
class MetricsLibraryTest : public testing::Test {
protected:
virtual void SetUp() {
@@ -19,15 +28,63 @@
lib_.Init();
EXPECT_TRUE(NULL != lib_.uma_events_file_);
lib_.uma_events_file_ = kTestUMAEventsFile.value().c_str();
+ SetMetricsEnabled(true);
+ // Defeat metrics enabled caching between tests.
+ lib_.cached_enabled_time_ = 0;
+ lib_.consent_file_ = kTestConsent;
}
virtual void TearDown() {
file_util::Delete(kTestUMAEventsFile, false);
}
+ void VerifyEnabledCacheHit(bool to_value);
+ void VerifyEnabledCacheEviction(bool to_value);
+
MetricsLibrary lib_;
};
+TEST_F(MetricsLibraryTest, AreMetricsEnabledFalse) {
+ SetMetricsEnabled(false);
+ EXPECT_FALSE(lib_.AreMetricsEnabled());
+}
+
+TEST_F(MetricsLibraryTest, AreMetricsEnabledTrue) {
+ EXPECT_TRUE(lib_.AreMetricsEnabled());
+}
+
+void MetricsLibraryTest::VerifyEnabledCacheHit(bool to_value) {
+ // We might step from one second to the next one time, but not 100
+ // times in a row.
+ for (int i = 0; i < 100; ++i) {
+ lib_.cached_enabled_time_ = 0;
+ SetMetricsEnabled(!to_value);
+ ASSERT_EQ(!to_value, lib_.AreMetricsEnabled());
+ SetMetricsEnabled(to_value);
+ if (lib_.AreMetricsEnabled() == !to_value)
+ return;
+ }
+ ADD_FAILURE() << "Did not see evidence of caching";
+}
+
+void MetricsLibraryTest::VerifyEnabledCacheEviction(bool to_value) {
+ lib_.cached_enabled_time_ = 0;
+ SetMetricsEnabled(!to_value);
+ ASSERT_EQ(!to_value, lib_.AreMetricsEnabled());
+ SetMetricsEnabled(to_value);
+ ASSERT_LT(abs(time(NULL) - lib_.cached_enabled_time_), 5);
+ // Sleep one second (or cheat to be faster).
+ --lib_.cached_enabled_time_;
+ ASSERT_EQ(to_value, lib_.AreMetricsEnabled());
+}
+
+TEST_F(MetricsLibraryTest, AreMetricsEnabledCaching) {
+ VerifyEnabledCacheHit(false);
+ VerifyEnabledCacheHit(true);
+ VerifyEnabledCacheEviction(false);
+ VerifyEnabledCacheEviction(true);
+}
+
TEST_F(MetricsLibraryTest, FormatChromeMessage) {
char buf[7];
const int kLen = 6;
@@ -55,6 +112,12 @@
EXPECT_EQ(0, memcmp(exp, buf, kLen));
}
+TEST_F(MetricsLibraryTest, SendEnumToUMANotEnabled) {
+ SetMetricsEnabled(false);
+ EXPECT_TRUE(lib_.SendEnumToUMA("Test.EnumMetric", 1, 3));
+ EXPECT_FALSE(file_util::PathExists(kTestUMAEventsFile));
+}
+
TEST_F(MetricsLibraryTest, SendMessageToChrome) {
EXPECT_TRUE(lib_.SendMessageToChrome(4, "test"));
EXPECT_TRUE(lib_.SendMessageToChrome(7, "content"));
@@ -84,6 +147,12 @@
EXPECT_EQ(0, memcmp(exp, buf, kLen));
}
+TEST_F(MetricsLibraryTest, SendToUMANotEnabled) {
+ SetMetricsEnabled(false);
+ EXPECT_TRUE(lib_.SendToUMA("Test.Metric", 2, 1, 100, 50));
+ EXPECT_FALSE(file_util::PathExists(kTestUMAEventsFile));
+}
+
class CMetricsLibraryTest : public testing::Test {
protected:
virtual void SetUp() {
@@ -93,6 +162,9 @@
CMetricsLibraryInit(lib_);
EXPECT_TRUE(NULL != ml.uma_events_file_);
ml.uma_events_file_ = kTestUMAEventsFile.value().c_str();
+ SetMetricsEnabled(true);
+ reinterpret_cast<MetricsLibrary*>(lib_)->cached_enabled_time_ = 0;
+ reinterpret_cast<MetricsLibrary*>(lib_)->consent_file_ = kTestConsent;
}
virtual void TearDown() {
@@ -103,6 +175,15 @@
CMetricsLibrary lib_;
};
+TEST_F(CMetricsLibraryTest, AreMetricsEnabledFalse) {
+ SetMetricsEnabled(false);
+ EXPECT_FALSE(CMetricsLibraryAreMetricsEnabled(lib_));
+}
+
+TEST_F(CMetricsLibraryTest, AreMetricsEnabledTrue) {
+ EXPECT_TRUE(CMetricsLibraryAreMetricsEnabled(lib_));
+}
+
TEST_F(CMetricsLibraryTest, SendEnumToUMA) {
char buf[100];
const int kLen = 40;
