@encharm/cws 4.5.1 → 4.5.3

package/src/headers/24/traced_value.h

@@ -0,0 +1,129 @@
+// Copyright 2016 the V8 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.
+
+#ifndef SRC_TRACING_TRACED_VALUE_H_
+#define SRC_TRACING_TRACED_VALUE_H_
+
+#include "v8-platform.h"
+
+#include <cstdint>
+#include <span>
+#include <string>
+
+namespace node {
+namespace tracing {
+
+template <typename T>
+std::unique_ptr<v8::ConvertableToTraceFormat> CastTracedValue(const T& value) {
+  return value.Cast();
+}
+
+class EnvironmentArgs {
+ public:
+  EnvironmentArgs(std::span<const std::string> args,
+                  std::span<const std::string> exec_args)
+      : args_(args), exec_args_(exec_args) {}
+
+  std::unique_ptr<v8::ConvertableToTraceFormat> Cast() const;
+
+ private:
+  std::span<const std::string> args_;
+  std::span<const std::string> exec_args_;
+};
+
+class AsyncWrapArgs {
+ public:
+  AsyncWrapArgs(int64_t execution_async_id, int64_t trigger_async_id)
+      : execution_async_id_(execution_async_id),
+        trigger_async_id_(trigger_async_id) {}
+
+  std::unique_ptr<v8::ConvertableToTraceFormat> Cast() const;
+
+ private:
+  int64_t execution_async_id_;
+  int64_t trigger_async_id_;
+};
+
+class ProcessMeta {
+ public:
+  std::unique_ptr<v8::ConvertableToTraceFormat> Cast() const;
+};
+
+// Do not use this class directly. Define a custom structured class to provide
+// a conversion method so that the class can be used with both V8 legacy
+// trace API and perfetto API.
+//
+// These classes provide a JSON-inspired way to write structed data into traces.
+//
+// To define how a custom class should be written into the trace, users should
+// define one of the two following functions:
+// - Foo::Cast(TracedValue) const
+//   (preferred for code which depends on perfetto directly)
+//
+// After defining a conversion method, the object can be used as a
+// TRACE_EVENT argument:
+//
+// Foo foo;
+// TRACE_EVENT("cat", "Event", "arg", CastTracedValue(foo));
+//
+// class Foo {
+//   std::unique_ptr<v8::ConvertableToTraceFormat> Cast() const {
+//     auto traced_value = tracing::TracedValue::Create();
+//     dict->SetInteger("key", 42);
+//     dict->SetString("foo", "bar");
+//     return traced_value;
+//   }
+// }
+class TracedValue : public v8::ConvertableToTraceFormat {
+ public:
+  ~TracedValue() override = default;
+
+  static std::unique_ptr<TracedValue> Create();
+  static std::unique_ptr<TracedValue> CreateArray();
+
+  void EndDictionary();
+  void EndArray();
+
+  // These methods assume that |name| is a long lived "quoted" string.
+  void SetInteger(const char* name, int value);
+  void SetDouble(const char* name, double value);
+  void SetBoolean(const char* name, bool value);
+  void SetNull(const char* name);
+  void SetString(const char* name, const char* value);
+  void SetString(const char* name, const std::string& value) {
+    SetString(name, value.c_str());
+  }
+  void BeginDictionary(const char* name);
+  void BeginArray(const char* name);
+
+  void AppendInteger(int);
+  void AppendDouble(double);
+  void AppendBoolean(bool);
+  void AppendNull();
+  void AppendString(const char*);
+  void AppendString(const std::string& value) { AppendString(value.c_str()); }
+  void BeginArray();
+  void BeginDictionary();
+
+  // ConvertableToTraceFormat implementation.
+  void AppendAsTraceFormat(std::string* out) const override;
+
+  TracedValue(const TracedValue&) = delete;
+  TracedValue& operator=(const TracedValue&) = delete;
+
+ private:
+  explicit TracedValue(bool root_is_array = false);
+
+  void WriteComma();
+  void WriteName(const char* name);
+
+  std::string data_;
+  bool first_item_;
+  bool root_is_array_;
+};
+
+}  // namespace tracing
+}  // namespace node
+
+#endif  // SRC_TRACING_TRACED_VALUE_H_

package/src/headers/24/tracing/agent.h

