| // Copyright 2016 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. |
| |
| syntax = "proto2"; |
| |
| option optimize_for = LITE_RUNTIME; |
| |
| package browser_watcher; |
| |
| // The state of the system on which Chrome is running (shutting down, battery |
| // level, load, etc.). |
| // Next id: 2 |
| message SystemState { |
| // The state of a system session. A system session begins when the system |
| // starts and ends when it shuts down. |
| enum SessionState { |
| UNKNOWN = 0; |
| CLEAN = 1; // Normal shutdown. |
| UNCLEAN = 2; // Abnormal shutdown (system crash, power loss). |
| } |
| |
| // The state of the system session that contained Chrome's execution. |
| optional SessionState session_state = 1; |
| } |
| |
| // Next id: 10 |
| message CodeModule { |
| // The base address of this code module as it was loaded by the process. |
| optional int64 base_address = 1; |
| |
| // The size of the code module. |
| optional int64 size = 2; |
| |
| // The path or file name that the code module was loaded from. |
| optional string code_file = 3; |
| |
| // An identifying string used to discriminate between multiple versions and |
| // builds of the same code module. This may contain a uuid, timestamp, |
| // version number, or any combination of this or other information, in an |
| // implementation-defined format. |
| optional string code_identifier = 4; |
| |
| // The filename containing debugging information associated with the code |
| // module. If debugging information is stored in a file separate from the |
| // code module itself (as is the case when .pdb or .dSYM files are used), |
| // this will be different from code_file. If debugging information is |
| // stored in the code module itself (possibly prior to stripping), this |
| // will be the same as code_file. |
| optional string debug_file = 5; |
| |
| // An identifying string similar to code_identifier, but identifies a |
| // specific version and build of the associated debug file. This may be |
| // the same as code_identifier when the debug_file and code_file are |
| // identical or when the same identifier is used to identify distinct |
| // debug and code files. |
| optional string debug_identifier = 6; |
| |
| // A human-readable representation of the code module's version. |
| optional string version = 7; |
| |
| optional int64 shrink_down_delta = 8; |
| |
| // Whether the module was still loaded into memory. |
| optional bool is_unloaded = 9; |
| } |
| |
| // A typed value holds values of interest or references to such values. |
| // Next id: 9 |
| message TypedValue { |
| // A reference to a value of interest. |
| message Reference { |
| optional uint64 address = 1; |
| optional int64 size = 2; |
| } |
| |
| oneof value { |
| bytes bytes_value = 1; |
| Reference bytes_reference = 2; |
| string string_value = 3; |
| Reference string_reference = 4; |
| string char_value = 5; |
| bool bool_value = 6; |
| int64 signed_value = 7; |
| uint64 unsigned_value = 8; |
| } |
| } |
| |
| // An activity represents information about something of interest on a thread. |
| // Next id: 14 |
| message Activity { |
| enum Type { |
| UNKNOWN = 0; |
| ACT_TASK_RUN = 1; |
| ACT_LOCK_ACQUIRE = 2; |
| ACT_EVENT_WAIT = 3; |
| ACT_THREAD_JOIN = 4; |
| ACT_PROCESS_WAIT = 5; |
| ACT_GENERIC = 6; |
| } |
| |
| // Identifies the type of the activity (and specifies which fields are |
| // relevant). |
| optional Type type = 1; |
| |
| // Creation time of the activity. |
| optional int64 time = 2; |
| |
| // The address that pushed the activity onto the stack. |
| optional uint64 address = 11; |
| |
| // The address that is the origin of the activity. This is useful for things |
| // like tasks that are posted from a completely different thread though most |
| // activities will leave it null. |
| optional uint64 origin_address = 3; |
| |
| // The sequence identifier of the posted task. |
| // Expected for ACT_TASK_* |
| optional uint64 task_sequence_id = 4; |
| |
| // The memory address of the lock object. |
| optional uint64 lock_address = 5; |
| |
| // The memory address of the event object. |
| optional uint64 event_address = 6; |
| |
| // A unique identifier for a thread within a process. |
| optional int64 thread_id = 7; |
| |
| // A unique identifier for a process. |
| optional int64 process_id = 8; |
| |
| // An arbitrary identifier used for association. |
| optional uint32 generic_id = 12; |
| |
| // An arbitrary value used for information purposes. |
| optional int32 generic_data = 13; |
| |
| // Tag id 10 is reserved for server side augmentation. |
| |
| // A key-value store. |
| map<string, TypedValue> user_data = 9; |
| } |
| |
| // The state of a thread. |
| // Next id: 5 |
| message ThreadState { |
| // The name of the thread, up to a maxiumum length. |
| optional string thread_name = 1; |
| |
| // The identifier of the thread. |
| optional int64 thread_id = 2; |
| |
| // The activity stack. |activity_count| specifies the number of activities on |
| // stack and |activities| holds the base of the stack (up to a maximum size). |
| optional int32 activity_count = 3; |
| repeated Activity activities = 4; |
| } |
| |
| // The state of a process. |
| // Next id: 4 |
| message ProcessState { |
| // The identifier of the process. |
| optional int64 process_id = 3; |
| |
| // Note: likely only a subset of modules of interest (e.g. Chromium's own |
| // modules). |
| repeated CodeModule modules = 1; |
| repeated ThreadState threads = 2; |
| // TODO(manzagop): add experiment state. |
| } |
| |
| // Description of a field trial or experiment that the user is currently |
| // enrolled in. This message is an analogue of the UMA proto in |
| // components/metrics/proto/system_profile.proto. For details about generating |
| // the identifiers from the field trial and group names, see |
| // variations::MakeActiveGroupId(). |
| // Next id: 3 |
| message FieldTrial { |
| // A 32-bit identifier for the name of the field trial. |
| optional fixed32 name_id = 1; |
| |
| // A 32-bit identifier for the user's group within the field trial. |
| optional fixed32 group_id = 2; |
| } |
| |
| // A stability report contains information pertaining to the execution of a |
| // single logical instance of a "chrome browser". It is comprised of information |
| // about the system state and about the chrome browser's processes. |
| // Next id: 7 |
| message StabilityReport { |
| // Whether the report is complete. Reports can be incomplete when the |
| // recording size quota is hit. |
| optional bool is_complete = 6; |
| |
| optional SystemState system_state = 1; |
| // TODO(manzagop): revisit whether a single repeated field should contain all |
| // processes, or whether it's preferable to have separate fields per type. |
| // TODO(manzagop): add information about the type of process, pid, process |
| // times (e.g. start time), hierarchical relationships (e.g. parent pid), |
| // command line, etc. |
| repeated ProcessState process_states = 2; |
| // TODO(manzagop): if/when reports contain multiple processes, attribute and |
| // relocate these to their process (and perhaps thread). |
| repeated string log_messages = 3; |
| map<string, TypedValue> global_data = 4; |
| |
| // The field trials the user is currently enrolled in. |
| repeated FieldTrial field_trials = 5; |
| } |