Tracing pre-filtering

base/trace_event/trace_config.cc

 // 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 <utility>
 
@@ skipping 37 matching lines @@
 // 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 kPeriodicIntervalParam[] = "periodic_interval_ms";
 const char kModeParam[] = "mode";
 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";
+
 // Default configuration of memory dumps.
 const TraceConfig::MemoryDumpConfig::Trigger kDefaultHeavyMemoryDumpTrigger = {
     2000,  // periodic_interval_ms
     MemoryDumpLevelOfDetail::DETAILED};
 const TraceConfig::MemoryDumpConfig::Trigger kDefaultLightMemoryDumpTrigger = {
     250,  // periodic_interval_ms
     MemoryDumpLevelOfDetail::LIGHT};
 
 class ConvertableTraceConfigToTraceFormat
     : public base::trace_event::ConvertableToTraceFormat {
  public:
   explicit ConvertableTraceConfigToTraceFormat(const TraceConfig& trace_config)
       : trace_config_(trace_config) {}
+
   ~ConvertableTraceConfigToTraceFormat() override {}
 
   void AppendAsTraceFormat(std::string* out) const override {
     out->append(trace_config_.ToString());
   }
 
  private:
   const TraceConfig trace_config_;
 };
 
@@ skipping 27 matching lines @@
     const MemoryDumpConfig& other) = default;
 
 TraceConfig::MemoryDumpConfig::~MemoryDumpConfig() {}
 
 void TraceConfig::MemoryDumpConfig::Clear() {
   allowed_dump_modes.clear();
   triggers.clear();
   heap_profiler_options.Clear();
 }
 
+TraceConfig::EventFilterConfig::EventFilterConfig(
+    const std::string& predicate_name)
+    : predicate_name_(predicate_name) {}
+TraceConfig::EventFilterConfig::~EventFilterConfig() {}

[shatch, 2016/08/15 21:25:47]

nit: Add newline

[oystein (OOO til 10th of July), 2016/08/16 22:17:52]

Done.

