Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	tracing/agent.cc	Lines:	131	133	98.5 %
Date:	2022-12-31 04:22:30	Branches:	41	52	78.8 %


#include "tracing/agent.h"

#include <string>
#include "trace_event.h"
#include "tracing/node_trace_buffer.h"
#include "debug_utils-inl.h"
#include "env-inl.h"

namespace node {
namespace tracing {

class Agent::ScopedSuspendTracing {
 public:
  ScopedSuspendTracing(TracingController* controller, Agent* agent,
                       bool do_suspend = true)
    : controller_(controller), agent_(do_suspend ? agent : nullptr) {
    if (do_suspend) {
      CHECK(agent_->started_);
      controller->StopTracing();
    }
  }

  ~ScopedSuspendTracing() {
    if (agent_ == nullptr) return;
    TraceConfig* config = agent_->CreateTraceConfig();
    if (config != nullptr) {
      controller_->StartTracing(config);
    }
  }

 private:
  TracingController* controller_;
  Agent* agent_;
};

namespace {

std::set<std::string> flatten(
    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;
}

}  // namespace

using v8::platform::tracing::TraceConfig;
using v8::platform::tracing::TraceWriter;
using std::string;

Agent::Agent() : tracing_controller_(new TracingController()) {
  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_));
}

void Agent::InitializeWritersOnThread() {
  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);
}

Agent::~Agent() {
  categories_.clear();
  writers_.clear();

  StopTracing();

  uv_close(reinterpret_cast<uv_handle_t*>(&initialize_writer_async_), nullptr);
  uv_run(&tracing_loop_, UV_RUN_ONCE);
  CheckedUvLoopClose(&tracing_loop_);
}

void Agent::Start() {
  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) {
    Agent* agent = static_cast<Agent*>(arg);
    uv_run(&agent->tracing_loop_, UV_RUN_DEFAULT);
  }, this));
  started_ = true;
}

AgentWriterHandle Agent::AddClient(
    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);
}

AgentWriterHandle Agent::DefaultHandle() {
  return AgentWriterHandle(this, kDefaultHandleId);
}

void Agent::StopTracing() {
  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_);
}

void Agent::Disconnect(int client) {
  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);
}

void Agent::Enable(int id, const std::set<std::string>& categories) {
  if (categories.empty())
    return;

  ScopedSuspendTracing suspend(tracing_controller_.get(), this,
                               id != kDefaultHandleId);
  categories_[id].insert(categories.begin(), categories.end());
}

void Agent::Disable(int id, const std::set<std::string>& categories) {
  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);
  }
}

TraceConfig* Agent::CreateTraceConfig() const {
  if (categories_.empty())
    return nullptr;
  TraceConfig* trace_config = new TraceConfig();
  for (const auto& category : flatten(categories_)) {
    trace_config->AddIncludedCategory(category.c_str());
  }
  return trace_config;
}

std::string Agent::GetEnabledCategories() const {
  std::string categories;
  for (const std::string& category : flatten(categories_)) {
    if (!categories.empty())
      categories += ',';
    categories += category;
  }
  return categories;
}

void Agent::AppendTraceEvent(TraceObject* trace_event) {
  for (const auto& id_writer : writers_)
    id_writer.second->AppendTraceEvent(trace_event);
}

void Agent::AddMetadataEvent(std::unique_ptr<TraceObject> event) {
  Mutex::ScopedLock lock(metadata_events_mutex_);
  metadata_events_.push_back(std::move(event));
}

void Agent::Flush(bool blocking) {
  {
    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);
}

