blob: 24cfa9b761368155ec1698486ceef795f8a89a82 [file] [log] [blame]
// Copyright 2016 The Chromium 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 "components/metrics/file_metrics_provider.h"
#include "base/command_line.h"
#include "base/files/file.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_util.h"
#include "base/files/memory_mapped_file.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/metrics/histogram_base.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/persistent_histogram_allocator.h"
#include "base/metrics/persistent_memory_allocator.h"
#include "base/strings/string_piece.h"
#include "base/task_runner.h"
#include "base/time/time.h"
#include "components/metrics/metrics_pref_names.h"
#include "components/metrics/metrics_service.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "components/variations/variations_associated_data.h"
namespace metrics {
namespace {
// These structures provide values used to define how files are opened and
// accessed. It obviates the need for multiple code-paths within several of
// the methods.
struct SourceOptions {
// The flags to be used to open a file on disk.
int file_open_flags;
// The access mode to be used when mapping a file into memory.
base::MemoryMappedFile::Access memory_mapped_access;
// Indicates if the file is to be accessed read-only.
bool is_read_only;
};
enum : int {
// Opening a file typically requires at least these flags.
STD_OPEN = base::File::FLAG_OPEN | base::File::FLAG_READ,
};
constexpr SourceOptions kSourceOptions[] = {
// SOURCE_HISTOGRAMS_ATOMIC_FILE
{
// Ensure that no other process reads this at the same time.
STD_OPEN | base::File::FLAG_EXCLUSIVE_READ,
base::MemoryMappedFile::READ_ONLY,
true
},
// SOURCE_HISTOGRAMS_ATOMIC_DIR
{
// Ensure that no other process reads this at the same time.
STD_OPEN | base::File::FLAG_EXCLUSIVE_READ,
base::MemoryMappedFile::READ_ONLY,
true
},
// SOURCE_HISTOGRAMS_ACTIVE_FILE
{
// Allow writing (updated "logged" values) to the file.
STD_OPEN | base::File::FLAG_WRITE,
base::MemoryMappedFile::READ_WRITE,
false
}
};
void DeleteFileWhenPossible(const base::FilePath& path) {
// Open (with delete) and then immediately close the file by going out of
// scope. This is the only cross-platform safe way to delete a file that may
// be open elsewhere, a distinct possibility given the asynchronous nature
// of the delete task.
base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ |
base::File::FLAG_DELETE_ON_CLOSE);
}
} // namespace
// This structure stores all the information about the sources being monitored
// and their current reporting state.
struct FileMetricsProvider::SourceInfo {
SourceInfo(SourceType source_type) : type(source_type) {}
~SourceInfo() {}
// How to access this source (file/dir, atomic/active).
const SourceType type;
// Where on disk the directory is located. This will only be populated when
// a directory is being monitored.
base::FilePath directory;
// Where on disk the file is located. If a directory is being monitored,
// this will be updated for whatever file is being read.
base::FilePath path;
// Name used inside prefs to persistent metadata.
std::string prefs_key;
// The last-seen time of this source to detect change.
base::Time last_seen;
// Indicates if the data has been read out or not.
bool read_complete = false;
// Once a file has been recognized as needing to be read, it is mapped
// into memory and assigned to an |allocator| object.
std::unique_ptr<base::PersistentHistogramAllocator> allocator;
private:
DISALLOW_COPY_AND_ASSIGN(SourceInfo);
};
FileMetricsProvider::FileMetricsProvider(
const scoped_refptr<base::TaskRunner>& task_runner,
PrefService* local_state)
: task_runner_(task_runner),
pref_service_(local_state),
weak_factory_(this) {
base::StatisticsRecorder::RegisterHistogramProvider(
weak_factory_.GetWeakPtr());
}
FileMetricsProvider::~FileMetricsProvider() {}
void FileMetricsProvider::RegisterSource(const base::FilePath& path,
SourceType type,
SourceAssociation source_association,
const base::StringPiece prefs_key) {
DCHECK(thread_checker_.CalledOnValidThread());
// Ensure that kSourceOptions has been filled for this type.
DCHECK_GT(arraysize(kSourceOptions), static_cast<size_t>(type));
std::unique_ptr<SourceInfo> source(new SourceInfo(type));
source->prefs_key = prefs_key.as_string();
switch (source->type) {
case SOURCE_HISTOGRAMS_ATOMIC_FILE:
case SOURCE_HISTOGRAMS_ACTIVE_FILE:
source->path = path;
break;
case SOURCE_HISTOGRAMS_ATOMIC_DIR:
source->directory = path;
break;
}
// |prefs_key| may be empty if the caller does not wish to persist the
// state across instances of the program.
if (pref_service_ && !prefs_key.empty()) {
source->last_seen = base::Time::FromInternalValue(
pref_service_->GetInt64(metrics::prefs::kMetricsLastSeenPrefix +
source->prefs_key));
}
switch (source_association) {
case ASSOCIATE_CURRENT_RUN:
sources_to_check_.push_back(std::move(source));
break;
case ASSOCIATE_PREVIOUS_RUN:
DCHECK_EQ(SOURCE_HISTOGRAMS_ATOMIC_FILE, source->type);
sources_for_previous_run_.push_back(std::move(source));
break;
}
}
// static
void FileMetricsProvider::RegisterPrefs(PrefRegistrySimple* prefs,
const base::StringPiece prefs_key) {
prefs->RegisterInt64Pref(metrics::prefs::kMetricsLastSeenPrefix +
prefs_key.as_string(), 0);
}
// static
bool FileMetricsProvider::LocateNextFileInDirectory(SourceInfo* source) {
DCHECK_EQ(SOURCE_HISTOGRAMS_ATOMIC_DIR, source->type);
DCHECK(!source->directory.empty());
// Open the directory and find all the files, remembering the oldest that
// has not been read. They can be removed and/or ignored if they're older
// than the last-check time.
base::Time oldest_file_time = base::Time::Now();
base::FilePath oldest_file_path;
base::FilePath file_path;
int file_count = 0;
int delete_count = 0;
base::FileEnumerator file_iter(source->directory, /*recursive=*/false,
base::FileEnumerator::FILES);
for (file_path = file_iter.Next(); !file_path.empty();
file_path = file_iter.Next()) {
base::FileEnumerator::FileInfo file_info = file_iter.GetInfo();
// Ignore directories and zero-sized files.
if (file_info.IsDirectory() || file_info.GetSize() == 0)
continue;
// Ignore temporary files.
base::FilePath::CharType first_character =
file_path.BaseName().value().front();
if (first_character == FILE_PATH_LITERAL('.') ||
first_character == FILE_PATH_LITERAL('_')) {
continue;
}
// Ignore non-PMA (Persistent Memory Allocator) files.
if (file_path.Extension() !=
base::PersistentMemoryAllocator::kFileExtension) {
continue;
}
// Process real files.
base::Time modified = file_info.GetLastModifiedTime();
if (modified > source->last_seen) {
// This file hasn't been read. Remember it if it is older than others.
if (modified < oldest_file_time) {
oldest_file_path = std::move(file_path);
oldest_file_time = modified;
}
++file_count;
} else {
// This file has been read. Try to delete it. Ignore any errors because
// the file may be un-removeable by this process. It could, for example,
// have been created by a privileged process like setup.exe. Even if it
// is not removed, it will continue to be ignored bacuse of the older
// modification time.
base::DeleteFile(file_path, /*recursive=*/false);
++delete_count;
}
}
UMA_HISTOGRAM_COUNTS_100("UMA.FileMetricsProvider.DirectoryFiles",
file_count);
UMA_HISTOGRAM_COUNTS_100("UMA.FileMetricsProvider.DeletedFiles",
delete_count);
// Stop now if there are no files to read.
if (oldest_file_path.empty())
return false;
// Set the active file to be the oldest modified file that has not yet
// been read.
source->path = std::move(oldest_file_path);
return true;
}
// static
void FileMetricsProvider::CheckAndMergeMetricSourcesOnTaskRunner(
SourceInfoList* sources) {
// This method has all state information passed in |sources| and is intended
// to run on a worker thread rather than the UI thread.
for (std::unique_ptr<SourceInfo>& source : *sources) {
AccessResult result = CheckAndMapMetricSource(source.get());
// Some results are not reported in order to keep the dashboard clean.
if (result != ACCESS_RESULT_DOESNT_EXIST &&
result != ACCESS_RESULT_NOT_MODIFIED) {
UMA_HISTOGRAM_ENUMERATION(
"UMA.FileMetricsProvider.AccessResult", result, ACCESS_RESULT_MAX);
}
// Mapping was successful. Merge it.
if (result == ACCESS_RESULT_SUCCESS) {
MergeHistogramDeltasFromSource(source.get());
DCHECK(source->read_complete);
}
// Different source types require different post-processing.
switch (source->type) {
case SOURCE_HISTOGRAMS_ATOMIC_FILE:
case SOURCE_HISTOGRAMS_ATOMIC_DIR:
// Done with this file so delete the allocator and its owned file.
source->allocator.reset();
// Remove the file if has been recorded. This prevents them from
// accumulating or also being recorded by different instances of
// the browser.
if (result == ACCESS_RESULT_SUCCESS ||
result == ACCESS_RESULT_NOT_MODIFIED) {
base::DeleteFile(source->path, /*recursive=*/false);
}
break;
case SOURCE_HISTOGRAMS_ACTIVE_FILE:
// Keep the allocator open so it doesn't have to be re-mapped each
// time. This also allows the contents to be merged on-demand.
break;
}
}
}
// This method has all state information passed in |source| and is intended
// to run on a worker thread rather than the UI thread.
// static
FileMetricsProvider::AccessResult FileMetricsProvider::CheckAndMapMetricSource(
SourceInfo* source) {
DCHECK(!source->allocator);
source->read_complete = false;
// If the source is a directory, look for files within it.
if (!source->directory.empty() && !LocateNextFileInDirectory(source))
return ACCESS_RESULT_DOESNT_EXIST;
// Do basic validation on the file metadata.
base::File::Info info;
if (!base::GetFileInfo(source->path, &info))
return ACCESS_RESULT_DOESNT_EXIST;
if (info.is_directory || info.size == 0)
return ACCESS_RESULT_INVALID_FILE;
if (source->last_seen >= info.last_modified)
return ACCESS_RESULT_NOT_MODIFIED;
// A new file of metrics has been found.
base::File file(source->path, kSourceOptions[source->type].file_open_flags);
if (!file.IsValid())
return ACCESS_RESULT_NO_OPEN;
std::unique_ptr<base::MemoryMappedFile> mapped(new base::MemoryMappedFile());
if (!mapped->Initialize(std::move(file),
kSourceOptions[source->type].memory_mapped_access)) {
return ACCESS_RESULT_SYSTEM_MAP_FAILURE;
}
// Ensure any problems below don't occur repeatedly.
source->last_seen = info.last_modified;
// Test the validity of the file contents.
const bool read_only = kSourceOptions[source->type].is_read_only;
if (!base::FilePersistentMemoryAllocator::IsFileAcceptable(*mapped,
read_only)) {
return ACCESS_RESULT_INVALID_CONTENTS;
}
// Create an allocator for the mapped file. Ownership passes to the allocator.
source->allocator.reset(new base::PersistentHistogramAllocator(
base::MakeUnique<base::FilePersistentMemoryAllocator>(
std::move(mapped), 0, 0, base::StringPiece(), read_only)));
return ACCESS_RESULT_SUCCESS;
}
// static
void FileMetricsProvider::MergeHistogramDeltasFromSource(SourceInfo* source) {
DCHECK(source->allocator);
base::PersistentHistogramAllocator::Iterator histogram_iter(
source->allocator.get());
const bool read_only = kSourceOptions[source->type].is_read_only;
int histogram_count = 0;
while (true) {
std::unique_ptr<base::HistogramBase> histogram = histogram_iter.GetNext();
if (!histogram)
break;
if (read_only) {
source->allocator->MergeHistogramFinalDeltaToStatisticsRecorder(
histogram.get());
} else {
source->allocator->MergeHistogramDeltaToStatisticsRecorder(
histogram.get());
}
++histogram_count;
}
source->read_complete = true;
DVLOG(1) << "Reported " << histogram_count << " histograms from "
<< source->path.value();
}
// static
void FileMetricsProvider::RecordHistogramSnapshotsFromSource(
base::HistogramSnapshotManager* snapshot_manager,
SourceInfo* source) {
DCHECK_EQ(SOURCE_HISTOGRAMS_ATOMIC_FILE, source->type);
base::PersistentHistogramAllocator::Iterator histogram_iter(
source->allocator.get());
int histogram_count = 0;
while (true) {
std::unique_ptr<base::HistogramBase> histogram = histogram_iter.GetNext();
if (!histogram)
break;
snapshot_manager->PrepareFinalDelta(histogram.get());
++histogram_count;
}
source->read_complete = true;
DVLOG(1) << "Reported " << histogram_count << " histograms from "
<< source->path.value();
}
void FileMetricsProvider::ScheduleSourcesCheck() {
DCHECK(thread_checker_.CalledOnValidThread());
if (sources_to_check_.empty())
return;
// Create an independent list of sources for checking. This will be Owned()
// by the reply call given to the task-runner, to be deleted when that call
// has returned. It is also passed Unretained() to the task itself, safe
// because that must complete before the reply runs.
SourceInfoList* check_list = new SourceInfoList();
std::swap(sources_to_check_, *check_list);
task_runner_->PostTaskAndReply(
FROM_HERE,
base::Bind(&FileMetricsProvider::CheckAndMergeMetricSourcesOnTaskRunner,
base::Unretained(check_list)),
base::Bind(&FileMetricsProvider::RecordSourcesChecked,
weak_factory_.GetWeakPtr(), base::Owned(check_list)));
}
void FileMetricsProvider::RecordSourcesChecked(SourceInfoList* checked) {
DCHECK(thread_checker_.CalledOnValidThread());
// Sources that still have an allocator at this point are read/write "active"
// files that may need their contents merged on-demand. If there is no
// allocator (not a read/write file) but a read was done on the task-runner,
// try again immediately to see if more is available (in a directory of
// files). Otherwise, remember the source for checking again at a later time.
bool did_read = false;
for (auto iter = checked->begin(); iter != checked->end();) {
auto temp = iter++;
SourceInfo* source = temp->get();
if (source->read_complete) {
RecordSourceAsRead(source);
did_read = true;
}
if (source->allocator)
sources_mapped_.splice(sources_mapped_.end(), *checked, temp);
else
sources_to_check_.splice(sources_to_check_.end(), *checked, temp);
}
// If a read was done, schedule another one immediately. In the case of a
// directory of files, this ensures that all entries get processed. It's
// done here instead of as a loop in CheckAndMergeMetricSourcesOnTaskRunner
// so that (a) it gives the disk a rest and (b) testing of individual reads
// is possible.
if (did_read)
ScheduleSourcesCheck();
}
void FileMetricsProvider::DeleteFileAsync(const base::FilePath& path) {
task_runner_->PostTask(FROM_HERE, base::Bind(DeleteFileWhenPossible, path));
}
void FileMetricsProvider::RecordSourceAsRead(SourceInfo* source) {
DCHECK(thread_checker_.CalledOnValidThread());
// Persistently record the "last seen" timestamp of the source file to
// ensure that the file is never read again unless it is modified again.
if (pref_service_ && !source->prefs_key.empty()) {
pref_service_->SetInt64(
metrics::prefs::kMetricsLastSeenPrefix + source->prefs_key,
source->last_seen.ToInternalValue());
}
}
void FileMetricsProvider::OnDidCreateMetricsLog() {
DCHECK(thread_checker_.CalledOnValidThread());
// Schedule a check to see if there are new metrics to load. If so, they
// will be reported during the next collection run after this one. The
// check is run off of the worker-pool so as to not cause delays on the
// main UI thread (which is currently where metric collection is done).
ScheduleSourcesCheck();
// Clear any data for initial metrics since they're always reported
// before the first call to this method. It couldn't be released after
// being reported in RecordInitialHistogramSnapshots because the data
// will continue to be used by the caller after that method returns. Once
// here, though, all actions to be done on the data have been completed.
for (const std::unique_ptr<SourceInfo>& source : sources_for_previous_run_)
DeleteFileAsync(source->path);
sources_for_previous_run_.clear();
}
bool FileMetricsProvider::HasInitialStabilityMetrics() {
DCHECK(thread_checker_.CalledOnValidThread());
// Check if there is an experiment that disables stability metrics.
std::string unreported = variations::GetVariationParamValueByFeature(
base::kPersistentHistogramsFeature, "send_unreported_metrics");
if (unreported == "no")
sources_for_previous_run_.clear();
// Measure the total time spent checking all sources as well as the time
// per individual file. This method is called during startup and thus blocks
// the initial showing of the browser window so it's important to know the
// total delay.
SCOPED_UMA_HISTOGRAM_TIMER("UMA.FileMetricsProvider.InitialCheckTime.Total");
// Check all sources for previous run to see if they need to be read.
for (auto iter = sources_for_previous_run_.begin();
iter != sources_for_previous_run_.end();) {
SCOPED_UMA_HISTOGRAM_TIMER("UMA.FileMetricsProvider.InitialCheckTime.File");
auto temp = iter++;
SourceInfo* source = temp->get();
// This would normally be done on a background I/O thread but there
// hasn't been a chance to run any at the time this method is called.
// Do the check in-line.
AccessResult result = CheckAndMapMetricSource(source);
UMA_HISTOGRAM_ENUMERATION("UMA.FileMetricsProvider.InitialAccessResult",
result, ACCESS_RESULT_MAX);
// If it couldn't be accessed, remove it from the list. There is only ever
// one chance to record it so no point keeping it around for later. Also
// mark it as having been read since uploading it with a future browser
// run would associate it with the then-previous run which would no longer
// be the run from which it came.
if (result != ACCESS_RESULT_SUCCESS) {
DCHECK(!source->allocator);
RecordSourceAsRead(source);
DeleteFileAsync(source->path);
sources_for_previous_run_.erase(temp);
}
}
return !sources_for_previous_run_.empty();
}
void FileMetricsProvider::RecordInitialHistogramSnapshots(
base::HistogramSnapshotManager* snapshot_manager) {
DCHECK(thread_checker_.CalledOnValidThread());
// Measure the total time spent processing all sources as well as the time
// per individual file. This method is called during startup and thus blocks
// the initial showing of the browser window so it's important to know the
// total delay.
SCOPED_UMA_HISTOGRAM_TIMER(
"UMA.FileMetricsProvider.InitialSnapshotTime.Total");
for (const std::unique_ptr<SourceInfo>& source : sources_for_previous_run_) {
SCOPED_UMA_HISTOGRAM_TIMER(
"UMA.FileMetricsProvider.InitialSnapshotTime.File");
// The source needs to have an allocator attached to it in order to read
// histograms out of it.
DCHECK(!source->read_complete);
DCHECK(source->allocator);
// Dump all histograms contained within the source to the snapshot-manager.
RecordHistogramSnapshotsFromSource(snapshot_manager, source.get());
// Update the last-seen time so it isn't read again unless it changes.
RecordSourceAsRead(source.get());
}
}
void FileMetricsProvider::MergeHistogramDeltas() {
DCHECK(thread_checker_.CalledOnValidThread());
// Measure the total time spent processing all sources as well as the time
// per individual file. This method is called on the UI thread so it's
// important to know how much total "jank" may be introduced.
SCOPED_UMA_HISTOGRAM_TIMER("UMA.FileMetricsProvider.SnapshotTime.Total");
for (std::unique_ptr<SourceInfo>& source : sources_mapped_) {
SCOPED_UMA_HISTOGRAM_TIMER("UMA.FileMetricsProvider.SnapshotTime.File");
MergeHistogramDeltasFromSource(source.get());
}
}
} // namespace metrics