Have all trace points emit to ETW.

base/debug/trace_event_win.cc

Index: base/debug/trace_event_win.cc
diff --git a/base/debug/trace_event_win.cc b/base/debug/trace_event_win.cc
index d5a21f49268f3b386a94e6d4d06d1fb57db1faeb..2348e9af2c7aa8dcb8cbac955e8e9e86b3914f06 100644
--- a/base/debug/trace_event_win.cc
+++ b/base/debug/trace_event_win.cc
@@ -5,6 +5,7 @@
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
+#include "base/strings/stringprintf.h"
 #include <initguid.h>  // NOLINT
 
 namespace base {
@@ -51,17 +52,29 @@ void TraceEventETWProvider::TraceEvent(const char* name,
     name = "";
   if (extra == NULL)
     extra = "";
-
   EtwEventType etw_type = 0;
   switch (type) {
     case TRACE_EVENT_PHASE_BEGIN:
+    case TRACE_EVENT_PHASE_ASYNC_BEGIN:
+    case TRACE_EVENT_PHASE_FLOW_BEGIN:
+    case TRACE_EVENT_PHASE_CREATE_OBJECT:
       etw_type = kTraceEventTypeBegin;
       break;
     case TRACE_EVENT_PHASE_END:
+    case TRACE_EVENT_PHASE_ASYNC_END:
+    case TRACE_EVENT_PHASE_FLOW_END:
+    case TRACE_EVENT_PHASE_DELETE_OBJECT:
       etw_type = kTraceEventTypeEnd;
       break;
 
     case TRACE_EVENT_PHASE_INSTANT:
+    case TRACE_EVENT_PHASE_INSTANT_OLD:
+    case TRACE_EVENT_PHASE_ASYNC_STEP:
+    case TRACE_EVENT_PHASE_FLOW_STEP:
+    case TRACE_EVENT_PHASE_METADATA:
+    case TRACE_EVENT_PHASE_COUNTER:
+    case TRACE_EVENT_PHASE_SAMPLE:
+    case TRACE_EVENT_PHASE_SNAPSHOT_OBJECT:
       etw_type = kTraceEventTypeInstant;
       break;
 
@@ -112,6 +125,37 @@ void TraceEventETWProvider::Trace(const char* name,
   }
 }
 
+void TraceEventETWProvider::TraceWithArgs(
+    const char* category_group,
+    const char* name,
+    char type,
+    const void* id,
+    int num_args,
+    const char** arg_names,
+    const unsigned char* arg_types,
+    const unsigned long long* arg_values,
+    scoped_ptr<ConvertableToTraceFormat> convertable_values[]) {
+  // Convert arguments to a string.
+  std::string extras = base::StringPrintf("[%s]", category_group);
+  for (int i = 0; i < num_args; ++i) {
+    if (i)
+      extras += ';';
+    extras += arg_names[i];
+    extras += '=';
+    std::string::size_type value_start = extras.length();
+    if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
+      convertable_values[i]->AppendAsTraceFormat(&extras);
+    } else {
+      base::debug::TraceEvent::TraceValue value;
+      value.as_uint = arg_values[i];
+      base::debug::TraceEvent::AppendValueAsJSON(arg_types[i], value, &extras);
+    }
+    // Replace separator with a similar character.
+    std::replace(extras.begin() + value_start, extras.end(), ';', ',');
+  }

[chrisha, 2013/09/05 20:21:30]

This string manipulation is relatively expensive. How often does it occur? On
every event?

If this is a bottleneck, is it worth memoizing the results so we don't do the
string manipulation each time?

Maybe wrap the whole thing inside of provider->IsTracing like the above
implementation of Trace?

[fdoray, 2013/09/08 18:35:50]

The method is called for every event.

I wrapped the code inside provider->IsTracing as you suggested.

Also, I changed the output format so that no expensive string manipulation is
necessary even when a tracing session is active. This new format follows what is
described at
http://msdn.microsoft.com/en-us/library/windows/desktop/aa364148(v=vs.85).aspx
to output many parameters. It's easier to parse the resulting .etl.

On 2013/09/05 20:21:30, chrisha wrote:

+  Trace(name, type, id, extras);
+}
+
 void TraceEventETWProvider::Resurrect() {
   StaticMemorySingletonTraits<TraceEventETWProvider>::Resurrect();
 }