Move metrics files into a subdir
Review URL: http://codereview.chromium.org/18302
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@8156 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/chrome/browser/metrics/metrics_log.cc b/chrome/browser/metrics/metrics_log.cc
new file mode 100644
index 0000000..3603e0c
--- /dev/null
+++ b/chrome/browser/metrics/metrics_log.cc
@@ -0,0 +1,695 @@
+// 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.
+
+#include "chrome/browser/metrics/metrics_log.h"
+
+#include "base/basictypes.h"
+#include "base/file_util.h"
+#include "base/file_version_info.h"
+#include "base/md5.h"
+#include "base/scoped_ptr.h"
+#include "base/string_util.h"
+#include "base/sys_info.h"
+#include "chrome/browser/autocomplete/autocomplete.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/common/logging_chrome.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/pref_service.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/base64.h"
+
+#define OPEN_ELEMENT_FOR_SCOPE(name) ScopedElement scoped_element(this, name)
+
+using base::Time;
+using base::TimeDelta;
+
+// http://blogs.msdn.com/oldnewthing/archive/2004/10/25/247180.aspx
+#if defined(OS_WIN)
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+#endif
+
+// libxml take xmlChar*, which is unsigned char*
+inline const unsigned char* UnsignedChar(const char* input) {
+ return reinterpret_cast<const unsigned char*>(input);
+}
+
+// static
+void MetricsLog::RegisterPrefs(PrefService* local_state) {
+ local_state->RegisterListPref(prefs::kStabilityPluginStats);
+}
+
+MetricsLog::MetricsLog(const std::string& client_id, int session_id)
+ : start_time_(Time::Now()),
+ client_id_(client_id),
+ session_id_(IntToString(session_id)),
+ locked_(false),
+ buffer_(NULL),
+ writer_(NULL),
+ num_events_(0) {
+
+ buffer_ = xmlBufferCreate();
+ DCHECK(buffer_);
+
+ writer_ = xmlNewTextWriterMemory(buffer_, 0);
+ DCHECK(writer_);
+
+ int result = xmlTextWriterSetIndent(writer_, 2);
+ DCHECK_EQ(0, result);
+
+ StartElement("log");
+ WriteAttribute("clientid", client_id_);
+
+ DCHECK_GE(result, 0);
+}
+
+MetricsLog::~MetricsLog() {
+ if (writer_)
+ xmlFreeTextWriter(writer_);
+
+ if (buffer_)
+ xmlBufferFree(buffer_);
+}
+
+void MetricsLog::CloseLog() {
+ DCHECK(!locked_);
+ locked_ = true;
+
+ int result = xmlTextWriterEndDocument(writer_);
+ DCHECK(result >= 0);
+
+ result = xmlTextWriterFlush(writer_);
+ DCHECK(result >= 0);
+}
+
+int MetricsLog::GetEncodedLogSize() {
+ DCHECK(locked_);
+ return buffer_->use;
+}
+
+bool MetricsLog::GetEncodedLog(char* buffer, int buffer_size) {
+ DCHECK(locked_);
+ if (buffer_size < GetEncodedLogSize())
+ return false;
+
+ memcpy(buffer, buffer_->content, GetEncodedLogSize());
+ return true;
+}
+
+int MetricsLog::GetElapsedSeconds() {
+ return static_cast<int>((Time::Now() - start_time_).InSeconds());
+}
+
+std::string MetricsLog::CreateHash(const std::string& value) {
+ MD5Context ctx;
+ MD5Init(&ctx);
+ MD5Update(&ctx, value.data(), value.length());
+
+ MD5Digest digest;
+ MD5Final(&digest, &ctx);
+
+ unsigned char reverse[8]; // UMA only uses first 8 chars of hash.
+ DCHECK(arraysize(digest.a) >= arraysize(reverse));
+ for (size_t i = 0; i < arraysize(reverse); ++i)
+ reverse[i] = digest.a[arraysize(reverse) - i - 1];
+ LOG(INFO) << "Metrics: Hash numeric [" << value << "]=["
+ << *reinterpret_cast<const uint64*>(&reverse[0]) << "]";
+ return std::string(reinterpret_cast<char*>(digest.a), arraysize(digest.a));
+}
+
+std::string MetricsLog::CreateBase64Hash(const std::string& string) {
+ std::string encoded_digest;
+ if (net::Base64Encode(CreateHash(string), &encoded_digest)) {
+ DLOG(INFO) << "Metrics: Hash [" << encoded_digest << "]=[" << string << "]";
+ return encoded_digest;
+ }
+ return std::string();
+}
+
+void MetricsLog::RecordUserAction(const wchar_t* key) {
+ DCHECK(!locked_);
+
+ std::string command_hash = CreateBase64Hash(WideToUTF8(key));
+ if (command_hash.empty()) {
+ NOTREACHED() << "Unable generate encoded hash of command: " << key;
+ return;
+ }
+
+ OPEN_ELEMENT_FOR_SCOPE("uielement");
+ WriteAttribute("action", "command");
+ WriteAttribute("targetidhash", command_hash);
+
+ // TODO(jhughes): Properly track windows.
+ WriteIntAttribute("window", 0);
+ WriteCommonEventAttributes();
+
+ ++num_events_;
+}
+
+void MetricsLog::RecordLoadEvent(int window_id,
+ const GURL& url,
+ PageTransition::Type origin,
+ int session_index,
+ TimeDelta load_time) {
+ DCHECK(!locked_);
+
+ OPEN_ELEMENT_FOR_SCOPE("document");
+ WriteAttribute("action", "load");
+ WriteIntAttribute("docid", session_index);
+ WriteIntAttribute("window", window_id);
+ WriteAttribute("loadtime", Int64ToString(load_time.InMilliseconds()));
+
+ std::string origin_string;
+
+ switch (PageTransition::StripQualifier(origin)) {
+ // TODO(jhughes): Some of these mappings aren't right... we need to add
+ // some values to the server's enum.
+ case PageTransition::LINK:
+ case PageTransition::MANUAL_SUBFRAME:
+ origin_string = "link";
+ break;
+
+ case PageTransition::TYPED:
+ origin_string = "typed";
+ break;
+
+ case PageTransition::AUTO_BOOKMARK:
+ origin_string = "bookmark";
+ break;
+
+ case PageTransition::AUTO_SUBFRAME:
+ case PageTransition::RELOAD:
+ origin_string = "refresh";
+ break;
+
+ case PageTransition::GENERATED:
+ origin_string = "global-history";
+ break;
+
+ case PageTransition::START_PAGE:
+ origin_string = "start-page";
+ break;
+
+ case PageTransition::FORM_SUBMIT:
+ origin_string = "form-submit";
+ break;
+
+ default:
+ NOTREACHED() << "Received an unknown page transition type: " <<
+ PageTransition::StripQualifier(origin);
+ }
+ if (!origin_string.empty())
+ WriteAttribute("origin", origin_string);
+
+ WriteCommonEventAttributes();
+
+ ++num_events_;
+}
+
+void MetricsLog::RecordWindowEvent(WindowEventType type,
+ int window_id,
+ int parent_id) {
+ DCHECK(!locked_);
+
+ OPEN_ELEMENT_FOR_SCOPE("window");
+ WriteAttribute("action", WindowEventTypeToString(type));
+ WriteAttribute("windowid", IntToString(window_id));
+ if (parent_id >= 0)
+ WriteAttribute("parent", IntToString(parent_id));
+ WriteCommonEventAttributes();
+
+ ++num_events_;
+}
+
+std::string MetricsLog::GetCurrentTimeString() {
+ return Uint64ToString(Time::Now().ToTimeT());
+}
+
+// These are the attributes that are common to every event.
+void MetricsLog::WriteCommonEventAttributes() {
+ WriteAttribute("session", session_id_);
+ WriteAttribute("time", GetCurrentTimeString());
+}
+
+void MetricsLog::WriteAttribute(const std::string& name,
+ const std::string& value) {
+ DCHECK(!locked_);
+ DCHECK(!name.empty());
+
+ int result = xmlTextWriterWriteAttribute(writer_,
+ UnsignedChar(name.c_str()),
+ UnsignedChar(value.c_str()));
+ DCHECK_GE(result, 0);
+}
+
+void MetricsLog::WriteIntAttribute(const std::string& name, int value) {
+ WriteAttribute(name, IntToString(value));
+}
+
+void MetricsLog::WriteInt64Attribute(const std::string& name, int64 value) {
+ WriteAttribute(name, Int64ToString(value));
+}
+
+// static
+const char* MetricsLog::WindowEventTypeToString(WindowEventType type) {
+ switch (type) {
+ case WINDOW_CREATE: return "create";
+ case WINDOW_OPEN: return "open";
+ case WINDOW_CLOSE: return "close";
+ case WINDOW_DESTROY: return "destroy";
+
+ default:
+ NOTREACHED();
+ return "unknown"; // Can't return NULL as this is used in a required
+ // attribute.
+ }
+}
+
+void MetricsLog::StartElement(const char* name) {
+ DCHECK(!locked_);
+ DCHECK(name);
+
+ int result = xmlTextWriterStartElement(writer_, UnsignedChar(name));
+ DCHECK_GE(result, 0);
+}
+
+void MetricsLog::EndElement() {
+ DCHECK(!locked_);
+
+ int result = xmlTextWriterEndElement(writer_);
+ DCHECK_GE(result, 0);
+}
+
+std::string MetricsLog::GetVersionString() const {
+ scoped_ptr<FileVersionInfo> version_info(
+ FileVersionInfo::CreateFileVersionInfoForCurrentModule());
+ if (version_info.get()) {
+ std::string version = WideToUTF8(version_info->product_version());
+ if (!version_info->is_official_build())
+ version.append("-devel");
+ return version;
+ } else {
+ NOTREACHED() << "Unable to retrieve version string.";
+ }
+
+ return std::string();
+}
+
+std::string MetricsLog::GetInstallDate() const {
+ PrefService* pref = g_browser_process->local_state();
+ if (pref) {
+ return WideToUTF8(pref->GetString(prefs::kMetricsClientIDTimestamp));
+ } else {
+ NOTREACHED();
+ return "0";
+ }
+}
+
+void MetricsLog::RecordIncrementalStabilityElements() {
+ DCHECK(!locked_);
+
+ PrefService* pref = g_browser_process->local_state();
+ DCHECK(pref);
+
+ OPEN_ELEMENT_FOR_SCOPE("profile");
+ WriteCommonEventAttributes();
+
+ WriteInstallElement(); // Supply appversion.
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("stability"); // Minimal set of stability elements.
+ WriteRequiredStabilityAttributes(pref);
+ WriteRealtimeStabilityAttributes(pref);
+
+ WritePluginStabilityElements(pref);
+ }
+}
+
+void MetricsLog::WriteStabilityElement() {
+ DCHECK(!locked_);
+
+ PrefService* pref = g_browser_process->local_state();
+ DCHECK(pref);
+
+ // Get stability attributes out of Local State, zeroing out stored values.
+ // NOTE: This could lead to some data loss if this report isn't successfully
+ // sent, but that's true for all the metrics.
+
+ OPEN_ELEMENT_FOR_SCOPE("stability");
+ WriteRequiredStabilityAttributes(pref);
+ WriteRealtimeStabilityAttributes(pref);
+
+ // TODO(jar): The following are all optional, so we *could* optimize them for
+ // values of zero (and not include them).
+ WriteIntAttribute("incompleteshutdowncount",
+ pref->GetInteger(
+ prefs::kStabilityIncompleteSessionEndCount));
+ pref->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
+
+
+ WriteIntAttribute("breakpadregistrationok",
+ pref->GetInteger(prefs::kStabilityBreakpadRegistrationSuccess));
+ pref->SetInteger(prefs::kStabilityBreakpadRegistrationSuccess, 0);
+ WriteIntAttribute("breakpadregistrationfail",
+ pref->GetInteger(prefs::kStabilityBreakpadRegistrationFail));
+ pref->SetInteger(prefs::kStabilityBreakpadRegistrationFail, 0);
+ WriteIntAttribute("debuggerpresent",
+ pref->GetInteger(prefs::kStabilityDebuggerPresent));
+ pref->SetInteger(prefs::kStabilityDebuggerPresent, 0);
+ WriteIntAttribute("debuggernotpresent",
+ pref->GetInteger(prefs::kStabilityDebuggerNotPresent));
+ pref->SetInteger(prefs::kStabilityDebuggerNotPresent, 0);
+
+ // Uptime is stored as a string, since there's no int64 in Value/JSON.
+ WriteAttribute("uptimesec",
+ WideToUTF8(pref->GetString(prefs::kStabilityUptimeSec)));
+ pref->SetString(prefs::kStabilityUptimeSec, L"0");
+
+ WritePluginStabilityElements(pref);
+}
+
+void MetricsLog::WritePluginStabilityElements(PrefService* pref) {
+ // Now log plugin stability info.
+ const ListValue* plugin_stats_list = pref->GetList(
+ prefs::kStabilityPluginStats);
+ if (plugin_stats_list) {
+ OPEN_ELEMENT_FOR_SCOPE("plugins");
+ for (ListValue::const_iterator iter = plugin_stats_list->begin();
+ iter != plugin_stats_list->end(); ++iter) {
+ if (!(*iter)->IsType(Value::TYPE_DICTIONARY)) {
+ NOTREACHED();
+ continue;
+ }
+ DictionaryValue* plugin_dict = static_cast<DictionaryValue*>(*iter);
+
+ std::wstring plugin_path;
+ plugin_dict->GetString(prefs::kStabilityPluginPath, &plugin_path);
+ plugin_path = file_util::GetFilenameFromPath(plugin_path);
+ if (plugin_path.empty()) {
+ NOTREACHED();
+ continue;
+ }
+
+ OPEN_ELEMENT_FOR_SCOPE("pluginstability");
+ WriteAttribute("filename", CreateBase64Hash(WideToUTF8(plugin_path)));
+
+ int launches = 0;
+ plugin_dict->GetInteger(prefs::kStabilityPluginLaunches, &launches);
+ WriteIntAttribute("launchcount", launches);
+
+ int instances = 0;
+ plugin_dict->GetInteger(prefs::kStabilityPluginInstances, &instances);
+ WriteIntAttribute("instancecount", instances);
+
+ int crashes = 0;
+ plugin_dict->GetInteger(prefs::kStabilityPluginCrashes, &crashes);
+ WriteIntAttribute("crashcount", crashes);
+ }
+
+ pref->ClearPref(prefs::kStabilityPluginStats);
+ }
+}
+
+void MetricsLog::WriteRequiredStabilityAttributes(PrefService* pref) {
+ // The server refuses data that doesn't have certain values. crashcount and
+ // launchcount are currently "required" in the "stability" group.
+ WriteIntAttribute("launchcount",
+ pref->GetInteger(prefs::kStabilityLaunchCount));
+ pref->SetInteger(prefs::kStabilityLaunchCount, 0);
+ WriteIntAttribute("crashcount",
+ pref->GetInteger(prefs::kStabilityCrashCount));
+ pref->SetInteger(prefs::kStabilityCrashCount, 0);
+}
+
+void MetricsLog::WriteRealtimeStabilityAttributes(PrefService* pref) {
+ // Update the stats which are critical for real-time stability monitoring.
+ // Since these are "optional," only list ones that are non-zero, as the counts
+ // are aggergated (summed) server side.
+
+ int count = pref->GetInteger(prefs::kStabilityPageLoadCount);
+ if (count) {
+ WriteIntAttribute("pageloadcount", count);
+ pref->SetInteger(prefs::kStabilityPageLoadCount, 0);
+ }
+
+ count = pref->GetInteger(prefs::kStabilityRendererCrashCount);
+ if (count) {
+ WriteIntAttribute("renderercrashcount", count);
+ pref->SetInteger(prefs::kStabilityRendererCrashCount, 0);
+ }
+
+ count = pref->GetInteger(prefs::kStabilityRendererHangCount);
+ if (count) {
+ WriteIntAttribute("rendererhangcount", count);
+ pref->SetInteger(prefs::kStabilityRendererHangCount, 0);
+ }
+}
+
+void MetricsLog::WritePluginList(
+ const std::vector<WebPluginInfo>& plugin_list) {
+ DCHECK(!locked_);
+
+ OPEN_ELEMENT_FOR_SCOPE("plugins");
+
+ for (std::vector<WebPluginInfo>::const_iterator iter = plugin_list.begin();
+ iter != plugin_list.end(); ++iter) {
+ OPEN_ELEMENT_FOR_SCOPE("plugin");
+
+ // Plugin name and filename are hashed for the privacy of those
+ // testing unreleased new extensions.
+ WriteAttribute("name", CreateBase64Hash(WideToUTF8(iter->name)));
+ WriteAttribute("filename",
+ CreateBase64Hash(WideToUTF8(iter->path.BaseName().ToWStringHack())));
+ WriteAttribute("version", WideToUTF8(iter->version));
+ }
+}
+
+void MetricsLog::WriteInstallElement() {
+ OPEN_ELEMENT_FOR_SCOPE("install");
+ WriteAttribute("installdate", GetInstallDate());
+ WriteIntAttribute("buildid", 0); // We're using appversion instead.
+ WriteAttribute("appversion", GetVersionString());
+}
+
+void MetricsLog::RecordEnvironment(
+ const std::vector<WebPluginInfo>& plugin_list,
+ const DictionaryValue* profile_metrics) {
+ DCHECK(!locked_);
+
+ PrefService* pref = g_browser_process->local_state();
+
+ OPEN_ELEMENT_FOR_SCOPE("profile");
+ WriteCommonEventAttributes();
+
+ WriteInstallElement();
+
+ WritePluginList(plugin_list);
+
+ WriteStabilityElement();
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("cpu");
+ WriteAttribute("arch", base::SysInfo::CPUArchitecture());
+ }
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("security");
+ WriteIntAttribute("rendereronsboxdesktop",
+ pref->GetInteger(prefs::kSecurityRendererOnSboxDesktop));
+ pref->SetInteger(prefs::kSecurityRendererOnSboxDesktop, 0);
+
+ WriteIntAttribute("rendererondefaultdesktop",
+ pref->GetInteger(prefs::kSecurityRendererOnDefaultDesktop));
+ pref->SetInteger(prefs::kSecurityRendererOnDefaultDesktop, 0);
+ }
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("memory");
+ WriteIntAttribute("mb", base::SysInfo::AmountOfPhysicalMemoryMB());
+#if defined(OS_WIN)
+ WriteIntAttribute("dllbase", reinterpret_cast<int>(&__ImageBase));
+#endif
+ }
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("os");
+ WriteAttribute("name",
+ base::SysInfo::OperatingSystemName());
+ WriteAttribute("version",
+ base::SysInfo::OperatingSystemVersion());
+ }
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("display");
+ int width = 0;
+ int height = 0;
+ base::SysInfo::GetPrimaryDisplayDimensions(&width, &height);
+ WriteIntAttribute("xsize", width);
+ WriteIntAttribute("ysize", height);
+ WriteIntAttribute("screens", base::SysInfo::DisplayCount());
+ }
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("bookmarks");
+ int num_bookmarks_on_bookmark_bar =
+ pref->GetInteger(prefs::kNumBookmarksOnBookmarkBar);
+ int num_folders_on_bookmark_bar =
+ pref->GetInteger(prefs::kNumFoldersOnBookmarkBar);
+ int num_bookmarks_in_other_bookmarks_folder =
+ pref->GetInteger(prefs::kNumBookmarksInOtherBookmarkFolder);
+ int num_folders_in_other_bookmarks_folder =
+ pref->GetInteger(prefs::kNumFoldersInOtherBookmarkFolder);
+ {
+ OPEN_ELEMENT_FOR_SCOPE("bookmarklocation");
+ WriteAttribute("name", "full-tree");
+ WriteIntAttribute("foldercount",
+ num_folders_on_bookmark_bar + num_folders_in_other_bookmarks_folder);
+ WriteIntAttribute("itemcount",
+ num_bookmarks_on_bookmark_bar +
+ num_bookmarks_in_other_bookmarks_folder);
+ }
+ {
+ OPEN_ELEMENT_FOR_SCOPE("bookmarklocation");
+ WriteAttribute("name", "toolbar");
+ WriteIntAttribute("foldercount", num_folders_on_bookmark_bar);
+ WriteIntAttribute("itemcount", num_bookmarks_on_bookmark_bar);
+ }
+ }
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("keywords");
+ WriteIntAttribute("count", pref->GetInteger(prefs::kNumKeywords));
+ }
+
+ if (profile_metrics)
+ WriteAllProfilesMetrics(*profile_metrics);
+}
+
+void MetricsLog::WriteAllProfilesMetrics(
+ const DictionaryValue& all_profiles_metrics) {
+ const std::wstring profile_prefix(prefs::kProfilePrefix);
+ for (DictionaryValue::key_iterator i = all_profiles_metrics.begin_keys();
+ i != all_profiles_metrics.end_keys(); ++i) {
+ const std::wstring& key_name = *i;
+ if (key_name.compare(0, profile_prefix.size(), profile_prefix) == 0) {
+ DictionaryValue* profile;
+ if (all_profiles_metrics.GetDictionary(key_name, &profile))
+ WriteProfileMetrics(key_name.substr(profile_prefix.size()), *profile);
+ }
+ }
+}
+
+void MetricsLog::WriteProfileMetrics(const std::wstring& profileidhash,
+ const DictionaryValue& profile_metrics) {
+ OPEN_ELEMENT_FOR_SCOPE("userprofile");
+ WriteAttribute("profileidhash", WideToUTF8(profileidhash));
+ for (DictionaryValue::key_iterator i = profile_metrics.begin_keys();
+ i != profile_metrics.end_keys(); ++i) {
+ Value* value;
+ if (profile_metrics.Get(*i, &value)) {
+ DCHECK(*i != L"id");
+ switch (value->GetType()) {
+ case Value::TYPE_STRING: {
+ std::string string_value;
+ if (value->GetAsString(&string_value)) {
+ OPEN_ELEMENT_FOR_SCOPE("profileparam");
+ WriteAttribute("name", WideToUTF8(*i));
+ WriteAttribute("value", string_value);
+ }
+ break;
+ }
+
+ case Value::TYPE_BOOLEAN: {
+ bool bool_value;
+ if (value->GetAsBoolean(&bool_value)) {
+ OPEN_ELEMENT_FOR_SCOPE("profileparam");
+ WriteAttribute("name", WideToUTF8(*i));
+ WriteIntAttribute("value", bool_value ? 1 : 0);
+ }
+ break;
+ }
+
+ case Value::TYPE_INTEGER: {
+ int int_value;
+ if (value->GetAsInteger(&int_value)) {
+ OPEN_ELEMENT_FOR_SCOPE("profileparam");
+ WriteAttribute("name", WideToUTF8(*i));
+ WriteIntAttribute("value", int_value);
+ }
+ break;
+ }
+
+ default:
+ NOTREACHED();
+ break;
+ }
+ }
+ }
+}
+
+void MetricsLog::RecordOmniboxOpenedURL(const AutocompleteLog& log) {
+ DCHECK(!locked_);
+
+ OPEN_ELEMENT_FOR_SCOPE("uielement");
+ WriteAttribute("action", "autocomplete");
+ WriteAttribute("targetidhash", "");
+ // TODO(kochi): Properly track windows.
+ WriteIntAttribute("window", 0);
+ WriteCommonEventAttributes();
+
+ {
+ OPEN_ELEMENT_FOR_SCOPE("autocomplete");
+
+ WriteIntAttribute("typedlength", static_cast<int>(log.text.length()));
+ WriteIntAttribute("selectedindex", static_cast<int>(log.selected_index));
+ WriteIntAttribute("completedlength",
+ static_cast<int>(log.inline_autocompleted_length));
+ const std::string input_type(
+ AutocompleteInput::TypeToString(log.input_type));
+ if (!input_type.empty())
+ WriteAttribute("inputtype", input_type);
+
+ for (AutocompleteResult::const_iterator i(log.result.begin());
+ i != log.result.end(); ++i) {
+ OPEN_ELEMENT_FOR_SCOPE("autocompleteitem");
+ if (i->provider)
+ WriteAttribute("provider", i->provider->name());
+ const std::string result_type(AutocompleteMatch::TypeToString(i->type));
+ if (!result_type.empty())
+ WriteAttribute("resulttype", result_type);
+ WriteIntAttribute("relevance", i->relevance);
+ WriteIntAttribute("isstarred", i->starred ? 1 : 0);
+ }
+ }
+
+ ++num_events_;
+}
+
+// TODO(JAR): A The following should really be part of the histogram class.
+// Internal state is being needlessly exposed, and it would be hard to reuse
+// this code. If we moved this into the Histogram class, then we could use
+// the same infrastructure for logging StatsCounters, RatesCounters, etc.
+void MetricsLog::RecordHistogramDelta(const Histogram& histogram,
+ const Histogram::SampleSet& snapshot) {
+ DCHECK(!locked_);
+ DCHECK(0 != snapshot.TotalCount());
+ snapshot.CheckSize(histogram);
+
+ // We will ignore the MAX_INT/infinite value in the last element of range[].
+
+ OPEN_ELEMENT_FOR_SCOPE("histogram");
+
+ WriteAttribute("name", CreateBase64Hash(histogram.histogram_name()));
+
+ WriteInt64Attribute("sum", snapshot.sum());
+ WriteInt64Attribute("sumsquares", snapshot.square_sum());
+
+ for (size_t i = 0; i < histogram.bucket_count(); i++) {
+ if (snapshot.counts(i)) {
+ OPEN_ELEMENT_FOR_SCOPE("histogrambucket");
+ WriteIntAttribute("min", histogram.ranges(i));
+ WriteIntAttribute("max", histogram.ranges(i + 1));
+ WriteIntAttribute("count", snapshot.counts(i));
+ }
+ }
+}
