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, 38 insertions, 4 deletions

diff --git a/src/tracing/agent.h b/src/tracing/agent.h
index ca5fd35417..fd79842759 100644
--- a/src/tracing/agent.h
+++ b/src/tracing/agent.h
@@ -7,11 +7,20 @@
 
 #include <set>
 #include <string>
+#include <unordered_map>
 
 namespace node {
 namespace tracing {
 
 using v8::platform::tracing::TraceConfig;
+using v8::platform::tracing::TraceObject;
+
+class AsyncTraceWriter {
+ public:
+  virtual ~AsyncTraceWriter() {}
+  virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
+  virtual void Flush(bool blocking) = 0;
+};
 
 class TracingController : public v8::platform::tracing::TracingController {
  public:
@@ -22,33 +31,58 @@ class TracingController : public v8::platform::tracing::TracingController {
   }
 };
 
+
 class Agent {
  public:
+  // Resetting the pointer disconnects client
+  using ClientHandle = std::unique_ptr<std::pair<Agent*, int>,
+                                       void (*)(std::pair<Agent*, int>*)>;
+
+  static ClientHandle EmptyClientHandle() {
+    return ClientHandle(nullptr, DisconnectClient);
+  }
   explicit Agent(const std::string& log_file_pattern);
   void Stop();
 
   TracingController* GetTracingController() { return tracing_controller_; }
 
+  // Destroying the handle disconnects the client
+  ClientHandle AddClient(const std::set<std::string>& categories,
+                         std::unique_ptr<AsyncTraceWriter> writer);
+
+  // These 3 methods operate on a "default" client, e.g. the file writer
   void Enable(const std::string& categories);
   void Enable(const std::set<std::string>& categories);
   void Disable(const std::set<std::string>& categories);
   std::string GetEnabledCategories();
 
+  void AppendTraceEvent(TraceObject* trace_event);
+  void Flush(bool blocking);
+
+  TraceConfig* CreateTraceConfig();
+
  private:
   static void ThreadCb(void* arg);
+  static void DisconnectClient(std::pair<Agent*, int>* id_agent) {
+    id_agent->first->Disconnect(id_agent->second);
+    delete id_agent;
+  }
 
   void Start();
-  void RestartTracing();
-
-  TraceConfig* CreateTraceConfig();
+  void StopTracing();
+  void Disconnect(int client);
 
   const std::string& log_file_pattern_;
   uv_thread_t thread_;
   uv_loop_t tracing_loop_;
   bool started_ = false;
 
-  std::multiset<std::string> categories_;
+  std::unordered_map<int, std::set<std::string>> categories_;
   TracingController* tracing_controller_ = nullptr;
+  ClientHandle file_writer_;
+  int next_writer_id_ = 1;
+  std::unordered_map<int, std::unique_ptr<AsyncTraceWriter>> writers_;
+  std::multiset<std::string> file_writer_categories_;
 };
 
 }  // namespace tracing