src,lib: expose node.http trace flag by array

Instead call the C++ code every time we make a HTTP request,
now we get the C++ pointer to the flag that holds the info
if the trace is enabled for node.http, then we expose that
flag using BindingData, with this change, no C++ call is made
and the access to the info happens in JS side, which has no
perf penalty.

Author: H4ad

lib/internal/http.js

@@ -8,7 +8,11 @@ const {
 } = primordials;
 
 const { setUnrefTimeout } = require('internal/timers');
-const { trace, isTraceCategoryEnabled } = internalBinding('trace_events');
+const { trace } = internalBinding('trace_events');
+// The trace variable must not be destructured
+// because it might break node snapshot serialization
+// ref: https://github.com/nodejs/node/pull/48142#discussion_r1204128367
+const tracing = internalBinding('tracing');
 const {
   CHAR_LOWERCASE_B,
   CHAR_LOWERCASE_E,
@@ -38,7 +42,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,100 @@
+#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"
+
+namespace node {
+namespace tracing {
+
+using v8::ArrayBuffer;
+using v8::Context;
+using v8::FunctionTemplate;
+using v8::HandleScope;
+using v8::Local;
+using v8::Object;
+using v8::Uint8Array;
+using v8::Value;
+
+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
+  uint8_t* http_flag_pointer = const_cast<uint8_t*>(
+    TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("node.http"));
+
+  // NO_OP deleter
+  // the idea of this chunk of code is to construct
+  auto nop_deleter = [](void*, size_t, void*) {};
+  auto backing_store = v8::ArrayBuffer::NewBackingStore(
+    http_flag_pointer, 1, nop_deleter, nullptr);
+  v8::Local<ArrayBuffer> array_buffer = v8::ArrayBuffer::New(
+    realm->isolate(), std::move(backing_store));
+  v8::Local<Uint8Array> uint8Array = v8::Uint8Array::New(array_buffer, 0, 1);
+
+  object
+      ->Set(realm->context(),
+            FIXED_ONE_BYTE_STRING(realm->isolate(), "tracingCategories"),
+            uint8Array)
+      .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
+
+}  // namespace 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_