rtc_base/event_tracer.cc - src - Git at Google

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "rtc_base/event_tracer.h"

 #include <inttypes.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>

 #include <string>
 #include <vector>

 #include "rtc_base/atomic_ops.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/event.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/platform_thread_types.h"
 #include "rtc_base/thread_annotations.h"
 #include "rtc_base/thread_checker.h"
 #include "rtc_base/time_utils.h"
 #include "rtc_base/trace_event.h"

 // This is a guesstimate that should be enough in most cases.
 static const size_t kEventLoggerArgsStrBufferInitialSize = 256;
 static const size_t kTraceArgBufferLength = 32;

 namespace webrtc {

 namespace {

 GetCategoryEnabledPtr g_get_category_enabled_ptr = nullptr;
 AddTraceEventPtr g_add_trace_event_ptr = nullptr;

 }  // namespace

 void SetupEventTracer(GetCategoryEnabledPtr get_category_enabled_ptr,
                       AddTraceEventPtr add_trace_event_ptr) {
   g_get_category_enabled_ptr = get_category_enabled_ptr;
   g_add_trace_event_ptr = add_trace_event_ptr;
 }

 const unsigned char* EventTracer::GetCategoryEnabled(const char* name) {
   if (g_get_category_enabled_ptr)
     return g_get_category_enabled_ptr(name);

   // A string with null terminator means category is disabled.
   return reinterpret_cast<const unsigned char*>("\0");
 }

 // Arguments to this function (phase, etc.) are as defined in
 // webrtc/rtc_base/trace_event.h.
 void EventTracer::AddTraceEvent(char phase,
                                 const unsigned char* category_enabled,
                                 const char* name,
                                 unsigned long long id,
                                 int num_args,
                                 const char** arg_names,
                                 const unsigned char* arg_types,
                                 const unsigned long long* arg_values,
                                 unsigned char flags) {
   if (g_add_trace_event_ptr) {
     g_add_trace_event_ptr(phase, category_enabled, name, id, num_args,
                           arg_names, arg_types, arg_values, flags);
   }
 }

 }  // namespace webrtc

 namespace rtc {
 namespace tracing {
 namespace {

 static void EventTracingThreadFunc(void* params);

 // Atomic-int fast path for avoiding logging when disabled.
 static volatile int g_event_logging_active = 0;

 // TODO(pbos): Log metadata for all threads, etc.
 class EventLogger final {
  public:
   EventLogger()
       : logging_thread_(EventTracingThreadFunc,
                         this,
                         "EventTracingThread",
                         kLowPriority) {}
   ~EventLogger() { RTC_DCHECK(thread_checker_.IsCurrent()); }

   void AddTraceEvent(const char* name,
                      const unsigned char* category_enabled,
                      char phase,
                      int num_args,
                      const char** arg_names,
                      const unsigned char* arg_types,
                      const unsigned long long* arg_values,
                      uint64_t timestamp,
                      int pid,
                      rtc::PlatformThreadId thread_id) {
     std::vector<TraceArg> args(num_args);
     for (int i = 0; i < num_args; ++i) {
       TraceArg& arg = args[i];
       arg.name = arg_names[i];
       arg.type = arg_types[i];
       arg.value.as_uint = arg_values[i];

       // Value is a pointer to a temporary string, so we have to make a copy.
       if (arg.type == TRACE_VALUE_TYPE_COPY_STRING) {
         // Space for the string and for the terminating null character.
         size_t str_length = strlen(arg.value.as_string) + 1;
         char* str_copy = new char[str_length];
         memcpy(str_copy, arg.value.as_string, str_length);
         arg.value.as_string = str_copy;
       }
     }
     rtc::CritScope lock(&crit_);
     trace_events_.push_back(
         {name, category_enabled, phase, args, timestamp, 1, thread_id});
   }

   // The TraceEvent format is documented here:
   // https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
   void Log() {
     RTC_DCHECK(output_file_);
     static const int kLoggingIntervalMs = 100;
     fprintf(output_file_, "{ \"traceEvents\": [\n");
     bool has_logged_event = false;
     while (true) {
       bool shutting_down = shutdown_event_.Wait(kLoggingIntervalMs);
       std::vector<TraceEvent> events;
       {
         rtc::CritScope lock(&crit_);
         trace_events_.swap(events);
       }
       std::string args_str;
       args_str.reserve(kEventLoggerArgsStrBufferInitialSize);
       for (TraceEvent& e : events) {
         args_str.clear();
         if (!e.args.empty()) {
           args_str += ", \"args\": {";
           bool is_first_argument = true;
           for (TraceArg& arg : e.args) {
             if (!is_first_argument)
               args_str += ",";
             is_first_argument = false;
             args_str += " \"";
             args_str += arg.name;
             args_str += "\": ";
             args_str += TraceArgValueAsString(arg);

             // Delete our copy of the string.
             if (arg.type == TRACE_VALUE_TYPE_COPY_STRING) {
               delete[] arg.value.as_string;
               arg.value.as_string = nullptr;
             }
           }
           args_str += " }";
         }
         fprintf(output_file_,
                 "%s{ \"name\": \"%s\""
                 ", \"cat\": \"%s\""
                 ", \"ph\": \"%c\""
                 ", \"ts\": %" PRIu64
                 ", \"pid\": %d"
 #if defined(WEBRTC_WIN)
                 ", \"tid\": %lu"
 #else
                 ", \"tid\": %d"
 #endif  // defined(WEBRTC_WIN)
                 "%s"
                 "}\n",
                 has_logged_event ? "," : " ", e.name, e.category_enabled,
                 e.phase, e.timestamp, e.pid, e.tid, args_str.c_str());
         has_logged_event = true;
       }
       if (shutting_down)
         break;
     }
     fprintf(output_file_, "]}\n");
     if (output_file_owned_)
       fclose(output_file_);
     output_file_ = nullptr;
   }

   void Start(FILE* file, bool owned) {
     RTC_DCHECK(thread_checker_.IsCurrent());
     RTC_DCHECK(file);
     RTC_DCHECK(!output_file_);
     output_file_ = file;
     output_file_owned_ = owned;
     {
       rtc::CritScope lock(&crit_);
       // Since the atomic fast-path for adding events to the queue can be
       // bypassed while the logging thread is shutting down there may be some
       // stale events in the queue, hence the vector needs to be cleared to not
       // log events from a previous logging session (which may be days old).
       trace_events_.clear();
     }
     // Enable event logging (fast-path). This should be disabled since starting
     // shouldn't be done twice.
     RTC_CHECK_EQ(0,
                  rtc::AtomicOps::CompareAndSwap(&g_event_logging_active, 0, 1));

     // Finally start, everything should be set up now.
     logging_thread_.Start();
     TRACE_EVENT_INSTANT0("webrtc", "EventLogger::Start");
   }

   void Stop() {
     RTC_DCHECK(thread_checker_.IsCurrent());
     TRACE_EVENT_INSTANT0("webrtc", "EventLogger::Stop");
     // Try to stop. Abort if we're not currently logging.
     if (rtc::AtomicOps::CompareAndSwap(&g_event_logging_active, 1, 0) == 0)
       return;

     // Wake up logging thread to finish writing.
     shutdown_event_.Set();
     // Join the logging thread.
     logging_thread_.Stop();
   }

  private:
   struct TraceArg {
     const char* name;
     unsigned char type;
     // Copied from webrtc/rtc_base/trace_event.h TraceValueUnion.
     union TraceArgValue {
       bool as_bool;
       unsigned long long as_uint;
       long long as_int;
       double as_double;
       const void* as_pointer;
       const char* as_string;
     } value;

     // Assert that the size of the union is equal to the size of the as_uint
     // field since we are assigning to arbitrary types using it.
     static_assert(sizeof(TraceArgValue) == sizeof(unsigned long long),
                   "Size of TraceArg value union is not equal to the size of "
                   "the uint field of that union.");
   };

   struct TraceEvent {
     const char* name;
     const unsigned char* category_enabled;
     char phase;
     std::vector<TraceArg> args;
     uint64_t timestamp;
     int pid;
     rtc::PlatformThreadId tid;
   };

   static std::string TraceArgValueAsString(TraceArg arg) {
     std::string output;

     if (arg.type == TRACE_VALUE_TYPE_STRING ||
         arg.type == TRACE_VALUE_TYPE_COPY_STRING) {
       // Space for every character to be an espaced character + two for
       // quatation marks.
       output.reserve(strlen(arg.value.as_string) * 2 + 2);
       output += '\"';
       const char* c = arg.value.as_string;
       do {
         if (*c == '"' || *c == '\\') {
           output += '\\';
           output += *c;
         } else {
           output += *c;
         }
       } while (*++c);
       output += '\"';
     } else {
       output.resize(kTraceArgBufferLength);
       size_t print_length = 0;
       switch (arg.type) {
         case TRACE_VALUE_TYPE_BOOL:
           if (arg.value.as_bool) {
             strcpy(&output[0], "true");
             print_length = 4;
           } else {
             strcpy(&output[0], "false");
             print_length = 5;
           }
           break;
         case TRACE_VALUE_TYPE_UINT:
           print_length = snprintf(&output[0], kTraceArgBufferLength, "%llu",
                                   arg.value.as_uint);
           break;
         case TRACE_VALUE_TYPE_INT:
           print_length = snprintf(&output[0], kTraceArgBufferLength, "%lld",
                                   arg.value.as_int);
           break;
         case TRACE_VALUE_TYPE_DOUBLE:
           print_length = snprintf(&output[0], kTraceArgBufferLength, "%f",
                                   arg.value.as_double);
           break;
         case TRACE_VALUE_TYPE_POINTER:
           print_length = snprintf(&output[0], kTraceArgBufferLength, "\"%p\"",
                                   arg.value.as_pointer);
           break;
       }
       size_t output_length = print_length < kTraceArgBufferLength
                                  ? print_length
                                  : kTraceArgBufferLength - 1;
       // This will hopefully be very close to nop. On most implementations, it
       // just writes null byte and sets the length field of the string.
       output.resize(output_length);
     }

     return output;
   }

   rtc::CriticalSection crit_;
   std::vector<TraceEvent> trace_events_ RTC_GUARDED_BY(crit_);
   rtc::PlatformThread logging_thread_;
   rtc::Event shutdown_event_;
   rtc::ThreadChecker thread_checker_;
   FILE* output_file_ = nullptr;
   bool output_file_owned_ = false;
 };

 static void EventTracingThreadFunc(void* params) {
   static_cast<EventLogger*>(params)->Log();
 }

 static EventLogger* volatile g_event_logger = nullptr;
 static const char* const kDisabledTracePrefix = TRACE_DISABLED_BY_DEFAULT("");
 const unsigned char* InternalGetCategoryEnabled(const char* name) {
   const char* prefix_ptr = &kDisabledTracePrefix[0];
   const char* name_ptr = name;
   // Check whether name contains the default-disabled prefix.
   while (*prefix_ptr == *name_ptr && *prefix_ptr != '\0') {
     ++prefix_ptr;
     ++name_ptr;
   }
   return reinterpret_cast<const unsigned char*>(*prefix_ptr == '\0' ? ""
                                                                     : name);
 }

 void InternalAddTraceEvent(char phase,
                            const unsigned char* category_enabled,
                            const char* name,
                            unsigned long long id,
                            int num_args,
                            const char** arg_names,
                            const unsigned char* arg_types,
                            const unsigned long long* arg_values,
                            unsigned char flags) {
   // Fast path for when event tracing is inactive.
   if (rtc::AtomicOps::AcquireLoad(&g_event_logging_active) == 0)
     return;

   g_event_logger->AddTraceEvent(name, category_enabled, phase, num_args,
                                 arg_names, arg_types, arg_values,
                                 rtc::TimeMicros(), 1, rtc::CurrentThreadId());
 }

 }  // namespace

 void SetupInternalTracer() {
   RTC_CHECK(rtc::AtomicOps::CompareAndSwapPtr(
                 &g_event_logger, static_cast<EventLogger*>(nullptr),
                 new EventLogger()) == nullptr);
   webrtc::SetupEventTracer(InternalGetCategoryEnabled, InternalAddTraceEvent);
 }

 void StartInternalCaptureToFile(FILE* file) {
   if (g_event_logger) {
     g_event_logger->Start(file, false);
   }
 }

 bool StartInternalCapture(const char* filename) {
   if (!g_event_logger)
     return false;

   FILE* file = fopen(filename, "w");
   if (!file) {
     RTC_LOG(LS_ERROR) << "Failed to open trace file '" << filename
                       << "' for writing.";
     return false;
   }
   g_event_logger->Start(file, true);
   return true;
 }

 void StopInternalCapture() {
   if (g_event_logger) {
     g_event_logger->Stop();
   }
 }

 void ShutdownInternalTracer() {
   StopInternalCapture();
   EventLogger* old_logger = rtc::AtomicOps::AcquireLoadPtr(&g_event_logger);
   RTC_DCHECK(old_logger);
   RTC_CHECK(rtc::AtomicOps::CompareAndSwapPtr(
                 &g_event_logger, old_logger,
                 static_cast<EventLogger*>(nullptr)) == old_logger);
   delete old_logger;
   webrtc::SetupEventTracer(nullptr, nullptr);
 }

 }  // namespace tracing
 }  // namespace rtc
	/*
	* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/
	#include "rtc_base/event_tracer.h"

	#include <inttypes.h>
	#include <stdint.h>
	#include <stdio.h>
	#include <string.h>

	#include <string>
	#include <vector>

	#include "rtc_base/atomic_ops.h"
	#include "rtc_base/checks.h"
	#include "rtc_base/critical_section.h"
	#include "rtc_base/event.h"
	#include "rtc_base/logging.h"
	#include "rtc_base/platform_thread.h"
	#include "rtc_base/platform_thread_types.h"
	#include "rtc_base/thread_annotations.h"
	#include "rtc_base/thread_checker.h"
	#include "rtc_base/time_utils.h"
	#include "rtc_base/trace_event.h"

	// This is a guesstimate that should be enough in most cases.
	static const size_t kEventLoggerArgsStrBufferInitialSize = 256;
	static const size_t kTraceArgBufferLength = 32;

	namespace webrtc {

	namespace {

	GetCategoryEnabledPtr g_get_category_enabled_ptr = nullptr;
	AddTraceEventPtr g_add_trace_event_ptr = nullptr;

	} // namespace

	void SetupEventTracer(GetCategoryEnabledPtr get_category_enabled_ptr,
	AddTraceEventPtr add_trace_event_ptr) {
	g_get_category_enabled_ptr = get_category_enabled_ptr;
	g_add_trace_event_ptr = add_trace_event_ptr;
	}

	const unsigned char* EventTracer::GetCategoryEnabled(const char* name) {
	if (g_get_category_enabled_ptr)
	return g_get_category_enabled_ptr(name);

	// A string with null terminator means category is disabled.
	return reinterpret_cast<const unsigned char*>("\0");
	}

	// Arguments to this function (phase, etc.) are as defined in
	// webrtc/rtc_base/trace_event.h.
	void EventTracer::AddTraceEvent(char phase,
	const unsigned char* category_enabled,
	const char* name,
	unsigned long long id,
	int num_args,
	const char** arg_names,
	const unsigned char* arg_types,
	const unsigned long long* arg_values,
	unsigned char flags) {
	if (g_add_trace_event_ptr) {
	g_add_trace_event_ptr(phase, category_enabled, name, id, num_args,
	arg_names, arg_types, arg_values, flags);
	}
	}

	} // namespace webrtc

	namespace rtc {
	namespace tracing {
	namespace {

	static void EventTracingThreadFunc(void* params);

	// Atomic-int fast path for avoiding logging when disabled.
	static volatile int g_event_logging_active = 0;

	// TODO(pbos): Log metadata for all threads, etc.
	class EventLogger final {
	public:
	EventLogger()
	: logging_thread_(EventTracingThreadFunc,
	this,
	"EventTracingThread",
	kLowPriority) {}
	~EventLogger() { RTC_DCHECK(thread_checker_.IsCurrent()); }

	void AddTraceEvent(const char* name,
	const unsigned char* category_enabled,
	char phase,
	int num_args,
	const char** arg_names,
	const unsigned char* arg_types,
	const unsigned long long* arg_values,
	uint64_t timestamp,
	int pid,
	rtc::PlatformThreadId thread_id) {
	std::vector<TraceArg> args(num_args);
	for (int i = 0; i < num_args; ++i) {
	TraceArg& arg = args[i];
	arg.name = arg_names[i];
	arg.type = arg_types[i];
	arg.value.as_uint = arg_values[i];

	// Value is a pointer to a temporary string, so we have to make a copy.
	if (arg.type == TRACE_VALUE_TYPE_COPY_STRING) {
	// Space for the string and for the terminating null character.
	size_t str_length = strlen(arg.value.as_string) + 1;
	char* str_copy = new char[str_length];
	memcpy(str_copy, arg.value.as_string, str_length);
	arg.value.as_string = str_copy;
	}
	}
	rtc::CritScope lock(&crit_);
	trace_events_.push_back(
	{name, category_enabled, phase, args, timestamp, 1, thread_id});
	}

	// The TraceEvent format is documented here:
	// https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
	void Log() {
	RTC_DCHECK(output_file_);
	static const int kLoggingIntervalMs = 100;
	fprintf(output_file_, "{ \"traceEvents\": [\n");
	bool has_logged_event = false;
	while (true) {
	bool shutting_down = shutdown_event_.Wait(kLoggingIntervalMs);
	std::vector<TraceEvent> events;
	{
	rtc::CritScope lock(&crit_);
	trace_events_.swap(events);
	}
	std::string args_str;
	args_str.reserve(kEventLoggerArgsStrBufferInitialSize);
	for (TraceEvent& e : events) {
	args_str.clear();
	if (!e.args.empty()) {
	args_str += ", \"args\": {";
	bool is_first_argument = true;
	for (TraceArg& arg : e.args) {
	if (!is_first_argument)
	args_str += ",";
	is_first_argument = false;
	args_str += " \"";
	args_str += arg.name;
	args_str += "\": ";
	args_str += TraceArgValueAsString(arg);

	// Delete our copy of the string.
	if (arg.type == TRACE_VALUE_TYPE_COPY_STRING) {
	delete[] arg.value.as_string;
	arg.value.as_string = nullptr;
	}
	}
	args_str += " }";
	}
	fprintf(output_file_,
	"%s{ \"name\": \"%s\""
	", \"cat\": \"%s\""
	", \"ph\": \"%c\""
	", \"ts\": %" PRIu64
	", \"pid\": %d"
	#if defined(WEBRTC_WIN)
	", \"tid\": %lu"
	#else
	", \"tid\": %d"
	#endif // defined(WEBRTC_WIN)
	"%s"
	"}\n",
	has_logged_event ? "," : " ", e.name, e.category_enabled,
	e.phase, e.timestamp, e.pid, e.tid, args_str.c_str());
	has_logged_event = true;
	}
	if (shutting_down)
	break;
	}
	fprintf(output_file_, "]}\n");
	if (output_file_owned_)
	fclose(output_file_);
	output_file_ = nullptr;
	}

	void Start(FILE* file, bool owned) {
	RTC_DCHECK(thread_checker_.IsCurrent());
	RTC_DCHECK(file);
	RTC_DCHECK(!output_file_);
	output_file_ = file;
	output_file_owned_ = owned;
	{
	rtc::CritScope lock(&crit_);
	// Since the atomic fast-path for adding events to the queue can be
	// bypassed while the logging thread is shutting down there may be some
	// stale events in the queue, hence the vector needs to be cleared to not
	// log events from a previous logging session (which may be days old).
	trace_events_.clear();
	}
	// Enable event logging (fast-path). This should be disabled since starting
	// shouldn't be done twice.
	RTC_CHECK_EQ(0,
	rtc::AtomicOps::CompareAndSwap(&g_event_logging_active, 0, 1));

	// Finally start, everything should be set up now.
	logging_thread_.Start();
	TRACE_EVENT_INSTANT0("webrtc", "EventLogger::Start");
	}

	void Stop() {
	RTC_DCHECK(thread_checker_.IsCurrent());
	TRACE_EVENT_INSTANT0("webrtc", "EventLogger::Stop");
	// Try to stop. Abort if we're not currently logging.
	if (rtc::AtomicOps::CompareAndSwap(&g_event_logging_active, 1, 0) == 0)
	return;

	// Wake up logging thread to finish writing.
	shutdown_event_.Set();
	// Join the logging thread.
	logging_thread_.Stop();
	}

	private:
	struct TraceArg {
	const char* name;
	unsigned char type;
	// Copied from webrtc/rtc_base/trace_event.h TraceValueUnion.
	union TraceArgValue {
	bool as_bool;
	unsigned long long as_uint;
	long long as_int;
	double as_double;
	const void* as_pointer;
	const char* as_string;
	} value;

	// Assert that the size of the union is equal to the size of the as_uint
	// field since we are assigning to arbitrary types using it.
	static_assert(sizeof(TraceArgValue) == sizeof(unsigned long long),
	"Size of TraceArg value union is not equal to the size of "
	"the uint field of that union.");
	};

	struct TraceEvent {
	const char* name;
	const unsigned char* category_enabled;
	char phase;
	std::vector<TraceArg> args;
	uint64_t timestamp;
	int pid;
	rtc::PlatformThreadId tid;
	};

	static std::string TraceArgValueAsString(TraceArg arg) {
	std::string output;

	if (arg.type == TRACE_VALUE_TYPE_STRING \|\|
	arg.type == TRACE_VALUE_TYPE_COPY_STRING) {
	// Space for every character to be an espaced character + two for
	// quatation marks.
	output.reserve(strlen(arg.value.as_string) * 2 + 2);
	output += '\"';
	const char* c = arg.value.as_string;
	do {
	if (c == '"' \|\| c == '\\') {
	output += '\\';
	output += *c;
	} else {
	output += *c;
	}
	} while (*++c);
	output += '\"';
	} else {
	output.resize(kTraceArgBufferLength);
	size_t print_length = 0;
	switch (arg.type) {
	case TRACE_VALUE_TYPE_BOOL:
	if (arg.value.as_bool) {
	strcpy(&output[0], "true");
	print_length = 4;
	} else {
	strcpy(&output[0], "false");
	print_length = 5;
	}
	break;
	case TRACE_VALUE_TYPE_UINT:
	print_length = snprintf(&output[0], kTraceArgBufferLength, "%llu",
	arg.value.as_uint);
	break;
	case TRACE_VALUE_TYPE_INT:
	print_length = snprintf(&output[0], kTraceArgBufferLength, "%lld",
	arg.value.as_int);
	break;
	case TRACE_VALUE_TYPE_DOUBLE:
	print_length = snprintf(&output[0], kTraceArgBufferLength, "%f",
	arg.value.as_double);
	break;
	case TRACE_VALUE_TYPE_POINTER:
	print_length = snprintf(&output[0], kTraceArgBufferLength, "\"%p\"",
	arg.value.as_pointer);
	break;
	}
	size_t output_length = print_length < kTraceArgBufferLength
	? print_length
	: kTraceArgBufferLength - 1;
	// This will hopefully be very close to nop. On most implementations, it
	// just writes null byte and sets the length field of the string.
	output.resize(output_length);
	}

	return output;
	}

	rtc::CriticalSection crit_;
	std::vector<TraceEvent> trace_events_ RTC_GUARDED_BY(crit_);
	rtc::PlatformThread logging_thread_;
	rtc::Event shutdown_event_;
	rtc::ThreadChecker thread_checker_;
	FILE* output_file_ = nullptr;
	bool output_file_owned_ = false;
	};

	static void EventTracingThreadFunc(void* params) {
	static_cast<EventLogger*>(params)->Log();
	}

	static EventLogger* volatile g_event_logger = nullptr;
	static const char* const kDisabledTracePrefix = TRACE_DISABLED_BY_DEFAULT("");
	const unsigned char* InternalGetCategoryEnabled(const char* name) {
	const char* prefix_ptr = &kDisabledTracePrefix[0];
	const char* name_ptr = name;
	// Check whether name contains the default-disabled prefix.
	while (prefix_ptr == name_ptr && *prefix_ptr != '\0') {
	++prefix_ptr;
	++name_ptr;
	}
	return reinterpret_cast<const unsigned char>(prefix_ptr == '\0' ? ""
	: name);
	}

	void InternalAddTraceEvent(char phase,
	const unsigned char* category_enabled,
	const char* name,
	unsigned long long id,
	int num_args,
	const char** arg_names,
	const unsigned char* arg_types,
	const unsigned long long* arg_values,
	unsigned char flags) {
	// Fast path for when event tracing is inactive.
	if (rtc::AtomicOps::AcquireLoad(&g_event_logging_active) == 0)
	return;

	g_event_logger->AddTraceEvent(name, category_enabled, phase, num_args,
	arg_names, arg_types, arg_values,
	rtc::TimeMicros(), 1, rtc::CurrentThreadId());
	}

	} // namespace

	void SetupInternalTracer() {
	RTC_CHECK(rtc::AtomicOps::CompareAndSwapPtr(
	&g_event_logger, static_cast<EventLogger*>(nullptr),
	new EventLogger()) == nullptr);
	webrtc::SetupEventTracer(InternalGetCategoryEnabled, InternalAddTraceEvent);
	}

	void StartInternalCaptureToFile(FILE* file) {
	if (g_event_logger) {
	g_event_logger->Start(file, false);
	}
	}

	bool StartInternalCapture(const char* filename) {
	if (!g_event_logger)
	return false;

	FILE* file = fopen(filename, "w");
	if (!file) {
	RTC_LOG(LS_ERROR) << "Failed to open trace file '" << filename
	<< "' for writing.";
	return false;
	}
	g_event_logger->Start(file, true);
	return true;
	}

	void StopInternalCapture() {
	if (g_event_logger) {
	g_event_logger->Stop();
	}
	}

	void ShutdownInternalTracer() {
	StopInternalCapture();
	EventLogger* old_logger = rtc::AtomicOps::AcquireLoadPtr(&g_event_logger);
	RTC_DCHECK(old_logger);
	RTC_CHECK(rtc::AtomicOps::CompareAndSwapPtr(
	&g_event_logger, old_logger,
	static_cast<EventLogger*>(nullptr)) == old_logger);
	delete old_logger;
	webrtc::SetupEventTracer(nullptr, nullptr);
	}

	} // namespace tracing
	} // namespace rtc