| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| syntax = "proto2"; |
| |
| import "protos/perfetto/trace/track_event/debug_annotation.proto"; |
| import "protos/perfetto/trace/track_event/log_message.proto"; |
| import "protos/perfetto/trace/track_event/task_execution.proto"; |
| import "protos/perfetto/trace/track_event/chrome_active_processes.proto"; |
| import "protos/perfetto/trace/track_event/chrome_application_state_info.proto"; |
| import "protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.proto"; |
| import "protos/perfetto/trace/track_event/chrome_content_settings_event_info.proto"; |
| import "protos/perfetto/trace/track_event/chrome_frame_reporter.proto"; |
| import "protos/perfetto/trace/track_event/chrome_histogram_sample.proto"; |
| import "protos/perfetto/trace/track_event/chrome_keyed_service.proto"; |
| import "protos/perfetto/trace/track_event/chrome_latency_info.proto"; |
| import "protos/perfetto/trace/track_event/chrome_legacy_ipc.proto"; |
| import "protos/perfetto/trace/track_event/chrome_message_pump.proto"; |
| import "protos/perfetto/trace/track_event/chrome_mojo_event_info.proto"; |
| import "protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.proto"; |
| import "protos/perfetto/trace/track_event/chrome_user_event.proto"; |
| import "protos/perfetto/trace/track_event/chrome_window_handle_event_info.proto"; |
| import "protos/perfetto/trace/track_event/screenshot.proto"; |
| import "protos/perfetto/trace/track_event/source_location.proto"; |
| |
| package perfetto.protos; |
| |
| // NOTE: Full TrackEvent support in the client lib and chrome is WIP, thus these |
| // protos are still subject to change. Don't depend on them staying as they are. |
| |
| // Trace events emitted by client instrumentation library (TRACE_EVENT macros), |
| // which describe activity on a track, such as a thread or asynchronous event |
| // track. The track is specified using separate TrackDescriptor messages and |
| // referred to via the track's UUID. |
| // |
| // A simple TrackEvent packet specifies a timestamp, category, name and type: |
| // ```protobuf |
| // trace_packet { |
| // timestamp: 1000 |
| // track_event { |
| // categories: ["my_cat"] |
| // name: "my_event" |
| // type: TYPE_INSTANT |
| // } |
| // } |
| // ``` |
| // |
| // To associate an event with a custom track (e.g. a thread), the track is |
| // defined in a separate packet and referred to from the TrackEvent by its UUID: |
| // ```protobuf |
| // trace_packet { |
| // track_descriptor { |
| // track_uuid: 1234 |
| // name: "my_track" |
| // |
| // // Optionally, associate the track with a thread. |
| // thread_descriptor { |
| // pid: 10 |
| // tid: 10 |
| // .. |
| // } |
| // } |
| // } |
| // ``` |
| // |
| // A pair of TYPE_SLICE_BEGIN and _END events form a slice on the track: |
| // |
| // ```protobuf |
| // trace_packet { |
| // timestamp: 1200 |
| // track_event { |
| // track_uuid: 1234 |
| // categories: ["my_cat"] |
| // name: "my_slice" |
| // type: TYPE_SLICE_BEGIN |
| // } |
| // } |
| // trace_packet { |
| // timestamp: 1400 |
| // track_event { |
| // track_uuid: 1234 |
| // type: TYPE_SLICE_END |
| // } |
| // } |
| // ``` |
| // TrackEvents also support optimizations to reduce data repetition and encoded |
| // data size, e.g. through data interning (names, categories, ...) and delta |
| // encoding of timestamps/counters. For details, see the InternedData message. |
| // Further, default values for attributes of events on the same sequence (e.g. |
| // their default track association) can be emitted as part of a |
| // TrackEventDefaults message. |
| // |
| // Next reserved id: 13 (up to 15). Next id: 51. |
| message TrackEvent { |
| // Names of categories of the event. In the client library, categories are a |
| // way to turn groups of individual events on or off. |
| // interned EventCategoryName. |
| repeated uint64 category_iids = 3; |
| // non-interned variant. |
| repeated string categories = 22; |
| |
| // Optional name of the event for its display in trace viewer. May be left |
| // unspecified for events with typed arguments. |
| // |
| // Note that metrics should not rely on event names, as they are prone to |
| // changing. Instead, they should use typed arguments to identify the events |
| // they are interested in. |
| oneof name_field { |
| // interned EventName. |
| uint64 name_iid = 10; |
| // non-interned variant. |
| string name = 23; |
| } |
| |
| // TODO(eseckler): Support using binary symbols for category/event names. |
| |
| // Type of the TrackEvent (required if |phase| in LegacyEvent is not set). |
| enum Type { |
| TYPE_UNSPECIFIED = 0; |
| |
| // Slice events are events that have a begin and end timestamp, i.e. a |
| // duration. They can be nested similar to a callstack: If, on the same |
| // track, event B begins after event A, but before A ends, B is a child |
| // event of A and will be drawn as a nested event underneath A in the UI. |
| // Note that child events should always end before their parents (e.g. B |
| // before A). |
| // |
| // Each slice event is formed by a pair of BEGIN + END events. The END event |
| // does not need to repeat any TrackEvent fields it has in common with its |
| // corresponding BEGIN event. Arguments and debug annotations of the BEGIN + |
| // END pair will be merged during trace import. |
| // |
| // Note that we deliberately chose not to support COMPLETE events (which |
| // would specify a duration directly) since clients would need to delay |
| // writing them until the slice is completed, which can result in reordered |
| // events in the trace and loss of unfinished events at the end of a trace. |
| TYPE_SLICE_BEGIN = 1; |
| TYPE_SLICE_END = 2; |
| |
| // Instant events are nestable events without duration. They can be children |
| // of slice events on the same track. |
| TYPE_INSTANT = 3; |
| |
| // Event that provides a value for a counter track. |track_uuid| should |
| // refer to a counter track and |counter_value| set to the new value. Note |
| // that most other TrackEvent fields (e.g. categories, name, ..) are not |
| // supported for TYPE_COUNTER events. See also CounterDescriptor. |
| TYPE_COUNTER = 4; |
| } |
| optional Type type = 9; |
| |
| // Identifies the track of the event. The default value may be overridden |
| // using TrackEventDefaults, e.g., to specify the track of the TraceWriter's |
| // sequence (in most cases sequence = one thread). If no value is specified |
| // here or in TrackEventDefaults, the TrackEvent will be associated with an |
| // implicit trace-global track (uuid 0). See TrackDescriptor::uuid. |
| optional uint64 track_uuid = 11; |
| |
| // A new value for a counter track. |track_uuid| should refer to a track with |
| // a CounterDescriptor, and |type| should be TYPE_COUNTER. For a more |
| // efficient encoding of counter values that are sampled at the beginning/end |
| // of a slice, see |extra_counter_values| and |extra_counter_track_uuids|. |
| // Counter values can optionally be encoded in as delta values (positive or |
| // negative) on each packet sequence (see CounterIncrementalBase). |
| oneof counter_value_field { |
| int64 counter_value = 30; |
| double double_counter_value = 44; |
| } |
| |
| // To encode counter values more efficiently, we support attaching additional |
| // counter values to a TrackEvent of any type. All values will share the same |
| // timestamp specified in the TracePacket. The value at |
| // extra_counter_values[N] is for the counter track referenced by |
| // extra_counter_track_uuids[N]. |
| // |
| // |extra_counter_track_uuids| may also be set via TrackEventDefaults. There |
| // should always be equal or more uuids than values. It is valid to set more |
| // uuids (e.g. via defaults) than values. If uuids are specified in |
| // TrackEventDefaults and a TrackEvent, the TrackEvent uuids override the |
| // default uuid list. |
| // |
| // For example, this allows snapshotting the thread time clock at each |
| // thread-track BEGIN and END event to capture the cpu time delta of a slice. |
| repeated uint64 extra_counter_track_uuids = 31; |
| repeated int64 extra_counter_values = 12; |
| |
| // Counter snapshots using floating point instead of integer values. |
| repeated uint64 extra_double_counter_track_uuids = 45; |
| repeated double extra_double_counter_values = 46; |
| |
| // IDs of flows originating, passing through, or ending at this event. |
| // Flow IDs are global within a trace. |
| // |
| // A flow connects a sequence of TrackEvents within or across tracks, e.g. |
| // an input event may be handled on one thread but cause another event on |
| // a different thread - a flow between the two events can associate them. |
| // |
| // The direction of the flows between events is inferred from the events' |
| // timestamps. The earliest event with the same flow ID becomes the source |
| // of the flow. Any events thereafter are intermediate steps of the flow, |
| // until the flow terminates at the last event with the flow ID. |
| // |
| // Flows can also be explicitly terminated (see |terminating_flow_ids|), so |
| // that the same ID can later be reused for another flow. |
| // DEPRECATED. Only kept for backwards compatibility. Use |flow_ids|. |
| repeated uint64 flow_ids_old = 36 [deprecated = true]; |
| // TODO(b/204341740): replace "flow_ids_old" with "flow_ids" to reduce memory |
| // consumption. |
| repeated fixed64 flow_ids = 47; |
| |
| // List of flow ids which should terminate on this event, otherwise same as |
| // |flow_ids|. |
| // Any one flow ID should be either listed as part of |flow_ids| OR |
| // |terminating_flow_ids|, not both. |
| // DEPRECATED. Only kept for backwards compatibility. Use |
| // |terminating_flow_ids|. |
| repeated uint64 terminating_flow_ids_old = 42 [deprecated = true]; |
| // TODO(b/204341740): replace "terminating_flow_ids_old" with |
| // "terminating_flow_ids" to reduce memory consumption. |
| repeated fixed64 terminating_flow_ids = 48; |
| |
| // --------------------------------------------------------------------------- |
| // TrackEvent arguments: |
| // --------------------------------------------------------------------------- |
| |
| // Unstable key/value annotations shown in the trace viewer but not intended |
| // for metrics use. |
| repeated DebugAnnotation debug_annotations = 4; |
| |
| // Typed event arguments: |
| optional TaskExecution task_execution = 5; |
| optional LogMessage log_message = 21; |
| optional ChromeCompositorSchedulerState cc_scheduler_state = 24; |
| optional ChromeUserEvent chrome_user_event = 25; |
| optional ChromeKeyedService chrome_keyed_service = 26; |
| optional ChromeLegacyIpc chrome_legacy_ipc = 27; |
| optional ChromeHistogramSample chrome_histogram_sample = 28; |
| optional ChromeLatencyInfo chrome_latency_info = 29; |
| optional ChromeFrameReporter chrome_frame_reporter = 32; |
| optional ChromeApplicationStateInfo chrome_application_state_info = 39; |
| optional ChromeRendererSchedulerState chrome_renderer_scheduler_state = 40; |
| optional ChromeWindowHandleEventInfo chrome_window_handle_event_info = 41; |
| optional ChromeContentSettingsEventInfo chrome_content_settings_event_info = |
| 43; |
| optional ChromeActiveProcesses chrome_active_processes = 49; |
| optional Screenshot screenshot = 50; |
| |
| // This field is used only if the source location represents the function that |
| // executes during this event. |
| oneof source_location_field { |
| // Non-interned field. |
| SourceLocation source_location = 33; |
| // Interned field. |
| uint64 source_location_iid = 34; |
| } |
| |
| optional ChromeMessagePump chrome_message_pump = 35; |
| optional ChromeMojoEventInfo chrome_mojo_event_info = 38; |
| |
| // New argument types go here :) |
| |
| // Extension range for typed events defined externally. |
| // See docs/design-docs/extensions.md for more details. |
| // |
| // Extension support is work-in-progress, in the future the way to reserve a |
| // subrange for a particular project will be described here and in the design |
| // document linked above. |
| // |
| // Contact perfetto-dev@googlegroups.com if you are interested in a subrange |
| // for your project. |
| |
| // Extension range reserved for chromium: |
| // https://source.chromium.org/chromium/chromium/src/+/main:base/tracing/protos/chrome_track_event.proto |
| extensions 1000 to 1999; |
| // Extension range reserved for https://b.corp.google.com/issues/301227627. |
| extensions 2000 to 2000; |
| // Extension range for future use. |
| extensions 2001 to 9899; |
| // Reserved for Perfetto unit and integration tests. |
| extensions 9900 to 10000; |
| |
| // --------------------------------------------------------------------------- |
| // Deprecated / legacy event fields, which will be removed in the future: |
| // --------------------------------------------------------------------------- |
| |
| // Deprecated. Use the |timestamp| and |timestamp_clock_id| fields in |
| // TracePacket instead. |
| // |
| // Timestamp in microseconds (usually CLOCK_MONOTONIC). |
| oneof timestamp { |
| // Delta timestamp value since the last TrackEvent or ThreadDescriptor. To |
| // calculate the absolute timestamp value, sum up all delta values of the |
| // preceding TrackEvents since the last ThreadDescriptor and add the sum to |
| // the |reference_timestamp| in ThreadDescriptor. This value should always |
| // be positive. |
| int64 timestamp_delta_us = 1; |
| // Absolute value (e.g. a manually specified timestamp in the macro). |
| // This is a one-off value that does not affect delta timestamp computation |
| // in subsequent TrackEvents. |
| int64 timestamp_absolute_us = 16; |
| } |
| |
| // Deprecated. Use |extra_counter_values| and |extra_counter_track_uuids| to |
| // encode thread time instead. |
| // |
| // CPU time for the current thread (e.g., CLOCK_THREAD_CPUTIME_ID) in |
| // microseconds. |
| oneof thread_time { |
| // Delta timestamp value since the last TrackEvent or ThreadDescriptor. To |
| // calculate the absolute timestamp value, sum up all delta values of the |
| // preceding TrackEvents since the last ThreadDescriptor and add the sum to |
| // the |reference_timestamp| in ThreadDescriptor. This value should always |
| // be positive. |
| int64 thread_time_delta_us = 2; |
| // This is a one-off absolute value that does not affect delta timestamp |
| // computation in subsequent TrackEvents. |
| int64 thread_time_absolute_us = 17; |
| } |
| |
| // Deprecated. Use |extra_counter_values| and |extra_counter_track_uuids| to |
| // encode thread instruction count instead. |
| // |
| // Value of the instruction counter for the current thread. |
| oneof thread_instruction_count { |
| // Same encoding as |thread_time| field above. |
| int64 thread_instruction_count_delta = 8; |
| int64 thread_instruction_count_absolute = 20; |
| } |
| |
| // Apart from {category, time, thread time, tid, pid}, other legacy trace |
| // event attributes are initially simply proxied for conversion to a JSON |
| // trace. We intend to gradually transition these attributes to similar native |
| // features in TrackEvent (e.g. async + flow events), or deprecate them |
| // without replacement where transition is unsuitable. |
| // |
| // Next reserved id: 16 (up to 16). |
| // Next id: 20. |
| message LegacyEvent { |
| // Deprecated, use TrackEvent::name(_iid) instead. |
| // interned EventName. |
| optional uint64 name_iid = 1; |
| optional int32 phase = 2; |
| optional int64 duration_us = 3; |
| optional int64 thread_duration_us = 4; |
| |
| // Elapsed retired instruction count during the event. |
| optional int64 thread_instruction_delta = 15; |
| |
| // used to be |flags|. |
| reserved 5; |
| |
| oneof id { |
| uint64 unscoped_id = 6; |
| uint64 local_id = 10; |
| uint64 global_id = 11; |
| } |
| // Additional optional scope for |id|. |
| optional string id_scope = 7; |
| |
| // Consider the thread timestamps for async BEGIN/END event pairs as valid. |
| optional bool use_async_tts = 9; |
| |
| // Idenfifies a flow. Flow events with the same bind_id are connected. |
| optional uint64 bind_id = 8; |
| // Use the enclosing slice as binding point for a flow end event instead of |
| // the next slice. Flow start/step events always bind to the enclosing |
| // slice. |
| optional bool bind_to_enclosing = 12; |
| |
| enum FlowDirection { |
| FLOW_UNSPECIFIED = 0; |
| FLOW_IN = 1; |
| FLOW_OUT = 2; |
| FLOW_INOUT = 3; |
| } |
| optional FlowDirection flow_direction = 13; |
| |
| enum InstantEventScope { |
| SCOPE_UNSPECIFIED = 0; |
| SCOPE_GLOBAL = 1; |
| SCOPE_PROCESS = 2; |
| SCOPE_THREAD = 3; |
| } |
| optional InstantEventScope instant_event_scope = 14; |
| |
| // Override the pid/tid if the writer needs to emit events on behalf of |
| // another process/thread. This should be the exception. Normally, the |
| // pid+tid from ThreadDescriptor is used. |
| optional int32 pid_override = 18; |
| optional int32 tid_override = 19; |
| } |
| |
| optional LegacyEvent legacy_event = 6; |
| } |
| |
| // Default values for fields of all TrackEvents on the same packet sequence. |
| // Should be emitted as part of TracePacketDefaults whenever incremental state |
| // is cleared. It's defined here because field IDs should match those of the |
| // corresponding fields in TrackEvent. |
| message TrackEventDefaults { |
| optional uint64 track_uuid = 11; |
| repeated uint64 extra_counter_track_uuids = 31; |
| repeated uint64 extra_double_counter_track_uuids = 45; |
| |
| // TODO(eseckler): Support default values for more TrackEvent fields. |
| } |
| |
| // -------------------- |
| // Interned data types: |
| // -------------------- |
| |
| message EventCategory { |
| optional uint64 iid = 1; |
| optional string name = 2; |
| } |
| |
| message EventName { |
| optional uint64 iid = 1; |
| optional string name = 2; |
| } |