inspector: add a "NodeTracing" domain support

This change adds a new inspector domain for receiving Node tracing
data.
  1. Node.js now can extend Inspector protocol with new domains with
     the API defined in the src/inspector/node_protocol.pdl.
  2. Plumbing code will be generated at the build time. /json/protocol
     HTTP endpoint returns both V8 and Node.js inspector protocol.
  3. "NodeTracing" domain was introduced. It is based on the Chrome
     "Tracing" domain.

PR-URL: https://github.com/nodejs/node/pull/20608
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ali Ijaz Sheikh <ofrobots@google.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

1 files changed, 106 insertions, 0 deletions

diff --git a/src/inspector/tracing_agent.cc b/src/inspector/tracing_agent.cc
new file mode 100644
index 0000000000..2d98fa1ee5
--- /dev/null
+++ b/src/inspector/tracing_agent.cc
@@ -0,0 +1,106 @@
+#include "tracing_agent.h"
+
+#include "env-inl.h"
+#include "v8.h"
+
+#include <set>
+#include <sstream>
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+namespace {
+using v8::platform::tracing::TraceWriter;
+
+class InspectorTraceWriter : public node::tracing::AsyncTraceWriter {
+ public:
+  explicit InspectorTraceWriter(NodeTracing::Frontend* frontend)
+                                : frontend_(frontend) {}
+
+  void AppendTraceEvent(
+      v8::platform::tracing::TraceObject* trace_event) override {
+    if (!json_writer_)
+      json_writer_.reset(TraceWriter::CreateJSONTraceWriter(stream_, "value"));
+    json_writer_->AppendTraceEvent(trace_event);
+  }
+
+  void Flush(bool) override {
+    if (!json_writer_)
+      return;
+    json_writer_.reset();
+    std::ostringstream result(
+        "{\"method\":\"NodeTracing.dataCollected\",\"data\":",
+        std::ostringstream::ate);
+    result << stream_.str();
+    result << "}";
+    frontend_->sendRawNotification(result.str());
+    stream_.str("");
+  }
+
+ private:
+  std::unique_ptr<TraceWriter> json_writer_;
+  std::ostringstream stream_;
+  NodeTracing::Frontend* frontend_;
+};
+}  // namespace
+
+TracingAgent::TracingAgent(Environment* env)
+                           : env_(env),
+                             trace_writer_(
+                                  tracing::Agent::EmptyClientHandle()) {
+}
+
+TracingAgent::~TracingAgent() {
+  trace_writer_.reset();
+}
+
+void TracingAgent::Wire(UberDispatcher* dispatcher) {
+  frontend_ = std::make_unique<NodeTracing::Frontend>(dispatcher->channel());
+  NodeTracing::Dispatcher::wire(dispatcher, this);
+}
+
+DispatchResponse TracingAgent::start(
+    std::unique_ptr<protocol::NodeTracing::TraceConfig> traceConfig) {
+  if (trace_writer_ != nullptr) {
+    return DispatchResponse::Error(
+        "Call NodeTracing::end to stop tracing before updating the config");
+  }
+
+  std::set<std::string> categories_set;
+  protocol::Array<std::string>* categories =
+      traceConfig->getIncludedCategories();
+  for (size_t i = 0; i < categories->length(); i++)
+    categories_set.insert(categories->get(i));
+
+  if (categories_set.empty())
+    return DispatchResponse::Error("At least one category should be enabled");
+
+  trace_writer_ = env_->tracing_agent()->AddClient(
+      categories_set, std::make_unique<InspectorTraceWriter>(frontend_.get()));
+  return DispatchResponse::OK();
+}
+
+DispatchResponse TracingAgent::stop() {
+  trace_writer_.reset();
+  frontend_->tracingComplete();
+  return DispatchResponse::OK();
+}
+
+DispatchResponse TracingAgent::getCategories(
+    std::unique_ptr<protocol::Array<String>>* categories) {
+  *categories = Array<String>::create();
+  categories->get()->addItem("node");
+  categories->get()->addItem("node.async");
+  categories->get()->addItem("node.bootstrap");
+  categories->get()->addItem("node.fs.sync");
+  categories->get()->addItem("node.perf");
+  categories->get()->addItem("node.perf.usertiming");
+  categories->get()->addItem("node.perf.timerify");
+  categories->get()->addItem("v8");
+  return DispatchResponse::OK();
+}
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node