diff options
Diffstat (limited to 'chrome/browser/metrics/metrics_service.cc')
| -rw-r--r-- | chrome/browser/metrics/metrics_service.cc | 1755 |
1 files changed, 1755 insertions, 0 deletions
diff --git a/chrome/browser/metrics/metrics_service.cc b/chrome/browser/metrics/metrics_service.cc new file mode 100644 index 0000000..399db59 --- /dev/null +++ b/chrome/browser/metrics/metrics_service.cc @@ -0,0 +1,1755 @@ +// Copyright (c) 2006-2008 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 XML text, and compressing the results for +// transmission. Transmission includes submitting a compressed log as data in a +// URL-get, and retransmitting (or retaining at process termination) if the +// attempted transmission failed. Retention across process terminations is done +// using the the PrefServices facilities. The format for the retained +// logs (ones that never got transmitted) is always the uncompressed textual +// representation. +// +// 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 the chrome +// product (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 20 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 log 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. +// +// 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 converted to text. Note +// that memory stats are not gathered during shutdown, as gathering *might* be +// too time consuming. The textual representation of the fragment of the +// ongoing log is then stored persistently as a string in the PrefServices, 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 +// stats, based on the State enum specified in the state_ member. Those states +// are: +// +// INITIALIZED, // Constructor was called. +// PLUGIN_LIST_REQUESTED, // Waiting for plugin list to be loaded. +// PLUGIN_LIST_ARRIVED, // Waiting for timer to send initial log. +// INITIAL_LOG_READY, // Initial log generated, and waiting for reply. +// SEND_OLD_INITIAL_LOGS, // Sending unsent logs from previous session. +// SENDING_OLD_LOGS, // Sending unsent logs from previous session. +// SENDING_CURRENT_LOGS, // Sending standard current logs as they accrue. +// +// In more detail, we have: +// +// INITIALIZED, // Constructor was called. +// The MS has been constructed, but has taken no actions to compose the +// initial log. +// +// PLUGIN_LIST_REQUESTED, // Waiting for plugin list to be loaded. +// Typically about 30 seconds after startup, a task is sent to a second thread +// to get the list of plugins. That task will (when complete) make an async +// callback (via a Task) to indicate the completion. +// +// PLUGIN_LIST_ARRIVED, // 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 task is dispatched. +// +// INITIAL_LOG_READY, // Initial log generated, and waiting for reply. +// This state is entered only after an initial log has been composed, and +// prepared for transmission. It is also the case that any previously unsent +// logs have been loaded into instance variables for possible transmission. +// +// SEND_OLD_INITIAL_LOGS, // Sending unsent logs from previous session. +// This state indicates that the initial log for this session has been +// successfully sent and it is now time to send any "initial logs" that were +// saved from previous sessions. Most commonly, there are none, but all old +// logs that were "initial logs" must be sent before this state is exited. +// +// SENDING_OLD_LOGS, // Sending unsent logs from previous session. +// This state indicates that there are no more unsent initial logs, and now any +// ongoing logs from previous sessions should be transmitted. All such logs +// will be transmitted before exiting this state, and proceeding with ongoing +// logs from the current session (see next state). +// +// SENDING_CURRENT_LOGS, // Sending standard current logs as they accrue. +// Current logs are being accumulated. Typically every 20 minutes a log is +// closed and finalized for transmission, at the same time as a new log is +// started. +// +// The progression through the above states is simple, and sequential, in the +// most common use cases. States proceed from INITIAL to SENDING_CURRENT_LOGS, +// and remain in the latter until shutdown. +// +// The one unusual case is when the user asks that we stop logging. When that +// happens, any pending (transmission in progress) log is pushed into the list +// of old unsent logs (the appropriate list, depending on whether it is an +// initial log, or an ongoing log). An addition, any log that is currently +// accumulating is also finalized, and pushed into the unsent log list. With +// those pushed performed, we regress back to the SEND_OLD_INITIAL_LOGS state in +// case the user enables log recording again during this session. This way +// anything we have "pushed back" will be sent automatically if/when we progress +// back to SENDING_CURRENT_LOG state. +// +// Also note that whenever the member variables containing unsent logs are +// modified (i.e., when we send an old log), we mirror the list of logs into +// the PrefServices. 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 significantly statistical problem. +// +// +//------------------------------------------------------------------------------ + +#include <windows.h> + +#include "chrome/browser/metrics/metrics_service.h" + +#include "base/file_path.h" +#include "base/histogram.h" +#include "base/path_service.h" +#include "base/string_util.h" +#include "base/task.h" +#include "chrome/browser/bookmarks/bookmark_model.h" +#include "chrome/browser/browser.h" +#include "chrome/browser/browser_list.h" +#include "chrome/browser/browser_process.h" +#include "chrome/browser/load_notification_details.h" +#include "chrome/browser/memory_details.h" +#include "chrome/browser/plugin_process_info.h" +#include "chrome/browser/plugin_service.h" +#include "chrome/browser/profile.h" +#include "chrome/browser/render_process_host.h" +#include "chrome/browser/search_engines/template_url.h" +#include "chrome/browser/search_engines/template_url_model.h" +#include "chrome/common/chrome_paths.h" +#include "chrome/common/libxml_utils.h" +#include "chrome/common/pref_names.h" +#include "chrome/common/pref_service.h" +#include "chrome/installer/util/google_update_settings.h" +#include "googleurl/src/gurl.h" +#include "net/base/load_flags.h" +#include "third_party/bzip2/bzlib.h" + +using base::Time; +using base::TimeDelta; + +// Check to see that we're being called on only one thread. +static bool IsSingleThreaded(); + +static const char kMetricsURL[] = + "https://toolbarqueries.google.com/firefox/metrics/collect"; + +static const char kMetricsType[] = "application/vnd.mozilla.metrics.bz2"; + +// The delay, in seconds, after startup before sending the first log message. +static const int kInitialInterlogDuration = 60; // one minute + +// The default maximum number of events in a log uploaded to the UMA server. +static const int kInitialEventLimit = 2400; + +// If an upload fails, and the transmission was over this byte count, then we +// will discard the log, and not try to retransmit it. We also don't persist +// the log to the prefs for transmission during the next chrome session if this +// limit is exceeded. +static const int kUploadLogAvoidRetransmitSize = 50000; + +// When we have logs from previous Chrome sessions to send, how long should we +// delay (in seconds) between each log transmission. +static const int kUnsentLogDelay = 15; // 15 seconds + +// Minimum time a log typically exists before sending, in seconds. +// This number is supplied by the server, but until we parse it out of a server +// response, we use this duration to specify how long we should wait before +// sending the next log. If the channel is busy, such as when there is a +// failure during an attempt to transmit a previous log, then a log may wait +// (and continue to accrue now log entries) for a much greater period of time. +static const int kMinSecondsPerLog = 20 * 60; // twenty minutes + +// When we don't succeed at transmitting a log to a server, we progressively +// wait longer and longer before sending the next log. This backoff process +// help reduce load on the server, and makes the amount of backoff vary between +// clients so that a collision (server overload?) on retransmit is less likely. +// The following is the constant we use to expand that inter-log duration. +static const double kBackoff = 1.1; +// We limit the maximum backoff to be no greater than some multiple of the +// default kMinSecondsPerLog. The following is that maximum ratio. +static const int kMaxBackoff = 10; + +// Interval, in seconds, between state saves. +static const int kSaveStateInterval = 5 * 60; // five minutes + +// The number of "initial" logs we're willing to save, and hope to send during +// a future Chrome session. Initial logs contain crash stats, and are pretty +// small. +static const size_t kMaxInitialLogsPersisted = 20; + +// The number of ongoing logs we're willing to save persistently, and hope to +// send during a this or future sessions. Note that each log will be pretty +// large, as presumably the related "initial" log wasn't sent (probably nothing +// was, as the user was probably off-line). As a result, the log probably kept +// accumulating while the "initial" log was stalled (pending_), and couldn't be +// sent. As a result, we don't want to save too many of these mega-logs. +// A "standard shutdown" will create a small log, including just the data that +// was not yet been transmitted, and that is normal (to have exactly one +// ongoing_log_ at startup). +static const size_t kMaxOngoingLogsPersisted = 4; + + +// Handles asynchronous fetching of memory details. +// Will run the provided task after finished. +class MetricsMemoryDetails : public MemoryDetails { + public: + explicit MetricsMemoryDetails(Task* completion) : completion_(completion) {} + + virtual void OnDetailsAvailable() { + MessageLoop::current()->PostTask(FROM_HERE, completion_); + } + + private: + Task* completion_; + DISALLOW_EVIL_CONSTRUCTORS(MetricsMemoryDetails); +}; + +class MetricsService::GetPluginListTaskComplete : public Task { + virtual void Run() { + g_browser_process->metrics_service()->OnGetPluginListTaskComplete(); + } +}; + +class MetricsService::GetPluginListTask : public Task { + public: + explicit GetPluginListTask(MessageLoop* callback_loop) + : callback_loop_(callback_loop) {} + + virtual void Run() { + std::vector<WebPluginInfo> plugins; + PluginService::GetInstance()->GetPlugins(false, &plugins); + + callback_loop_->PostTask(FROM_HERE, new GetPluginListTaskComplete()); + } + + private: + MessageLoop* callback_loop_; +}; + +// static +void MetricsService::RegisterPrefs(PrefService* local_state) { + DCHECK(IsSingleThreaded()); + local_state->RegisterStringPref(prefs::kMetricsClientID, L""); + local_state->RegisterStringPref(prefs::kMetricsClientIDTimestamp, L"0"); + local_state->RegisterStringPref(prefs::kStabilityLaunchTimeSec, L"0"); + local_state->RegisterStringPref(prefs::kStabilityLastTimestampSec, L"0"); + local_state->RegisterStringPref(prefs::kStabilityUptimeSec, L"0"); + local_state->RegisterBooleanPref(prefs::kStabilityExitedCleanly, true); + local_state->RegisterBooleanPref(prefs::kStabilitySessionEndCompleted, true); + local_state->RegisterIntegerPref(prefs::kMetricsSessionID, -1); + local_state->RegisterIntegerPref(prefs::kStabilityLaunchCount, 0); + local_state->RegisterIntegerPref(prefs::kStabilityCrashCount, 0); + local_state->RegisterIntegerPref(prefs::kStabilityIncompleteSessionEndCount, + 0); + local_state->RegisterIntegerPref(prefs::kStabilityPageLoadCount, 0); + local_state->RegisterIntegerPref(prefs::kSecurityRendererOnSboxDesktop, 0); + local_state->RegisterIntegerPref(prefs::kSecurityRendererOnDefaultDesktop, 0); + local_state->RegisterIntegerPref(prefs::kStabilityRendererCrashCount, 0); + local_state->RegisterIntegerPref(prefs::kStabilityRendererHangCount, 0); + local_state->RegisterIntegerPref(prefs::kStabilityBreakpadRegistrationFail, + 0); + local_state->RegisterIntegerPref(prefs::kStabilityBreakpadRegistrationSuccess, + 0); + local_state->RegisterIntegerPref(prefs::kStabilityDebuggerPresent, 0); + local_state->RegisterIntegerPref(prefs::kStabilityDebuggerNotPresent, 0); + + local_state->RegisterDictionaryPref(prefs::kProfileMetrics); + local_state->RegisterIntegerPref(prefs::kNumBookmarksOnBookmarkBar, 0); + local_state->RegisterIntegerPref(prefs::kNumFoldersOnBookmarkBar, 0); + local_state->RegisterIntegerPref(prefs::kNumBookmarksInOtherBookmarkFolder, + 0); + local_state->RegisterIntegerPref(prefs::kNumFoldersInOtherBookmarkFolder, 0); + local_state->RegisterIntegerPref(prefs::kNumKeywords, 0); + local_state->RegisterListPref(prefs::kMetricsInitialLogs); + local_state->RegisterListPref(prefs::kMetricsOngoingLogs); +} + +MetricsService::MetricsService() + : recording_active_(false), + reporting_active_(false), + user_permits_upload_(false), + server_permits_upload_(true), + state_(INITIALIZED), + pending_log_(NULL), + pending_log_text_(""), + current_fetch_(NULL), + current_log_(NULL), + idle_since_last_transmission_(false), + next_window_id_(0), + log_sender_factory_(this), + state_saver_factory_(this), + logged_samples_(), + interlog_duration_(TimeDelta::FromSeconds(kInitialInterlogDuration)), + log_event_limit_(kInitialEventLimit), + timer_pending_(false) { + DCHECK(IsSingleThreaded()); + InitializeMetricsState(); +} + +MetricsService::~MetricsService() { + SetRecording(false); +} + +void MetricsService::SetUserPermitsUpload(bool enabled) { + HandleIdleSinceLastTransmission(false); + user_permits_upload_ = enabled; +} + +void MetricsService::Start() { + SetRecording(true); + SetReporting(true); +} + +void MetricsService::StartRecordingOnly() { + SetRecording(true); + SetReporting(false); +} + +void MetricsService::Stop() { + SetReporting(false); + SetRecording(false); +} + +void MetricsService::SetRecording(bool enabled) { + DCHECK(IsSingleThreaded()); + + if (enabled == recording_active_) + return; + + if (enabled) { + StartRecording(); + ListenerRegistration(true); + } else { + // Turn off all observers. + ListenerRegistration(false); + PushPendingLogsToUnsentLists(); + DCHECK(!pending_log()); + if (state_ > INITIAL_LOG_READY && unsent_logs()) + state_ = SEND_OLD_INITIAL_LOGS; + } + recording_active_ = enabled; +} + +bool MetricsService::recording_active() const { + DCHECK(IsSingleThreaded()); + return recording_active_; +} + +void MetricsService::SetReporting(bool enable) { + if (reporting_active_ != enable) { + reporting_active_ = enable; + if (reporting_active_) + StartLogTransmissionTimer(); + } +} + +bool MetricsService::reporting_active() const { + DCHECK(IsSingleThreaded()); + return reporting_active_; +} + +void MetricsService::Observe(NotificationType type, + const NotificationSource& source, + const NotificationDetails& details) { + DCHECK(current_log_); + DCHECK(IsSingleThreaded()); + + if (!CanLogNotification(type, source, details)) + return; + + switch (type) { + case NOTIFY_USER_ACTION: + current_log_->RecordUserAction(*Details<const wchar_t*>(details).ptr()); + break; + + case NOTIFY_BROWSER_OPENED: + case NOTIFY_BROWSER_CLOSED: + LogWindowChange(type, source, details); + break; + + case NOTIFY_TAB_PARENTED: + case NOTIFY_TAB_CLOSING: + LogWindowChange(type, source, details); + break; + + case NOTIFY_LOAD_STOP: + LogLoadComplete(type, source, details); + break; + + case NOTIFY_LOAD_START: + LogLoadStarted(); + break; + + case NOTIFY_RENDERER_PROCESS_TERMINATED: + if (!*Details<bool>(details).ptr()) + LogRendererCrash(); + break; + + case NOTIFY_RENDERER_PROCESS_HANG: + LogRendererHang(); + break; + + case NOTIFY_RENDERER_PROCESS_IN_SBOX: + LogRendererInSandbox(*Details<bool>(details).ptr()); + break; + + case NOTIFY_PLUGIN_PROCESS_HOST_CONNECTED: + case NOTIFY_PLUGIN_PROCESS_CRASHED: + case NOTIFY_PLUGIN_INSTANCE_CREATED: + LogPluginChange(type, source, details); + break; + + case TEMPLATE_URL_MODEL_LOADED: + LogKeywords(Source<TemplateURLModel>(source).ptr()); + break; + + case NOTIFY_OMNIBOX_OPENED_URL: + current_log_->RecordOmniboxOpenedURL( + *Details<AutocompleteLog>(details).ptr()); + break; + + case NOTIFY_BOOKMARK_MODEL_LOADED: + LogBookmarks(Source<Profile>(source)->GetBookmarkModel()); + break; + + default: + NOTREACHED(); + break; + } + + HandleIdleSinceLastTransmission(false); + + if (current_log_) + DLOG(INFO) << "METRICS: NUMBER OF LOGS = " << current_log_->num_events(); +} + +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_) + StartLogTransmissionTimer(); + idle_since_last_transmission_ = in_idle; +} + +void MetricsService::RecordCleanShutdown() { + RecordBooleanPrefValue(prefs::kStabilityExitedCleanly, true); +} + +void MetricsService::RecordStartOfSessionEnd() { + RecordBooleanPrefValue(prefs::kStabilitySessionEndCompleted, false); +} + +void MetricsService::RecordCompletedSessionEnd() { + RecordBooleanPrefValue(prefs::kStabilitySessionEndCompleted, true); +} + +void MetricsService:: RecordBreakpadRegistration(bool success) { + if (!success) + IncrementPrefValue(prefs::kStabilityBreakpadRegistrationFail); + else + IncrementPrefValue(prefs::kStabilityBreakpadRegistrationSuccess); +} + +void MetricsService::RecordBreakpadHasDebugger(bool has_debugger) { + if (!has_debugger) + IncrementPrefValue(prefs::kStabilityDebuggerNotPresent); + else + IncrementPrefValue(prefs::kStabilityDebuggerPresent); +} + +//------------------------------------------------------------------------------ +// private methods +//------------------------------------------------------------------------------ + + +//------------------------------------------------------------------------------ +// Initialization methods + +void MetricsService::InitializeMetricsState() { + PrefService* pref = g_browser_process->local_state(); + DCHECK(pref); + + client_id_ = WideToUTF8(pref->GetString(prefs::kMetricsClientID)); + if (client_id_.empty()) { + client_id_ = GenerateClientID(); + pref->SetString(prefs::kMetricsClientID, UTF8ToWide(client_id_)); + + // Might as well make a note of how long this ID has existed + pref->SetString(prefs::kMetricsClientIDTimestamp, + Int64ToWString(Time::Now().ToTimeT())); + } + + // Update session ID + session_id_ = pref->GetInteger(prefs::kMetricsSessionID); + ++session_id_; + pref->SetInteger(prefs::kMetricsSessionID, session_id_); + + // Stability bookkeeping + IncrementPrefValue(prefs::kStabilityLaunchCount); + + if (!pref->GetBoolean(prefs::kStabilityExitedCleanly)) { + IncrementPrefValue(prefs::kStabilityCrashCount); + } + + // This will be set to 'true' if we exit cleanly. + pref->SetBoolean(prefs::kStabilityExitedCleanly, false); + + if (!pref->GetBoolean(prefs::kStabilitySessionEndCompleted)) { + IncrementPrefValue(prefs::kStabilityIncompleteSessionEndCount); + } + // This is marked false when we get a WM_ENDSESSION. + pref->SetBoolean(prefs::kStabilitySessionEndCompleted, true); + + int64 last_start_time = + StringToInt64(pref->GetString(prefs::kStabilityLaunchTimeSec)); + int64 last_end_time = + StringToInt64(pref->GetString(prefs::kStabilityLastTimestampSec)); + int64 uptime = + StringToInt64(pref->GetString(prefs::kStabilityUptimeSec)); + + if (last_start_time && last_end_time) { + // TODO(JAR): Exclude sleep time. ... which must be gathered in UI loop. + uptime += last_end_time - last_start_time; + pref->SetString(prefs::kStabilityUptimeSec, Int64ToWString(uptime)); + } + pref->SetString(prefs::kStabilityLaunchTimeSec, + Int64ToWString(Time::Now().ToTimeT())); + + // Save profile metrics. + PrefService* prefs = g_browser_process->local_state(); + if (prefs) { + // Remove the current dictionary and store it for use when sending data to + // server. By removing the value we prune potentially dead profiles + // (and keys). All valid values are added back once services startup. + const DictionaryValue* profile_dictionary = + prefs->GetDictionary(prefs::kProfileMetrics); + if (profile_dictionary) { + // Do a deep copy of profile_dictionary since ClearPref will delete it. + profile_dictionary_.reset(static_cast<DictionaryValue*>( + profile_dictionary->DeepCopy())); + prefs->ClearPref(prefs::kProfileMetrics); + } + } + + // Kick off the process of saving the state (so the uptime numbers keep + // getting updated) every n minutes. + ScheduleNextStateSave(); +} + +void MetricsService::OnGetPluginListTaskComplete() { + DCHECK(state_ == PLUGIN_LIST_REQUESTED); + if (state_ == PLUGIN_LIST_REQUESTED) + state_ = PLUGIN_LIST_ARRIVED; +} + +std::string MetricsService::GenerateClientID() { + const int kGUIDSize = 39; + + GUID guid; + HRESULT guid_result = CoCreateGuid(&guid); + DCHECK(SUCCEEDED(guid_result)); + + std::wstring guid_string; + int result = StringFromGUID2(guid, + WriteInto(&guid_string, kGUIDSize), kGUIDSize); + DCHECK(result == kGUIDSize); + + return WideToUTF8(guid_string.substr(1, guid_string.length() - 2)); +} + + +//------------------------------------------------------------------------------ +// State save methods + +void MetricsService::ScheduleNextStateSave() { + state_saver_factory_.RevokeAll(); + + MessageLoop::current()->PostDelayedTask(FROM_HERE, + state_saver_factory_.NewRunnableMethod(&MetricsService::SaveLocalState), + kSaveStateInterval * 1000); +} + +void MetricsService::SaveLocalState() { + PrefService* pref = g_browser_process->local_state(); + if (!pref) { + NOTREACHED(); + return; + } + + RecordCurrentState(pref); + pref->ScheduleSavePersistentPrefs(g_browser_process->file_thread()); + + ScheduleNextStateSave(); +} + + +//------------------------------------------------------------------------------ +// Recording control methods + +void MetricsService::StartRecording() { + if (current_log_) + return; + + current_log_ = new MetricsLog(client_id_, session_id_); + if (state_ == INITIALIZED) { + // We only need to schedule that run once. + state_ = PLUGIN_LIST_REQUESTED; + + // Make sure the plugin list is loaded before the inital log is sent, so + // that the main thread isn't blocked generating the list. + g_browser_process->file_thread()->message_loop()->PostDelayedTask(FROM_HERE, + new GetPluginListTask(MessageLoop::current()), + kInitialInterlogDuration * 1000 / 2); + } +} + +void MetricsService::StopRecording(MetricsLog** log) { + if (!current_log_) + return; + + // TODO(jar): Integrate bounds on log recording more consistently, so that we + // can stop recording logs that are too big much sooner. + if (current_log_->num_events() > log_event_limit_) { + UMA_HISTOGRAM_COUNTS(L"UMA.Discarded Log Events", + current_log_->num_events()); + current_log_->CloseLog(); + delete current_log_; + current_log_ = NULL; + StartRecording(); // Start trivial log to hold our histograms. + } + + // Put incremental data (histogram deltas, and realtime stats deltas) at the + // end of all log transmissions (initial log handles this separately). + // Don't bother if we're going to discard current_log_. + if (log) { + current_log_->RecordIncrementalStabilityElements(); + RecordCurrentHistograms(); + } + + current_log_->CloseLog(); + if (log) + *log = current_log_; + else + delete current_log_; + current_log_ = NULL; +} + +void MetricsService::ListenerRegistration(bool start_listening) { + AddOrRemoveObserver(this, NOTIFY_BROWSER_OPENED, start_listening); + AddOrRemoveObserver(this, NOTIFY_BROWSER_CLOSED, start_listening); + AddOrRemoveObserver(this, NOTIFY_USER_ACTION, start_listening); + AddOrRemoveObserver(this, NOTIFY_TAB_PARENTED, start_listening); + AddOrRemoveObserver(this, NOTIFY_TAB_CLOSING, start_listening); + AddOrRemoveObserver(this, NOTIFY_LOAD_START, start_listening); + AddOrRemoveObserver(this, NOTIFY_LOAD_STOP, start_listening); + AddOrRemoveObserver(this, NOTIFY_RENDERER_PROCESS_IN_SBOX, start_listening); + AddOrRemoveObserver(this, NOTIFY_RENDERER_PROCESS_TERMINATED, + start_listening); + AddOrRemoveObserver(this, NOTIFY_RENDERER_PROCESS_HANG, start_listening); + AddOrRemoveObserver(this, NOTIFY_PLUGIN_PROCESS_HOST_CONNECTED, + start_listening); + AddOrRemoveObserver(this, NOTIFY_PLUGIN_INSTANCE_CREATED, start_listening); + AddOrRemoveObserver(this, NOTIFY_PLUGIN_PROCESS_CRASHED, start_listening); + AddOrRemoveObserver(this, TEMPLATE_URL_MODEL_LOADED, start_listening); + AddOrRemoveObserver(this, NOTIFY_OMNIBOX_OPENED_URL, start_listening); + AddOrRemoveObserver(this, NOTIFY_BOOKMARK_MODEL_LOADED, start_listening); +} + +// static +void MetricsService::AddOrRemoveObserver(NotificationObserver* observer, + NotificationType type, + bool is_add) { + NotificationService* service = NotificationService::current(); + + if (is_add) + service->AddObserver(observer, type, NotificationService::AllSources()); + else + service->RemoveObserver(observer, type, NotificationService::AllSources()); +} + +void MetricsService::PushPendingLogsToUnsentLists() { + if (state_ < INITIAL_LOG_READY) + return; // We didn't and still don't have time to get plugin list etc. + + if (pending_log()) { + PreparePendingLogText(); + if (state_ == INITIAL_LOG_READY) { + // We may race here, and send second copy of initial log later. + unsent_initial_logs_.push_back(pending_log_text_); + state_ = SEND_OLD_INITIAL_LOGS; + } else { + PushPendingLogTextToUnsentOngoingLogs(); + } + DiscardPendingLog(); + } + DCHECK(!pending_log()); + StopRecording(&pending_log_); + PreparePendingLogText(); + PushPendingLogTextToUnsentOngoingLogs(); + DiscardPendingLog(); + StoreUnsentLogs(); +} + +void MetricsService::PushPendingLogTextToUnsentOngoingLogs() { + // If UMA response told us not to upload, there's no need to save the pending + // log. It wasn't supposed to be uploaded anyway. + if (!server_permits_upload_) + return; + + if (pending_log_text_.length() > kUploadLogAvoidRetransmitSize) { + UMA_HISTOGRAM_COUNTS(L"UMA.Large Accumulated Log Not Persisted", + static_cast<int>(pending_log_text_.length())); + return; + } + unsent_ongoing_logs_.push_back(pending_log_text_); +} + +//------------------------------------------------------------------------------ +// Transmission of logs methods + +void MetricsService::StartLogTransmissionTimer() { + // If we're not reporting, there's no point in starting a log transmission + // timer. + if (!reporting_active()) + return; + + if (!current_log_) + return; // Recorder is shutdown. + + // If there is already a timer running, we leave it running. + // If timer_pending is true because the fetch is waiting for a response, + // we return for now and let the response handler start the timer. + if (timer_pending_) + return; + + // Before starting the timer, set timer_pending_ to true. + timer_pending_ = true; + + // Right before the UMA transmission gets started, there's one more thing we'd + // like to record: the histogram of memory usage, so we spawn a task to + // collect the memory details and when that task is finished, we arrange for + // TryToStartTransmission to take over. + MessageLoop::current()->PostDelayedTask(FROM_HERE, + log_sender_factory_. + NewRunnableMethod(&MetricsService::CollectMemoryDetails), + static_cast<int>(interlog_duration_.InMilliseconds())); +} + +void MetricsService::TryToStartTransmission() { + DCHECK(IsSingleThreaded()); + + // This function should only be called via timer, so timer_pending_ + // should be true. + DCHECK(timer_pending_); + timer_pending_ = false; + + DCHECK(!current_fetch_.get()); + + // 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 + // don't restart the transmission timer. + if (idle_since_last_transmission_) + return; + + // If somehow there is a fetch in progress, we return setting timer_pending_ + // to true and hope things work out. + if (current_fetch_.get()) { + timer_pending_ = true; + return; + } + + // If uploads are forbidden by UMA response, there's no point in keeping + // the current_log_, and the more often we delete it, the less likely it is + // to expand forever. + if (!server_permits_upload_ && current_log_) { + StopRecording(NULL); + StartRecording(); + } + + if (!current_log_) + return; // Logging was disabled. + if (!reporting_active()) + return; // Don't do work if we're not going to send anything now. + + MakePendingLog(); + + // MakePendingLog should have put something in the pending log, if it didn't, + // we start the timer again, return and hope things work out. + if (!pending_log()) { + StartLogTransmissionTimer(); + return; + } + + // If we're not supposed to upload any UMA data because the response or the + // user said so, cancel the upload at this point, but start the timer. + if (!TransmissionPermitted()) { + DiscardPendingLog(); + StartLogTransmissionTimer(); + return; + } + + PrepareFetchWithPendingLog(); + + if (!current_fetch_.get()) { + // Compression failed, and log discarded :-/. + DiscardPendingLog(); + StartLogTransmissionTimer(); // Maybe we'll do better next time + // TODO(jar): If compression failed, we should have created a tiny log and + // compressed that, so that we can signal that we're losing logs. + return; + } + + DCHECK(!timer_pending_); + + // The URL fetch is a like timer in that after a while we get called back + // so we set timer_pending_ true just as we start the url fetch. + timer_pending_ = true; + current_fetch_->Start(); + + HandleIdleSinceLastTransmission(true); +} + + +void MetricsService::MakePendingLog() { + if (pending_log()) + return; + + switch (state_) { + case INITIALIZED: + case PLUGIN_LIST_REQUESTED: // We should be further along by now. + DCHECK(false); + return; + + case PLUGIN_LIST_ARRIVED: + // We need to wait for the initial log to be ready before sending + // anything, because the server will tell us whether it wants to hear + // from us. + PrepareInitialLog(); + DCHECK(state_ == PLUGIN_LIST_ARRIVED); + RecallUnsentLogs(); + state_ = INITIAL_LOG_READY; + break; + + case SEND_OLD_INITIAL_LOGS: + if (!unsent_initial_logs_.empty()) { + pending_log_text_ = unsent_initial_logs_.back(); + break; + } + state_ = SENDING_OLD_LOGS; + // Fall through. + + case SENDING_OLD_LOGS: + if (!unsent_ongoing_logs_.empty()) { + pending_log_text_ = unsent_ongoing_logs_.back(); + break; + } + state_ = SENDING_CURRENT_LOGS; + // Fall through. + + case SENDING_CURRENT_LOGS: + StopRecording(&pending_log_); + StartRecording(); + break; + + default: + DCHECK(false); + return; + } + + DCHECK(pending_log()); +} + +bool MetricsService::TransmissionPermitted() const { + // If the user forbids uploading that's they're business, and we don't upload + // anything. If the server forbids uploading, that's our business, so we take + // that to mean it forbids current logs, but we still send up the inital logs + // and any old logs. + if (!user_permits_upload_) + return false; + if (server_permits_upload_) + return true; + + switch (state_) { + case INITIAL_LOG_READY: + case SEND_OLD_INITIAL_LOGS: + case SENDING_OLD_LOGS: + return true; + + case SENDING_CURRENT_LOGS: + default: + return false; + } +} + +void MetricsService::CollectMemoryDetails() { + Task* task = log_sender_factory_. + NewRunnableMethod(&MetricsService::TryToStartTransmission); + MetricsMemoryDetails* details = new MetricsMemoryDetails(task); + details->StartFetch(); + + // Collect WebCore cache information to put into a histogram. + for (RenderProcessHost::iterator it = RenderProcessHost::begin(); + it != RenderProcessHost::end(); ++it) { + it->second->Send(new ViewMsg_GetCacheResourceStats()); + } +} + +void MetricsService::PrepareInitialLog() { + DCHECK(state_ == PLUGIN_LIST_ARRIVED); + std::vector<WebPluginInfo> plugins; + PluginService::GetInstance()->GetPlugins(false, &plugins); + + MetricsLog* log = new MetricsLog(client_id_, session_id_); + log->RecordEnvironment(plugins, profile_dictionary_.get()); + + // Histograms only get written to current_log_, so setup for the write. + MetricsLog* save_log = current_log_; + current_log_ = log; + RecordCurrentHistograms(); // Into current_log_... which is really log. + current_log_ = save_log; + + log->CloseLog(); + DCHECK(!pending_log()); + pending_log_ = log; +} + +void MetricsService::RecallUnsentLogs() { + DCHECK(unsent_initial_logs_.empty()); + DCHECK(unsent_ongoing_logs_.empty()); + + PrefService* local_state = g_browser_process->local_state(); + DCHECK(local_state); + + ListValue* unsent_initial_logs = local_state->GetMutableList( + prefs::kMetricsInitialLogs); + for (ListValue::iterator it = unsent_initial_logs->begin(); + it != unsent_initial_logs->end(); ++it) { + std::string log; + (*it)->GetAsString(&log); + unsent_initial_logs_.push_back(log); + } + + ListValue* unsent_ongoing_logs = local_state->GetMutableList( + prefs::kMetricsOngoingLogs); + for (ListValue::iterator it = unsent_ongoing_logs->begin(); + it != unsent_ongoing_logs->end(); ++it) { + std::string log; + (*it)->GetAsString(&log); + unsent_ongoing_logs_.push_back(log); + } +} + +void MetricsService::StoreUnsentLogs() { + if (state_ < INITIAL_LOG_READY) + return; // We never Recalled the prior unsent logs. + + PrefService* local_state = g_browser_process->local_state(); + DCHECK(local_state); + + ListValue* unsent_initial_logs = local_state->GetMutableList( + prefs::kMetricsInitialLogs); + unsent_initial_logs->Clear(); + size_t start = 0; + if (unsent_initial_logs_.size() > kMaxInitialLogsPersisted) + start = unsent_initial_logs_.size() - kMaxInitialLogsPersisted; + for (size_t i = start; i < unsent_initial_logs_.size(); ++i) + unsent_initial_logs->Append( + Value::CreateStringValue(unsent_initial_logs_[i])); + + ListValue* unsent_ongoing_logs = local_state->GetMutableList( + prefs::kMetricsOngoingLogs); + unsent_ongoing_logs->Clear(); + start = 0; + if (unsent_ongoing_logs_.size() > kMaxOngoingLogsPersisted) + start = unsent_ongoing_logs_.size() - kMaxOngoingLogsPersisted; + for (size_t i = start; i < unsent_ongoing_logs_.size(); ++i) + unsent_ongoing_logs->Append( + Value::CreateStringValue(unsent_ongoing_logs_[i])); +} + +void MetricsService::PreparePendingLogText() { + DCHECK(pending_log()); + if (!pending_log_text_.empty()) + return; + int original_size = pending_log_->GetEncodedLogSize(); + pending_log_->GetEncodedLog(WriteInto(&pending_log_text_, original_size), + original_size); +} + +void MetricsService::PrepareFetchWithPendingLog() { + DCHECK(pending_log()); + DCHECK(!current_fetch_.get()); + PreparePendingLogText(); + DCHECK(!pending_log_text_.empty()); + + // Allow security conscious users to see all metrics logs that we send. + LOG(INFO) << "METRICS LOG: " << pending_log_text_; + + std::string compressed_log; + if (!Bzip2Compress(pending_log_text_, &compressed_log)) { + NOTREACHED() << "Failed to compress log for transmission."; + DiscardPendingLog(); + StartLogTransmissionTimer(); // Maybe we'll do better on next log :-/. + return; + } + + current_fetch_.reset(new URLFetcher(GURL(kMetricsURL), URLFetcher::POST, + this)); + current_fetch_->set_request_context(Profile::GetDefaultRequestContext()); + current_fetch_->set_upload_data(kMetricsType, compressed_log); + // This flag works around the cert mismatch on toolbarqueries.google.com. + current_fetch_->set_load_flags(net::LOAD_IGNORE_CERT_COMMON_NAME_INVALID); +} + +void MetricsService::DiscardPendingLog() { + if (pending_log_) { // Shutdown might have deleted it! + delete pending_log_; + pending_log_ = NULL; + } + pending_log_text_.clear(); +} + +// This implementation is based on the Firefox MetricsService implementation. +bool MetricsService::Bzip2Compress(const std::string& input, + std::string* output) { + bz_stream stream = {0}; + // As long as our input is smaller than the bzip2 block size, we should get + // the best compression. For example, if your input was 250k, using a block + // size of 300k or 500k should result in the same compression ratio. Since + // our data should be under 100k, using the minimum block size of 100k should + // allocate less temporary memory, but result in the same compression ratio. + int result = BZ2_bzCompressInit(&stream, + 1, // 100k (min) block size + 0, // quiet + 0); // default "work factor" + if (result != BZ_OK) { // out of memory? + return false; + } + + output->clear(); + + stream.next_in = const_cast<char*>(input.data()); + stream.avail_in = static_cast<int>(input.size()); + // NOTE: we don't need a BZ_RUN phase since our input buffer contains + // the entire input + do { + output->resize(output->size() + 1024); + stream.next_out = &((*output)[stream.total_out_lo32]); + stream.avail_out = static_cast<int>(output->size()) - stream.total_out_lo32; + result = BZ2_bzCompress(&stream, BZ_FINISH); + } while (result == BZ_FINISH_OK); + if (result != BZ_STREAM_END) // unknown failure? + return false; + result = BZ2_bzCompressEnd(&stream); + DCHECK(result == BZ_OK); + + output->resize(stream.total_out_lo32); + + return true; +} + +static const char* StatusToString(const URLRequestStatus& status) { + switch (status.status()) { + case URLRequestStatus::SUCCESS: + return "SUCCESS"; + + case URLRequestStatus::IO_PENDING: + return "IO_PENDING"; + + case URLRequestStatus::HANDLED_EXTERNALLY: + return "HANDLED_EXTERNALLY"; + + case URLRequestStatus::CANCELED: + return "CANCELED"; + + case URLRequestStatus::FAILED: + return "FAILED"; + + default: + NOTREACHED(); + return "Unknown"; + } +} + +void MetricsService::OnURLFetchComplete(const URLFetcher* source, + const GURL& url, + const URLRequestStatus& status, + int response_code, + const ResponseCookies& cookies, + const std::string& data) { + DCHECK(timer_pending_); + timer_pending_ = false; + DCHECK(current_fetch_.get()); + current_fetch_.reset(NULL); // We're not allowed to re-use it. + + // Confirm send so that we can move on. + DLOG(INFO) << "METRICS RESPONSE CODE: " << response_code << " status=" << + StatusToString(status); + + // TODO(petersont): Refactor or remove the following so that we don't have to + // fake a valid response code. + if (response_code != 200 && + pending_log_text_.length() > kUploadLogAvoidRetransmitSize) { + UMA_HISTOGRAM_COUNTS(L"UMA.Large Rejected Log was Discarded", + static_cast<int>(pending_log_text_.length())); + response_code = 200; // Simulate transmission so we will discard log. + } + + if (response_code != 200) { + HandleBadResponseCode(); + } else { // Success. + DLOG(INFO) << "METRICS RESPONSE DATA: " << data; + switch (state_) { + case INITIAL_LOG_READY: + state_ = SEND_OLD_INITIAL_LOGS; + break; + + case SEND_OLD_INITIAL_LOGS: + DCHECK(!unsent_initial_logs_.empty()); + unsent_initial_logs_.pop_back(); + StoreUnsentLogs(); + break; + + case SENDING_OLD_LOGS: + DCHECK(!unsent_ongoing_logs_.empty()); + unsent_ongoing_logs_.pop_back(); + StoreUnsentLogs(); + break; + + case SENDING_CURRENT_LOGS: + break; + + default: + DCHECK(false); + break; + } + + DiscardPendingLog(); + // Since we sent a log, make sure our in-memory state is recorded to disk. + PrefService* local_state = g_browser_process->local_state(); + DCHECK(local_state); + if (local_state) + local_state->ScheduleSavePersistentPrefs( + g_browser_process->file_thread()); + + // Provide a default (free of exponetial backoff, other varances) in case + // the server does not specify a value. + interlog_duration_ = TimeDelta::FromSeconds(kMinSecondsPerLog); + + GetSettingsFromResponseData(data); + // Override server specified interlog delay if there are unsent logs to + // transmit. + if (unsent_logs()) { + DCHECK(state_ < SENDING_CURRENT_LOGS); + interlog_duration_ = TimeDelta::FromSeconds(kUnsentLogDelay); + } + } + + StartLogTransmissionTimer(); +} + +void MetricsService::HandleBadResponseCode() { + DLOG(INFO) << "METRICS: transmission attempt returned a failure code. " + "Verify network connectivity"; +#ifndef NDEBUG + DLOG(INFO) << "Verify your metrics logs are formatted correctly. " + "Verify server is active at " << kMetricsURL; +#endif + if (!pending_log()) { + DLOG(INFO) << "METRICS: Recorder shutdown during log transmission."; + } else { + // Send progressively less frequently. + DCHECK(kBackoff > 1.0); + interlog_duration_ = TimeDelta::FromMicroseconds( + static_cast<int64>(kBackoff * interlog_duration_.InMicroseconds())); + + if (kMaxBackoff * TimeDelta::FromSeconds(kMinSecondsPerLog) < + interlog_duration_) { + interlog_duration_ = kMaxBackoff * + TimeDelta::FromSeconds(kMinSecondsPerLog); + } + + DLOG(INFO) << "METRICS: transmission retry being scheduled in " << + interlog_duration_.InSeconds() << " seconds for " << + pending_log_text_; + } +} + +void MetricsService::GetSettingsFromResponseData(const std::string& data) { + // We assume that the file is structured as a block opened by <response> + // and that inside response, there is a block opened by tag <chrome_config> + // other tags are ignored for now except the content of <chrome_config>. + DLOG(INFO) << "METRICS: getting settings from response data: " << data; + + int data_size = static_cast<int>(data.size()); + if (data_size < 0) { + DLOG(INFO) << "METRICS: server response data bad size: " << data_size << + "; aborting extraction of settings"; + return; + } + xmlDocPtr doc = xmlReadMemory(data.c_str(), data_size, "", NULL, 0); + DCHECK(doc); + // If the document is malformed, we just use the settings that were there. + if (!doc) { + DLOG(INFO) << "METRICS: reading xml from server response data failed"; + return; + } + + xmlNodePtr top_node = xmlDocGetRootElement(doc), chrome_config_node = NULL; + // Here, we find the chrome_config node by name. + for (xmlNodePtr p = top_node->children; p; p = p->next) { + if (xmlStrEqual(p->name, BAD_CAST "chrome_config")) { + chrome_config_node = p; + break; + } + } + // If the server data is formatted wrong and there is no + // config node where we expect, we just drop out. + if (chrome_config_node != NULL) + GetSettingsFromChromeConfigNode(chrome_config_node); + xmlFreeDoc(doc); +} + +void MetricsService::GetSettingsFromChromeConfigNode( + xmlNodePtr chrome_config_node) { + // Iterate through all children of the config node. + for (xmlNodePtr current_node = chrome_config_node->children; + current_node; + current_node = current_node->next) { + // If we find the upload tag, we appeal to another function + // GetSettingsFromUploadNode to read all the data in it. + if (xmlStrEqual(current_node->name, BAD_CAST "upload")) { + GetSettingsFromUploadNode(current_node); + continue; + } + } +} + +void MetricsService::InheritedProperties::OverwriteWhereNeeded( + xmlNodePtr node) { + xmlChar* salt_value = xmlGetProp(node, BAD_CAST "salt"); + if (salt_value) // If the property isn't there, xmlGetProp returns NULL. + salt = atoi(reinterpret_cast<char*>(salt_value)); + // If the property isn't there, we keep the value the property had before + + xmlChar* denominator_value = xmlGetProp(node, BAD_CAST "denominator"); + if (denominator_value) + denominator = atoi(reinterpret_cast<char*>(denominator_value)); +} + +void MetricsService::GetSettingsFromUploadNode(xmlNodePtr upload_node) { + InheritedProperties props; + GetSettingsFromUploadNodeRecursive(upload_node, props, "", true); +} + +void MetricsService::GetSettingsFromUploadNodeRecursive( + xmlNodePtr node, + InheritedProperties props, + std::string path_prefix, + bool uploadOn) { + props.OverwriteWhereNeeded(node); + + // The bool uploadOn is set to true if the data represented by current + // node should be uploaded. This gets inherited in the tree; the children + // of a node that has already been rejected for upload get rejected for + // upload. + uploadOn = uploadOn && NodeProbabilityTest(node, props); + + // The path is a / separated list of the node names ancestral to the current + // one. So, if you want to check if the current node has a certain name, + // compare to name. If you want to check if it is a certan tag at a certain + // place in the tree, compare to the whole path. + std::string name = std::string(reinterpret_cast<const char*>(node->name)); + std::string path = path_prefix + "/" + name; + + if (path == "/upload") { + xmlChar* upload_interval_val = xmlGetProp(node, BAD_CAST "interval"); + if (upload_interval_val) { + interlog_duration_ = TimeDelta::FromSeconds( + atoi(reinterpret_cast<char*>(upload_interval_val))); + } + + server_permits_upload_ = uploadOn; + } + if (path == "/upload/logs") { + xmlChar* log_event_limit_val = xmlGetProp(node, BAD_CAST "event_limit"); + if (log_event_limit_val) + log_event_limit_ = atoi(reinterpret_cast<char*>(log_event_limit_val)); + } + if (name == "histogram") { + xmlChar* type_value = xmlGetProp(node, BAD_CAST "type"); + if (type_value) { + std::string type = (reinterpret_cast<char*>(type_value)); + if (uploadOn) + histograms_to_upload_.insert(type); + else + histograms_to_omit_.insert(type); + } + } + if (name == "log") { + xmlChar* type_value = xmlGetProp(node, BAD_CAST "type"); + if (type_value) { + std::string type = (reinterpret_cast<char*>(type_value)); + if (uploadOn) + logs_to_upload_.insert(type); + else + logs_to_omit_.insert(type); + } + } + + // Recursive call. If the node is a leaf i.e. if it ends in a "/>", then it + // doesn't have children, so node->children is NULL, and this loop doesn't + // call (that's how the recursion ends). + for (xmlNodePtr child_node = node->children; + child_node; + child_node = child_node->next) { + GetSettingsFromUploadNodeRecursive(child_node, props, path, uploadOn); + } +} + +bool MetricsService::NodeProbabilityTest(xmlNodePtr node, + InheritedProperties props) const { + // Default value of probability on any node is 1, but recall that + // its parents can already have been rejected for upload. + double probability = 1; + + // If a probability is specified in the node, we use it instead. + xmlChar* probability_value = xmlGetProp(node, BAD_CAST "probability"); + if (probability_value) + probability = atoi(reinterpret_cast<char*>(probability_value)); + + return ProbabilityTest(probability, props.salt, props.denominator); +} + +bool MetricsService::ProbabilityTest(double probability, + int salt, + int denominator) const { + // Okay, first we figure out how many of the digits of the + // client_id_ we need in order to make a nice pseudorandomish + // number in the range [0,denominator). Too many digits is + // fine. + int relevant_digits = + static_cast<int>(log10(static_cast<double>(denominator)) + 1.0); + + // n is the length of the client_id_ string + size_t n = client_id_.size(); + + // idnumber is a positive integer generated from the client_id_. + // It plus salt is going to give us our pseudorandom number. + int idnumber = 0; + const char* client_id_c_str = client_id_.c_str(); + + // Here we hash the relevant digits of the client_id_ + // string somehow to get a big integer idnumber (could be negative + // from wraparound) + int big = 1; + for (size_t j = n - 1; j >= 0; --j) { + idnumber += static_cast<int>(client_id_c_str[j]) * big; + big *= 10; + } + + // Mod id number by denominator making sure to get a non-negative + // answer. + idnumber = ((idnumber % denominator) + denominator) % denominator; + + // ((idnumber + salt) % denominator) / denominator is in the range [0,1] + // if it's less than probability we call that an affirmative coin + // toss. + return static_cast<double>((idnumber + salt) % denominator) < + probability * denominator; +} + +void MetricsService::LogWindowChange(NotificationType type, + const NotificationSource& source, + const NotificationDetails& details) { + int controller_id = -1; + uintptr_t window_or_tab = source.map_key(); + MetricsLog::WindowEventType window_type; + + // Note: since we stop all logging when a single OTR session is active, it is + // possible that we start getting notifications about a window that we don't + // know about. + if (window_map_.find(window_or_tab) == window_map_.end()) { + controller_id = next_window_id_++; + window_map_[window_or_tab] = controller_id; + } else { + controller_id = window_map_[window_or_tab]; + } + DCHECK(controller_id != -1); + + switch (type) { + case NOTIFY_TAB_PARENTED: + case NOTIFY_BROWSER_OPENED: + window_type = MetricsLog::WINDOW_CREATE; + break; + + case NOTIFY_TAB_CLOSING: + case NOTIFY_BROWSER_CLOSED: + window_map_.erase(window_map_.find(window_or_tab)); + window_type = MetricsLog::WINDOW_DESTROY; + break; + + default: + NOTREACHED(); + break; + } + + // TODO(brettw) we should have some kind of ID for the parent. + current_log_->RecordWindowEvent(window_type, controller_id, 0); +} + +void MetricsService::LogLoadComplete(NotificationType type, + const NotificationSource& source, + const NotificationDetails& details) { + if (details == NotificationService::NoDetails()) + return; + + // TODO(jar): There is a bug causing this to be called too many times, and + // the log overflows. For now, we won't record these events. + UMA_HISTOGRAM_COUNTS(L"UMA.LogLoadComplete called", 1); + return; + + const Details<LoadNotificationDetails> load_details(details); + int controller_id = window_map_[details.map_key()]; + current_log_->RecordLoadEvent(controller_id, + load_details->url(), + load_details->origin(), + load_details->session_index(), + load_details->load_time()); +} + +void MetricsService::IncrementPrefValue(const wchar_t* path) { + PrefService* pref = g_browser_process->local_state(); + DCHECK(pref); + int value = pref->GetInteger(path); + pref->SetInteger(path, value + 1); +} + +void MetricsService::LogLoadStarted() { + IncrementPrefValue(prefs::kStabilityPageLoadCount); + // We need to save the prefs, as page load count is a critical stat, and it + // might be lost due to a crash :-(. +} + +void MetricsService::LogRendererInSandbox(bool on_sandbox_desktop) { + PrefService* prefs = g_browser_process->local_state(); + DCHECK(prefs); + if (on_sandbox_desktop) + IncrementPrefValue(prefs::kSecurityRendererOnSboxDesktop); + else + IncrementPrefValue(prefs::kSecurityRendererOnDefaultDesktop); +} + +void MetricsService::LogRendererCrash() { + IncrementPrefValue(prefs::kStabilityRendererCrashCount); +} + +void MetricsService::LogRendererHang() { + IncrementPrefValue(prefs::kStabilityRendererHangCount); +} + +void MetricsService::LogPluginChange(NotificationType type, + const NotificationSource& source, + const NotificationDetails& details) { + FilePath plugin = Details<PluginProcessInfo>(details)->plugin_path(); + + if (plugin_stats_buffer_.find(plugin) == plugin_stats_buffer_.end()) { + plugin_stats_buffer_[plugin] = PluginStats(); + } + + PluginStats& stats = plugin_stats_buffer_[plugin]; + switch (type) { + case NOTIFY_PLUGIN_PROCESS_HOST_CONNECTED: + stats.process_launches++; + break; + + case NOTIFY_PLUGIN_INSTANCE_CREATED: + stats.instances++; + break; + + case NOTIFY_PLUGIN_PROCESS_CRASHED: + stats.process_crashes++; + break; + + default: + NOTREACHED() << "Unexpected notification type " << type; + return; + } +} + +// Recursively counts the number of bookmarks and folders in node. +static void CountBookmarks(BookmarkNode* node, int* bookmarks, int* folders) { + if (node->GetType() == history::StarredEntry::URL) + (*bookmarks)++; + else + (*folders)++; + for (int i = 0; i < node->GetChildCount(); ++i) + CountBookmarks(node->GetChild(i), bookmarks, folders); +} + +void MetricsService::LogBookmarks(BookmarkNode* node, + const wchar_t* num_bookmarks_key, + const wchar_t* num_folders_key) { + DCHECK(node); + int num_bookmarks = 0; + int num_folders = 0; + CountBookmarks(node, &num_bookmarks, &num_folders); + num_folders--; // Don't include the root folder in the count. + + PrefService* pref = g_browser_process->local_state(); + DCHECK(pref); + pref->SetInteger(num_bookmarks_key, num_bookmarks); + pref->SetInteger(num_folders_key, num_folders); +} + +void MetricsService::LogBookmarks(BookmarkModel* model) { + DCHECK(model); + LogBookmarks(model->GetBookmarkBarNode(), + prefs::kNumBookmarksOnBookmarkBar, + prefs::kNumFoldersOnBookmarkBar); + LogBookmarks(model->other_node(), + prefs::kNumBookmarksInOtherBookmarkFolder, + prefs::kNumFoldersInOtherBookmarkFolder); + ScheduleNextStateSave(); +} + +void MetricsService::LogKeywords(const TemplateURLModel* url_model) { + DCHECK(url_model); + + PrefService* pref = g_browser_process->local_state(); + DCHECK(pref); + pref->SetInteger(prefs::kNumKeywords, + static_cast<int>(url_model->GetTemplateURLs().size())); + ScheduleNextStateSave(); +} + +void MetricsService::RecordPluginChanges(PrefService* pref) { + ListValue* plugins = pref->GetMutableList(prefs::kStabilityPluginStats); + DCHECK(plugins); + + for (ListValue::iterator value_iter = plugins->begin(); + value_iter != plugins->end(); ++value_iter) { + if (!(*value_iter)->IsType(Value::TYPE_DICTIONARY)) { + NOTREACHED(); + continue; + } + + DictionaryValue* plugin_dict = static_cast<DictionaryValue*>(*value_iter); + FilePath::StringType plugin_path_str; + plugin_dict->GetString(prefs::kStabilityPluginPath, &plugin_path_str); + if (plugin_path_str.empty()) { + NOTREACHED(); + continue; + } + + FilePath plugin_path(plugin_path_str); + if (plugin_stats_buffer_.find(plugin_path) == plugin_stats_buffer_.end()) + continue; + + PluginStats stats = plugin_stats_buffer_[plugin_path]; + if (stats.process_launches) { + int launches = 0; + plugin_dict->GetInteger(prefs::kStabilityPluginLaunches, &launches); + launches += stats.process_launches; + plugin_dict->SetInteger(prefs::kStabilityPluginLaunches, launches); + } + if (stats.process_crashes) { + int crashes = 0; + plugin_dict->GetInteger(prefs::kStabilityPluginCrashes, &crashes); + crashes += stats.process_crashes; + plugin_dict->SetInteger(prefs::kStabilityPluginCrashes, crashes); + } + if (stats.instances) { + int instances = 0; + plugin_dict->GetInteger(prefs::kStabilityPluginInstances, &instances); + instances += stats.instances; + plugin_dict->SetInteger(prefs::kStabilityPluginInstances, instances); + } + + plugin_stats_buffer_.erase(plugin_path); + } + + // Now go through and add dictionaries for plugins that didn't already have + // reports in Local State. + for (std::map<FilePath, PluginStats>::iterator cache_iter = + plugin_stats_buffer_.begin(); + cache_iter != plugin_stats_buffer_.end(); ++cache_iter) { + FilePath plugin_path = cache_iter->first; + PluginStats stats = cache_iter->second; + DictionaryValue* plugin_dict = new DictionaryValue; + + plugin_dict->SetString(prefs::kStabilityPluginPath, plugin_path.value()); + plugin_dict->SetInteger(prefs::kStabilityPluginLaunches, + stats.process_launches); + plugin_dict->SetInteger(prefs::kStabilityPluginCrashes, + stats.process_crashes); + plugin_dict->SetInteger(prefs::kStabilityPluginInstances, + stats.instances); + plugins->Append(plugin_dict); + } + plugin_stats_buffer_.clear(); +} + +bool MetricsService::CanLogNotification(NotificationType type, + const NotificationSource& source, + const NotificationDetails& details) { + // We simply don't log anything to UMA if there is a single off the record + // session visible. The problem is that we always notify using the orginal + // profile in order to simplify notification processing. + return !BrowserList::IsOffTheRecordSessionActive(); +} + +void MetricsService::RecordBooleanPrefValue(const wchar_t* path, bool value) { + DCHECK(IsSingleThreaded()); + + PrefService* pref = g_browser_process->local_state(); + DCHECK(pref); + + pref->SetBoolean(path, value); + RecordCurrentState(pref); +} + +void MetricsService::RecordCurrentState(PrefService* pref) { + pref->SetString(prefs::kStabilityLastTimestampSec, + Int64ToWString(Time::Now().ToTimeT())); + + RecordPluginChanges(pref); +} + +void MetricsService::RecordCurrentHistograms() { + DCHECK(current_log_); + + StatisticsRecorder::Histograms histograms; + StatisticsRecorder::GetHistograms(&histograms); + for (StatisticsRecorder::Histograms::iterator it = histograms.begin(); + histograms.end() != it; + ++it) { + if ((*it)->flags() & kUmaTargetedHistogramFlag) + // TODO(petersont): Only record historgrams if they are not precluded by + // the UMA response data. + // Bug http://code.google.com/p/chromium/issues/detail?id=2739. + RecordHistogram(**it); + } +} + +void MetricsService::RecordHistogram(const Histogram& histogram) { + // Get up-to-date snapshot of sample stats. + Histogram::SampleSet snapshot; + histogram.SnapshotSample(&snapshot); + + const std::string& histogram_name = histogram.histogram_name(); + + // Find the already sent stats, or create an empty set. + LoggedSampleMap::iterator it = logged_samples_.find(histogram_name); + Histogram::SampleSet* already_logged; + if (logged_samples_.end() == it) { + // Add new entry + already_logged = &logged_samples_[histogram.histogram_name()]; + already_logged->Resize(histogram); // Complete initialization. + } else { + already_logged = &(it->second); + // Deduct any stats we've already logged from our snapshot. + snapshot.Subtract(*already_logged); + } + + // snapshot now contains only a delta to what we've already_logged. + + if (snapshot.TotalCount() > 0) { + current_log_->RecordHistogramDelta(histogram, snapshot); + // Add new data into our running total. + already_logged->Add(snapshot); + } +} + +void MetricsService::AddProfileMetric(Profile* profile, + const std::wstring& key, + int value) { + // Restriction of types is needed for writing values. See + // MetricsLog::WriteProfileMetrics. + DCHECK(profile && !key.empty()); + PrefService* prefs = g_browser_process->local_state(); + DCHECK(prefs); + + // Key is stored in prefs, which interpret '.'s as paths. As such, key + // shouldn't have any '.'s in it. + DCHECK(key.find(L'.') == std::wstring::npos); + // The id is most likely an email address. We shouldn't send it to the server. + const std::wstring id_hash = + UTF8ToWide(MetricsLog::CreateBase64Hash(WideToUTF8(profile->GetID()))); + DCHECK(id_hash.find('.') == std::string::npos); + + DictionaryValue* prof_prefs = prefs->GetMutableDictionary( + prefs::kProfileMetrics); + DCHECK(prof_prefs); + const std::wstring pref_key = std::wstring(prefs::kProfilePrefix) + id_hash + + L"." + key; + prof_prefs->SetInteger(pref_key.c_str(), value); +} + +static bool IsSingleThreaded() { + static int thread_id = 0; + if (!thread_id) + thread_id = GetCurrentThreadId(); + return GetCurrentThreadId() == thread_id; +} |