123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740 |
- // Copyright (c) 2015 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.
- #include "base/trace_event/trace_config.h"
- #include <stddef.h>
- #include <algorithm>
- #include <utility>
- #include "base/json/json_reader.h"
- #include "base/json/json_writer.h"
- #include "base/logging.h"
- #include "base/memory/ptr_util.h"
- #include "base/notreached.h"
- #include "base/strings/string_split.h"
- #include "base/trace_event/memory_dump_manager.h"
- #include "base/trace_event/memory_dump_request_args.h"
- #include "base/trace_event/trace_event.h"
- #include "third_party/abseil-cpp/absl/types/optional.h"
- namespace base {
- namespace trace_event {
- namespace {
- // String options that can be used to initialize TraceOptions.
- const char kRecordUntilFull[] = "record-until-full";
- const char kRecordContinuously[] = "record-continuously";
- const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
- const char kTraceToConsole[] = "trace-to-console";
- const char kEnableSystrace[] = "enable-systrace";
- constexpr int kEnableSystraceLength = sizeof(kEnableSystrace) - 1;
- const char kEnableArgumentFilter[] = "enable-argument-filter";
- // String parameters that can be used to parse the trace config string.
- const char kRecordModeParam[] = "record_mode";
- const char kTraceBufferSizeInEvents[] = "trace_buffer_size_in_events";
- const char kTraceBufferSizeInKb[] = "trace_buffer_size_in_kb";
- const char kEnableSystraceParam[] = "enable_systrace";
- const char kSystraceEventsParam[] = "enable_systrace_events";
- const char kEnableArgumentFilterParam[] = "enable_argument_filter";
- const char kEnableEventPackageNameFilterParam[] = "enable_package_name_filter";
- // String parameters that is used to parse memory dump config in trace config
- // string.
- const char kMemoryDumpConfigParam[] = "memory_dump_config";
- const char kAllowedDumpModesParam[] = "allowed_dump_modes";
- const char kTriggersParam[] = "triggers";
- const char kTriggerModeParam[] = "mode";
- const char kMinTimeBetweenDumps[] = "min_time_between_dumps_ms";
- const char kTriggerTypeParam[] = "type";
- const char kPeriodicIntervalLegacyParam[] = "periodic_interval_ms";
- const char kHeapProfilerOptions[] = "heap_profiler_options";
- const char kBreakdownThresholdBytes[] = "breakdown_threshold_bytes";
- // String parameters used to parse category event filters.
- const char kEventFiltersParam[] = "event_filters";
- const char kFilterPredicateParam[] = "filter_predicate";
- const char kFilterArgsParam[] = "filter_args";
- // String parameter used to parse process filter.
- const char kIncludedProcessesParam[] = "included_process_ids";
- const char kHistogramNamesParam[] = "histogram_names";
- class ConvertableTraceConfigToTraceFormat
- : public base::trace_event::ConvertableToTraceFormat {
- public:
- explicit ConvertableTraceConfigToTraceFormat(const TraceConfig& trace_config)
- : trace_config_(trace_config) {}
- ~ConvertableTraceConfigToTraceFormat() override = default;
- void AppendAsTraceFormat(std::string* out) const override {
- out->append(trace_config_.ToString());
- }
- private:
- const TraceConfig trace_config_;
- };
- std::set<MemoryDumpLevelOfDetail> GetDefaultAllowedMemoryDumpModes() {
- std::set<MemoryDumpLevelOfDetail> all_modes;
- for (uint32_t mode = static_cast<uint32_t>(MemoryDumpLevelOfDetail::FIRST);
- mode <= static_cast<uint32_t>(MemoryDumpLevelOfDetail::LAST); mode++) {
- all_modes.insert(static_cast<MemoryDumpLevelOfDetail>(mode));
- }
- return all_modes;
- }
- } // namespace
- TraceConfig::MemoryDumpConfig::HeapProfiler::HeapProfiler()
- : breakdown_threshold_bytes(kDefaultBreakdownThresholdBytes) {}
- void TraceConfig::MemoryDumpConfig::HeapProfiler::Clear() {
- breakdown_threshold_bytes = kDefaultBreakdownThresholdBytes;
- }
- void TraceConfig::ResetMemoryDumpConfig(
- const TraceConfig::MemoryDumpConfig& memory_dump_config) {
- memory_dump_config_.Clear();
- memory_dump_config_ = memory_dump_config;
- }
- TraceConfig::MemoryDumpConfig::MemoryDumpConfig() = default;
- TraceConfig::MemoryDumpConfig::MemoryDumpConfig(
- const MemoryDumpConfig& other) = default;
- TraceConfig::MemoryDumpConfig::~MemoryDumpConfig() = default;
- void TraceConfig::MemoryDumpConfig::Clear() {
- allowed_dump_modes.clear();
- triggers.clear();
- heap_profiler_options.Clear();
- }
- void TraceConfig::MemoryDumpConfig::Merge(
- const TraceConfig::MemoryDumpConfig& config) {
- triggers.insert(triggers.end(), config.triggers.begin(),
- config.triggers.end());
- allowed_dump_modes.insert(config.allowed_dump_modes.begin(),
- config.allowed_dump_modes.end());
- heap_profiler_options.breakdown_threshold_bytes =
- std::min(heap_profiler_options.breakdown_threshold_bytes,
- config.heap_profiler_options.breakdown_threshold_bytes);
- }
- TraceConfig::ProcessFilterConfig::ProcessFilterConfig() = default;
- TraceConfig::ProcessFilterConfig::ProcessFilterConfig(
- const ProcessFilterConfig& other) = default;
- TraceConfig::ProcessFilterConfig::ProcessFilterConfig(
- const std::unordered_set<base::ProcessId>& included_process_ids)
- : included_process_ids_(included_process_ids) {}
- TraceConfig::ProcessFilterConfig::~ProcessFilterConfig() = default;
- void TraceConfig::ProcessFilterConfig::Clear() {
- included_process_ids_.clear();
- }
- void TraceConfig::ProcessFilterConfig::Merge(
- const ProcessFilterConfig& config) {
- included_process_ids_.insert(config.included_process_ids_.begin(),
- config.included_process_ids_.end());
- }
- void TraceConfig::ProcessFilterConfig::InitializeFromConfigDict(
- const Value& dict) {
- included_process_ids_.clear();
- const Value* value = dict.FindListKey(kIncludedProcessesParam);
- if (!value)
- return;
- for (auto& pid_value : value->GetListDeprecated()) {
- if (pid_value.is_int()) {
- included_process_ids_.insert(
- static_cast<base::ProcessId>(pid_value.GetInt()));
- }
- }
- }
- void TraceConfig::ProcessFilterConfig::ToDict(Value::Dict& dict) const {
- if (included_process_ids_.empty())
- return;
- base::Value::List list;
- std::set<base::ProcessId> ordered_set(included_process_ids_.begin(),
- included_process_ids_.end());
- for (auto process_id : ordered_set)
- list.Append(static_cast<int>(process_id));
- dict.Set(kIncludedProcessesParam, std::move(list));
- }
- bool TraceConfig::ProcessFilterConfig::IsEnabled(
- base::ProcessId process_id) const {
- return included_process_ids_.empty() ||
- included_process_ids_.count(process_id);
- }
- TraceConfig::EventFilterConfig::EventFilterConfig(
- const std::string& predicate_name)
- : predicate_name_(predicate_name) {}
- TraceConfig::EventFilterConfig::~EventFilterConfig() = default;
- TraceConfig::EventFilterConfig::EventFilterConfig(const EventFilterConfig& tc) {
- *this = tc;
- }
- TraceConfig::EventFilterConfig& TraceConfig::EventFilterConfig::operator=(
- const TraceConfig::EventFilterConfig& rhs) {
- if (this == &rhs)
- return *this;
- predicate_name_ = rhs.predicate_name_;
- category_filter_ = rhs.category_filter_;
- if (!rhs.args_.is_none())
- args_ = rhs.args_.Clone();
- return *this;
- }
- void TraceConfig::EventFilterConfig::InitializeFromConfigDict(
- const Value& event_filter) {
- category_filter_.InitializeFromConfigDict(event_filter);
- const Value* args_dict = event_filter.FindDictKey(kFilterArgsParam);
- if (args_dict)
- args_ = args_dict->Clone();
- }
- void TraceConfig::EventFilterConfig::SetCategoryFilter(
- const TraceConfigCategoryFilter& category_filter) {
- category_filter_ = category_filter;
- }
- void TraceConfig::EventFilterConfig::ToDict(Value::Dict& filter_dict) const {
- filter_dict.Set(kFilterPredicateParam, predicate_name());
- category_filter_.ToDict(filter_dict);
- if (!args_.is_none())
- filter_dict.Set(kFilterArgsParam, args_.Clone());
- }
- bool TraceConfig::EventFilterConfig::GetArgAsSet(
- const char* key,
- std::unordered_set<std::string>* out_set) const {
- const Value* list = args_.FindListPath(key);
- if (!list)
- return false;
- for (const Value& item : list->GetListDeprecated()) {
- if (item.is_string())
- out_set->insert(item.GetString());
- }
- return true;
- }
- bool TraceConfig::EventFilterConfig::IsCategoryGroupEnabled(
- const StringPiece& category_group_name) const {
- return category_filter_.IsCategoryGroupEnabled(category_group_name);
- }
- // static
- std::string TraceConfig::TraceRecordModeToStr(TraceRecordMode record_mode) {
- switch (record_mode) {
- case RECORD_UNTIL_FULL:
- return kRecordUntilFull;
- case RECORD_CONTINUOUSLY:
- return kRecordContinuously;
- case RECORD_AS_MUCH_AS_POSSIBLE:
- return kRecordAsMuchAsPossible;
- case ECHO_TO_CONSOLE:
- return kTraceToConsole;
- default:
- NOTREACHED();
- }
- return kRecordUntilFull;
- }
- TraceConfig::TraceConfig() {
- InitializeDefault();
- }
- TraceConfig::TraceConfig(StringPiece category_filter_string,
- StringPiece trace_options_string) {
- InitializeFromStrings(category_filter_string, trace_options_string);
- }
- TraceConfig::TraceConfig(StringPiece category_filter_string,
- TraceRecordMode record_mode) {
- InitializeFromStrings(category_filter_string,
- TraceConfig::TraceRecordModeToStr(record_mode));
- }
- TraceConfig::TraceConfig(const Value& config) {
- InitializeFromConfigDict(config);
- }
- TraceConfig::TraceConfig(StringPiece config_string) {
- if (!config_string.empty())
- InitializeFromConfigString(config_string);
- else
- InitializeDefault();
- }
- TraceConfig::TraceConfig(const TraceConfig& tc) = default;
- TraceConfig::~TraceConfig() = default;
- TraceConfig& TraceConfig::operator=(const TraceConfig& rhs) {
- if (this == &rhs)
- return *this;
- record_mode_ = rhs.record_mode_;
- trace_buffer_size_in_events_ = rhs.trace_buffer_size_in_events_;
- trace_buffer_size_in_kb_ = rhs.trace_buffer_size_in_kb_;
- enable_systrace_ = rhs.enable_systrace_;
- enable_argument_filter_ = rhs.enable_argument_filter_;
- category_filter_ = rhs.category_filter_;
- process_filter_config_ = rhs.process_filter_config_;
- enable_event_package_name_filter_ = rhs.enable_event_package_name_filter_;
- memory_dump_config_ = rhs.memory_dump_config_;
- event_filters_ = rhs.event_filters_;
- histogram_names_ = rhs.histogram_names_;
- systrace_events_ = rhs.systrace_events_;
- return *this;
- }
- std::string TraceConfig::ToString() const {
- Value dict = ToValue();
- std::string json;
- JSONWriter::Write(dict, &json);
- return json;
- }
- std::unique_ptr<ConvertableToTraceFormat>
- TraceConfig::AsConvertableToTraceFormat() const {
- return std::make_unique<ConvertableTraceConfigToTraceFormat>(*this);
- }
- std::string TraceConfig::ToCategoryFilterString() const {
- return category_filter_.ToFilterString();
- }
- bool TraceConfig::IsCategoryGroupEnabled(
- const StringPiece& category_group_name) const {
- // TraceLog should call this method only as part of enabling/disabling
- // categories.
- return category_filter_.IsCategoryGroupEnabled(category_group_name);
- }
- void TraceConfig::Merge(const TraceConfig& config) {
- if (record_mode_ != config.record_mode_ ||
- enable_systrace_ != config.enable_systrace_ ||
- enable_argument_filter_ != config.enable_argument_filter_ ||
- enable_event_package_name_filter_ !=
- config.enable_event_package_name_filter_) {
- DLOG(ERROR) << "Attempting to merge trace config with a different "
- << "set of options.";
- }
- DCHECK_EQ(trace_buffer_size_in_events_, config.trace_buffer_size_in_events_)
- << "Cannot change trace buffer size";
- category_filter_.Merge(config.category_filter_);
- memory_dump_config_.Merge(config.memory_dump_config_);
- process_filter_config_.Merge(config.process_filter_config_);
- event_filters_.insert(event_filters_.end(), config.event_filters().begin(),
- config.event_filters().end());
- histogram_names_.insert(config.histogram_names().begin(),
- config.histogram_names().end());
- }
- void TraceConfig::Clear() {
- record_mode_ = RECORD_UNTIL_FULL;
- trace_buffer_size_in_events_ = 0;
- trace_buffer_size_in_kb_ = 0;
- enable_systrace_ = false;
- enable_argument_filter_ = false;
- enable_event_package_name_filter_ = false;
- category_filter_.Clear();
- memory_dump_config_.Clear();
- process_filter_config_.Clear();
- event_filters_.clear();
- histogram_names_.clear();
- systrace_events_.clear();
- }
- void TraceConfig::InitializeDefault() {
- record_mode_ = RECORD_UNTIL_FULL;
- trace_buffer_size_in_events_ = 0;
- trace_buffer_size_in_kb_ = 0;
- enable_systrace_ = false;
- enable_argument_filter_ = false;
- enable_event_package_name_filter_ = false;
- }
- void TraceConfig::InitializeFromConfigDict(const Value& dict) {
- record_mode_ = RECORD_UNTIL_FULL;
- const std::string* record_mode = dict.FindStringKey(kRecordModeParam);
- if (record_mode) {
- if (*record_mode == kRecordUntilFull) {
- record_mode_ = RECORD_UNTIL_FULL;
- } else if (*record_mode == kRecordContinuously) {
- record_mode_ = RECORD_CONTINUOUSLY;
- } else if (*record_mode == kTraceToConsole) {
- record_mode_ = ECHO_TO_CONSOLE;
- } else if (*record_mode == kRecordAsMuchAsPossible) {
- record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
- }
- }
- trace_buffer_size_in_events_ = base::saturated_cast<size_t>(
- dict.FindIntKey(kTraceBufferSizeInEvents).value_or(0));
- trace_buffer_size_in_kb_ = base::saturated_cast<size_t>(
- dict.FindIntKey(kTraceBufferSizeInKb).value_or(0));
- enable_systrace_ = dict.FindBoolKey(kEnableSystraceParam).value_or(false);
- enable_argument_filter_ =
- dict.FindBoolKey(kEnableArgumentFilterParam).value_or(false);
- enable_event_package_name_filter_ =
- dict.FindBoolKey(kEnableEventPackageNameFilterParam).value_or(false);
- category_filter_.InitializeFromConfigDict(dict);
- process_filter_config_.InitializeFromConfigDict(dict);
- const Value* category_event_filters = dict.FindListKey(kEventFiltersParam);
- if (category_event_filters)
- SetEventFiltersFromConfigList(*category_event_filters);
- const Value* histogram_names = dict.FindListKey(kHistogramNamesParam);
- if (histogram_names)
- SetHistogramNamesFromConfigList(*histogram_names);
- if (category_filter_.IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
- // If dump triggers not set, the client is using the legacy with just
- // category enabled. So, use the default periodic dump config.
- const Value* memory_dump_config = dict.FindDictKey(kMemoryDumpConfigParam);
- if (memory_dump_config)
- SetMemoryDumpConfigFromConfigDict(*memory_dump_config);
- else
- SetDefaultMemoryDumpConfig();
- }
- systrace_events_.clear();
- if (enable_systrace_) {
- const Value* systrace_events = dict.FindListKey(kSystraceEventsParam);
- if (systrace_events) {
- for (const Value& value : systrace_events->GetListDeprecated())
- systrace_events_.insert(value.GetString());
- }
- }
- }
- void TraceConfig::InitializeFromConfigString(StringPiece config_string) {
- absl::optional<Value> dict = JSONReader::Read(config_string);
- if (dict && dict->is_dict())
- InitializeFromConfigDict(*dict);
- else
- InitializeDefault();
- }
- void TraceConfig::InitializeFromStrings(StringPiece category_filter_string,
- StringPiece trace_options_string) {
- if (!category_filter_string.empty())
- category_filter_.InitializeFromString(category_filter_string);
- record_mode_ = RECORD_UNTIL_FULL;
- trace_buffer_size_in_events_ = 0;
- trace_buffer_size_in_kb_ = 0;
- enable_systrace_ = false;
- systrace_events_.clear();
- enable_argument_filter_ = false;
- enable_event_package_name_filter_ = false;
- if (!trace_options_string.empty()) {
- std::vector<std::string> split =
- SplitString(trace_options_string, ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
- for (const std::string& token : split) {
- if (token == kRecordUntilFull) {
- record_mode_ = RECORD_UNTIL_FULL;
- } else if (token == kRecordContinuously) {
- record_mode_ = RECORD_CONTINUOUSLY;
- } else if (token == kTraceToConsole) {
- record_mode_ = ECHO_TO_CONSOLE;
- } else if (token == kRecordAsMuchAsPossible) {
- record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
- } else if (token.find(kEnableSystrace) == 0) {
- // Find optional events list.
- const size_t length = token.length();
- if (length == kEnableSystraceLength) {
- // Use all predefined categories.
- enable_systrace_ = true;
- continue;
- }
- const auto system_events_not_trimmed =
- token.substr(kEnableSystraceLength);
- const auto system_events =
- TrimString(system_events_not_trimmed, kWhitespaceASCII, TRIM_ALL);
- if (system_events[0] != '=') {
- LOG(ERROR) << "Failed to parse " << token;
- continue;
- }
- enable_systrace_ = true;
- const std::vector<std::string> split_systrace_events = SplitString(
- system_events.substr(1), " ", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
- for (const std::string& systrace_event : split_systrace_events)
- systrace_events_.insert(systrace_event);
- } else if (token == kEnableArgumentFilter) {
- enable_argument_filter_ = true;
- }
- }
- }
- if (category_filter_.IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
- SetDefaultMemoryDumpConfig();
- }
- }
- void TraceConfig::SetMemoryDumpConfigFromConfigDict(
- const Value& memory_dump_config) {
- // Set allowed dump modes.
- memory_dump_config_.allowed_dump_modes.clear();
- const Value* allowed_modes_list =
- memory_dump_config.FindListKey(kAllowedDumpModesParam);
- if (allowed_modes_list) {
- for (const Value& item : allowed_modes_list->GetListDeprecated()) {
- DCHECK(item.is_string());
- memory_dump_config_.allowed_dump_modes.insert(
- StringToMemoryDumpLevelOfDetail(item.GetString()));
- }
- } else {
- // If allowed modes param is not given then allow all modes by default.
- memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes();
- }
- // Set triggers
- memory_dump_config_.triggers.clear();
- const Value* trigger_list = memory_dump_config.FindListKey(kTriggersParam);
- if (trigger_list) {
- for (const Value& trigger : trigger_list->GetListDeprecated()) {
- if (!trigger.is_dict())
- continue;
- MemoryDumpConfig::Trigger dump_config;
- absl::optional<int> interval = trigger.FindIntKey(kMinTimeBetweenDumps);
- if (!interval) {
- // If "min_time_between_dumps_ms" param was not given, then the trace
- // config uses old format where only periodic dumps are supported.
- interval = trigger.FindIntKey(kPeriodicIntervalLegacyParam);
- dump_config.trigger_type = MemoryDumpType::PERIODIC_INTERVAL;
- } else {
- const std::string* trigger_type_str =
- trigger.FindStringKey(kTriggerTypeParam);
- DCHECK(trigger_type_str);
- dump_config.trigger_type = StringToMemoryDumpType(*trigger_type_str);
- }
- DCHECK(interval.has_value());
- DCHECK_GT(*interval, 0);
- dump_config.min_time_between_dumps_ms = static_cast<uint32_t>(*interval);
- const std::string* level_of_detail_str =
- trigger.FindStringKey(kTriggerModeParam);
- DCHECK(level_of_detail_str);
- dump_config.level_of_detail =
- StringToMemoryDumpLevelOfDetail(*level_of_detail_str);
- memory_dump_config_.triggers.push_back(dump_config);
- }
- }
- // Set heap profiler options
- const Value* heap_profiler_options =
- memory_dump_config.FindDictKey(kHeapProfilerOptions);
- if (heap_profiler_options) {
- absl::optional<int> min_size_bytes =
- heap_profiler_options->FindIntKey(kBreakdownThresholdBytes);
- if (min_size_bytes && *min_size_bytes >= 0) {
- memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
- static_cast<uint32_t>(*min_size_bytes);
- } else {
- memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes =
- MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes;
- }
- }
- }
- void TraceConfig::SetDefaultMemoryDumpConfig() {
- memory_dump_config_.Clear();
- memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes();
- }
- void TraceConfig::SetProcessFilterConfig(const ProcessFilterConfig& config) {
- process_filter_config_ = config;
- }
- void TraceConfig::SetHistogramNamesFromConfigList(
- const Value& histogram_names) {
- histogram_names_.clear();
- for (const Value& value : histogram_names.GetListDeprecated())
- histogram_names_.insert(value.GetString());
- }
- void TraceConfig::SetEventFiltersFromConfigList(
- const Value& category_event_filters) {
- event_filters_.clear();
- for (const Value& event_filter : category_event_filters.GetListDeprecated()) {
- if (!event_filter.is_dict())
- continue;
- const std::string* predicate_name =
- event_filter.FindStringKey(kFilterPredicateParam);
- CHECK(predicate_name) << "Invalid predicate name in category event filter.";
- EventFilterConfig new_config(*predicate_name);
- new_config.InitializeFromConfigDict(event_filter);
- event_filters_.push_back(new_config);
- }
- }
- Value TraceConfig::ToValue() const {
- Value::Dict dict;
- dict.Set(kRecordModeParam, TraceConfig::TraceRecordModeToStr(record_mode_));
- dict.Set(kEnableSystraceParam, enable_systrace_);
- dict.Set(kEnableArgumentFilterParam, enable_argument_filter_);
- if (trace_buffer_size_in_events_ > 0) {
- dict.Set(kTraceBufferSizeInEvents,
- base::checked_cast<int>(trace_buffer_size_in_events_));
- }
- if (trace_buffer_size_in_kb_ > 0) {
- dict.Set(kTraceBufferSizeInKb,
- base::checked_cast<int>(trace_buffer_size_in_kb_));
- }
- dict.Set(kEnableEventPackageNameFilterParam,
- enable_event_package_name_filter_);
- category_filter_.ToDict(dict);
- process_filter_config_.ToDict(dict);
- if (!event_filters_.empty()) {
- Value::List filter_list;
- for (const EventFilterConfig& filter : event_filters_) {
- Value::Dict filter_dict;
- filter.ToDict(filter_dict);
- filter_list.Append(std::move(filter_dict));
- }
- dict.Set(kEventFiltersParam, std::move(filter_list));
- }
- if (category_filter_.IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
- Value::List allowed_modes;
- for (auto dump_mode : memory_dump_config_.allowed_dump_modes)
- allowed_modes.Append(MemoryDumpLevelOfDetailToString(dump_mode));
- Value::Dict memory_dump_config;
- memory_dump_config.Set(kAllowedDumpModesParam, std::move(allowed_modes));
- Value::List triggers_list;
- for (const auto& config : memory_dump_config_.triggers) {
- Value::Dict trigger_dict;
- trigger_dict.Set(kTriggerTypeParam,
- MemoryDumpTypeToString(config.trigger_type));
- trigger_dict.Set(kMinTimeBetweenDumps,
- static_cast<int>(config.min_time_between_dumps_ms));
- trigger_dict.Set(kTriggerModeParam,
- MemoryDumpLevelOfDetailToString(config.level_of_detail));
- triggers_list.Append(std::move(trigger_dict));
- }
- // Empty triggers will still be specified explicitly since it means that
- // the periodic dumps are not enabled.
- memory_dump_config.Set(kTriggersParam, std::move(triggers_list));
- if (memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes !=
- MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes) {
- Value options(Value::Type::DICTIONARY);
- options.SetIntKey(
- kBreakdownThresholdBytes,
- base::checked_cast<int>(memory_dump_config_.heap_profiler_options
- .breakdown_threshold_bytes));
- memory_dump_config.Set(kHeapProfilerOptions, std::move(options));
- }
- dict.Set(kMemoryDumpConfigParam, std::move(memory_dump_config));
- }
- if (!histogram_names_.empty()) {
- base::Value::List histogram_names;
- for (const std::string& histogram_name : histogram_names_)
- histogram_names.Append(histogram_name);
- dict.Set(kHistogramNamesParam, std::move(histogram_names));
- }
- if (enable_systrace_) {
- if (!systrace_events_.empty()) {
- base::Value::List systrace_events;
- for (const std::string& systrace_event : systrace_events_)
- systrace_events.Append(systrace_event);
- dict.Set(kSystraceEventsParam, std::move(systrace_events));
- }
- }
- return Value(std::move(dict));
- }
- void TraceConfig::EnableSystraceEvent(const std::string& systrace_event) {
- systrace_events_.insert(systrace_event);
- }
- void TraceConfig::EnableHistogram(const std::string& histogram_name) {
- histogram_names_.insert(histogram_name);
- }
- std::string TraceConfig::ToTraceOptionsString() const {
- std::string ret;
- switch (record_mode_) {
- case RECORD_UNTIL_FULL:
- ret = kRecordUntilFull;
- break;
- case RECORD_CONTINUOUSLY:
- ret = kRecordContinuously;
- break;
- case RECORD_AS_MUCH_AS_POSSIBLE:
- ret = kRecordAsMuchAsPossible;
- break;
- case ECHO_TO_CONSOLE:
- ret = kTraceToConsole;
- break;
- default:
- NOTREACHED();
- }
- if (enable_systrace_) {
- ret += ",";
- ret += kEnableSystrace;
- bool first_param = true;
- for (const std::string& systrace_event : systrace_events_) {
- if (first_param) {
- ret += "=";
- first_param = false;
- } else {
- ret += " ";
- }
- ret = ret + systrace_event;
- }
- }
- if (enable_argument_filter_) {
- ret += ",";
- ret += kEnableArgumentFilter;
- }
- return ret;
- }
- } // namespace trace_event
- } // namespace base
|