OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 // | |
5 // Stores information about the user's brower and system configuration. | |
6 // The system configuration fields are recorded once per client session. | |
7 | |
8 syntax = "proto2"; | |
9 | |
10 option optimize_for = LITE_RUNTIME; | |
11 | |
12 package metrics; | |
13 | |
14 // Next tag: 19 | |
15 message SystemProfileProto { | |
16 // The time when the client was compiled/linked, in seconds since the epoch. | |
17 optional int64 build_timestamp = 1; | |
18 | |
19 // A version number string for the application. | |
20 // Most commonly this is the browser version number found in a user agent | |
21 // string, and is typically a 4-tuple of numbers separated by periods. In | |
22 // cases where the user agent version might be ambiguous (example: Linux 64- | |
23 // bit build, rather than 32-bit build, or a Windows version used in some | |
24 // special context, such as ChromeFrame running in IE), then this may include | |
25 // some additional postfix to provide clarification not available in the UA | |
26 // string. | |
27 // | |
28 // An example of a browser version 4-tuple is "5.0.322.0". Currently used | |
29 // postfixes are: | |
30 // | |
31 // "-64": a 64-bit build | |
32 // "-F": Chrome is running under control of ChromeFrame | |
33 // "-devel": this is not an official build of Chrome | |
34 // | |
35 // A full version number string could look similar to: | |
36 // "5.0.322.0-F-devel". | |
37 // | |
38 // This value, when available, is more trustworthy than the UA string | |
39 // associated with the request; and including the postfix, may be more | |
40 // specific. | |
41 optional string app_version = 2; | |
42 | |
43 // The brand code or distribution tag assigned to a partner, if available. | |
44 // Brand codes are only available on Windows. Not every Windows install | |
45 // though will have a brand code. | |
46 optional string brand_code = 12; | |
47 | |
48 // The possible channels for an installation, from least to most stable. | |
49 enum Channel { | |
50 CHANNEL_UNKNOWN = 0; // Unknown channel -- perhaps an unofficial build? | |
51 CHANNEL_CANARY = 1; | |
52 CHANNEL_DEV = 2; | |
53 CHANNEL_BETA = 3; | |
54 CHANNEL_STABLE = 4; | |
55 } | |
56 optional Channel channel = 10; | |
57 | |
58 // The date the user enabled UMA, in seconds since the epoch. | |
59 // If the user has toggled the UMA enabled state multiple times, this will | |
60 // be the most recent date on which UMA was enabled. | |
61 // For privacy, this is rounded to the nearest hour. | |
62 optional int64 uma_enabled_date = 3; | |
63 | |
64 // The time when the client was installed, in seconds since the epoch. | |
65 // For privacy, this is rounded to the nearest hour. | |
66 optional int64 install_date = 16; | |
67 | |
68 // The user's selected application locale, i.e. the user interface language. | |
69 // The locale includes a language code and, possibly, also a country code, | |
70 // e.g. "en-US". | |
71 optional string application_locale = 4; | |
72 | |
73 // Information on the user's operating system. | |
74 message OS { | |
75 // The user's operating system. | |
76 optional string name = 1; | |
77 | |
78 // The version of the OS. The meaning of this field is OS-dependent. | |
79 optional string version = 2; | |
80 | |
81 // The fingerprint of the build. This field is used only on Android. | |
82 optional string fingerprint = 3; | |
83 } | |
84 optional OS os = 5; | |
85 | |
86 // Next tag for Hardware: 16 | |
87 // Information on the user's hardware. | |
88 message Hardware { | |
89 // The CPU architecture (x86, PowerPC, x86_64, ...) | |
90 optional string cpu_architecture = 1; | |
91 | |
92 // The amount of RAM present on the system, in megabytes. | |
93 optional int64 system_ram_mb = 2; | |
94 | |
95 // The base memory address that chrome.dll was loaded at. | |
96 // (Logged only on Windows.) | |
97 optional int64 dll_base = 3; | |
98 | |
99 // The Chrome OS device hardware class ID is a unique string associated with | |
100 // each Chrome OS device product revision generally assigned at hardware | |
101 // qualification time. The hardware class effectively identifies the | |
102 // configured system components such as CPU, WiFi adapter, etc. | |
103 // | |
104 // An example of such a hardware class is "IEC MARIO PONY 6101". An | |
105 // internal database associates this hardware class with the qualified | |
106 // device specifications including OEM information, schematics, hardware | |
107 // qualification reports, test device tags, etc. | |
108 optional string hardware_class = 4; | |
109 | |
110 // The number of physical screens. | |
111 optional int32 screen_count = 5; | |
112 | |
113 // The screen dimensions of the primary screen, in pixels. | |
114 optional int32 primary_screen_width = 6; | |
115 optional int32 primary_screen_height = 7; | |
116 | |
117 // The device scale factor of the primary screen. | |
118 optional float primary_screen_scale_factor = 12; | |
119 | |
120 // Max DPI for any attached screen. (Windows only) | |
121 optional float max_dpi_x = 9; | |
122 optional float max_dpi_y = 10; | |
123 | |
124 // Information on the CPU obtained by CPUID. | |
125 message CPU { | |
126 // A 12 character string naming the vendor, e.g. "GeniuneIntel". | |
127 optional string vendor_name = 1; | |
128 | |
129 // The signature reported by CPUID (from EAX). | |
130 optional uint32 signature = 2; | |
131 } | |
132 optional CPU cpu = 13; | |
133 | |
134 // Information on the GPU | |
135 message Graphics { | |
136 // The GPU manufacturer's vendor id. | |
137 optional uint32 vendor_id = 1; | |
138 | |
139 // The GPU manufacturer's device id for the chip set. | |
140 optional uint32 device_id = 2; | |
141 | |
142 // The driver version on the GPU. | |
143 optional string driver_version = 3; | |
144 | |
145 // The driver date on the GPU. | |
146 optional string driver_date = 4; | |
147 | |
148 // The GPU performance statistics. | |
149 // See http://src.chromium.org/viewvc/chrome/trunk/src/content/public/comm
on/gpu_performance_stats.h?view=markup | |
150 // for details. Currently logged only on Windows. | |
151 message PerformanceStatistics { | |
152 optional float graphics_score = 1; | |
153 optional float gaming_score = 2; | |
154 optional float overall_score = 3; | |
155 } | |
156 optional PerformanceStatistics performance_statistics = 5; | |
157 | |
158 // The GL_VENDOR string. An example of a gl_vendor string is | |
159 // "Imagination Technologies". "" if we are not using OpenGL. | |
160 optional string gl_vendor = 6; | |
161 | |
162 // The GL_RENDERER string. An example of a gl_renderer string is | |
163 // "PowerVR SGX 540". "" if we are not using OpenGL. | |
164 optional string gl_renderer = 7; | |
165 } | |
166 optional Graphics gpu = 8; | |
167 | |
168 // Information about Bluetooth devices paired with the system. | |
169 message Bluetooth { | |
170 // Whether Bluetooth is present on this system. | |
171 optional bool is_present = 1; | |
172 | |
173 // Whether Bluetooth is enabled on this system. | |
174 optional bool is_enabled = 2; | |
175 | |
176 // Describes a paired device. | |
177 message PairedDevice { | |
178 // Assigned class of the device. This is a bitfield according to the | |
179 // Bluetooth specification available at the following URL: | |
180 // https://www.bluetooth.org/en-us/specification/assigned-numbers-overvi
ew/baseband | |
181 optional uint32 bluetooth_class = 1; | |
182 | |
183 // Decoded device type. | |
184 enum Type { | |
185 DEVICE_UNKNOWN = 0; | |
186 DEVICE_COMPUTER = 1; | |
187 DEVICE_PHONE = 2; | |
188 DEVICE_MODEM = 3; | |
189 DEVICE_AUDIO = 4; | |
190 DEVICE_CAR_AUDIO = 5; | |
191 DEVICE_VIDEO = 6; | |
192 DEVICE_PERIPHERAL = 7; | |
193 DEVICE_JOYSTICK = 8; | |
194 DEVICE_GAMEPAD = 9; | |
195 DEVICE_KEYBOARD = 10; | |
196 DEVICE_MOUSE = 11; | |
197 DEVICE_TABLET = 12; | |
198 DEVICE_KEYBOARD_MOUSE_COMBO = 13; | |
199 } | |
200 optional Type type = 2; | |
201 | |
202 // Vendor prefix of the Bluetooth address, these are OUI registered by | |
203 // the IEEE and are encoded with the first byte in bits 16-23, the | |
204 // second byte in bits 8-15 and the third byte in bits 0-7. | |
205 // | |
206 // ie. Google's OUI (00:1A:11) is encoded as 0x00001A11 | |
207 optional uint32 vendor_prefix = 4; | |
208 | |
209 // The Vendor ID of a device, returned in vendor_id below, can be | |
210 // either allocated by the Bluetooth SIG or USB IF, providing two | |
211 // completely overlapping namespaces for identifiers. | |
212 // | |
213 // This field should be read along with vendor_id to correctly | |
214 // identify the vendor. For example Google is identified by either | |
215 // vendor_id_source = VENDOR_ID_BLUETOOTH, vendor_id = 0x00E0 or | |
216 // vendor_id_source = VENDOR_ID_USB, vendor_id = 0x18D1. | |
217 // | |
218 // If the device does not support the Device ID specification the | |
219 // unknown value will be set. | |
220 enum VendorIDSource { | |
221 VENDOR_ID_UNKNOWN = 0; | |
222 VENDOR_ID_BLUETOOTH = 1; | |
223 VENDOR_ID_USB = 2; | |
224 } | |
225 optional VendorIDSource vendor_id_source = 8; | |
226 | |
227 // Vendor ID of the device, where available. | |
228 optional uint32 vendor_id = 5; | |
229 | |
230 // Product ID of the device, where available. | |
231 optional uint32 product_id = 6; | |
232 | |
233 // Device ID of the device, generally the release or version number in | |
234 // BCD format, where available. | |
235 optional uint32 device_id = 7; | |
236 } | |
237 repeated PairedDevice paired_device = 3; | |
238 } | |
239 optional Bluetooth bluetooth = 11; | |
240 | |
241 // Whether the internal display produces touch events. Omitted if unknown. | |
242 // Logged on ChromeOS only. | |
243 optional bool internal_display_supports_touch = 14; | |
244 | |
245 // Vendor ids and product ids of external touchscreens. | |
246 message TouchScreen { | |
247 // Touch screen vendor id. | |
248 optional uint32 vendor_id = 1; | |
249 // Touch screen product id. | |
250 optional uint32 product_id = 2; | |
251 } | |
252 // Lists vendor and product ids of external touchscreens. | |
253 // Logged on ChromeOS only. | |
254 repeated TouchScreen external_touchscreen = 15; | |
255 } | |
256 optional Hardware hardware = 6; | |
257 | |
258 // Information about the network connection. | |
259 message Network { | |
260 // Set to true if connection_type changed during the lifetime of the log. | |
261 optional bool connection_type_is_ambiguous = 1; | |
262 | |
263 // See net::NetworkChangeNotifier::ConnectionType. | |
264 enum ConnectionType { | |
265 CONNECTION_UNKNOWN = 0; | |
266 CONNECTION_ETHERNET = 1; | |
267 CONNECTION_WIFI = 2; | |
268 CONNECTION_2G = 3; | |
269 CONNECTION_3G = 4; | |
270 CONNECTION_4G = 5; | |
271 } | |
272 // The connection type according to NetworkChangeNotifier. | |
273 optional ConnectionType connection_type = 2; | |
274 | |
275 // Set to true if wifi_phy_layer_protocol changed during the lifetime of the
log. | |
276 optional bool wifi_phy_layer_protocol_is_ambiguous = 3; | |
277 | |
278 // See net::WifiPHYLayerProtocol. | |
279 enum WifiPHYLayerProtocol { | |
280 WIFI_PHY_LAYER_PROTOCOL_NONE = 0; | |
281 WIFI_PHY_LAYER_PROTOCOL_ANCIENT = 1; | |
282 WIFI_PHY_LAYER_PROTOCOL_A = 2; | |
283 WIFI_PHY_LAYER_PROTOCOL_B = 3; | |
284 WIFI_PHY_LAYER_PROTOCOL_G = 4; | |
285 WIFI_PHY_LAYER_PROTOCOL_N = 5; | |
286 WIFI_PHY_LAYER_PROTOCOL_UNKNOWN = 6; | |
287 } | |
288 // The physical layer mode of the associated wifi access point, if any. | |
289 optional WifiPHYLayerProtocol wifi_phy_layer_protocol = 4; | |
290 } | |
291 optional Network network = 13; | |
292 | |
293 // Information on the Google Update install that is managing this client. | |
294 message GoogleUpdate { | |
295 // Whether the Google Update install is system-level or user-level. | |
296 optional bool is_system_install = 1; | |
297 | |
298 // The date at which Google Update last started performing an automatic | |
299 // update check, in seconds since the Unix epoch. | |
300 optional int64 last_automatic_start_timestamp = 2; | |
301 | |
302 // The date at which Google Update last successfully sent an update check | |
303 // and recieved an intact response from the server, in seconds since the | |
304 // Unix epoch. (The updates don't need to be successfully installed.) | |
305 optional int64 last_update_check_timestamp = 3; | |
306 | |
307 // Describes a product being managed by Google Update. (This can also | |
308 // describe Google Update itself.) | |
309 message ProductInfo { | |
310 // The current version of the product that is installed. | |
311 optional string version = 1; | |
312 | |
313 // The date at which Google Update successfully updated this product, | |
314 // stored in seconds since the Unix epoch. This is updated when an update | |
315 // is successfully applied, or if the server reports that no update | |
316 // is available. | |
317 optional int64 last_update_success_timestamp = 2; | |
318 | |
319 // The result reported by the product updater on its last run. | |
320 enum InstallResult { | |
321 INSTALL_RESULT_SUCCESS = 0; | |
322 INSTALL_RESULT_FAILED_CUSTOM_ERROR = 1; | |
323 INSTALL_RESULT_FAILED_MSI_ERROR = 2; | |
324 INSTALL_RESULT_FAILED_SYSTEM_ERROR = 3; | |
325 INSTALL_RESULT_EXIT_CODE = 4; | |
326 } | |
327 optional InstallResult last_result = 3; | |
328 | |
329 // The error code reported by the product updater on its last run. This | |
330 // will typically be a error code specific to the product installer. | |
331 optional int32 last_error = 4; | |
332 | |
333 // The extra error code reported by the product updater on its last run. | |
334 // This will typically be a Win32 error code. | |
335 optional int32 last_extra_error = 5; | |
336 } | |
337 optional ProductInfo google_update_status = 4; | |
338 optional ProductInfo client_status = 5; | |
339 } | |
340 optional GoogleUpdate google_update = 11; | |
341 | |
342 // Information on all installed plugins. | |
343 message Plugin { | |
344 // The plugin's self-reported name and filename (without path). | |
345 optional string name = 1; | |
346 optional string filename = 2; | |
347 | |
348 // The plugin's version. | |
349 optional string version = 3; | |
350 | |
351 // True if the plugin is disabled. | |
352 // If a client has multiple local Chrome user accounts, this is logged based | |
353 // on the first user account launched during the current session. | |
354 optional bool is_disabled = 4; | |
355 | |
356 // True if the plugin is PPAPI. | |
357 optional bool is_pepper = 5; | |
358 } | |
359 repeated Plugin plugin = 7; | |
360 | |
361 // Figures that can be used to generate application stability metrics. | |
362 // All values are counts of events since the last time that these | |
363 // values were reported. | |
364 // Next tag: 24 | |
365 message Stability { | |
366 // Total amount of time that the program was running, in seconds, | |
367 // since the last time a log was recorded, as measured using a client-side | |
368 // clock implemented via TimeTicks, which guarantees that it is monotonic | |
369 // and does not jump if the user changes his/her clock. The TimeTicks | |
370 // implementation also makes the clock not count time the computer is | |
371 // suspended. | |
372 optional int64 incremental_uptime_sec = 1; | |
373 | |
374 // Total amount of time that the program was running, in seconds, | |
375 // since startup, as measured using a client-side clock implemented | |
376 // via TimeTicks, which guarantees that it is monotonic and does not | |
377 // jump if the user changes his/her clock. The TimeTicks implementation | |
378 // also makes the clock not count time the computer is suspended. | |
379 // This field was added for M-35. | |
380 optional int64 uptime_sec = 23; | |
381 | |
382 // Page loads along with renderer crashes and hangs, since page load count | |
383 // roughly corresponds to usage. | |
384 optional int32 page_load_count = 2; | |
385 optional int32 renderer_crash_count = 3; | |
386 optional int32 renderer_hang_count = 4; | |
387 | |
388 // Number of renderer crashes that were for extensions. | |
389 // TODO(isherman): Figure out whether this is also counted in | |
390 // |renderer_crash_count|. | |
391 optional int32 extension_renderer_crash_count = 5; | |
392 | |
393 // Number of non-renderer child process crashes. | |
394 optional int32 child_process_crash_count = 6; | |
395 | |
396 // Number of times the browser has crashed while logged in as the "other | |
397 // user" (guest) account. | |
398 // Logged on ChromeOS only. | |
399 optional int32 other_user_crash_count = 7; | |
400 | |
401 // Number of times the kernel has crashed. | |
402 // Logged on ChromeOS only. | |
403 optional int32 kernel_crash_count = 8; | |
404 | |
405 // Number of times the system has shut down uncleanly. | |
406 // Logged on ChromeOS only. | |
407 optional int32 unclean_system_shutdown_count = 9; | |
408 | |
409 // | |
410 // All the remaining fields in the Stability are recorded at most once per | |
411 // client session. | |
412 // | |
413 | |
414 // The number of times the program was launched. | |
415 // This will typically be equal to 1. However, it is possible that Chrome | |
416 // was unable to upload stability metrics for previous launches (e.g. due to | |
417 // crashing early during startup), and hence this value might be greater | |
418 // than 1. | |
419 optional int32 launch_count = 15; | |
420 // The number of times that it didn't exit cleanly (which we assume to be | |
421 // mostly crashes). | |
422 optional int32 crash_count = 16; | |
423 | |
424 // The number of times the program began, but did not complete, the shutdown | |
425 // process. (For example, this may occur when Windows is shutting down, and | |
426 // it only gives the process a few seconds to clean up.) | |
427 optional int32 incomplete_shutdown_count = 17; | |
428 | |
429 // The number of times the program was able register with breakpad crash | |
430 // services. | |
431 optional int32 breakpad_registration_success_count = 18; | |
432 | |
433 // The number of times the program failed to register with breakpad crash | |
434 // services. If crash registration fails then when the program crashes no | |
435 // crash report will be generated. | |
436 optional int32 breakpad_registration_failure_count = 19; | |
437 | |
438 // The number of times the program has run under a debugger. This should | |
439 // be an exceptional condition. Running under a debugger prevents crash | |
440 // dumps from being generated. | |
441 optional int32 debugger_present_count = 20; | |
442 | |
443 // The number of times the program has run without a debugger attached. | |
444 // This should be most common scenario and should be very close to | |
445 // |launch_count|. | |
446 optional int32 debugger_not_present_count = 21; | |
447 | |
448 // Stability information for all installed plugins. | |
449 message PluginStability { | |
450 // The relevant plugin's information (name, etc.) | |
451 optional Plugin plugin = 1; | |
452 | |
453 // The number of times this plugin's process was launched. | |
454 optional int32 launch_count = 2; | |
455 | |
456 // The number of times this plugin was instantiated on a web page. | |
457 // This will be >= |launch_count|. | |
458 // (A page load with multiple sections drawn by this plugin will | |
459 // increase this count multiple times.) | |
460 optional int32 instance_count = 3; | |
461 | |
462 // The number of times this plugin process crashed. | |
463 // This value will be <= |launch_count|. | |
464 optional int32 crash_count = 4; | |
465 | |
466 // The number of times this plugin could not be loaded. | |
467 optional int32 loading_error_count = 5; | |
468 } | |
469 repeated PluginStability plugin_stability = 22; | |
470 } | |
471 optional Stability stability = 8; | |
472 | |
473 // Description of a field trial or experiment that the user is currently | |
474 // enrolled in. | |
475 // All metrics reported in this upload can potentially be influenced by the | |
476 // field trial. | |
477 message FieldTrial { | |
478 // The name of the field trial, as a 32-bit identifier. | |
479 // Currently, the identifier is a hash of the field trial's name. | |
480 optional fixed32 name_id = 1; | |
481 | |
482 // The user's group within the field trial, as a 32-bit identifier. | |
483 // Currently, the identifier is a hash of the group's name. | |
484 optional fixed32 group_id = 2; | |
485 } | |
486 repeated FieldTrial field_trial = 9; | |
487 | |
488 // Number of users currently signed into a multiprofile session. | |
489 // A zero value indicates that the user count changed while the log is open. | |
490 // Logged only on ChromeOS. | |
491 optional uint32 multi_profile_user_count = 17; | |
492 | |
493 // Information about extensions that are installed, masked to provide better | |
494 // privacy. Only extensions from a single profile are reported; this will | |
495 // generally be the profile used when the browser is started. The profile | |
496 // reported on will remain consistent at least until the browser is | |
497 // relaunched (or the profile is deleted by the user). | |
498 // | |
499 // Each client first picks a value for client_key derived from its UMA | |
500 // client_id: | |
501 // client_key = client_id % 4096 | |
502 // Then, each installed extension is mapped into a hash bucket according to | |
503 // bucket = CityHash64(StringPrintf("%d:%s", | |
504 // client_key, extension_id)) % 1024 | |
505 // The client reports the set of hash buckets occupied by all installed | |
506 // extensions. If multiple extensions map to the same bucket, that bucket is | |
507 // still only reported once. | |
508 repeated int32 occupied_extension_bucket = 18; | |
509 } | |
OLD | NEW |