+
+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_;
+  included_categories_ = rhs.included_categories_;
+  excluded_categories_ = rhs.excluded_categories_;
+  if (rhs.args_)
+    args_ = rhs.args_->CreateDeepCopy();
+
+  return *this;
+}
+
+void TraceConfig::EventFilterConfig::AddIncludedCategory(
+    const std::string& category) {
+  included_categories_.push_back(category);
+}
+
+void TraceConfig::EventFilterConfig::AddExcludedCategory(
+    const std::string& category) {
+  excluded_categories_.push_back(category);
+}
+
+void TraceConfig::EventFilterConfig::SetArgs(
+    std::unique_ptr<base::DictionaryValue> args) {
+  args_ = std::move(args);
+}
+
+bool TraceConfig::EventFilterConfig::IsCategoryGroupEnabled(
+    const char* category_group_name) const {
+  CStringTokenizer category_group_tokens(
+      category_group_name, category_group_name + strlen(category_group_name),
+      ",");
+  while (category_group_tokens.GetNext()) {
+    std::string category_group_token = category_group_tokens.token();
+
+    for (const auto& excluded_category : excluded_categories_) {
+      if (base::MatchPattern(category_group_token, excluded_category)) {
+        return false;
+      }
+    }
+
+    for (const auto& included_category : included_categories_) {
+      if (base::MatchPattern(category_group_token, included_category)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 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,
@@ skipping 31 matching lines @@
 
 TraceConfig::TraceConfig(const TraceConfig& tc)
     : record_mode_(tc.record_mode_),
       enable_sampling_(tc.enable_sampling_),
       enable_systrace_(tc.enable_systrace_),
       enable_argument_filter_(tc.enable_argument_filter_),
       memory_dump_config_(tc.memory_dump_config_),
       included_categories_(tc.included_categories_),
       disabled_categories_(tc.disabled_categories_),
       excluded_categories_(tc.excluded_categories_),
-      synthetic_delays_(tc.synthetic_delays_) {}
+      synthetic_delays_(tc.synthetic_delays_),
+      event_filters_(tc.event_filters_) {}
 
 TraceConfig::~TraceConfig() {
 }
 
 TraceConfig& TraceConfig::operator=(const TraceConfig& rhs) {
   if (this == &rhs)
     return *this;
 
   record_mode_ = rhs.record_mode_;
   enable_sampling_ = rhs.enable_sampling_;
   enable_systrace_ = rhs.enable_systrace_;
   enable_argument_filter_ = rhs.enable_argument_filter_;
   memory_dump_config_ = rhs.memory_dump_config_;
   included_categories_ = rhs.included_categories_;
   disabled_categories_ = rhs.disabled_categories_;
   excluded_categories_ = rhs.excluded_categories_;
   synthetic_delays_ = rhs.synthetic_delays_;
+  event_filters_ = rhs.event_filters_;
   return *this;
 }
 
 const TraceConfig::StringList& TraceConfig::GetSyntheticDelayValues() const {
   return synthetic_delays_;
 }
 
 std::string TraceConfig::ToString() const {
   std::unique_ptr<DictionaryValue> dict = ToDict();
   std::string json;
@@ skipping 110 matching lines @@
 void TraceConfig::Clear() {
   record_mode_ = RECORD_UNTIL_FULL;
   enable_sampling_ = false;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
   included_categories_.clear();
   disabled_categories_.clear();
   excluded_categories_.clear();
   synthetic_delays_.clear();
   memory_dump_config_.Clear();
+  event_filters_.clear();
 }
 
 void TraceConfig::InitializeDefault() {
   record_mode_ = RECORD_UNTIL_FULL;
   enable_sampling_ = false;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
 }
 
 void TraceConfig::InitializeFromConfigDict(const DictionaryValue& dict) {
@@ skipping 27 matching lines @@
 
   if (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 DictionaryValue* memory_dump_config = nullptr;
     if (dict.GetDictionary(kMemoryDumpConfigParam, &memory_dump_config))
       SetMemoryDumpConfigFromConfigDict(*memory_dump_config);
     else
       SetDefaultMemoryDumpConfig();
   }
+
+  const base::ListValue* category_event_filters = nullptr;
+  if (dict.GetList(kEventFiltersParam, &category_event_filters))
+    SetEventFilters(*category_event_filters);
 }
 
 void TraceConfig::InitializeFromConfigString(StringPiece config_string) {
   auto dict = DictionaryValue::From(JSONReader::Read(config_string));
   if (dict)
     InitializeFromConfigDict(*dict);
   else
     InitializeDefault();
 }
 
@@ skipping 174 matching lines @@
   }
 }
 
 void TraceConfig::SetDefaultMemoryDumpConfig() {
   memory_dump_config_.Clear();
   memory_dump_config_.triggers.push_back(kDefaultHeavyMemoryDumpTrigger);
   memory_dump_config_.triggers.push_back(kDefaultLightMemoryDumpTrigger);
   memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes();
 }
 
+void TraceConfig::SetEventFilters(
+    const base::ListValue& category_event_filters) {
+  event_filters_.clear();
+
+  for (size_t event_filter_index = 0;
+       event_filter_index < category_event_filters.GetSize();
+       ++event_filter_index) {
+    const base::DictionaryValue* event_filter = nullptr;
+    if (!category_event_filters.GetDictionary(event_filter_index,
+                                              &event_filter))
+      continue;
+
+    std::string predicate_name;
+    CHECK(event_filter->GetString(kFilterPredicateParam, &predicate_name))
+        << "Invalid predicate name in category event filter.";
+
+    EventFilterConfig new_config(predicate_name);
+    const base::ListValue* included_list = nullptr;
+    CHECK(event_filter->GetList(kIncludedCategoriesParam, &included_list))
+        << "Missing included_categories in category event filter.";
+
+    for (size_t i = 0; i < included_list->GetSize(); ++i) {
+      std::string category;
+      if (included_list->GetString(i, &category))
+        new_config.AddIncludedCategory(category);
+    }
+
+    const base::ListValue* excluded_list = nullptr;
+    if (event_filter->GetList(kExcludedCategoriesParam, &excluded_list)) {
+      for (size_t i = 0; i < excluded_list->GetSize(); ++i) {
+        std::string category;
+        if (excluded_list->GetString(i, &category))
+          new_config.AddExcludedCategory(category);
+      }
+    }
+
+    const base::DictionaryValue* args_dict = nullptr;
+    if (event_filter->GetDictionary(kFilterArgsParam, &args_dict))
+      new_config.SetArgs(args_dict->CreateDeepCopy());
+
+    event_filters_.push_back(new_config);
+  }
+}
+
 std::unique_ptr<DictionaryValue> TraceConfig::ToDict() const {
   auto dict = MakeUnique<DictionaryValue>();
   switch (record_mode_) {
     case RECORD_UNTIL_FULL:
       dict->SetString(kRecordModeParam, kRecordUntilFull);
       break;
     case RECORD_CONTINUOUSLY:
       dict->SetString(kRecordModeParam, kRecordContinuously);
       break;
     case RECORD_AS_MUCH_AS_POSSIBLE:
@@ skipping 11 matching lines @@
   dict->SetBoolean(kEnableArgumentFilterParam, enable_argument_filter_);
 
   StringList categories(included_categories_);
   categories.insert(categories.end(),
                     disabled_categories_.begin(),
                     disabled_categories_.end());
   AddCategoryToDict(dict.get(), kIncludedCategoriesParam, categories);
   AddCategoryToDict(dict.get(), kExcludedCategoriesParam, excluded_categories_);
   AddCategoryToDict(dict.get(), kSyntheticDelaysParam, synthetic_delays_);
 
+  if (!event_filters_.empty()) {
+    std::unique_ptr<base::ListValue> filter_list(new base::ListValue());
+    for (const EventFilterConfig& filter : event_filters_) {
+      std::unique_ptr<base::DictionaryValue> filter_dict(
+          new base::DictionaryValue());
+      filter_dict->SetString(kFilterPredicateParam, filter.predicate_name());
+
+      std::unique_ptr<base::ListValue> included_categories_list(
+          new base::ListValue());
+      for (const std::string& included_category : filter.included_categories())
+        included_categories_list->AppendString(included_category);
+
+      filter_dict->Set(kIncludedCategoriesParam,
+                       std::move(included_categories_list));
+
+      if (!filter.excluded_categories().empty()) {
+        std::unique_ptr<base::ListValue> excluded_categories_list(
+            new base::ListValue());
+        for (const std::string& excluded_category :
+             filter.excluded_categories())
+          excluded_categories_list->AppendString(excluded_category);
+
+        filter_dict->Set(kExcludedCategoriesParam,
+                         std::move(excluded_categories_list));
+      }
+
+      if (filter.filter_args())
+        filter_dict->Set(kFilterArgsParam,
+                         filter.filter_args()->CreateDeepCopy());
+
+      filter_list->Append(std::move(filter_dict));
+    }
+    dict->Set(kEventFiltersParam, std::move(filter_list));
+  }
+
   if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
     auto allowed_modes = MakeUnique<ListValue>();
     for (auto dump_mode : memory_dump_config_.allowed_dump_modes)
       allowed_modes->AppendString(MemoryDumpLevelOfDetailToString(dump_mode));
 
     auto memory_dump_config = MakeUnique<DictionaryValue>();
     memory_dump_config->Set(kAllowedDumpModesParam, std::move(allowed_modes));
 
     auto triggers_list = MakeUnique<ListValue>();
     for (const auto& config : memory_dump_config_.triggers) {
@@ skipping 98 matching lines @@
     StringPiece str) {
   return str.empty() || str.front() == ' ' || str.back() == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base