| 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 |