void TracingController::AddMetadataEvent(
    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));
}

}  // namespace tracing
}  // namespace node


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "tracing/agent.h"
2
3			#include <string>
4			#include "trace_event.h"
5			#include "tracing/node_trace_buffer.h"
6			#include "debug_utils-inl.h"
7			#include "env-inl.h"
8
9			namespace node {
10			namespace tracing {
11
12			class Agent::ScopedSuspendTracing {
13			public:
14		206	ScopedSuspendTracing(TracingController* controller, Agent* agent,
15			bool do_suspend = true)
16	✓✗	206	: controller_(controller), agent_(do_suspend ? agent : nullptr) {
17	✓✗	206	if (do_suspend) {
18	✗✓	206	CHECK(agent_->started_);
19		206	controller->StopTracing();
20			}
21		206	}
22
23		206	~ScopedSuspendTracing() {
24	✗✓	206	if (agent_ == nullptr) return;
25		206	TraceConfig* config = agent_->CreateTraceConfig();
26	✓✓	206	if (config != nullptr) {
27		204	controller_->StartTracing(config);
28			}
29		206	}
30
31			private:
32			TracingController* controller_;
33			Agent* agent_;
34			};
35
36			namespace {
37
38		221	std::set<std::string> flatten(
39			const std::unordered_map<int, std::multiset<std::string>>& map) {
40		221	std::set<std::string> result;
41	✓✓	569	for (const auto& id_value : map)
42		348	result.insert(id_value.second.begin(), id_value.second.end());
43		221	return result;
44			}
45
46			} // namespace
47
48			using v8::platform::tracing::TraceConfig;
49			using v8::platform::tracing::TraceWriter;
50			using std::string;
51
52		5726	Agent::Agent() : tracing_controller_(new TracingController()) {
53		5726	tracing_controller_->Initialize(nullptr);
54
55	✗✓	5726	CHECK_EQ(uv_loop_init(&tracing_loop_), 0);
56	✗✓	5816	CHECK_EQ(uv_async_init(&tracing_loop_,
57			&initialize_writer_async_,
58			[](uv_async_t* async) {
59			Agent* agent = ContainerOf(&Agent::initialize_writer_async_, async);
60			agent->InitializeWritersOnThread();
61			}), 0);
62		5726	uv_unref(reinterpret_cast<uv_handle_t*>(&initialize_writer_async_));
63		5726	}
64
65		90	void Agent::InitializeWritersOnThread() {
66		180	Mutex::ScopedLock lock(initialize_writer_mutex_);
67	✓✓	180	while (!to_be_initialized_.empty()) {
68		90	AsyncTraceWriter* head = *to_be_initialized_.begin();
69		90	head->InitializeOnThread(&tracing_loop_);
70		90	to_be_initialized_.erase(head);
71			}
72		90	initialize_writer_condvar_.Broadcast(lock);
73		90	}
74
75		5726	Agent::~Agent() {
76		5726	categories_.clear();
77		5726	writers_.clear();
78
79		5726	StopTracing();
80
81		5726	uv_close(reinterpret_cast<uv_handle_t*>(&initialize_writer_async_), nullptr);
82		5726	uv_run(&tracing_loop_, UV_RUN_ONCE);
83		5726	CheckedUvLoopClose(&tracing_loop_);
84		5726	}
85
86		90	void Agent::Start() {
87	✗✓	90	if (started_)
88			return;
89
90			NodeTraceBuffer* trace_buffer_ = new NodeTraceBuffer(
91		90	NodeTraceBuffer::kBufferChunks, this, &tracing_loop_);
92		90	tracing_controller_->Initialize(trace_buffer_);
93
94			// This thread should be created after async handles are created
95			// (within NodeTraceWriter and NodeTraceBuffer constructors).
96			// Otherwise the thread could shut down prematurely.
97	✗✓	180	CHECK_EQ(0, uv_thread_create(&thread_, [](void* arg) {
98			Agent* agent = static_cast<Agent*>(arg);
99			uv_run(&agent->tracing_loop_, UV_RUN_DEFAULT);
100			}, this));
101		90	started_ = true;
102			}
103
104		90	AgentWriterHandle Agent::AddClient(
105			const std::set<std::string>& categories,
106			std::unique_ptr<AsyncTraceWriter> writer,
107			enum UseDefaultCategoryMode mode) {
108		90	Start();
109
110		90	const std::set<std::string>* use_categories = &categories;
111
112		180	std::set<std::string> categories_with_default;
113	✓✓	90	if (mode == kUseDefaultCategories) {
114		88	categories_with_default.insert(categories.begin(), categories.end());
115		88	categories_with_default.insert(categories_[kDefaultHandleId].begin(),
116		88	categories_[kDefaultHandleId].end());
117		88	use_categories = &categories_with_default;
118			}
119
120		180	ScopedSuspendTracing suspend(tracing_controller_.get(), this);
121		90	int id = next_writer_id_++;
122		90	AsyncTraceWriter* raw = writer.get();
123		90	writers_[id] = std::move(writer);
124		90	categories_[id] = { use_categories->begin(), use_categories->end() };
125
126			{
127		180	Mutex::ScopedLock lock(initialize_writer_mutex_);
128		90	to_be_initialized_.insert(raw);
129		90	uv_async_send(&initialize_writer_async_);
130	✓✓	180	while (to_be_initialized_.count(raw) > 0)
131		90	initialize_writer_condvar_.Wait(lock);
132			}
133
134		90	return AgentWriterHandle(this, id);
135			}
136
137		5725	AgentWriterHandle Agent::DefaultHandle() {
138		5725	return AgentWriterHandle(this, kDefaultHandleId);
139			}
140
141		5726	void Agent::StopTracing() {
142	✓✓	5726	if (!started_)
143		5636	return;
144			// Perform final Flush on TraceBuffer. We don't want the tracing controller
145			// to flush the buffer again on destruction of the V8::Platform.
146		90	tracing_controller_->StopTracing();
147		90	tracing_controller_->Initialize(nullptr);
148		90	started_ = false;
149
150			// Thread should finish when the tracing loop is stopped.
151		90	uv_thread_join(&thread_);
152			}
153
154		5815	void Agent::Disconnect(int client) {
155	✓✓	5815	if (client == kDefaultHandleId) return;
156			{
157		90	Mutex::ScopedLock lock(initialize_writer_mutex_);
158		90	to_be_initialized_.erase(writers_[client].get());
159			}
160		180	ScopedSuspendTracing suspend(tracing_controller_.get(), this);
161		90	writers_.erase(client);
162		90	categories_.erase(client);
163			}
164
165		20	void Agent::Enable(int id, const std::set<std::string>& categories) {
166	✗✓	20	if (categories.empty())
167			return;
168
169			ScopedSuspendTracing suspend(tracing_controller_.get(), this,
170		40	id != kDefaultHandleId);
171		20	categories_[id].insert(categories.begin(), categories.end());
172			}
173
174		6	void Agent::Disable(int id, const std::set<std::string>& categories) {
175			ScopedSuspendTracing suspend(tracing_controller_.get(), this,
176		12	id != kDefaultHandleId);
177		6	std::multiset<std::string>& writer_categories = categories_[id];
178	✓✓	12	for (const std::string& category : categories) {
179		6	auto it = writer_categories.find(category);
180	✓✗	6	if (it != writer_categories.end())
181		6	writer_categories.erase(it);
182			}
183		6	}
184
185		206	TraceConfig* Agent::CreateTraceConfig() const {
186	✓✓	206	if (categories_.empty())
187		2	return nullptr;
188		204	TraceConfig* trace_config = new TraceConfig();
189	✓✓	415	for (const auto& category : flatten(categories_)) {
190		211	trace_config->AddIncludedCategory(category.c_str());
191			}
192		204	return trace_config;
193			}
194
195		17	std::string Agent::GetEnabledCategories() const {
196		17	std::string categories;
197	✓✓	33	for (const std::string& category : flatten(categories_)) {
198	✓✓	16	if (!categories.empty())
199		2	categories += ',';
200		16	categories += category;
201			}
202		17	return categories;
203			}
204
205		4513	void Agent::AppendTraceEvent(TraceObject* trace_event) {
206	✓✓	7456	for (const auto& id_writer : writers_)
207		2943	id_writer.second->AppendTraceEvent(trace_event);
208		4513	}
209
210		793	void Agent::AddMetadataEvent(std::unique_ptr<TraceObject> event) {
211		1586	Mutex::ScopedLock lock(metadata_events_mutex_);
212		793	metadata_events_.push_back(std::move(event));
213		793	}
214
215		408	void Agent::Flush(bool blocking) {
216			{
217		816	Mutex::ScopedLock lock(metadata_events_mutex_);
218	✓✓	3872	for (const auto& event : metadata_events_)
219		3464	AppendTraceEvent(event.get());
220			}
221
222	✓✓	640	for (const auto& id_writer : writers_)
223		232	id_writer.second->Flush(blocking);
224		408	}
225
226		793	void TracingController::AddMetadataEvent(
227			const unsigned char* category_group_enabled,
228			const char* name,
229			int num_args,
230			const char** arg_names,
231			const unsigned char* arg_types,
232			const uint64_t* arg_values,
233			std::unique_ptr<v8::ConvertableToTraceFormat>* convertable_values,
234			unsigned int flags) {
235		1586	std::unique_ptr<TraceObject> trace_event(new TraceObject);
236		1586	trace_event->Initialize(
237			TRACE_EVENT_PHASE_METADATA, category_group_enabled, name,
238			node::tracing::kGlobalScope, // scope
239			node::tracing::kNoId, // id
240			node::tracing::kNoId, // bind_id
241			num_args, arg_names, arg_types, arg_values, convertable_values,
242			TRACE_EVENT_FLAG_NONE,
243		793	CurrentTimestampMicroseconds(),
244		793	CurrentCpuTimestampMicroseconds());
245		793	Agent* node_agent = node::tracing::TraceEventHelper::GetAgent();
246	✓✗	793	if (node_agent != nullptr)
247		793	node_agent->AddMetadataEvent(std::move(trace_event));
248		793	}
249
250			} // namespace tracing
251			} // namespace node