Tracing pre-filtering

base/trace_event/trace_event.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_TRACE_EVENT_TRACE_EVENT_H_
 #define BASE_TRACE_EVENT_TRACE_EVENT_H_
 
 // This header file defines implementation details of how the trace macros in
 // trace_event_common.h collect and store trace events. Anything not
 // implementation-specific should go in trace_event_common.h instead of here.
@@ skipping 58 matching lines @@
     trace_event_internal::TraceEventSamplingStateScope<bucket_number>   \
         traceEventSamplingScope(category "\0" name);
 
 #define TRACE_EVENT_API_CURRENT_THREAD_ID \
   static_cast<int>(base::PlatformThread::CurrentId())
 
 #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
   UNLIKELY(*INTERNAL_TRACE_EVENT_UID(category_group_enabled) &           \
            (base::trace_event::TraceLog::ENABLED_FOR_RECORDING |         \
             base::trace_event::TraceLog::ENABLED_FOR_EVENT_CALLBACK |    \
-            base::trace_event::TraceLog::ENABLED_FOR_ETW_EXPORT))
+            base::trace_event::TraceLog::ENABLED_FOR_ETW_EXPORT |        \
+            base::trace_event::TraceLog::ENABLED_FOR_FILTERING))

[Primiano Tucci (use gerrit), 2016/05/31 15:41:23]

Do you really need this or-ed here?
I'd assume that in the case of filtering the category is enabled for (RECORDING
| FILTERING).
Otherwise if the category gets only the ENABLED_FOR_FILTERING flag, you won't be
able to filter the events coming from the subprojects (blink, skia) without
making changes to them.

In other words the question here should be: what is the semantic of saying that
category "foo" is both part of the enabled categories and the filter?
1) It gets always inserted in the trace and is also passed to the filter
2) It is inserted in the trace only if it passes the filter.

[oystein (OOO til 10th of July), 2016/08/01 13:39:49]

I think that's right, 2) makes sense to me. The only reason to keep these
separate would be if the config could essentially override the result of the
filters, or something similar, but that just introduces confused semantics.
Done.

+
+#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_FILTERING_MODE( \
+    category_group_enabled)                                             \
+  UNLIKELY(category_group_enabled&                                      \
+               base::trace_event::TraceLog::ENABLED_FOR_FILTERING)
 
 ////////////////////////////////////////////////////////////////////////////////
 // Implementation specific tracing API definitions.
 
 // Get a pointer to the enabled state of the given trace category. Only
 // long-lived literal strings should be given as the category group. The
 // returned pointer can be held permanently in a local static for example. If
 // the unsigned char is non-zero, tracing is enabled. If tracing is enabled,
 // TRACE_EVENT_API_ADD_TRACE_EVENT can be called. It's OK if tracing is disabled
 // between the load of the tracing state and the call to
@@ skipping 88 matching lines @@
       ->AddTraceEventWithThreadIdAndTimestamp
 
 // Set the duration field of a COMPLETE trace event.
 // void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
 //     const unsigned char* category_group_enabled,
 //     const char* name,
 //     base::trace_event::TraceEventHandle id)
 #define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION \
     base::trace_event::TraceLog::GetInstance()->UpdateTraceEventDuration
 
+// Call EndEvent on the filter for a filtered event.
+// void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
+//     const unsigned char* category_group_enabled,
+//     const char* name,
+//     base::trace_event::TraceEventHandle id)
+#define TRACE_EVENT_API_END_FILTERED_EVENT \
+  base::trace_event::TraceLog::GetInstance()->EndFilteredEvent

[Primiano Tucci (use gerrit), 2016/05/27 17:47:06]

Not sure you need this macro since you need this only in one place

+
 // Adds a metadata event to the trace log. The |AppendValueAsTraceFormat| method
 // on the convertable value will be called at flush time.
 // TRACE_EVENT_API_ADD_METADATA_EVENT(
 //     const unsigned char* category_group_enabled,
 //     const char* event_name,
 //     const char* arg_name,
 //     std::unique_ptr<ConvertableToTraceFormat> arg_value)
 #define TRACE_EVENT_API_ADD_METADATA_EVENT \
     trace_event_internal::AddMetadataEvent
 
@@ skipping 769 matching lines @@
       arg_values, nullptr, TRACE_EVENT_FLAG_NONE);
 }
 
 // Used by TRACE_EVENTx macros. Do not use directly.
 class TRACE_EVENT_API_CLASS_EXPORT ScopedTracer {
  public:
   // Note: members of data_ intentionally left uninitialized. See Initialize.
   ScopedTracer() : p_data_(NULL) {}
 
   ~ScopedTracer() {
-    if (p_data_ && *data_.category_group_enabled)
+    if (p_data_ && *data_.category_group_enabled) {
       TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
           data_.category_group_enabled, data_.name, data_.event_handle);
+      if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_FILTERING_MODE(
+              *data_.category_group_enabled)) {
+        TRACE_EVENT_API_END_FILTERED_EVENT(data_.category_group_enabled,
+                                           data_.name, data_.event_handle);
+      }
+    }
   }
 
   void Initialize(const unsigned char* category_group_enabled,
                   const char* name,
                   base::trace_event::TraceEventHandle event_handle) {
     data_.category_group_enabled = category_group_enabled;
     data_.name = name;
     data_.event_handle = event_handle;
     p_data_ = &data_;
   }
@@ skipping 93 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_