1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
// Copyright (c) 2012 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.
// This file defines a set of user experience metrics data recorded by
// the MetricsService. This is the unit of data that is sent to the server.
#ifndef CHROME_BROWSER_METRICS_METRICS_LOG_H_
#define CHROME_BROWSER_METRICS_METRICS_LOG_H_
#pragma once
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "chrome/common/metrics/metrics_log_base.h"
#include "chrome/installer/util/google_update_settings.h"
#include "content/public/common/process_type.h"
#include "ui/gfx/size.h"
struct AutocompleteLog;
class PrefService;
namespace base {
class DictionaryValue;
}
namespace tracked_objects {
struct ProcessDataSnapshot;
}
namespace experiments_helper {
struct SelectedGroupId;
}
namespace webkit {
struct WebPluginInfo;
}
// This is a small helper struct to pass Google Update metrics in a single
// reference argument to MetricsLog::RecordEnvironment().
struct GoogleUpdateMetrics {
GoogleUpdateMetrics();
~GoogleUpdateMetrics();
// Defines whether this is a user-level or system-level install.
bool is_system_install;
// The time at which Google Update last started an automatic update check.
base::Time last_started_au;
// The time at which Google Update last successfully recieved update
// information from Google servers.
base::Time last_checked;
// Details about Google Update's attempts to update itself.
GoogleUpdateSettings::ProductData google_update_data;
// Details about Google Update's attempts to update this product.
GoogleUpdateSettings::ProductData product_data;
};
class MetricsLog : public MetricsLogBase {
public:
// Creates a new metrics log
// client_id is the identifier for this profile on this installation
// session_id is an integer that's incremented on each application launch
MetricsLog(const std::string& client_id, int session_id);
virtual ~MetricsLog();
static void RegisterPrefs(PrefService* prefs);
// Get the amount of uptime in seconds since this function was last called.
// This updates the cumulative uptime metric for uninstall as a side effect.
static int64 GetIncrementalUptime(PrefService* pref);
// Get the current version of the application as a string.
static std::string GetVersionString();
// Use |extension| in all uploaded appversions in addition to the standard
// version string.
static void set_version_extension(const std::string& extension);
static const std::string& version_extension();
// Records the current operating environment. Takes the list of installed
// plugins and Google Update statistics as parameters because those can't be
// obtained synchronously from the UI thread.
// profile_metrics, if non-null, gives a dictionary of all profile metrics
// that are to be recorded. Each value in profile_metrics should be a
// dictionary giving the metrics for the profile.
void RecordEnvironment(
const std::vector<webkit::WebPluginInfo>& plugin_list,
const GoogleUpdateMetrics& google_update_metrics,
const base::DictionaryValue* profile_metrics);
// Records the current operating environment. Takes the list of installed
// plugins and Google Update statistics as parameters because those can't be
// obtained synchronously from the UI thread. This is exposed as a separate
// method from the |RecordEnvironment()| method above because we record the
// environment with *each* protobuf upload, but only with the initial XML
// upload.
void RecordEnvironmentProto(
const std::vector<webkit::WebPluginInfo>& plugin_list,
const GoogleUpdateMetrics& google_update_metrics);
// Records the input text, available choices, and selected entry when the
// user uses the Omnibox to open a URL.
void RecordOmniboxOpenedURL(const AutocompleteLog& log);
// Records the passed profiled data, which should be a snapshot of the
// browser's profiled performance during startup for a single process.
void RecordProfilerData(
const tracked_objects::ProcessDataSnapshot& process_data,
content::ProcessType process_type);
// Record recent delta for critical stability metrics. We can't wait for a
// restart to gather these, as that delay biases our observation away from
// users that run happily for a looooong time. We send increments with each
// uma log upload, just as we send histogram data. Takes the list of
// installed plugins as a parameter because that can't be obtained
// synchronously from the UI thread.
void RecordIncrementalStabilityElements(
const std::vector<webkit::WebPluginInfo>& plugin_list);
protected:
// Exposed for the sake of mocking in test code.
// Returns the PrefService from which to log metrics data.
virtual PrefService* GetPrefService();
// Returns the screen size for the primary monitor.
virtual gfx::Size GetScreenSize() const;
// Returns the number of monitors the user is using.
virtual int GetScreenCount() const;
// Fills |field_trial_ids| with the list of initialized field trials name and
// group ids.
virtual void GetFieldTrialIds(
std::vector<experiments_helper::SelectedGroupId>* field_trial_ids) const;
private:
FRIEND_TEST_ALL_PREFIXES(MetricsLogTest, ChromeOSStabilityData);
// Writes application stability metrics (as part of the profile log).
// NOTE: Has the side-effect of clearing those counts.
void WriteStabilityElement(
const std::vector<webkit::WebPluginInfo>& plugin_list,
PrefService* pref);
// Within stability group, write plugin crash stats.
void WritePluginStabilityElements(
const std::vector<webkit::WebPluginInfo>& plugin_list,
PrefService* pref);
// Within the stability group, write required attributes.
void WriteRequiredStabilityAttributes(PrefService* pref);
// Within the stability group, write attributes that need to be updated asap
// and can't be delayed until the user decides to restart chromium.
// Delaying these stats would bias metrics away from happy long lived
// chromium processes (ones that don't crash, and keep on running).
void WriteRealtimeStabilityAttributes(PrefService* pref);
// Writes the list of installed plugins. If |write_as_xml| is true, writes
// the XML version. Otherwise, writes the protobuf version.
void WritePluginList(
const std::vector<webkit::WebPluginInfo>& plugin_list,
bool write_as_xml);
// Within the profile group, write basic install info including appversion.
void WriteInstallElement();
// Writes all profile metrics. This invokes WriteProfileMetrics for each key
// in all_profiles_metrics that starts with kProfilePrefix.
void WriteAllProfilesMetrics(
const base::DictionaryValue& all_profiles_metrics);
// Writes metrics for the profile identified by key. This writes all
// key/value pairs in profile_metrics.
void WriteProfileMetrics(const std::string& key,
const base::DictionaryValue& profile_metrics);
// Writes info about the Google Update install that is managing this client.
// This is a no-op if called on a non-Windows platform.
void WriteGoogleUpdateProto(const GoogleUpdateMetrics& google_update_metrics);
DISALLOW_COPY_AND_ASSIGN(MetricsLog);
};
#endif // CHROME_BROWSER_METRICS_METRICS_LOG_H_
|
