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,"
     "\"record_mode\":\"record-until-full\""
   "}";
 
 const char kCustomTraceConfigString[] =
-  "{"
+    "{"
     "\"enable_argument_filter\":true,"
     "\"enable_sampling\":true,"
     "\"enable_systrace\":true,"
+    "\"event_filters\":["
+    "{"
+    "\"excluded_categories\":[\"unfiltered_cat\"],"
+    "\"filter_args\":{\"event_name_whitelist\":[\"a snake\",\"a dog\"]},"
+    "\"filter_predicate\":\"event_whitelist_predicate\","
+    "\"included_categories\":[\"*\"]"
+    "}"
+    "],"
     "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
     "\"included_categories\":[\"included\","
-                            "\"inc_pattern*\","
-                            "\"disabled-by-default-cc\","
-                            "\"disabled-by-default-memory-infra\"],"
+    "\"inc_pattern*\","
+    "\"disabled-by-default-cc\","
+    "\"disabled-by-default-memory-infra\"],"
     "\"memory_dump_config\":{"
-      "\"allowed_dump_modes\":[\"background\",\"light\",\"detailed\"],"
-      "\"heap_profiler_options\":{"
-        "\"breakdown_threshold_bytes\":10240"
-      "},"
-      "\"triggers\":["
-        "{\"mode\":\"light\",\"periodic_interval_ms\":50},"
-        "{\"mode\":\"detailed\",\"periodic_interval_ms\":1000}"
-      "]"
+    "\"allowed_dump_modes\":[\"background\",\"light\",\"detailed\"],"
+    "\"heap_profiler_options\":{"
+    "\"breakdown_threshold_bytes\":10240"
+    "},"
+    "\"triggers\":["
+    "{\"mode\":\"light\",\"periodic_interval_ms\":50},"
+    "{\"mode\":\"detailed\",\"periodic_interval_ms\":1000}"
+    "]"
     "},"
     "\"record_mode\":\"record-continuously\","
     "\"synthetic_delays\":[\"test.Delay1;16\",\"test.Delay2;32\"]"
-  "}";
+    "}";
 
 void CheckDefaultTraceConfigBehavior(const TraceConfig& tc) {
   EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
   EXPECT_FALSE(tc.IsSamplingEnabled());
   EXPECT_FALSE(tc.IsSystraceEnabled());
   EXPECT_FALSE(tc.IsArgumentFilterEnabled());
 
   // Default trace config enables every category filter except the
   // disabled-by-default-* ones.
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1"));
@@ skipping 263 matching lines @@
 
 TEST(TraceConfigTest, DisabledByDefaultCategoryFilterString) {
   TraceConfig tc("foo,disabled-by-default-foo", "");
   EXPECT_STREQ("foo,disabled-by-default-foo",
                tc.ToCategoryFilterString().c_str());
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("foo"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-foo"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("bar"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-bar"));
 
+  EXPECT_TRUE(tc.event_filters().empty());
   // Enabling only the disabled-by-default-* category means the default ones
   // are also enabled.
   tc = TraceConfig("disabled-by-default-foo", "");
   EXPECT_STREQ("disabled-by-default-foo", tc.ToCategoryFilterString().c_str());
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-foo"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("foo"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("bar"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-bar"));
 }
 
@@ skipping 37 matching lines @@
   EXPECT_STREQ("included,inc_pattern*,"
                "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[] =
-    "{"
+      "{"
       "\"enable_argument_filter\":true,"
       "\"enable_sampling\":true,"
       "\"enable_systrace\":true,"
+      "\"event_filters\":["
+      "{"
+      "\"excluded_categories\":[\"unfiltered_cat\"],"
+      "\"filter_args\":{\"event_name_whitelist\":[\"a snake\",\"a dog\"]},"
+      "\"filter_predicate\":\"event_whitelist_predicate\","
+      "\"included_categories\":[\"*\"]"
+      "}"
+      "],"
       "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
       "\"included_categories\":[\"included\","
-                               "\"inc_pattern*\","
-                               "\"disabled-by-default-cc\"],"
+      "\"inc_pattern*\","
+      "\"disabled-by-default-cc\"],"
       "\"record_mode\":\"record-continuously\","
       "\"synthetic_delays\":[\"test.Delay1;16\",\"test.Delay2;32\"]"
-    "}";
+      "}";
   TraceConfig tc(config_string);
 
   EXPECT_STREQ(config_string, tc.ToString().c_str());
   EXPECT_EQ(RECORD_CONTINUOUSLY, tc.GetTraceRecordMode());
   EXPECT_TRUE(tc.IsSamplingEnabled());
   EXPECT_TRUE(tc.IsSystraceEnabled());
   EXPECT_TRUE(tc.IsArgumentFilterEnabled());
   EXPECT_STREQ("included,inc_pattern*,disabled-by-default-cc,-excluded,"
                "-exc_pattern*,DELAY(test.Delay1;16),DELAY(test.Delay2;32)",
                tc.ToCategoryFilterString().c_str());
@@ skipping 16 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.event_filters().size(), 1u);
+  const TraceConfig::EventFilterConfig& event_filter = tc.event_filters()[0];
+  EXPECT_STREQ("event_whitelist_predicate",
+               event_filter.predicate_name().c_str());
+  EXPECT_EQ(1u, event_filter.included_categories().size());
+  EXPECT_STREQ("*", event_filter.included_categories()[0].c_str());
+  EXPECT_EQ(1u, event_filter.excluded_categories().size());
+  EXPECT_STREQ("unfiltered_cat", event_filter.excluded_categories()[0].c_str());
+  EXPECT_TRUE(event_filter.filter_args());
+
+  std::string json_out;
+  base::JSONWriter::Write(*event_filter.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 229 matching lines @@
   EXPECT_NE(std::string::npos, tc.ToString().find("memory_dump_config"));
   EXPECT_EQ(2u, tc.memory_dump_config_.triggers.size());
   EXPECT_EQ(TraceConfig::MemoryDumpConfig::HeapProfiler
             ::kDefaultBreakdownThresholdBytes,
             tc.memory_dump_config_.heap_profiler_options
             .breakdown_threshold_bytes);
 }
 
 }  // namespace trace_event
 }  // namespace base