inspector: reduce http inspection overhead

Encode initiator stacks directly into CBOR to avoid the intermediate
protocol value tree. Retain asynchronous caller frames, cycle checks
and the maximum nesting depth.

Pass Buffer and Uint8Array chunks directly to the native request-body
cache, which synchronously copies the bytes, and omit unused fields
from the body-completion notification.

Add regression coverage for reused request buffers, delayed and async
initiators, and stack serialization.

Signed-off-by: GrinZero <774933704@qq.com>
Assisted-by: Codex

Author: GrinZero

lib/internal/inspector/network_http.js

@@ -195,7 +195,9 @@ function onClientRequestBodyChunkSent({ request, chunk, encoding }) {
 
   const buffer = typeof chunk === 'string' ?
     Buffer.from(chunk, encoding ?? undefined) :
-    Buffer.from(chunk);
+    chunk;
+  // The native request-body cache synchronously copies the bytes, so there is
+  // no need to copy Buffer or Uint8Array chunks before passing them to it.
   Network.dataSent({
     requestId: request[kInspectorRequestId],
     timestamp: getMonotonicTime(),
@@ -215,9 +217,6 @@ function onClientRequestBodySent({ request }) {
 
   Network.dataSent({
     requestId: request[kInspectorRequestId],
-    timestamp: getMonotonicTime(),
-    dataLength: 0,
-    data: Buffer.alloc(0),
     finished: true,
   });
 }

src/inspector/network_agent.cc

@@ -1,5 +1,6 @@
 #include "network_agent.h"
 #include <string>
+#include "crdtp/cbor.h"
 #include "debug_utils-inl.h"
 #include "env-inl.h"
 #include "inspector/inspector_object_utils.h"
@@ -37,93 +38,88 @@ static void ThrowEventError(v8::Isolate* isolate, const std::string& message) {
       v8::String::NewFromUtf8(isolate, message.c_str()).ToLocalChecked()));
 }
 
-static std::unique_ptr<protocol::Value> V8ToProtocolValue(
-    Isolate* isolate,
-    Local<Context> context,
-    Local<Value> value,
-    LocalVector<Object>* ancestors) {
+// Encode directly into the format consumed by the imported V8 StackTrace
+// parser, avoiding an intermediate tree of protocol::Value allocations.
+static bool EncodeV8Value(Isolate* isolate,
+                          Local<Context> context,
+                          Local<Value> value,
+                          LocalVector<Object>* ancestors,
+                          std::vector<uint8_t>* bytes,
+                          bool* has_call_frames = nullptr) {
+  namespace cbor = crdtp::cbor;
   if (value->IsNullOrUndefined()) {
-    return protocol::Value::null();
+    bytes->push_back(cbor::EncodeNull());
+    return true;
   }
   if (value->IsBoolean()) {
-    return protocol::FundamentalValue::create(value.As<Boolean>()->Value());
+    bytes->push_back(value.As<Boolean>()->Value() ? cbor::EncodeTrue()
+                                                  : cbor::EncodeFalse());
+    return true;
   }
   if (value->IsInt32()) {
-    return protocol::FundamentalValue::create(value.As<Int32>()->Value());
+    cbor::EncodeInt32(value.As<Int32>()->Value(), bytes);
+    return true;
   }
   if (value->IsNumber()) {
-    return protocol::FundamentalValue::create(value.As<Number>()->Value());
+    cbor::EncodeDouble(value.As<Number>()->Value(), bytes);
+    return true;
   }
   if (value->IsString()) {
-    return protocol::StringValue::create(ToProtocolString(isolate, value));
-  }
-
-  if (!value->IsObject()) {
-    return nullptr;
+    Utf8Value string(isolate, value);
+    cbor::EncodeString8(
+        crdtp::span<uint8_t>(reinterpret_cast<const uint8_t*>(*string),
+                             string.length()),
+        bytes);
+    return true;
   }
+  if (!value->IsObject()) return false;
 
   Local<Object> object = value.As<Object>();
-  if (ancestors->size() >= kMaxProtocolValueDepth) {
-    return nullptr;
-  }
+  if (ancestors->size() >= kMaxProtocolValueDepth) return false;
   for (const auto& ancestor : *ancestors) {
-    if (ancestor == object) {
-      return nullptr;
-    }
+    if (ancestor == object) return false;
   }
   ancestors->push_back(object);
   auto pop_ancestor = OnScopeLeave([ancestors]() { ancestors->pop_back(); });
-
+  cbor::EnvelopeEncoder envelope;
+  envelope.EncodeStart(bytes);
   if (value->IsArray()) {
     Local<Array> array = value.As<Array>();
-    std::unique_ptr<protocol::ListValue> list = protocol::ListValue::create();
-    list->reserve(array->Length());
+    bytes->push_back(cbor::EncodeIndefiniteLengthArrayStart());
     for (uint32_t i = 0; i < array->Length(); i++) {
       Local<Value> element;
-      if (!array->Get(context, i).ToLocal(&element)) {
-        return nullptr;
-      }
-      std::unique_ptr<protocol::Value> protocol_value =
-          V8ToProtocolValue(isolate, context, element, ancestors);
-      if (!protocol_value) {
-        return nullptr;
+      if (!array->Get(context, i).ToLocal(&element) ||
+          !EncodeV8Value(isolate, context, element, ancestors, bytes)) {
+        return false;
       }
-      list->pushValue(std::move(protocol_value));
-    }
-    return list;
-  }
-
-  Local<Array> property_names;
-  if (!object->GetOwnPropertyNames(context).ToLocal(&property_names)) {
-    return nullptr;
-  }
-  std::unique_ptr<protocol::DictionaryValue> dict =
-      protocol::DictionaryValue::create();
-  for (uint32_t i = 0; i < property_names->Length(); i++) {
-    Local<Value> property_name;
-    if (!property_names->Get(context, i).ToLocal(&property_name) ||
-        !property_name->IsString()) {
-      return nullptr;
     }
-    Local<Value> property;
-    if (!object->Get(context, property_name).ToLocal(&property)) {
-      return nullptr;
+  } else {
+    Local<Array> property_names;
+    if (!object->GetOwnPropertyNames(context).ToLocal(&property_names)) {
+      return false;
     }
-    std::unique_ptr<protocol::Value> protocol_value =
-        V8ToProtocolValue(isolate, context, property, ancestors);
-    if (!protocol_value) {
-      return nullptr;
+    bytes->push_back(cbor::EncodeIndefiniteLengthMapStart());
+    for (uint32_t i = 0; i < property_names->Length(); i++) {
+      Local<Value> property_name;
+      if (!property_names->Get(context, i).ToLocal(&property_name) ||
+          !property_name->IsString()) {
+        return false;
+      }
+      if (has_call_frames != nullptr &&
+          property_name.As<v8::String>()->StringEquals(
+              FIXED_ONE_BYTE_STRING(isolate, "callFrames"))) {
+        *has_call_frames = true;
+      }
+      Local<Value> property;
+      if (!object->Get(context, property_name).ToLocal(&property) ||
+          !EncodeV8Value(isolate, context, property_name, ancestors, bytes) ||
+          !EncodeV8Value(isolate, context, property, ancestors, bytes)) {
+        return false;
+      }
     }
-    dict->setValue(ToProtocolString(isolate, property_name),
-                   std::move(protocol_value));
   }
-  return dict;
-}
-
-static std::unique_ptr<protocol::Value> V8ToProtocolValue(
-    Isolate* isolate, Local<Context> context, Local<Value> value) {
-  LocalVector<Object> ancestors(isolate);
-  return V8ToProtocolValue(isolate, context, value, &ancestors);
+  bytes->push_back(cbor::EncodeStop());
+  return envelope.EncodeStop(bytes);
 }
 
 // Create a protocol::Network::Headers from the v8 object.
@@ -179,25 +175,21 @@ NetworkAgent::createInitiatorFromObject(v8::Local<v8::Context> context,
 
   Local<Object> stack_obj;
   if (ObjectGetObject(context, initiator_obj, "stack").ToLocal(&stack_obj)) {
-    std::unique_ptr<protocol::Value> stack_value =
-        V8ToProtocolValue(isolate, context, stack_obj);
-    if (!stack_value) {
+    LocalVector<Object> ancestors(isolate);
+    std::vector<uint8_t> bytes;
+    bool has_call_frames = false;
+    if (!EncodeV8Value(isolate,
+                       context,
+                       stack_obj,
+                       &ancestors,
+                       &bytes,
+                       &has_call_frames) ||
+        !has_call_frames) {
       ThrowEventError(isolate, "Invalid initiator.stack in event");
       return {};
     }
-
-    protocol::DictionaryValue* stack_dict =
-        protocol::DictionaryValue::cast(stack_value.get());
-    if (!stack_dict || stack_dict->get("callFrames") == nullptr) {
-      ThrowEventError(isolate, "Invalid initiator.stack in event");
-      return {};
-    }
-
-    protocol::ErrorSupport errors;
-    std::unique_ptr<v8_inspector::protocol::Runtime::API::StackTrace> stack =
-        protocol::ValueConversions<v8_inspector::protocol::Runtime::API::
-                                       StackTrace>::fromValue(stack_value.get(),
-                                                              &errors);
+    auto stack = v8_inspector::protocol::Runtime::API::StackTrace::fromBinary(
+        bytes.data(), bytes.size());
     if (!stack) {
       ThrowEventError(isolate, "Invalid initiator.stack in event");
       return {};

test/parallel/test-inspector-network-http-body-buffer-mutation.js

@@ -0,0 +1,60 @@
+// Flags: --experimental-network-inspection
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const assert = require('node:assert');
+const http = require('node:http');
+const { Session } = require('node:inspector/promises');
+
+// The inspector cache must own its bytes even when the HTTP caller reuses
+// a Buffer or a view into a larger Uint8Array after writing it.
+async function main() {
+  const session = new Session();
+  session.connect();
+  await session.post('Network.enable');
+
+  const server = http.createServer(common.mustCall((req, res) => {
+    const chunks = [];
+    req.on('data', (chunk) => chunks.push(chunk));
+    req.on('end', common.mustCall(() => {
+      assert.strictEqual(Buffer.concat(chunks).toString(), 'buffer-view-ü');
+      res.end();
+    }));
+  }));
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+
+  let requestId;
+  session.on('Network.requestWillBeSent', common.mustCall(({ params }) => {
+    requestId = params.requestId;
+    assert.strictEqual(params.request.hasPostData, true);
+  }));
+  const finished = new Promise((resolve) => {
+    session.once('Network.loadingFinished', resolve);
+  });
+  const req = http.request({
+    host: '127.0.0.1',
+    port: server.address().port,
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+  }, common.mustCall((res) => res.resume()));
+  req.on('error', common.mustNotCall());
+
+  const buffer = Buffer.from('buffer-');
+  await new Promise((resolve) => req.write(buffer, resolve));
+  buffer.fill(0x78);
+
+  const backing = new Uint8Array(Buffer.from('!view-?'));
+  const view = backing.subarray(1, backing.length - 1);
+  await new Promise((resolve) => req.write(view, resolve));
+  backing.fill(0x79);
+  req.end('ü', 'utf8');
+
+  await finished;
+  const { postData } = await session.post('Network.getRequestPostData', { requestId });
+  assert.strictEqual(postData, 'buffer-view-ü');
+  session.disconnect();
+  await new Promise((resolve) => server.close(resolve));
+}
+
+main().then(common.mustCall());

test/parallel/test-inspector-network-http-initiator-async.js

@@ -0,0 +1,38 @@
+// Flags: --experimental-network-inspection
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+const assert = require('node:assert');
+const http = require('node:http');
+const { Session } = require('node:inspector/promises');
+
+async function main() {
+  const session = new Session();
+  session.connect();
+  await session.post('Network.enable');
+  const server = http.createServer(common.mustCall((req, res) => res.end()));
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const event = new Promise((resolve) => session.once('Network.requestWillBeSent', resolve));
+  const finished = new Promise((resolve) => session.once('Network.loadingFinished', resolve));
+  async function requestFromAsync() {
+    await Promise.resolve();
+    const req = http.request({ port: server.address().port }, (res) => res.resume());
+    req.on('error', common.mustNotCall());
+    req.end();
+  }
+
+  async function parentAsync() {
+    await requestFromAsync();
+  }
+  await parentAsync();
+  const { params } = await event;
+  const frames = params.initiator.stack.callFrames;
+  assert.strictEqual(frames[0].functionName, 'requestFromAsync');
+  assert.strictEqual(frames[0].url, __filename);
+  assert.ok(frames.some((frame) => frame.functionName === 'parentAsync' && frame.url === __filename));
+  assert.ok(frames.some((frame) => frame.functionName === 'main' && frame.url === __filename));
+  await finished;
+  session.disconnect();
+  await new Promise((resolve) => server.close(resolve));
+}
+main().then(common.mustCall());

test/parallel/test-inspector-network-http-initiator-delayed.js

@@ -0,0 +1,68 @@
+// Flags: --experimental-network-inspection
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const assert = require('node:assert');
+const http = require('node:http');
+const { Session } = require('node:inspector/promises');
+
+async function main() {
+  const session = new Session();
+  session.connect();
+  await session.post('Network.enable');
+  const server = http.createServer(common.mustCall((req, res) => res.end()));
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+
+  // Capture the original caller even if the body is sent from a later callback,
+  // and do not depend on user changes to Error stack formatting or limits.
+  const oldLimit = Error.stackTraceLimit;
+  const oldPrepare = Error.prepareStackTrace;
+  Error.stackTraceLimit = 0;
+  Error.prepareStackTrace = common.mustNotCall();
+  let request;
+  function createRequest() {
+    // Keep this next line paired with the marker used below.
+    request = http.request({
+      host: '127.0.0.1',
+      port: server.address().port,
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+    }, (res) => res.resume());
+    request.on('error', common.mustNotCall());
+  }
+
+  function nested(depth) {
+    if (depth === 0) createRequest();
+    else nested(depth - 1);
+  }
+
+  function originalCaller() {
+    nested(220);
+  }
+  const source = require('node:fs').readFileSync(__filename, 'utf8').split('\n');
+  const creationLine = source.findIndex((line) => line.trim().startsWith('request = http.request('));
+  originalCaller();
+  Error.stackTraceLimit = oldLimit;
+  Error.prepareStackTrace = oldPrepare;
+
+  const event = new Promise((resolve) => session.once('Network.requestWillBeSent', resolve));
+  const finished = new Promise((resolve) => session.once('Network.loadingFinished', resolve));
+  setImmediate(function sendFromLaterCallback() {
+    request.end('hello');
+  });
+  const { params } = await event;
+  const frames = params.initiator.stack.callFrames;
+  assert.strictEqual(frames[0].url, __filename);
+  assert.strictEqual(frames[0].functionName, 'createRequest');
+  assert.strictEqual(frames[0].lineNumber, creationLine);
+  assert.ok(frames[0].columnNumber >= 0);
+  assert.ok(frames.some((frame) => frame.functionName === 'originalCaller'));
+  assert.ok(!frames.some((frame) => frame.functionName === 'sendFromLaterCallback'));
+  await finished;
+  const { postData } = await session.post('Network.getRequestPostData', { requestId: params.requestId });
+  assert.strictEqual(postData, 'hello');
+  session.disconnect();
+  await new Promise((resolve) => server.close(resolve));
+}
+main().then(common.mustCall());