blob: 01ed8be1ef5f2e1e7adca33da9dd3e0837fbd837 [file] [log] [blame]
// Copyright 2014 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.
//------------------------------------------------------------------------------
// Description of the life cycle of a instance of MetricsService.
//
// OVERVIEW
//
// A MetricsService instance is typically created at application startup. It is
// the central controller for the acquisition of log data, and the automatic
// transmission of that log data to an external server. Its major job is to
// manage logs, grouping them for transmission, and transmitting them. As part
// of its grouping, MS finalizes logs by including some just-in-time gathered
// memory statistics, snapshotting the current stats of numerous histograms,
// closing the logs, translating to protocol buffer format, and compressing the
// results for transmission. Transmission includes submitting a compressed log
// as data in a URL-post, and retransmitting (or retaining at process
// termination) if the attempted transmission failed. Retention across process
// terminations is done using the the PrefServices facilities. The retained logs
// (the ones that never got transmitted) are compressed and base64-encoded
// before being persisted.
//
// Logs fall into one of two categories: "initial logs," and "ongoing logs."
// There is at most one initial log sent for each complete run of Chrome (from
// startup, to browser shutdown). An initial log is generally transmitted some
// short time (1 minute?) after startup, and includes stats such as recent crash
// info, the number and types of plugins, etc. The external server's response
// to the initial log conceptually tells this MS if it should continue
// transmitting logs (during this session). The server response can actually be
// much more detailed, and always includes (at a minimum) how often additional
// ongoing logs should be sent.
//
// After the above initial log, a series of ongoing logs will be transmitted.
// The first ongoing log actually begins to accumulate information stating when
// the MS was first constructed. Note that even though the initial log is
// commonly sent a full minute after startup, the initial log does not include
// much in the way of user stats. The most common interlog period (delay)
// is 30 minutes. That time period starts when the first user action causes a
// logging event. This means that if there is no user action, there may be long
// periods without any (ongoing) log transmissions. Ongoing logs typically
// contain very detailed records of user activities (ex: opened tab, closed
// tab, fetched URL, maximized window, etc.) In addition, just before an
// ongoing log is closed out, a call is made to gather memory statistics. Those
// memory statistics are deposited into a histogram, and the log finalization
// code is then called. In the finalization, a call to a Histogram server
// acquires a list of all local histograms that have been flagged for upload
// to the UMA server. The finalization also acquires the most recent number
// of page loads, along with any counts of renderer or plugin crashes.
//
// When the browser shuts down, there will typically be a fragment of an ongoing
// log that has not yet been transmitted. At shutdown time, that fragment is
// closed (including snapshotting histograms), and persisted, for potential
// transmission during a future run of the product.
//
// There are two slightly abnormal shutdown conditions. There is a
// "disconnected scenario," and a "really fast startup and shutdown" scenario.
// In the "never connected" situation, the user has (during the running of the
// process) never established an internet connection. As a result, attempts to
// transmit the initial log have failed, and a lot(?) of data has accumulated in
// the ongoing log (which didn't yet get closed, because there was never even a
// contemplation of sending it). There is also a kindred "lost connection"
// situation, where a loss of connection prevented an ongoing log from being
// transmitted, and a (still open) log was stuck accumulating a lot(?) of data,
// while the earlier log retried its transmission. In both of these
// disconnected situations, two logs need to be, and are, persistently stored
// for future transmission.
//
// The other unusual shutdown condition, termed "really fast startup and
// shutdown," involves the deliberate user termination of the process before
// the initial log is even formed or transmitted. In that situation, no logging
// is done, but the historical crash statistics remain (unlogged) for inclusion
// in a future run's initial log. (i.e., we don't lose crash stats).
//
// With the above overview, we can now describe the state machine's various
// states, based on the State enum specified in the state_ member. Those states
// are:
//
// INITIALIZED, // Constructor was called.
// INIT_TASK_SCHEDULED, // Waiting for deferred init tasks to finish.
// INIT_TASK_DONE, // Waiting for timer to send initial log.
// SENDING_LOGS, // Sending logs and creating new ones when we run out.
//
// In more detail, we have:
//
// INITIALIZED, // Constructor was called.
// The MS has been constructed, but has taken no actions to compose the
// initial log.
//
// INIT_TASK_SCHEDULED, // Waiting for deferred init tasks to finish.
// Typically about 30 seconds after startup, a task is sent to a second thread
// (the file thread) to perform deferred (lower priority and slower)
// initialization steps such as getting the list of plugins. That task will
// (when complete) make an async callback (via a Task) to indicate the
// completion.
//
// INIT_TASK_DONE, // Waiting for timer to send initial log.
// The callback has arrived, and it is now possible for an initial log to be
// created. This callback typically arrives back less than one second after
// the deferred init task is dispatched.
//
// SENDING_LOGS, // Sending logs an creating new ones when we run out.
// Logs from previous sessions have been loaded, and initial logs have been
// created (an optional stability log and the first metrics log). We will
// send all of these logs, and when run out, we will start cutting new logs
// to send. We will also cut a new log if we expect a shutdown.
//
// The progression through the above states is simple, and sequential.
// States proceed from INITIAL to SENDING_LOGS, and remain in the latter until
// shutdown.
//
// Also note that whenever we successfully send a log, we mirror the list
// of logs into the PrefService. This ensures that IF we crash, we won't start
// up and retransmit our old logs again.
//
// Due to race conditions, it is always possible that a log file could be sent
// twice. For example, if a log file is sent, but not yet acknowledged by
// the external server, and the user shuts down, then a copy of the log may be
// saved for re-transmission. These duplicates could be filtered out server
// side, but are not expected to be a significant problem.
//
//
//------------------------------------------------------------------------------
#include "components/metrics/metrics_service.h"
#include <stddef.h>
#include <algorithm>
#include <utility>
#include "base/bind.h"
#include "base/callback.h"
#include "base/location.h"
#include "base/metrics/histogram_base.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/histogram_samples.h"
#include "base/metrics/persistent_histogram_allocator.h"
#include "base/metrics/statistics_recorder.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_piece.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "components/metrics/environment_recorder.h"
#include "components/metrics/field_trials_provider.h"
#include "components/metrics/metrics_log.h"
#include "components/metrics/metrics_log_manager.h"
#include "components/metrics/metrics_log_uploader.h"
#include "components/metrics/metrics_pref_names.h"
#include "components/metrics/metrics_rotation_scheduler.h"
#include "components/metrics/metrics_service_client.h"
#include "components/metrics/metrics_state_manager.h"
#include "components/metrics/persistent_system_profile.h"
#include "components/metrics/stability_metrics_provider.h"
#include "components/metrics/url_constants.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "components/variations/entropy_provider.h"
namespace metrics {
namespace {
// The delay, in seconds, after starting recording before doing expensive
// initialization work.
#if defined(OS_ANDROID) || defined(OS_IOS)
// On mobile devices, a significant portion of sessions last less than a minute.
// Use a shorter timer on these platforms to avoid losing data.
// TODO(dfalcantara): To avoid delaying startup, tighten up initialization so
// that it occurs after the user gets their initial page.
const int kInitializationDelaySeconds = 5;
#else
const int kInitializationDelaySeconds = 30;
#endif
// The browser last live timestamp is updated every 15 minutes.
const int kUpdateAliveTimestampSeconds = 15 * 60;
#if defined(OS_ANDROID) || defined(OS_IOS)
void MarkAppCleanShutdownAndCommit(CleanExitBeacon* clean_exit_beacon,
PrefService* local_state) {
clean_exit_beacon->WriteBeaconValue(true);
ExecutionPhaseManager(local_state).OnAppEnterBackground();
// Start writing right away (write happens on a different thread).
local_state->CommitPendingWrite();
}
#endif // defined(OS_ANDROID) || defined(OS_IOS)
} // namespace
// static
MetricsService::ShutdownCleanliness MetricsService::clean_shutdown_status_ =
MetricsService::CLEANLY_SHUTDOWN;
// static
void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
CleanExitBeacon::RegisterPrefs(registry);
MetricsStateManager::RegisterPrefs(registry);
MetricsLog::RegisterPrefs(registry);
StabilityMetricsProvider::RegisterPrefs(registry);
ExecutionPhaseManager::RegisterPrefs(registry);
MetricsReportingService::RegisterPrefs(registry);
registry->RegisterIntegerPref(prefs::kMetricsSessionID, -1);
registry->RegisterInt64Pref(prefs::kUninstallLaunchCount, 0);
registry->RegisterInt64Pref(prefs::kUninstallMetricsUptimeSec, 0);
}
MetricsService::MetricsService(MetricsStateManager* state_manager,
MetricsServiceClient* client,
PrefService* local_state)
: reporting_service_(client, local_state),
histogram_snapshot_manager_(this),
state_manager_(state_manager),
client_(client),
local_state_(local_state),
recording_state_(UNSET),
test_mode_active_(false),
state_(INITIALIZED),
idle_since_last_transmission_(false),
session_id_(-1),
self_ptr_factory_(this) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(state_manager_);
DCHECK(client_);
DCHECK(local_state_);
RegisterMetricsProvider(
std::make_unique<StabilityMetricsProvider>(local_state_));
RegisterMetricsProvider(state_manager_->GetProvider());
RegisterMetricsProvider(std::make_unique<variations::FieldTrialsProvider>(
&synthetic_trial_registry_, base::StringPiece()));
}
MetricsService::~MetricsService() {
DisableRecording();
}
void MetricsService::InitializeMetricsRecordingState() {
reporting_service_.Initialize();
InitializeMetricsState();
base::Closure upload_callback =
base::Bind(&MetricsService::StartScheduledUpload,
self_ptr_factory_.GetWeakPtr());
rotation_scheduler_.reset(new MetricsRotationScheduler(
upload_callback,
// MetricsServiceClient outlives MetricsService, and
// MetricsRotationScheduler is tied to the lifetime of |this|.
base::Bind(&MetricsServiceClient::GetStandardUploadInterval,
base::Unretained(client_))));
// Init() has to be called after LogCrash() in order for LogCrash() to work.
delegating_provider_.Init();
}
void MetricsService::Start() {
HandleIdleSinceLastTransmission(false);
EnableRecording();
EnableReporting();
}
void MetricsService::StartRecordingForTests() {
test_mode_active_ = true;
EnableRecording();
DisableReporting();
}
void MetricsService::StartUpdatingLastLiveTimestamp() {
base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
base::BindOnce(&MetricsService::UpdateLastLiveTimestampTask,
self_ptr_factory_.GetWeakPtr()),
base::TimeDelta::FromSeconds(kUpdateAliveTimestampSeconds));
}
void MetricsService::Stop() {
HandleIdleSinceLastTransmission(false);
DisableReporting();
DisableRecording();
}
void MetricsService::EnableReporting() {
if (reporting_service_.reporting_active())
return;
reporting_service_.EnableReporting();
StartSchedulerIfNecessary();
}
void MetricsService::DisableReporting() {
reporting_service_.DisableReporting();
}
std::string MetricsService::GetClientId() {
return state_manager_->client_id();
}
int64_t MetricsService::GetInstallDate() {
return state_manager_->GetInstallDate();
}
bool MetricsService::WasLastShutdownClean() const {
return state_manager_->clean_exit_beacon()->exited_cleanly();
}
void MetricsService::EnableRecording() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (recording_state_ == ACTIVE)
return;
recording_state_ = ACTIVE;
state_manager_->ForceClientIdCreation();
client_->SetMetricsClientId(state_manager_->client_id());
SystemProfileProto system_profile;
MetricsLog::RecordCoreSystemProfile(client_, &system_profile);
GlobalPersistentSystemProfile::GetInstance()->SetSystemProfile(
system_profile, /*complete=*/false);
if (!log_manager_.current_log())
OpenNewLog();
delegating_provider_.OnRecordingEnabled();
base::RemoveActionCallback(action_callback_);
action_callback_ = base::Bind(&MetricsService::OnUserAction,
base::Unretained(this));
base::AddActionCallback(action_callback_);
}
void MetricsService::DisableRecording() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (recording_state_ == INACTIVE)
return;
recording_state_ = INACTIVE;
base::RemoveActionCallback(action_callback_);
delegating_provider_.OnRecordingDisabled();
PushPendingLogsToPersistentStorage();
}
bool MetricsService::recording_active() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return recording_state_ == ACTIVE;
}
bool MetricsService::reporting_active() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return reporting_service_.reporting_active();
}
bool MetricsService::has_unsent_logs() const {
return reporting_service_.metrics_log_store()->has_unsent_logs();
}
void MetricsService::RecordDelta(const base::HistogramBase& histogram,
const base::HistogramSamples& snapshot) {
log_manager_.current_log()->RecordHistogramDelta(histogram.histogram_name(),
snapshot);
}
void MetricsService::HandleIdleSinceLastTransmission(bool in_idle) {
// If there wasn't a lot of action, maybe the computer was asleep, in which
// case, the log transmissions should have stopped. Here we start them up
// again.
if (!in_idle && idle_since_last_transmission_)
StartSchedulerIfNecessary();
idle_since_last_transmission_ = in_idle;
}
void MetricsService::OnApplicationNotIdle() {
if (recording_state_ == ACTIVE)
HandleIdleSinceLastTransmission(false);
}
void MetricsService::RecordStartOfSessionEnd() {
LogCleanShutdown(false);
}
void MetricsService::RecordCompletedSessionEnd() {
LogCleanShutdown(true);
}
#if defined(OS_ANDROID) || defined(OS_IOS)
void MetricsService::OnAppEnterBackground() {
rotation_scheduler_->Stop();
reporting_service_.Stop();
MarkAppCleanShutdownAndCommit(state_manager_->clean_exit_beacon(),
local_state_);
// Give providers a chance to persist histograms as part of being
// backgrounded.
delegating_provider_.OnAppEnterBackground();
// At this point, there's no way of knowing when the process will be
// killed, so this has to be treated similar to a shutdown, closing and
// persisting all logs. Unlinke a shutdown, the state is primed to be ready
// to continue logging and uploading if the process does return.
if (recording_active() && state_ >= SENDING_LOGS) {
PushPendingLogsToPersistentStorage();
// Persisting logs closes the current log, so start recording a new log
// immediately to capture any background work that might be done before the
// process is killed.
OpenNewLog();
}
}
void MetricsService::OnAppEnterForeground() {
state_manager_->clean_exit_beacon()->WriteBeaconValue(false);
ExecutionPhaseManager(local_state_).OnAppEnterForeground();
StartSchedulerIfNecessary();
}
#else
void MetricsService::LogNeedForCleanShutdown() {
state_manager_->clean_exit_beacon()->WriteBeaconValue(false);
// Redundant setting to be sure we call for a clean shutdown.
clean_shutdown_status_ = NEED_TO_SHUTDOWN;
}
#endif // defined(OS_ANDROID) || defined(OS_IOS)
// static
void MetricsService::SetExecutionPhase(ExecutionPhase execution_phase,
PrefService* local_state) {
ExecutionPhaseManager(local_state).SetExecutionPhase(execution_phase);
}
void MetricsService::RecordBreakpadRegistration(bool success) {
StabilityMetricsProvider(local_state_).RecordBreakpadRegistration(success);
}
void MetricsService::RecordBreakpadHasDebugger(bool has_debugger) {
StabilityMetricsProvider(local_state_)
.RecordBreakpadHasDebugger(has_debugger);
}
void MetricsService::ClearSavedStabilityMetrics() {
delegating_provider_.ClearSavedStabilityMetrics();
}
void MetricsService::PushExternalLog(const std::string& log) {
log_store()->StoreLog(log, MetricsLog::ONGOING_LOG);
}
void MetricsService::UpdateMetricsUsagePrefs(int message_size,
bool is_cellular,
bool is_metrics_service_usage) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
reporting_service_.UpdateMetricsUsagePrefs(message_size, is_cellular,
is_metrics_service_usage);
}
//------------------------------------------------------------------------------
// private methods
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Initialization methods
void MetricsService::InitializeMetricsState() {
const int64_t buildtime = MetricsLog::GetBuildTime();
const std::string version = client_->GetVersionString();
bool version_changed = false;
EnvironmentRecorder recorder(local_state_);
int64_t previous_buildtime = recorder.GetLastBuildtime();
std::string previous_version = recorder.GetLastVersion();
if (previous_buildtime != buildtime || previous_version != version) {
recorder.SetBuildtimeAndVersion(buildtime, version);
version_changed = true;
}
session_id_ = local_state_->GetInteger(prefs::kMetricsSessionID);
StabilityMetricsProvider provider(local_state_);
if (!state_manager_->clean_exit_beacon()->exited_cleanly()) {
provider.LogCrash(
state_manager_->clean_exit_beacon()->browser_last_live_timestamp());
// Reset flag, and wait until we call LogNeedForCleanShutdown() before
// monitoring.
state_manager_->clean_exit_beacon()->WriteBeaconValue(true);
ExecutionPhaseManager manager(local_state_);
base::UmaHistogramSparse("Chrome.Browser.CrashedExecutionPhase",
static_cast<int>(manager.GetExecutionPhase()));
manager.SetExecutionPhase(ExecutionPhase::UNINITIALIZED_PHASE);
}
// HasPreviousSessionData is called first to ensure it is never bypassed.
const bool is_initial_stability_log_required =
delegating_provider_.HasPreviousSessionData() ||
!state_manager_->clean_exit_beacon()->exited_cleanly();
bool has_initial_stability_log = false;
if (is_initial_stability_log_required) {
// If the previous session didn't exit cleanly, or if any provider
// explicitly requests it, prepare an initial stability log -
// provided UMA is enabled.
if (state_manager_->IsMetricsReportingEnabled()) {
has_initial_stability_log = PrepareInitialStabilityLog(previous_version);
if (!has_initial_stability_log)
provider.LogStabilityLogDeferred();
}
}
// If the version changed, but no initial stability log was generated, clear
// the stability stats from the previous version (so that they don't get
// attributed to the current version). This could otherwise happen due to a
// number of different edge cases, such as if the last version crashed before
// it could save off a system profile or if UMA reporting is disabled (which
// normally results in stats being accumulated).
if (version_changed && !has_initial_stability_log) {
ClearSavedStabilityMetrics();
provider.LogStabilityDataDiscarded();
}
// If the version changed, the system profile is obsolete and needs to be
// cleared. This is to avoid the stability data misattribution that could
// occur if the current version crashed before saving its own system profile.
// Note however this clearing occurs only after preparing the initial
// stability log, an operation that requires the previous version's system
// profile. At this point, stability metrics pertaining to the previous
// version have been cleared.
if (version_changed)
recorder.ClearEnvironmentFromPrefs();
// Update session ID.
++session_id_;
local_state_->SetInteger(prefs::kMetricsSessionID, session_id_);
// Notify stability metrics providers about the launch.
provider.LogLaunch();
SetExecutionPhase(ExecutionPhase::START_METRICS_RECORDING, local_state_);
provider.CheckLastSessionEndCompleted();
// Call GetUptimes() for the first time, thus allowing all later calls
// to record incremental uptimes accurately.
base::TimeDelta ignored_uptime_parameter;
base::TimeDelta startup_uptime;
GetUptimes(local_state_, &startup_uptime, &ignored_uptime_parameter);
DCHECK_EQ(0, startup_uptime.InMicroseconds());
// Bookkeeping for the uninstall metrics.
IncrementLongPrefsValue(prefs::kUninstallLaunchCount);
}
void MetricsService::OnUserAction(const std::string& action) {
log_manager_.current_log()->RecordUserAction(action);
HandleIdleSinceLastTransmission(false);
}
void MetricsService::FinishedInitTask() {
DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
state_ = INIT_TASK_DONE;
// Create the initial log.
if (!initial_metrics_log_) {
initial_metrics_log_ = CreateLog(MetricsLog::ONGOING_LOG);
delegating_provider_.OnDidCreateMetricsLog();
}
rotation_scheduler_->InitTaskComplete();
}
void MetricsService::GetUptimes(PrefService* pref,
base::TimeDelta* incremental_uptime,
base::TimeDelta* uptime) {
base::TimeTicks now = base::TimeTicks::Now();
// If this is the first call, init |first_updated_time_| and
// |last_updated_time_|.
if (last_updated_time_.is_null()) {
first_updated_time_ = now;
last_updated_time_ = now;
}
*incremental_uptime = now - last_updated_time_;
*uptime = now - first_updated_time_;
last_updated_time_ = now;
const int64_t incremental_time_secs = incremental_uptime->InSeconds();
if (incremental_time_secs > 0) {
int64_t metrics_uptime = pref->GetInt64(prefs::kUninstallMetricsUptimeSec);
metrics_uptime += incremental_time_secs;
pref->SetInt64(prefs::kUninstallMetricsUptimeSec, metrics_uptime);
}
}
//------------------------------------------------------------------------------
// Recording control methods
void MetricsService::OpenNewLog() {
DCHECK(!log_manager_.current_log());
log_manager_.BeginLoggingWithLog(CreateLog(MetricsLog::ONGOING_LOG));
delegating_provider_.OnDidCreateMetricsLog();
if (state_ == INITIALIZED) {
// We only need to schedule that run once.
state_ = INIT_TASK_SCHEDULED;
base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
base::BindOnce(&MetricsService::StartInitTask,
self_ptr_factory_.GetWeakPtr()),
base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
base::BindOnce(&MetricsService::PrepareProviderMetricsTask,
self_ptr_factory_.GetWeakPtr()),
base::TimeDelta::FromSeconds(2 * kInitializationDelaySeconds));
}
}
void MetricsService::StartInitTask() {
delegating_provider_.AsyncInit(base::Bind(&MetricsService::FinishedInitTask,
self_ptr_factory_.GetWeakPtr()));
}
void MetricsService::CloseCurrentLog() {
if (!log_manager_.current_log())
return;
// If a persistent allocator is in use, update its internal histograms (such
// as how much memory is being used) before reporting.
base::PersistentHistogramAllocator* allocator =
base::GlobalHistogramAllocator::Get();
if (allocator)
allocator->UpdateTrackingHistograms();
// Put incremental data (histogram deltas, and realtime stats deltas) at the
// end of all log transmissions (initial log handles this separately).
// RecordIncrementalStabilityElements only exists on the derived
// MetricsLog class.
MetricsLog* current_log = log_manager_.current_log();
DCHECK(current_log);
RecordCurrentEnvironment(current_log);
base::TimeDelta incremental_uptime;
base::TimeDelta uptime;
GetUptimes(local_state_, &incremental_uptime, &uptime);
current_log->RecordCurrentSessionData(&delegating_provider_,
incremental_uptime, uptime);
RecordCurrentHistograms();
current_log->TruncateEvents();
DVLOG(1) << "Generated an ongoing log.";
log_manager_.FinishCurrentLog(log_store());
}
void MetricsService::PushPendingLogsToPersistentStorage() {
if (state_ < SENDING_LOGS)
return; // We didn't and still don't have time to get plugin list etc.
CloseCurrentLog();
log_store()->PersistUnsentLogs();
}
//------------------------------------------------------------------------------
// Transmission of logs methods
void MetricsService::StartSchedulerIfNecessary() {
// Never schedule cutting or uploading of logs in test mode.
if (test_mode_active_)
return;
// Even if reporting is disabled, the scheduler is needed to trigger the
// creation of the initial log, which must be done in order for any logs to be
// persisted on shutdown or backgrounding.
if (recording_active() &&
(reporting_active() || state_ < SENDING_LOGS)) {
rotation_scheduler_->Start();
reporting_service_.Start();
}
}
void MetricsService::StartScheduledUpload() {
DVLOG(1) << "StartScheduledUpload";
DCHECK(state_ >= INIT_TASK_DONE);
// If we're getting no notifications, then the log won't have much in it, and
// it's possible the computer is about to go to sleep, so don't upload and
// stop the scheduler.
// If recording has been turned off, the scheduler doesn't need to run.
// If reporting is off, proceed if the initial log hasn't been created, since
// that has to happen in order for logs to be cut and stored when persisting.
// TODO(stuartmorgan): Call Stop() on the scheduler when reporting and/or
// recording are turned off instead of letting it fire and then aborting.
if (idle_since_last_transmission_ ||
!recording_active() ||
(!reporting_active() && state_ >= SENDING_LOGS)) {
rotation_scheduler_->Stop();
rotation_scheduler_->RotationFinished();
return;
}
// If there are unsent logs, send the next one. If not, start the asynchronous
// process of finalizing the current log for upload.
if (state_ == SENDING_LOGS && has_unsent_logs()) {
reporting_service_.Start();
rotation_scheduler_->RotationFinished();
} else {
// There are no logs left to send, so start creating a new one.
client_->CollectFinalMetricsForLog(
base::Bind(&MetricsService::OnFinalLogInfoCollectionDone,
self_ptr_factory_.GetWeakPtr()));
}
}
void MetricsService::OnFinalLogInfoCollectionDone() {
DVLOG(1) << "OnFinalLogInfoCollectionDone";
// Abort if metrics were turned off during the final info gathering.
if (!recording_active()) {
rotation_scheduler_->Stop();
rotation_scheduler_->RotationFinished();
return;
}
if (state_ == INIT_TASK_DONE) {
PrepareInitialMetricsLog();
} else {
DCHECK_EQ(SENDING_LOGS, state_);
CloseCurrentLog();
OpenNewLog();
}
reporting_service_.Start();
rotation_scheduler_->RotationFinished();
HandleIdleSinceLastTransmission(true);
}
bool MetricsService::PrepareInitialStabilityLog(
const std::string& prefs_previous_version) {
DCHECK_EQ(INITIALIZED, state_);
std::unique_ptr<MetricsLog> initial_stability_log(
CreateLog(MetricsLog::INITIAL_STABILITY_LOG));
// Do not call OnDidCreateMetricsLog here because the stability
// log describes stats from the _previous_ session.
std::string system_profile_app_version;
if (!initial_stability_log->LoadSavedEnvironmentFromPrefs(
local_state_, &system_profile_app_version)) {
return false;
}
if (system_profile_app_version != prefs_previous_version)
StabilityMetricsProvider(local_state_).LogStabilityVersionMismatch();
log_manager_.PauseCurrentLog();
log_manager_.BeginLoggingWithLog(std::move(initial_stability_log));
// Note: Some stability providers may record stability stats via histograms,
// so this call has to be after BeginLoggingWithLog().
log_manager_.current_log()->RecordPreviousSessionData(&delegating_provider_);
RecordCurrentStabilityHistograms();
DVLOG(1) << "Generated an stability log.";
log_manager_.FinishCurrentLog(log_store());
log_manager_.ResumePausedLog();
// Store unsent logs, including the stability log that was just saved, so
// that they're not lost in case of a crash before upload time.
log_store()->PersistUnsentLogs();
return true;
}
void MetricsService::PrepareInitialMetricsLog() {
DCHECK_EQ(INIT_TASK_DONE, state_);
RecordCurrentEnvironment(initial_metrics_log_.get());
base::TimeDelta incremental_uptime;
base::TimeDelta uptime;
GetUptimes(local_state_, &incremental_uptime, &uptime);
// Histograms only get written to the current log, so make the new log current
// before writing them.
log_manager_.PauseCurrentLog();
log_manager_.BeginLoggingWithLog(std::move(initial_metrics_log_));
// Note: Some stability providers may record stability stats via histograms,
// so this call has to be after BeginLoggingWithLog().
log_manager_.current_log()->RecordCurrentSessionData(
&delegating_provider_, base::TimeDelta(), base::TimeDelta());
RecordCurrentHistograms();
DVLOG(1) << "Generated an initial log.";
log_manager_.FinishCurrentLog(log_store());
log_manager_.ResumePausedLog();
// Store unsent logs, including the initial log that was just saved, so
// that they're not lost in case of a crash before upload time.
log_store()->PersistUnsentLogs();
state_ = SENDING_LOGS;
}
void MetricsService::IncrementLongPrefsValue(const char* path) {
int64_t value = local_state_->GetInt64(path);
local_state_->SetInt64(path, value + 1);
}
bool MetricsService::UmaMetricsProperlyShutdown() {
CHECK(clean_shutdown_status_ == CLEANLY_SHUTDOWN ||
clean_shutdown_status_ == NEED_TO_SHUTDOWN);
return clean_shutdown_status_ == CLEANLY_SHUTDOWN;
}
void MetricsService::RegisterMetricsProvider(
std::unique_ptr<MetricsProvider> provider) {
DCHECK_EQ(INITIALIZED, state_);
delegating_provider_.RegisterMetricsProvider(std::move(provider));
}
void MetricsService::CheckForClonedInstall() {
state_manager_->CheckForClonedInstall();
}
std::unique_ptr<MetricsLog> MetricsService::CreateLog(
MetricsLog::LogType log_type) {
return std::make_unique<MetricsLog>(state_manager_->client_id(), session_id_,
log_type, client_);
}
std::string MetricsService::RecordCurrentEnvironmentHelper(
MetricsLog* log,
PrefService* local_state,
DelegatingProvider* delegating_provider) {
const SystemProfileProto& system_profile =
log->RecordEnvironment(delegating_provider);
EnvironmentRecorder recorder(local_state);
return recorder.SerializeAndRecordEnvironmentToPrefs(system_profile);
}
void MetricsService::RecordCurrentEnvironment(MetricsLog* log) {
DCHECK(client_);
std::string serialized_proto =
RecordCurrentEnvironmentHelper(log, local_state_, &delegating_provider_);
GlobalPersistentSystemProfile::GetInstance()->SetSystemProfile(
serialized_proto, /*complete=*/true);
client_->OnEnvironmentUpdate(&serialized_proto);
}
void MetricsService::RecordCurrentHistograms() {
DCHECK(log_manager_.current_log());
// "true" indicates that StatisticsRecorder should include histograms held in
// persistent storage.
base::StatisticsRecorder::PrepareDeltas(
true, base::Histogram::kNoFlags,
base::Histogram::kUmaTargetedHistogramFlag, &histogram_snapshot_manager_);
delegating_provider_.RecordHistogramSnapshots(&histogram_snapshot_manager_);
}
void MetricsService::RecordCurrentStabilityHistograms() {
DCHECK(log_manager_.current_log());
// "true" indicates that StatisticsRecorder should include histograms held in
// persistent storage.
base::StatisticsRecorder::PrepareDeltas(
true, base::Histogram::kNoFlags,
base::Histogram::kUmaStabilityHistogramFlag,
&histogram_snapshot_manager_);
delegating_provider_.RecordInitialHistogramSnapshots(
&histogram_snapshot_manager_);
}
bool MetricsService::PrepareProviderMetricsLog() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Create a new log. This will have some defaut values injected in it but
// those will be overwritten when an embedded profile is extracted.
std::unique_ptr<MetricsLog> log = CreateLog(MetricsLog::INDEPENDENT_LOG);
for (auto& provider : delegating_provider_.GetProviders()) {
if (log->LoadIndependentMetrics(provider.get())) {
log_manager_.PauseCurrentLog();
log_manager_.BeginLoggingWithLog(std::move(log));
log_manager_.FinishCurrentLog(log_store());
log_manager_.ResumePausedLog();
return true;
}
}
return false;
}
void MetricsService::PrepareProviderMetricsTask() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
bool found = PrepareProviderMetricsLog();
base::TimeDelta next_check = found ? base::TimeDelta::FromSeconds(5)
: base::TimeDelta::FromMinutes(15);
base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
base::BindOnce(&MetricsService::PrepareProviderMetricsTask,
self_ptr_factory_.GetWeakPtr()),
next_check);
}
void MetricsService::LogCleanShutdown(bool end_completed) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Redundant setting to assure that we always reset this value at shutdown
// (and that we don't use some alternate path, and not call LogCleanShutdown).
clean_shutdown_status_ = CLEANLY_SHUTDOWN;
client_->OnLogCleanShutdown();
state_manager_->clean_exit_beacon()->WriteBeaconValue(true);
SetExecutionPhase(ExecutionPhase::SHUTDOWN_COMPLETE, local_state_);
StabilityMetricsProvider(local_state_).MarkSessionEndCompleted(end_completed);
}
void MetricsService::UpdateLastLiveTimestampTask() {
state_manager_->clean_exit_beacon()->UpdateLastLiveTimestamp();
// Schecule the next update.
StartUpdatingLastLiveTimestamp();
}
} // namespace metrics