Tracing pre-filtering

base/trace_event/trace_config_unittest.cc

 // Copyright 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 <stddef.h>
 
 #include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_config.h"
 #include "base/trace_event/trace_config_memory_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 const char kDefaultTraceConfigString[] =
   "{"
     "\"enable_argument_filter\":false,"
     "\"enable_sampling\":false,"
     "\"enable_systrace\":false,"
     "\"excluded_categories\":[\"*Debug\",\"*Test\"],"
     "\"record_mode\":\"record-until-full\""
   "}";
 
 const char kCustomTraceConfigString[] =
   "{"
+    "\"category_event_filters\":["
+      "{"
+        "\"args\":{\"event_name_whitelist\":[\"a snake\",\"a dog\"]},"
+        "\"excluded_categories\":[\"unfiltered_cat\"],"
+        "\"included_categories\":[\"*\"],"
+        "\"predicate\":\"event_whitelist_predicate\""

[Primiano Tucci (use gerrit), 2016/05/11 16:11:57]

maybe if these were called

predicate -> filter_predicate
args -> filter_args
would be a bit more clear. Args feels a bit too generic, this is really args for
the given predicate.

Also, I wonder if this section should just be "event_filters" instead of
"category_event_filters". I know that you want to capture the fact that the
category is somehow prioritary, but for somebody who reads this for the first
time "category_event_filters" makes it harder to guess what this is about.
The reality is that you filter by category AND event, but IMHO the category is
more a detail of the filter.

Also I think would help if in this example (and the other file below), predicate
and args were back to back, e.g. in this sequence:
 - excluded_cat
 - included_cat
 - predicate
 - args

[oystein (OOO til 10th of July), 2016/05/20 20:03:43]

Yeah, I like that better; done. The ordering I can't do much about, it has to be
alphabetical (has to be transitive when parsed to and back from JSON).

+      "}"
+    "],"
     "\"enable_argument_filter\":true,"
     "\"enable_sampling\":true,"
     "\"enable_systrace\":true,"
     "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
     "\"included_categories\":[\"included\","
                             "\"inc_pattern*\","
                             "\"disabled-by-default-cc\","
                             "\"disabled-by-default-memory-infra\"],"
     "\"memory_dump_config\":{"
       "\"triggers\":["
@@ skipping 232 matching lines @@
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("not-excluded-category"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("CategoryTest"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("CategoryDebug"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-cc"));
 
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1,CategoryDebug"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("CategoryDebug,Category1"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("CategoryTest,not-excluded-category"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("CategoryDebug,CategoryTest"));
+
+  EXPECT_TRUE(tc.category_event_filters().empty());
 }
 
 TEST(TraceConfigTest, TraceConfigFromDict) {
   // Passing in empty dictionary will not result in default trace config.
   DictionaryValue dict;
   TraceConfig tc(dict);
   EXPECT_STRNE(kDefaultTraceConfigString, tc.ToString().c_str());
   EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
   EXPECT_FALSE(tc.IsSamplingEnabled());
   EXPECT_FALSE(tc.IsSystraceEnabled());
@@ skipping 30 matching lines @@
                "disabled-by-default-cc,disabled-by-default-memory-infra,"
                "-excluded,-exc_pattern*,"
                "DELAY(test.Delay1;16),DELAY(test.Delay2;32)",
                custom_tc.ToCategoryFilterString().c_str());
 }
 
 TEST(TraceConfigTest, TraceConfigFromValidString) {
   // Using some non-empty config string.
   const char config_string[] =
     "{"
+      "\"category_event_filters\":["
+        "{"
+          "\"args\":{\"event_name_whitelist\":[\"a snake\",\"a dog\"]},"
+          "\"excluded_categories\":[\"unfiltered_cat\"],"
+          "\"included_categories\":[\"*\"],"
+          "\"predicate\":\"event_whitelist_predicate\""
+        "}"
+      "],"
       "\"enable_argument_filter\":true,"
       "\"enable_sampling\":true,"
       "\"enable_systrace\":true,"
       "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
       "\"included_categories\":[\"included\","
                                "\"inc_pattern*\","
                                "\"disabled-by-default-cc\"],"
       "\"record_mode\":\"record-continuously\","
       "\"synthetic_delays\":[\"test.Delay1;16\",\"test.Delay2;32\"]"
     "}";
@@ skipping 26 matching lines @@
 
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("included,excluded"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded,exc_pattern_category"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("included,DELAY(test.Delay1;16)"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("DELAY(test.Delay1;16)"));
 
   EXPECT_EQ(2u, tc.GetSyntheticDelayValues().size());
   EXPECT_STREQ("test.Delay1;16", tc.GetSyntheticDelayValues()[0].c_str());
   EXPECT_STREQ("test.Delay2;32", tc.GetSyntheticDelayValues()[1].c_str());
 
+  EXPECT_EQ(tc.category_event_filters().size(), 1u);
+  const TraceConfig::CategoryEventFilterConfig& category_filter =
+      tc.category_event_filters()[0];
+  EXPECT_STREQ(category_filter.predicate_name().c_str(),
+               "event_whitelist_predicate");
+  EXPECT_EQ(category_filter.included_categories().size(), 1u);
+  EXPECT_STREQ(category_filter.included_categories()[0].c_str(), "*");
+  EXPECT_EQ(category_filter.excluded_categories().size(), 1u);
+  EXPECT_STREQ(category_filter.excluded_categories()[0].c_str(),
+               "unfiltered_cat");
+  EXPECT_TRUE(category_filter.args());
+
+  std::string json_out;
+  base::JSONWriter::Write(*category_filter.args(), &json_out);
+  EXPECT_STREQ(json_out.c_str(),
+               "{\"event_name_whitelist\":[\"a snake\",\"a dog\"]}");
+
   const char config_string_2[] = "{\"included_categories\":[\"*\"]}";
   TraceConfig tc2(config_string_2);
   EXPECT_TRUE(tc2.IsCategoryEnabled("non-disabled-by-default-pattern"));
   EXPECT_FALSE(tc2.IsCategoryEnabled("disabled-by-default-pattern"));
   EXPECT_TRUE(tc2.IsCategoryGroupEnabled("non-disabled-by-default-pattern"));
   EXPECT_FALSE(tc2.IsCategoryGroupEnabled("disabled-by-default-pattern"));
 
   // Clear
   tc.Clear();
   EXPECT_STREQ(tc.ToString().c_str(),
@@ skipping 203 matching lines @@
 
 TEST(TraceConfigTest, LegacyStringToMemoryDumpConfig) {
   TraceConfig tc(MemoryDumpManager::kTraceCategory, "");
   EXPECT_TRUE(tc.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
   EXPECT_NE(std::string::npos, tc.ToString().find("memory_dump_config"));
   EXPECT_EQ(2u, tc.memory_dump_config_.size());
 }
 
 }  // namespace trace_event
 }  // namespace base