// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/external_metrics/external_metrics.h"
#include <memory>
#include "ash/constants/ash_switches.h"
#include "base/command_line.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/metrics/statistics_recorder.h"
#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/metrics/user_action_tester.h"
#include "components/metrics/serialization/metric_sample.h"
#include "components/metrics/serialization/serialization_utils.h"
#include "content/public/test/browser_task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ash {
class ExternalMetricsTest : public testing::Test {
public:
ExternalMetricsTest() = default;
~ExternalMetricsTest() override = default;
void Init() {
// Create directory containing UMA metrics after the stateful partition is
// mounted.
ASSERT_TRUE(uma_events_dir_.CreateUniqueTempDir());
std::string test_uma_dir =
uma_events_dir_.GetPath().Append("test-uma-events.d").value();
ASSERT_TRUE(base::CreateDirectory(base::FilePath(test_uma_dir)));
// Create directory containing early UMA metrics before the stateful
// partition is mounted. For the tests, we are assuming this directory
// exists before the stateful partition is mounted.
ASSERT_TRUE(uma_early_metrics_dir_.CreateUniqueTempDir());
std::string test_early_uma_dir = uma_early_metrics_dir_.GetPath()
.Append("metrics/early-metrics")
.value();
ASSERT_TRUE(base::CreateDirectory(base::FilePath(test_early_uma_dir)));
external_metrics_ = ExternalMetrics::CreateForTesting(
uma_events_dir_.GetPath().Append("testfile").value(), test_uma_dir,
test_early_uma_dir);
}
void WriteSampleMetricToFile(const base::FilePath& file_path,
std::string histogram_name,
int num_of_samples) {
base::HistogramTester histogram_tester;
base::UserActionTester action_tester;
std::unique_ptr<metrics::MetricSample> sample =
metrics::MetricSample::LinearHistogramSample(
histogram_name, /*sample=*/1, /*max=*/2,
/*num_samples=*/num_of_samples);
EXPECT_TRUE(metrics::SerializationUtils::WriteMetricToFile(
*sample, file_path.value()));
}
base::ScopedTempDir uma_events_dir_;
base::ScopedTempDir uma_early_metrics_dir_;
scoped_refptr<ExternalMetrics> external_metrics_;
content::BrowserTaskEnvironment task_environment_;
};
TEST_F(ExternalMetricsTest, CustomInterval) {
base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
switches::kExternalMetricsCollectionInterval, "5");
Init();
EXPECT_EQ(base::Seconds(5), external_metrics_->collection_interval_);
}
TEST_F(ExternalMetricsTest, ProcessSamplesSuccessfully) {
// Test the variety of histogram functions to ensure all the supported
// metric types are collected.
Init();
base::HistogramTester histogram_tester;
base::UserActionTester action_tester;
int expected_samples = 0;
std::vector<std::unique_ptr<metrics::MetricSample>> samples;
// We do not test CrashSample here because the underlying class,
// ChromeOSMetricsProvider, relies heavily on |g_browser_process|, which is
// not set in unit tests.
// It is not currently possible to inject a mock for ChromeOSMetricsProvider.
samples.push_back(metrics::MetricSample::UserActionSample(
"foo_useraction", /*num_samples=*/100));
expected_samples += 100;
samples.push_back(metrics::MetricSample::HistogramSample(
"foo_histogram", /*sample=*/2, /*min=*/1,
/*max=*/100, /*bucket_count=*/10,
/*num_samples=*/2));
expected_samples += 2;
samples.push_back(metrics::MetricSample::LinearHistogramSample(
"foo_linear", /*sample=*/1, /*max=*/2, /*num_samples=*/3));
expected_samples += 3;
samples.push_back(metrics::MetricSample::SparseHistogramSample(
"foo_sparse", /*sample=*/1, /*num_samples=*/20));
expected_samples += 20;
size_t pid = 0;
for (const auto& sample : samples) {
std::string pid_uma_file =
base::StrCat({external_metrics_->uma_events_dir_, "/",
base::NumberToString(pid), ".uma"});
EXPECT_TRUE(
metrics::SerializationUtils::WriteMetricToFile(*sample, pid_uma_file));
++pid;
}
base::RunLoop loop;
EXPECT_EQ(expected_samples, external_metrics_->CollectEvents());
loop.RunUntilIdle();
EXPECT_EQ(action_tester.GetActionCount("foo_useraction"), 100);
histogram_tester.ExpectTotalCount("foo_histogram", 2);
histogram_tester.ExpectTotalCount("foo_linear", 3);
histogram_tester.ExpectTotalCount("foo_sparse", 20);
EXPECT_TRUE(base::IsDirectoryEmpty(
base::FilePath(external_metrics_->uma_events_dir_)));
}
TEST_F(ExternalMetricsTest, HandleMissingFile) {
Init();
ASSERT_TRUE(
base::DeleteFile(base::FilePath(external_metrics_->uma_events_file_)));
EXPECT_EQ(0, external_metrics_->CollectEvents());
}
TEST_F(ExternalMetricsTest, CanReceiveHistogram) {
Init();
base::HistogramTester histogram_tester;
base::UserActionTester action_tester;
int expected_samples = 0;
std::vector<std::unique_ptr<metrics::MetricSample>> samples;
// We do not test CrashSample here because the underlying class,
// ChromeOSMetricsProvider, relies heavily on |g_browser_process|, which is
// not set in unit tests.
// It is not currently possible to inject a mock for ChromeOSMetricsProvider.
samples.push_back(metrics::MetricSample::UserActionSample(
"foo_useraction", /*num_samples=*/100));
expected_samples += 100;
samples.push_back(metrics::MetricSample::HistogramSample(
"foo_histogram", /*sample=*/2, /*min=*/1,
/*max=*/100, /*bucket_count=*/10,
/*num_samples=*/2));
expected_samples += 2;
samples.push_back(metrics::MetricSample::LinearHistogramSample(
"foo_linear", /*sample=*/1, /*max=*/2, /*num_samples=*/3));
expected_samples += 3;
samples.push_back(metrics::MetricSample::SparseHistogramSample(
"foo_sparse", /*sample=*/1, /*num_samples=*/20));
expected_samples += 20;
for (const auto& sample : samples) {
EXPECT_TRUE(metrics::SerializationUtils::WriteMetricToFile(
*sample, external_metrics_->uma_events_file_));
}
base::RunLoop loop;
EXPECT_EQ(expected_samples, external_metrics_->CollectEvents());
loop.RunUntilIdle();
EXPECT_EQ(action_tester.GetActionCount("foo_useraction"), 100);
histogram_tester.ExpectTotalCount("foo_histogram", 2);
histogram_tester.ExpectTotalCount("foo_linear", 3);
histogram_tester.ExpectTotalCount("foo_sparse", 20);
}
TEST_F(ExternalMetricsTest, CanReceiveHistogramFromPidFiles) {
Init();
base::HistogramTester histogram_tester;
base::UserActionTester action_tester;
int expected_samples = 0;
const size_t expected_num_files = 10;
std::vector<std::unique_ptr<metrics::MetricSample>> samples;
// We do not test CrashSample here because the underlying class,
// ChromeOSMetricsProvider, relies heavily on |g_browser_process|, which is
// not set in unit tests.
// It is not currently possible to inject a mock for ChromeOSMetricsProvider.
samples.push_back(metrics::MetricSample::UserActionSample(
"foo_useraction", /*num_samples=*/100));
expected_samples += 100 * expected_num_files;
samples.push_back(metrics::MetricSample::HistogramSample(
"foo_histogram", /*sample=*/2, /*min=*/1,
/*max=*/100, /*bucket_count=*/10,
/*num_samples=*/2));
expected_samples += 2 * expected_num_files;
samples.push_back(metrics::MetricSample::LinearHistogramSample(
"foo_linear", /*sample=*/1, /*max=*/2, /*num_samples=*/3));
expected_samples += 3 * expected_num_files;
samples.push_back(metrics::MetricSample::SparseHistogramSample(
"foo_sparse", /*sample=*/1, /*num_samples=*/20));
expected_samples += 20 * expected_num_files;
size_t pid = 0;
for (const auto& sample : samples) {
// Create 10 of each file.
for (size_t count = 0; count < expected_num_files; count++) {
std::string pid_uma_file =
base::StrCat({external_metrics_->uma_events_dir_, "/",
base::NumberToString(pid), ".uma"});
EXPECT_TRUE(metrics::SerializationUtils::WriteMetricToFile(*sample,
pid_uma_file));
++pid;
}
}
base::RunLoop loop;
EXPECT_EQ(expected_samples, external_metrics_->CollectEvents());
loop.RunUntilIdle();
EXPECT_EQ(action_tester.GetActionCount("foo_useraction"), 1000);
histogram_tester.ExpectTotalCount("foo_histogram", 20);
histogram_tester.ExpectTotalCount("foo_linear", 30);
histogram_tester.ExpectTotalCount("foo_sparse", 200);
EXPECT_TRUE(base::IsDirectoryEmpty(
base::FilePath(external_metrics_->uma_events_dir_)));
}
TEST_F(ExternalMetricsTest, CanReceiveMetricsFromEarlyMetricsDir) {
Init();
// Create filepaths under the early metrics directory to write metrics.
base::FilePath foo_histogram_1 =
base::FilePath(external_metrics_->uma_early_metrics_dir_)
.Append("pid_early1.uma");
base::FilePath foo_histogram_2 =
base::FilePath(external_metrics_->uma_early_metrics_dir_)
.Append("pid_early2.uma");
// Expected number of samples of each histogram written to file.
int foo_histogram_1_samples = 5;
int foo_histogram_2_samples = 8;
WriteSampleMetricToFile(foo_histogram_1, "foo_histogram_1",
foo_histogram_1_samples); // 5 samples
WriteSampleMetricToFile(foo_histogram_2, "foo_histogram_2",
foo_histogram_2_samples); // 8 samples
// Expectation from the test data.
base::HistogramTester histogram_tester;
int expected_samples = foo_histogram_1_samples + foo_histogram_2_samples;
// Exercise the function to parse and collect the early metric event
// histograms.
EXPECT_EQ(expected_samples, external_metrics_->CollectEvents());
// Verify expected behavior: the number of histograms written to file matches
// the number of histograms parsed by the test. This ensures that histogram
// data is correctly logged and processed.
histogram_tester.ExpectTotalCount("foo_histogram_1", foo_histogram_1_samples);
histogram_tester.ExpectTotalCount("foo_histogram_2", foo_histogram_2_samples);
// Verify that the |uma_early_metrics_dir_| is cleaned up after
// external_metrics_->CollectEvents.
EXPECT_TRUE(base::IsDirectoryEmpty(
base::FilePath(external_metrics_->uma_early_metrics_dir_)));
}
TEST_F(ExternalMetricsTest, IncorrectHistogramsAreDiscarded) {
Init();
base::HistogramTester histogram_tester;
// Malformed histogram (min > max).
std::unique_ptr<metrics::MetricSample> hist =
metrics::MetricSample::HistogramSample("bar", /*sample=*/30, /*min=*/200,
/*max=*/20, /*bucket_count=*/10,
/*num_samples=*/1);
EXPECT_TRUE(metrics::SerializationUtils::WriteMetricToFile(
*hist.get(), external_metrics_->uma_events_file_));
external_metrics_->CollectEvents();
histogram_tester.ExpectTotalCount("bar", 0);
}
} // namespace ash
Codebase Browser
chromium