Have all trace points emit to ETW.

base/debug/trace_event_win.cc

 // 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.
 #include "base/debug/trace_event_win.h"
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
+#include "base/strings/stringprintf.h"
 #include <initguid.h>  // NOLINT
 
 namespace base {
 namespace debug {
 
 using base::win::EtwEventType;
 using base::win::EtwMofEvent;
 
 // {3DADA31D-19EF-4dc1-B345-037927193422}
 const GUID kChromeTraceProviderName = {
@@ skipping 26 matching lines @@
                                        size_t name_len,
                                        char type,
                                        const void* id,
                                        const char* extra,
                                        size_t extra_len) {
   // Make sure we don't touch NULL.
   if (name == NULL)
     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;
 
     default:
       NOTREACHED() << "Unknown event type";
       etw_type = kTraceEventTypeInstant;
       break;
   }
 
   EtwMofEvent<5> event(kTraceEventClass32,
@@ skipping 30 matching lines @@
     // Compute the name & extra lengths if not supplied already.
     if (name_len == -1)
       name_len = (name == NULL) ? 0 : strlen(name);
     if (extra_len == -1)
       extra_len = (extra == NULL) ? 0 : strlen(extra);
 
     provider->TraceEvent(name, name_len, type, id, extra, extra_len);
   }
 }
 
+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();
 }
 
 }  // namespace debug
 }  // namespace base