@@ -0,0 +1,195 @@
+#ifndef SRC_TRACING_AGENT_H_
+#define SRC_TRACING_AGENT_H_
+
+#include "libplatform/v8-tracing.h"
+#include "uv.h"
+#include "util.h"
+#include "node_mutex.h"
+
+#include <list>
+#include <set>
+#include <string>
+#include <unordered_map>
+
+namespace v8 {
+class ConvertableToTraceFormat;
+class TracingController;
+}  // namespace v8
+
+namespace node {
+namespace tracing {
+
+using v8::platform::tracing::TraceConfig;
+using v8::platform::tracing::TraceObject;
+
+class Agent;
+
+class AsyncTraceWriter {
+ public:
+  virtual ~AsyncTraceWriter() = default;
+  virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
+  virtual void Flush(bool blocking) = 0;
+  virtual void InitializeOnThread(uv_loop_t* loop) {}
+};
+
+class TracingController : public v8::platform::tracing::TracingController {
+ public:
+  TracingController() : v8::platform::tracing::TracingController() {}
+
+  int64_t CurrentTimestampMicroseconds() override {
+    return uv_hrtime() / 1000;
+  }
+  void 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);
+};
+
+class AgentWriterHandle {
+ public:
+  inline AgentWriterHandle() = default;
+  inline ~AgentWriterHandle() { reset(); }
+
+  inline AgentWriterHandle(AgentWriterHandle&& other);
+  inline AgentWriterHandle& operator=(AgentWriterHandle&& other);
+  inline bool empty() const { return agent_ == nullptr; }
+  inline void reset();
+
+  inline void Enable(const std::set<std::string>& categories);
+  inline void Disable(const std::set<std::string>& categories);
+
+  inline bool IsDefaultHandle();
+
+  inline Agent* agent() { return agent_; }
+
+  inline v8::TracingController* GetTracingController();
+
+  AgentWriterHandle(const AgentWriterHandle& other) = delete;
+  AgentWriterHandle& operator=(const AgentWriterHandle& other) = delete;
+
+ private:
+  inline AgentWriterHandle(Agent* agent, int id) : agent_(agent), id_(id) {}
+
+  Agent* agent_ = nullptr;
+  int id_ = 0;
+
+  friend class Agent;
+};
+
+class Agent {
+ public:
+  Agent();
+  ~Agent();
+
+  TracingController* GetTracingController() {
+    TracingController* controller = tracing_controller_.get();
+    CHECK_NOT_NULL(controller);
+    return controller;
+  }
+
+  enum UseDefaultCategoryMode {
+    kUseDefaultCategories,
+    kIgnoreDefaultCategories
+  };
+
+  // Destroying the handle disconnects the client
+  AgentWriterHandle AddClient(const std::set<std::string>& categories,
+                              std::unique_ptr<AsyncTraceWriter> writer,
+                              enum UseDefaultCategoryMode mode);
+  // A handle that is only used for managing the default categories
+  // (which can then implicitly be used through using `USE_DEFAULT_CATEGORIES`
+  // when adding a client later).
+  AgentWriterHandle DefaultHandle();
+
+  // Returns a comma-separated list of enabled categories.
+  std::string GetEnabledCategories() const;
+
+  // Writes to all writers registered through AddClient().
+  void AppendTraceEvent(TraceObject* trace_event);
+
+  void AddMetadataEvent(std::unique_ptr<TraceObject> event);
+  // Flushes all writers registered through AddClient().
+  void Flush(bool blocking);
+
+  TraceConfig* CreateTraceConfig() const;
+
+ private:
+  friend class AgentWriterHandle;
+
+  void InitializeWritersOnThread();
+
+  void Start();
+  void StopTracing();
+  void Disconnect(int client);
+
+  void Enable(int id, const std::set<std::string>& categories);
+  void Disable(int id, const std::set<std::string>& categories);
+
+  uv_thread_t thread_;
+  uv_loop_t tracing_loop_;
+
+  bool started_ = false;
+  class ScopedSuspendTracing;
+
+  // Each individual Writer has one id.
+  int next_writer_id_ = 1;
+  enum { kDefaultHandleId = -1 };
+  // These maps store the original arguments to AddClient(), by id.
+  std::unordered_map<int, std::multiset<std::string>> categories_;
+  std::unordered_map<int, std::unique_ptr<AsyncTraceWriter>> writers_;
+  std::unique_ptr<TracingController> tracing_controller_;
+
+  // Variables related to initializing per-event-loop properties of individual
+  // writers, such as libuv handles.
+  Mutex initialize_writer_mutex_;
+  ConditionVariable initialize_writer_condvar_;
+  uv_async_t initialize_writer_async_;
+  std::set<AsyncTraceWriter*> to_be_initialized_;
+
+  Mutex metadata_events_mutex_;
+  std::list<std::unique_ptr<TraceObject>> metadata_events_;
+};
+
+void AgentWriterHandle::reset() {
+  if (agent_ != nullptr)
+    agent_->Disconnect(id_);
+  agent_ = nullptr;
+}
+
+AgentWriterHandle& AgentWriterHandle::operator=(AgentWriterHandle&& other) {
+  reset();
+  agent_ = other.agent_;
+  id_ = other.id_;
+  other.agent_ = nullptr;
+  return *this;
+}
+
+AgentWriterHandle::AgentWriterHandle(AgentWriterHandle&& other) {
+  *this = std::move(other);
+}
+
+void AgentWriterHandle::Enable(const std::set<std::string>& categories) {
+  if (agent_ != nullptr) agent_->Enable(id_, categories);
+}
+
+void AgentWriterHandle::Disable(const std::set<std::string>& categories) {
+  if (agent_ != nullptr) agent_->Disable(id_, categories);
+}
+
+bool AgentWriterHandle::IsDefaultHandle() {
+  return agent_ != nullptr && id_ == Agent::kDefaultHandleId;
+}
+
+inline v8::TracingController* AgentWriterHandle::GetTracingController() {
+  return agent_ != nullptr ? agent_->GetTracingController() : nullptr;
+}
+
+}  // namespace tracing
+}  // namespace node
+
+#endif  // SRC_TRACING_AGENT_H_