| /* |
| * Copyright (C) 2017 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. |
| */ |
| |
| /******************************************************************************* |
| * AUTOGENERATED - DO NOT EDIT |
| ******************************************************************************* |
| * This file has been generated from the protobuf message |
| * perfetto/config/trace_config.proto |
| * by |
| * ../../tools/proto_to_cpp/proto_to_cpp.cc. |
| * If you need to make changes here, change the .proto file and then run |
| * ./tools/gen_tracing_cpp_headers_from_protos |
| */ |
| |
| #ifndef INCLUDE_PERFETTO_TRACING_CORE_TRACE_CONFIG_H_ |
| #define INCLUDE_PERFETTO_TRACING_CORE_TRACE_CONFIG_H_ |
| |
| #include <stdint.h> |
| #include <string> |
| #include <type_traits> |
| #include <vector> |
| |
| #include "perfetto/base/export.h" |
| |
| #include "perfetto/tracing/core/data_source_config.h" |
| |
| // Forward declarations for protobuf types. |
| namespace perfetto { |
| namespace protos { |
| class TraceConfig; |
| class TraceConfig_BufferConfig; |
| class TraceConfig_DataSource; |
| class DataSourceConfig; |
| class FtraceConfig; |
| class ChromeConfig; |
| class InodeFileConfig; |
| class InodeFileConfig_MountPointMappingEntry; |
| class ProcessStatsConfig; |
| class SysStatsConfig; |
| class HeapprofdConfig; |
| class HeapprofdConfig_ContinuousDumpConfig; |
| class AndroidPowerConfig; |
| class AndroidLogConfig; |
| class PackagesListConfig; |
| class TestConfig; |
| class TestConfig_DummyFields; |
| class TraceConfig_BuiltinDataSource; |
| class TraceConfig_ProducerConfig; |
| class TraceConfig_StatsdMetadata; |
| class TraceConfig_GuardrailOverrides; |
| class TraceConfig_TriggerConfig; |
| class TraceConfig_TriggerConfig_Trigger; |
| class TraceConfig_IncrementalStateConfig; |
| class TraceConfig_IncidentReportConfig; |
| } // namespace protos |
| } // namespace perfetto |
| |
| namespace perfetto { |
| |
| class PERFETTO_EXPORT TraceConfig { |
| public: |
| class PERFETTO_EXPORT BufferConfig { |
| public: |
| enum FillPolicy { |
| UNSPECIFIED = 0, |
| RING_BUFFER = 1, |
| DISCARD = 2, |
| }; |
| BufferConfig(); |
| ~BufferConfig(); |
| BufferConfig(BufferConfig&&) noexcept; |
| BufferConfig& operator=(BufferConfig&&); |
| BufferConfig(const BufferConfig&); |
| BufferConfig& operator=(const BufferConfig&); |
| bool operator==(const BufferConfig&) const; |
| bool operator!=(const BufferConfig& other) const { |
| return !(*this == other); |
| } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_BufferConfig&); |
| void ToProto(perfetto::protos::TraceConfig_BufferConfig*) const; |
| |
| uint32_t size_kb() const { return size_kb_; } |
| void set_size_kb(uint32_t value) { size_kb_ = value; } |
| |
| FillPolicy fill_policy() const { return fill_policy_; } |
| void set_fill_policy(FillPolicy value) { fill_policy_ = value; } |
| |
| private: |
| uint32_t size_kb_ = {}; |
| FillPolicy fill_policy_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| class PERFETTO_EXPORT DataSource { |
| public: |
| DataSource(); |
| ~DataSource(); |
| DataSource(DataSource&&) noexcept; |
| DataSource& operator=(DataSource&&); |
| DataSource(const DataSource&); |
| DataSource& operator=(const DataSource&); |
| bool operator==(const DataSource&) const; |
| bool operator!=(const DataSource& other) const { return !(*this == other); } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_DataSource&); |
| void ToProto(perfetto::protos::TraceConfig_DataSource*) const; |
| |
| const DataSourceConfig& config() const { return config_; } |
| DataSourceConfig* mutable_config() { return &config_; } |
| |
| int producer_name_filter_size() const { |
| return static_cast<int>(producer_name_filter_.size()); |
| } |
| const std::vector<std::string>& producer_name_filter() const { |
| return producer_name_filter_; |
| } |
| std::vector<std::string>* mutable_producer_name_filter() { |
| return &producer_name_filter_; |
| } |
| void clear_producer_name_filter() { producer_name_filter_.clear(); } |
| std::string* add_producer_name_filter() { |
| producer_name_filter_.emplace_back(); |
| return &producer_name_filter_.back(); |
| } |
| |
| private: |
| DataSourceConfig config_ = {}; |
| std::vector<std::string> producer_name_filter_; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| class PERFETTO_EXPORT BuiltinDataSource { |
| public: |
| BuiltinDataSource(); |
| ~BuiltinDataSource(); |
| BuiltinDataSource(BuiltinDataSource&&) noexcept; |
| BuiltinDataSource& operator=(BuiltinDataSource&&); |
| BuiltinDataSource(const BuiltinDataSource&); |
| BuiltinDataSource& operator=(const BuiltinDataSource&); |
| bool operator==(const BuiltinDataSource&) const; |
| bool operator!=(const BuiltinDataSource& other) const { |
| return !(*this == other); |
| } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_BuiltinDataSource&); |
| void ToProto(perfetto::protos::TraceConfig_BuiltinDataSource*) const; |
| |
| bool disable_clock_snapshotting() const { |
| return disable_clock_snapshotting_; |
| } |
| void set_disable_clock_snapshotting(bool value) { |
| disable_clock_snapshotting_ = value; |
| } |
| |
| bool disable_trace_config() const { return disable_trace_config_; } |
| void set_disable_trace_config(bool value) { disable_trace_config_ = value; } |
| |
| bool disable_system_info() const { return disable_system_info_; } |
| void set_disable_system_info(bool value) { disable_system_info_ = value; } |
| |
| private: |
| bool disable_clock_snapshotting_ = {}; |
| bool disable_trace_config_ = {}; |
| bool disable_system_info_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| enum LockdownModeOperation { |
| LOCKDOWN_UNCHANGED = 0, |
| LOCKDOWN_CLEAR = 1, |
| LOCKDOWN_SET = 2, |
| }; |
| |
| class PERFETTO_EXPORT ProducerConfig { |
| public: |
| ProducerConfig(); |
| ~ProducerConfig(); |
| ProducerConfig(ProducerConfig&&) noexcept; |
| ProducerConfig& operator=(ProducerConfig&&); |
| ProducerConfig(const ProducerConfig&); |
| ProducerConfig& operator=(const ProducerConfig&); |
| bool operator==(const ProducerConfig&) const; |
| bool operator!=(const ProducerConfig& other) const { |
| return !(*this == other); |
| } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_ProducerConfig&); |
| void ToProto(perfetto::protos::TraceConfig_ProducerConfig*) const; |
| |
| const std::string& producer_name() const { return producer_name_; } |
| void set_producer_name(const std::string& value) { producer_name_ = value; } |
| |
| uint32_t shm_size_kb() const { return shm_size_kb_; } |
| void set_shm_size_kb(uint32_t value) { shm_size_kb_ = value; } |
| |
| uint32_t page_size_kb() const { return page_size_kb_; } |
| void set_page_size_kb(uint32_t value) { page_size_kb_ = value; } |
| |
| private: |
| std::string producer_name_ = {}; |
| uint32_t shm_size_kb_ = {}; |
| uint32_t page_size_kb_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| class PERFETTO_EXPORT StatsdMetadata { |
| public: |
| StatsdMetadata(); |
| ~StatsdMetadata(); |
| StatsdMetadata(StatsdMetadata&&) noexcept; |
| StatsdMetadata& operator=(StatsdMetadata&&); |
| StatsdMetadata(const StatsdMetadata&); |
| StatsdMetadata& operator=(const StatsdMetadata&); |
| bool operator==(const StatsdMetadata&) const; |
| bool operator!=(const StatsdMetadata& other) const { |
| return !(*this == other); |
| } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_StatsdMetadata&); |
| void ToProto(perfetto::protos::TraceConfig_StatsdMetadata*) const; |
| |
| int64_t triggering_alert_id() const { return triggering_alert_id_; } |
| void set_triggering_alert_id(int64_t value) { |
| triggering_alert_id_ = value; |
| } |
| |
| int32_t triggering_config_uid() const { return triggering_config_uid_; } |
| void set_triggering_config_uid(int32_t value) { |
| triggering_config_uid_ = value; |
| } |
| |
| int64_t triggering_config_id() const { return triggering_config_id_; } |
| void set_triggering_config_id(int64_t value) { |
| triggering_config_id_ = value; |
| } |
| |
| int64_t triggering_subscription_id() const { |
| return triggering_subscription_id_; |
| } |
| void set_triggering_subscription_id(int64_t value) { |
| triggering_subscription_id_ = value; |
| } |
| |
| private: |
| int64_t triggering_alert_id_ = {}; |
| int32_t triggering_config_uid_ = {}; |
| int64_t triggering_config_id_ = {}; |
| int64_t triggering_subscription_id_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| class PERFETTO_EXPORT GuardrailOverrides { |
| public: |
| GuardrailOverrides(); |
| ~GuardrailOverrides(); |
| GuardrailOverrides(GuardrailOverrides&&) noexcept; |
| GuardrailOverrides& operator=(GuardrailOverrides&&); |
| GuardrailOverrides(const GuardrailOverrides&); |
| GuardrailOverrides& operator=(const GuardrailOverrides&); |
| bool operator==(const GuardrailOverrides&) const; |
| bool operator!=(const GuardrailOverrides& other) const { |
| return !(*this == other); |
| } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_GuardrailOverrides&); |
| void ToProto(perfetto::protos::TraceConfig_GuardrailOverrides*) const; |
| |
| uint64_t max_upload_per_day_bytes() const { |
| return max_upload_per_day_bytes_; |
| } |
| void set_max_upload_per_day_bytes(uint64_t value) { |
| max_upload_per_day_bytes_ = value; |
| } |
| |
| private: |
| uint64_t max_upload_per_day_bytes_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| class PERFETTO_EXPORT TriggerConfig { |
| public: |
| enum TriggerMode { |
| UNSPECIFIED = 0, |
| START_TRACING = 1, |
| STOP_TRACING = 2, |
| }; |
| |
| class PERFETTO_EXPORT Trigger { |
| public: |
| Trigger(); |
| ~Trigger(); |
| Trigger(Trigger&&) noexcept; |
| Trigger& operator=(Trigger&&); |
| Trigger(const Trigger&); |
| Trigger& operator=(const Trigger&); |
| bool operator==(const Trigger&) const; |
| bool operator!=(const Trigger& other) const { return !(*this == other); } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto( |
| const perfetto::protos::TraceConfig_TriggerConfig_Trigger&); |
| void ToProto(perfetto::protos::TraceConfig_TriggerConfig_Trigger*) const; |
| |
| const std::string& name() const { return name_; } |
| void set_name(const std::string& value) { name_ = value; } |
| |
| const std::string& producer_name_regex() const { |
| return producer_name_regex_; |
| } |
| void set_producer_name_regex(const std::string& value) { |
| producer_name_regex_ = value; |
| } |
| |
| uint32_t stop_delay_ms() const { return stop_delay_ms_; } |
| void set_stop_delay_ms(uint32_t value) { stop_delay_ms_ = value; } |
| |
| private: |
| std::string name_ = {}; |
| std::string producer_name_regex_ = {}; |
| uint32_t stop_delay_ms_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| TriggerConfig(); |
| ~TriggerConfig(); |
| TriggerConfig(TriggerConfig&&) noexcept; |
| TriggerConfig& operator=(TriggerConfig&&); |
| TriggerConfig(const TriggerConfig&); |
| TriggerConfig& operator=(const TriggerConfig&); |
| bool operator==(const TriggerConfig&) const; |
| bool operator!=(const TriggerConfig& other) const { |
| return !(*this == other); |
| } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_TriggerConfig&); |
| void ToProto(perfetto::protos::TraceConfig_TriggerConfig*) const; |
| |
| TriggerMode trigger_mode() const { return trigger_mode_; } |
| void set_trigger_mode(TriggerMode value) { trigger_mode_ = value; } |
| |
| int triggers_size() const { return static_cast<int>(triggers_.size()); } |
| const std::vector<Trigger>& triggers() const { return triggers_; } |
| std::vector<Trigger>* mutable_triggers() { return &triggers_; } |
| void clear_triggers() { triggers_.clear(); } |
| Trigger* add_triggers() { |
| triggers_.emplace_back(); |
| return &triggers_.back(); |
| } |
| |
| uint32_t trigger_timeout_ms() const { return trigger_timeout_ms_; } |
| void set_trigger_timeout_ms(uint32_t value) { trigger_timeout_ms_ = value; } |
| |
| private: |
| TriggerMode trigger_mode_ = {}; |
| std::vector<Trigger> triggers_; |
| uint32_t trigger_timeout_ms_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| class PERFETTO_EXPORT IncrementalStateConfig { |
| public: |
| IncrementalStateConfig(); |
| ~IncrementalStateConfig(); |
| IncrementalStateConfig(IncrementalStateConfig&&) noexcept; |
| IncrementalStateConfig& operator=(IncrementalStateConfig&&); |
| IncrementalStateConfig(const IncrementalStateConfig&); |
| IncrementalStateConfig& operator=(const IncrementalStateConfig&); |
| bool operator==(const IncrementalStateConfig&) const; |
| bool operator!=(const IncrementalStateConfig& other) const { |
| return !(*this == other); |
| } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_IncrementalStateConfig&); |
| void ToProto(perfetto::protos::TraceConfig_IncrementalStateConfig*) const; |
| |
| uint32_t clear_period_ms() const { return clear_period_ms_; } |
| void set_clear_period_ms(uint32_t value) { clear_period_ms_ = value; } |
| |
| private: |
| uint32_t clear_period_ms_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| enum CompressionType { |
| COMPRESSION_TYPE_UNSPECIFIED = 0, |
| COMPRESSION_TYPE_DEFLATE = 1, |
| }; |
| |
| class PERFETTO_EXPORT IncidentReportConfig { |
| public: |
| IncidentReportConfig(); |
| ~IncidentReportConfig(); |
| IncidentReportConfig(IncidentReportConfig&&) noexcept; |
| IncidentReportConfig& operator=(IncidentReportConfig&&); |
| IncidentReportConfig(const IncidentReportConfig&); |
| IncidentReportConfig& operator=(const IncidentReportConfig&); |
| bool operator==(const IncidentReportConfig&) const; |
| bool operator!=(const IncidentReportConfig& other) const { |
| return !(*this == other); |
| } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig_IncidentReportConfig&); |
| void ToProto(perfetto::protos::TraceConfig_IncidentReportConfig*) const; |
| |
| const std::string& destination_package() const { |
| return destination_package_; |
| } |
| void set_destination_package(const std::string& value) { |
| destination_package_ = value; |
| } |
| |
| const std::string& destination_class() const { return destination_class_; } |
| void set_destination_class(const std::string& value) { |
| destination_class_ = value; |
| } |
| |
| int32_t privacy_level() const { return privacy_level_; } |
| void set_privacy_level(int32_t value) { privacy_level_ = value; } |
| |
| bool skip_dropbox() const { return skip_dropbox_; } |
| void set_skip_dropbox(bool value) { skip_dropbox_ = value; } |
| |
| private: |
| std::string destination_package_ = {}; |
| std::string destination_class_ = {}; |
| int32_t privacy_level_ = {}; |
| bool skip_dropbox_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| TraceConfig(); |
| ~TraceConfig(); |
| TraceConfig(TraceConfig&&) noexcept; |
| TraceConfig& operator=(TraceConfig&&); |
| TraceConfig(const TraceConfig&); |
| TraceConfig& operator=(const TraceConfig&); |
| bool operator==(const TraceConfig&) const; |
| bool operator!=(const TraceConfig& other) const { return !(*this == other); } |
| |
| // Conversion methods from/to the corresponding protobuf types. |
| void FromProto(const perfetto::protos::TraceConfig&); |
| void ToProto(perfetto::protos::TraceConfig*) const; |
| |
| int buffers_size() const { return static_cast<int>(buffers_.size()); } |
| const std::vector<BufferConfig>& buffers() const { return buffers_; } |
| std::vector<BufferConfig>* mutable_buffers() { return &buffers_; } |
| void clear_buffers() { buffers_.clear(); } |
| BufferConfig* add_buffers() { |
| buffers_.emplace_back(); |
| return &buffers_.back(); |
| } |
| |
| int data_sources_size() const { |
| return static_cast<int>(data_sources_.size()); |
| } |
| const std::vector<DataSource>& data_sources() const { return data_sources_; } |
| std::vector<DataSource>* mutable_data_sources() { return &data_sources_; } |
| void clear_data_sources() { data_sources_.clear(); } |
| DataSource* add_data_sources() { |
| data_sources_.emplace_back(); |
| return &data_sources_.back(); |
| } |
| |
| const BuiltinDataSource& builtin_data_sources() const { |
| return builtin_data_sources_; |
| } |
| BuiltinDataSource* mutable_builtin_data_sources() { |
| return &builtin_data_sources_; |
| } |
| |
| uint32_t duration_ms() const { return duration_ms_; } |
| void set_duration_ms(uint32_t value) { duration_ms_ = value; } |
| |
| bool enable_extra_guardrails() const { return enable_extra_guardrails_; } |
| void set_enable_extra_guardrails(bool value) { |
| enable_extra_guardrails_ = value; |
| } |
| |
| LockdownModeOperation lockdown_mode() const { return lockdown_mode_; } |
| void set_lockdown_mode(LockdownModeOperation value) { |
| lockdown_mode_ = value; |
| } |
| |
| int producers_size() const { return static_cast<int>(producers_.size()); } |
| const std::vector<ProducerConfig>& producers() const { return producers_; } |
| std::vector<ProducerConfig>* mutable_producers() { return &producers_; } |
| void clear_producers() { producers_.clear(); } |
| ProducerConfig* add_producers() { |
| producers_.emplace_back(); |
| return &producers_.back(); |
| } |
| |
| const StatsdMetadata& statsd_metadata() const { return statsd_metadata_; } |
| StatsdMetadata* mutable_statsd_metadata() { return &statsd_metadata_; } |
| |
| bool write_into_file() const { return write_into_file_; } |
| void set_write_into_file(bool value) { write_into_file_ = value; } |
| |
| uint32_t file_write_period_ms() const { return file_write_period_ms_; } |
| void set_file_write_period_ms(uint32_t value) { |
| file_write_period_ms_ = value; |
| } |
| |
| uint64_t max_file_size_bytes() const { return max_file_size_bytes_; } |
| void set_max_file_size_bytes(uint64_t value) { max_file_size_bytes_ = value; } |
| |
| const GuardrailOverrides& guardrail_overrides() const { |
| return guardrail_overrides_; |
| } |
| GuardrailOverrides* mutable_guardrail_overrides() { |
| return &guardrail_overrides_; |
| } |
| |
| bool deferred_start() const { return deferred_start_; } |
| void set_deferred_start(bool value) { deferred_start_ = value; } |
| |
| uint32_t flush_period_ms() const { return flush_period_ms_; } |
| void set_flush_period_ms(uint32_t value) { flush_period_ms_ = value; } |
| |
| uint32_t flush_timeout_ms() const { return flush_timeout_ms_; } |
| void set_flush_timeout_ms(uint32_t value) { flush_timeout_ms_ = value; } |
| |
| bool notify_traceur() const { return notify_traceur_; } |
| void set_notify_traceur(bool value) { notify_traceur_ = value; } |
| |
| const TriggerConfig& trigger_config() const { return trigger_config_; } |
| TriggerConfig* mutable_trigger_config() { return &trigger_config_; } |
| |
| int activate_triggers_size() const { |
| return static_cast<int>(activate_triggers_.size()); |
| } |
| const std::vector<std::string>& activate_triggers() const { |
| return activate_triggers_; |
| } |
| std::vector<std::string>* mutable_activate_triggers() { |
| return &activate_triggers_; |
| } |
| void clear_activate_triggers() { activate_triggers_.clear(); } |
| std::string* add_activate_triggers() { |
| activate_triggers_.emplace_back(); |
| return &activate_triggers_.back(); |
| } |
| |
| const IncrementalStateConfig& incremental_state_config() const { |
| return incremental_state_config_; |
| } |
| IncrementalStateConfig* mutable_incremental_state_config() { |
| return &incremental_state_config_; |
| } |
| |
| bool allow_user_build_tracing() const { return allow_user_build_tracing_; } |
| void set_allow_user_build_tracing(bool value) { |
| allow_user_build_tracing_ = value; |
| } |
| |
| const std::string& unique_session_name() const { |
| return unique_session_name_; |
| } |
| void set_unique_session_name(const std::string& value) { |
| unique_session_name_ = value; |
| } |
| |
| CompressionType compression_type() const { return compression_type_; } |
| void set_compression_type(CompressionType value) { |
| compression_type_ = value; |
| } |
| |
| const IncidentReportConfig& incident_report_config() const { |
| return incident_report_config_; |
| } |
| IncidentReportConfig* mutable_incident_report_config() { |
| return &incident_report_config_; |
| } |
| |
| private: |
| std::vector<BufferConfig> buffers_; |
| std::vector<DataSource> data_sources_; |
| BuiltinDataSource builtin_data_sources_ = {}; |
| uint32_t duration_ms_ = {}; |
| bool enable_extra_guardrails_ = {}; |
| LockdownModeOperation lockdown_mode_ = {}; |
| std::vector<ProducerConfig> producers_; |
| StatsdMetadata statsd_metadata_ = {}; |
| bool write_into_file_ = {}; |
| uint32_t file_write_period_ms_ = {}; |
| uint64_t max_file_size_bytes_ = {}; |
| GuardrailOverrides guardrail_overrides_ = {}; |
| bool deferred_start_ = {}; |
| uint32_t flush_period_ms_ = {}; |
| uint32_t flush_timeout_ms_ = {}; |
| bool notify_traceur_ = {}; |
| TriggerConfig trigger_config_ = {}; |
| std::vector<std::string> activate_triggers_; |
| IncrementalStateConfig incremental_state_config_ = {}; |
| bool allow_user_build_tracing_ = {}; |
| std::string unique_session_name_ = {}; |
| CompressionType compression_type_ = {}; |
| IncidentReportConfig incident_report_config_ = {}; |
| |
| // Allows to preserve unknown protobuf fields for compatibility |
| // with future versions of .proto files. |
| std::string unknown_fields_; |
| }; |
| |
| } // namespace perfetto |
| |
| #endif // INCLUDE_PERFETTO_TRACING_CORE_TRACE_CONFIG_H_ |