bool do_suspend = true)

: controller_(controller), agent_(do_suspend ? agent : nullptr) {

if (do_suspend) {

CHECK(agent_->started_);

controller->StopTracing();

}

const std::unordered_map<int, std::multiset<std::string>>& map) {

std::set<std::string> result;

for (const auto& id_value : map)

result.insert(id_value.second.begin(), id_value.second.end());

return result;

tracing_controller_->Initialize(nullptr);

CHECK_EQ(uv_loop_init(&tracing_loop_), 0);

CHECK_EQ(uv_async_init(&tracing_loop_,

&initialize_writer_async_,

[](uv_async_t* async) {

Agent* agent = ContainerOf(&Agent::initialize_writer_async_, async);

agent->InitializeWritersOnThread();

}), 0);

uv_unref(reinterpret_cast<uv_handle_t*>(&initialize_writer_async_));

Mutex::ScopedLock lock(initialize_writer_mutex_);

while (!to_be_initialized_.empty()) {

AsyncTraceWriter* head = *to_be_initialized_.begin();

head->InitializeOnThread(&tracing_loop_);

to_be_initialized_.erase(head);

}

initialize_writer_condvar_.Broadcast(lock);

if (started_)

return;

NodeTraceBuffer* trace_buffer_ = new NodeTraceBuffer(

NodeTraceBuffer::kBufferChunks, this, &tracing_loop_);

tracing_controller_->Initialize(trace_buffer_);

// This thread should be created *after* async handles are created

// (within NodeTraceWriter and NodeTraceBuffer constructors).

// Otherwise the thread could shut down prematurely.

CHECK_EQ(0,

uv_thread_create(

&thread_,

[](void* arg) {

uv_thread_setname("TraceEventWorker");

Agent* agent = static_cast<Agent*>(arg);

uv_run(&agent->tracing_loop_, UV_RUN_DEFAULT);

},

this));

started_ = true;

const std::set<std::string>& categories,

std::unique_ptr<AsyncTraceWriter> writer,

enum UseDefaultCategoryMode mode) {

Start();

const std::set<std::string>* use_categories = &categories;

std::set<std::string> categories_with_default;

if (mode == kUseDefaultCategories) {

categories_with_default.insert(categories.begin(), categories.end());

categories_with_default.insert(categories_[kDefaultHandleId].begin(),

categories_[kDefaultHandleId].end());

use_categories = &categories_with_default;

}

ScopedSuspendTracing suspend(tracing_controller_.get(), this);

int id = next_writer_id_++;

AsyncTraceWriter* raw = writer.get();

writers_[id] = std::move(writer);

categories_[id] = { use_categories->begin(), use_categories->end() };

{

Mutex::ScopedLock lock(initialize_writer_mutex_);

to_be_initialized_.insert(raw);

uv_async_send(&initialize_writer_async_);

while (to_be_initialized_.count(raw) > 0)

initialize_writer_condvar_.Wait(lock);

}

return AgentWriterHandle(this, id);

if (!started_)

return;

// Perform final Flush on TraceBuffer. We don't want the tracing controller

// to flush the buffer again on destruction of the V8::Platform.

tracing_controller_->StopTracing();

tracing_controller_->Initialize(nullptr);

started_ = false;

// Thread should finish when the tracing loop is stopped.

uv_thread_join(&thread_);

if (client == kDefaultHandleId) return;

{

Mutex::ScopedLock lock(initialize_writer_mutex_);

to_be_initialized_.erase(writers_[client].get());

}

ScopedSuspendTracing suspend(tracing_controller_.get(), this);

writers_.erase(client);

categories_.erase(client);

if (categories.empty())

return;

ScopedSuspendTracing suspend(tracing_controller_.get(), this,

id != kDefaultHandleId);

categories_[id].insert(categories.begin(), categories.end());

ScopedSuspendTracing suspend(tracing_controller_.get(), this,

id != kDefaultHandleId);

std::multiset<std::string>& writer_categories = categories_[id];

for (const std::string& category : categories) {

auto it = writer_categories.find(category);

if (it != writer_categories.end())

writer_categories.erase(it);

}

std::string categories;

for (const std::string& category : flatten(categories_)) {

if (!categories.empty())

categories += ',';

categories += category;

}

return categories;

{

Mutex::ScopedLock lock(metadata_events_mutex_);

for (const auto& event : metadata_events_)

AppendTraceEvent(event.get());

}

for (const auto& id_writer : writers_)

id_writer.second->Flush(blocking);

const unsigned char* category_group_enabled,

const char* name,

int num_args,

const char** arg_names,

const unsigned char* arg_types,

const uint64_t* arg_values,

std::unique_ptr<v8::ConvertableToTraceFormat>* convertable_values,

unsigned int flags) {

std::unique_ptr<TraceObject> trace_event(new TraceObject);

trace_event->Initialize(

TRACE_EVENT_PHASE_METADATA, category_group_enabled, name,

node::tracing::kGlobalScope, // scope

node::tracing::kNoId, // id

node::tracing::kNoId, // bind_id

num_args, arg_names, arg_types, arg_values, convertable_values,

TRACE_EVENT_FLAG_NONE,

CurrentTimestampMicroseconds(),

CurrentCpuTimestampMicroseconds());

Agent* node_agent = node::tracing::TraceEventHelper::GetAgent();

if (node_agent != nullptr)

node_agent->AddMetadataEvent(std::move(trace_event));