src: expose node.http trace flag by array

Author: H4ad

lib/internal/http.js

@@ -8,7 +8,8 @@ const {
 } = primordials;
 
 const { setUnrefTimeout } = require('internal/timers');
-const { trace, isTraceCategoryEnabled } = internalBinding('trace_events');
+const { trace } = internalBinding('trace_events');
+const tracing = internalBinding('tracing');
 const {
   CHAR_LOWERCASE_B,
   CHAR_LOWERCASE_E,
@@ -38,7 +39,7 @@ function getNextTraceEventId() {
 }
 
 function isTraceHTTPEnabled() {
-  return isTraceCategoryEnabled('node.http');
+  return tracing.tracingCategories[0] > 0;
 }
 
 const traceEventCategory = 'node,node.http';

node.gyp

@@ -128,6 +128,7 @@
       'src/node_symbols.cc',
       'src/node_task_queue.cc',
       'src/node_trace_events.cc',
+      'src/node_tracing.cc',
       'src/node_types.cc',
       'src/node_url.cc',
       'src/node_util.cc',
@@ -248,6 +249,7 @@
       'src/node_sockaddr-inl.h',
       'src/node_stat_watcher.h',
       'src/node_union_bytes.h',
+      'src/node_tracing.h',
       'src/node_url.h',
       'src/node_util.h',
       'src/node_version.h',

src/base_object_types.h

@@ -16,7 +16,8 @@ namespace node {
   V(blob_binding_data, BlobBindingData)                                        \
   V(process_binding_data, process::BindingData)                                \
   V(timers_binding_data, timers::BindingData)                                  \
-  V(url_binding_data, url::BindingData)
+  V(url_binding_data, url::BindingData)                                        \
+  V(tracing_binding_data, tracing::BindingData)
 
 #define UNSERIALIZABLE_BINDING_TYPES(V)                                        \
   V(http2_binding_data, http2::BindingData)                                    \

src/node_binding.cc

@@ -69,6 +69,7 @@
   V(task_queue)                                                                \
   V(tcp_wrap)                                                                  \
   V(timers)                                                                    \
+  V(tracing)                                                                   \
   V(trace_events)                                                              \
   V(tty_wrap)                                                                  \
   V(types)                                                                     \

src/node_builtins.cc

@@ -113,7 +113,7 @@ BuiltinLoader::BuiltinCategories BuiltinLoader::GetBuiltinCategories() const {
 #endif  // !HAVE_INSPECTOR
 
 #if !NODE_USE_V8_PLATFORM || !defined(NODE_HAVE_I18N_SUPPORT)
-        "trace_events",
+        "tracing", "trace_events",
 #endif  // !NODE_USE_V8_PLATFORM || !defined(NODE_HAVE_I18N_SUPPORT)
 
 #if !HAVE_OPENSSL

src/node_external_reference.h

@@ -110,6 +110,7 @@ class ExternalReferenceRegistry {
   V(string_decoder)                                                            \
   V(stream_wrap)                                                               \
   V(signal_wrap)                                                               \
+  V(tracing)                                                                   \
   V(trace_events)                                                              \
   V(timers)                                                                    \
   V(types)                                                                     \

src/node_snapshotable.cc

@@ -19,6 +19,7 @@
 #include "node_metadata.h"
 #include "node_process.h"
 #include "node_snapshot_builder.h"
+#include "node_tracing.h"
 #include "node_url.h"
 #include "node_util.h"
 #include "node_v8.h"

src/node_tracing.cc

@@ -0,0 +1,96 @@
+#include "node_tracing.h"
+#include "base_object-inl.h"
+#include "env-inl.h"
+#include "memory_tracker-inl.h"
+#include "node.h"
+#include "node_external_reference.h"
+#include "node_internals.h"
+#include "node_v8_platform-inl.h"
+#include "tracing/agent.h"
+#include "util-inl.h"
+#include "v8.h"
+
+#include <set>
+#include <string>
+#include <numeric>
+
+namespace node {
+namespace tracing {
+
+using v8::Context;
+using v8::FunctionTemplate;
+using v8::HandleScope;
+using v8::Isolate;
+using v8::Local;
+using v8::Value;
+using v8::Object;
+using v8::String;
+using v8::Uint8Array;
+
+void BindingData::MemoryInfo(MemoryTracker* tracker) const {}
+
+BindingData::BindingData(Realm* realm, v8::Local<v8::Object> object)
+    : SnapshotableObject(realm, object, type_int) {
+
+  // get the pointer of the memory for the flag that store if trace is enabled for http
+  // the pointer will always be the same and if the category does not exist, it creates: https://github.com/nodejs/node/blob/6bbf2a57fcf33266c5859497f8cc32e1389a358a/deps/v8/src/libplatform/tracing/tracing-controller.cc#L322-L342
+  auto p = const_cast<uint8_t*>(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("node.http"));
+
+  auto nop = [](void*, size_t, void*) {}; // no-op deleter
+  auto bs = v8::ArrayBuffer::NewBackingStore(p, 1, nop, nullptr);
+  auto ab = v8::ArrayBuffer::New(realm->isolate(), std::move(bs));
+  v8::Local<Uint8Array> u8 = v8::Uint8Array::New(ab, 0, 1);
+
+  object
+      ->Set(realm->context(),
+            FIXED_ONE_BYTE_STRING(realm->isolate(), "tracingCategories"),
+            u8)
+      .Check();
+}
+
+bool BindingData::PrepareForSerialization(v8::Local<v8::Context> context,
+                                          v8::SnapshotCreator* creator) {
+  return true;
+}
+
+InternalFieldInfoBase* BindingData::Serialize(int index) {
+  DCHECK_EQ(index, BaseObject::kEmbedderType);
+  InternalFieldInfo* info =
+      InternalFieldInfoBase::New<InternalFieldInfo>(type());
+  return info;
+}
+
+void BindingData::Deserialize(v8::Local<v8::Context> context,
+                              v8::Local<v8::Object> holder,
+                              int index,
+                              InternalFieldInfoBase* info) {
+  DCHECK_EQ(index, BaseObject::kEmbedderType);
+  v8::HandleScope scope(context->GetIsolate());
+  Realm* realm = Realm::GetCurrent(context);
+  BindingData* binding = realm->AddBindingData<BindingData>(context, holder);
+  CHECK_NOT_NULL(binding);
+}
+
+void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
+                                             Local<FunctionTemplate> ctor) {}
+
+void BindingData::CreatePerContextProperties(Local<Object> target,
+                                             Local<Value> unused,
+                                             Local<Context> context,
+                                             void* priv) {
+  Realm* realm = Realm::GetCurrent(context);
+  realm->AddBindingData<BindingData>(context, target);
+}
+
+void BindingData::RegisterExternalReferences(ExternalReferenceRegistry* registry) {}
+
+}  // namespace tracing
+
+} // node
+
+NODE_BINDING_CONTEXT_AWARE_INTERNAL(
+    tracing, node::tracing::BindingData::CreatePerContextProperties)
+NODE_BINDING_PER_ISOLATE_INIT(
+    tracing, node::tracing::BindingData::CreatePerIsolateProperties)
+NODE_BINDING_EXTERNAL_REFERENCE(
+    tracing, node::tracing::BindingData::RegisterExternalReferences)

src/node_tracing.h

@@ -0,0 +1,45 @@
+#ifndef SRC_NODE_TRACING_H_
+#define SRC_NODE_TRACING_H_
+
+#include <cinttypes>
+#include "aliased_buffer.h"
+#include "node.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+#include <string>
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace tracing {
+
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* realm, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(tracing_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::FunctionTemplate> ctor);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+};
+
+}  // namespace tracing
+
+}  // namespace node
+
+#endif // SRC_NODE_TRACING_H_