inspector: add initial support for network inspection

Author: cola119

lib/_http_client.js

@@ -24,6 +24,7 @@
 const {
  ArrayIsArray,
  Boolean,
+ DateNow,
  Error,
  FunctionPrototypeCall,
  NumberIsFinite,
@@ -70,6 +71,7 @@ const {
  isTraceHTTPEnabled,
  traceBegin,
  traceEnd,
+ getNextInspectorEventId,
  getNextTraceEventId,
 } = require('internal/http');
 const {
@@ -93,6 +95,14 @@ const {
  stopPerf,
 } = require('internal/perf/observe');
 
+const {
+ isEnabled: isInspectorEnabled,
+ requestWillBeSent,
+ responseReceived,
+ dataReceived,
+ loadingFinished,
+} = internalBinding('inspector');
+
 const kClientRequestStatistics = Symbol('ClientRequestStatistics');
 
 const dc = require('diagnostics_channel');
@@ -375,14 +385,15 @@ ObjectSetPrototypeOf(ClientRequest, OutgoingMessage);
 
 ClientRequest.prototype._finish = function _finish() {
  FunctionPrototypeCall(OutgoingMessage.prototype._finish, this);
+ const url = `${this.protocol}//${this.host}${this.path}`;
  if (hasObserver('http')) {
  startPerf(this, kClientRequestStatistics, {
  type: 'http',
  name: 'HttpClient',
  detail: {
  req: {
  method: this.method,
- url: `${this.protocol}//${this.host}${this.path}`,
+ url,
  headers: typeof this.getHeaders === 'function' ? this.getHeaders() : {},
  },
  },
@@ -393,6 +404,14 @@ ClientRequest.prototype._finish = function _finish() {
  request: this,
  });
  }
+
+ if (isInspectorEnabled()) {
+ this._inspectorEventId = getNextInspectorEventId();
+ const wallTime = DateNow();
+ const timestamp = wallTime / 1000;
+ requestWillBeSent(this._inspectorEventId, url, this.method, timestamp, wallTime);
+ }
+
  if (isTraceHTTPEnabled()) {
  this._traceEventId = getNextTraceEventId();
  traceBegin(HTTP_CLIENT_TRACE_EVENT_NAME, this._traceEventId);
@@ -680,6 +699,21 @@ function parserOnIncomingClient(res, shouldKeepAlive) {
  response: res,
  });
  }
+
+ if (isInspectorEnabled() && typeof req._inspectorEventId === 'string') {
+ responseReceived(req._inspectorEventId, DateNow() / 1000);
+ let response = '';
+ const onData = (chunk) => {
+ dataReceived(req._inspectorEventId, DateNow() / 1000, chunk.length);
+ response += chunk.toString();
+ };
+ res.on('data', onData);
+ res.on('end', () => {
+ loadingFinished(req._inspectorEventId, response, DateNow() / 1000, response.length);
+ res.removeListener('data', onData);
+ });
+ }
+
  if (isTraceHTTPEnabled() && typeof req._traceEventId === 'number') {
  traceEnd(HTTP_CLIENT_TRACE_EVENT_NAME, req._traceEventId, {
  path: req.path,

lib/internal/http.js

@@ -31,6 +31,13 @@ function resetCache() {
  utcCache = undefined;
 }
 
+let inspectorEventId = 0;
+
+function getNextInspectorEventId() {
+ const id = ++inspectorEventId;
+ return `node-network-inspect-event-${id}`;
+}
+
 let traceEventId = 0;
 
 function getNextTraceEventId() {
@@ -57,6 +64,7 @@ module.exports = {
  utcDate,
  traceBegin,
  traceEnd,
+ getNextInspectorEventId,
  getNextTraceEventId,
  isTraceHTTPEnabled,
 };

src/inspector/network_agent.cc

@@ -0,0 +1,60 @@
+#include "network_agent.h"
+
+#include "inspector_agent.h"
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+std::unique_ptr<Network::Request> Request(const String& url,
+ const String& method) {
+ return Network::Request::create().setUrl(url).setMethod(method).build();
+}
+
+NetworkAgent::NetworkAgent() {}
+
+void NetworkAgent::Wire(UberDispatcher* dispatcher) {
+ frontend_ = std::make_unique<Network::Frontend>(dispatcher->channel());
+ Network::Dispatcher::wire(dispatcher, this);
+}
+
+DispatchResponse NetworkAgent::getResponseBody(const String& in_requestId,
+ String* out_body) {
+ auto it = request_id_to_response_.find(in_requestId);
+ if (it != request_id_to_response_.end()) {
+ *out_body = it->second;
+ }
+ return DispatchResponse::OK();
+}
+
+void NetworkAgent::requestWillBeSent(const String& request_id,
+ const String& url,
+ const String& method,
+ double timestamp,
+ double wall_time) {
+ frontend_->requestWillBeSent(
+ request_id, Request(url, method), timestamp, wall_time);
+}
+
+void NetworkAgent::responseReceived(const String& request_id,
+ double timestamp) {
+ frontend_->responseReceived(request_id, timestamp);
+}
+
+void NetworkAgent::dataReceived(const String& request_id,
+ double timestamp,
+ int data_length) {
+ frontend_->dataReceived(request_id, timestamp, data_length);
+}
+
+void NetworkAgent::loadingFinished(const String& request_id,
+ const String& response,
+ double timestamp,
+ int encoded_data_length) {
+ request_id_to_response_[request_id] = response;
+ frontend_->loadingFinished(request_id, timestamp, encoded_data_length);
+}
+
+} // namespace protocol
+} // namespace inspector
+} // namespace node

src/inspector/network_agent.h

@@ -0,0 +1,49 @@
+#ifndef SRC_INSPECTOR_NETWORK_AGENT_H_
+#define SRC_INSPECTOR_NETWORK_AGENT_H_
+
+#include "node/inspector/protocol/Network.h"
+#include "v8.h"
+
+#include <unordered_map>
+
+namespace node {
+
+namespace inspector {
+namespace protocol {
+
+class NetworkAgent : public Network::Backend {
+ public:
+ NetworkAgent();
+
+ void Wire(UberDispatcher* dispatcher);
+
+ DispatchResponse getResponseBody(const String& in_requestId,
+ String* out_body) override;
+
+ void requestWillBeSent(const String& request_id,
+ const String& url,
+ const String& method,
+ double timestamp,
+ double wall_time);
+
+ void responseReceived(const String& request_id, double timestamp);
+
+ void dataReceived(const String& request_id,
+ double timestamp,
+ int data_length);
+
+ void loadingFinished(const String& request_id,
+ const String& response,
+ double timestamp,
+ int encoded_data_length);
+
+ private:
+ std::shared_ptr<Network::Frontend> frontend_;
+ std::unordered_map<String, String> request_id_to_response_;
+};
+
+} // namespace protocol
+} // namespace inspector
+} // namespace node
+
+#endif // SRC_INSPECTOR_NETWORK_AGENT_H_

src/inspector/node_inspector.gypi

@@ -23,6 +23,8 @@
  'src/inspector/tracing_agent.h',
  'src/inspector/worker_agent.cc',
  'src/inspector/worker_agent.h',
+ 'src/inspector/network_agent.cc',
+ 'src/inspector/network_agent.h',
  'src/inspector/worker_inspector.cc',
  'src/inspector/worker_inspector.h',
  ],
@@ -36,6 +38,8 @@
  '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeTracing.h',
  '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeRuntime.cpp',
  '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeRuntime.h',
+ '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.cpp',
+ '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.h',
  ],
  'node_protocol_files': [
  '<(protocol_tool_path)/lib/Allocator_h.template',

src/inspector/node_protocol.pdl

@@ -98,6 +98,71 @@ experimental domain NodeWorker
  SessionID sessionId
  string message
 
+# Partial support for Network domain of ChromeDevTools Protocol.
+# https://chromedevtools.github.io/devtools-protocol/tot/Network
+experimental domain Network
+ # Unique request identifier.
+ type RequestId extends string
+
+ # UTC time in seconds, counted from January 1, 1970.
+ type TimeSinceEpoch extends number
+
+ # Monotonically increasing time in seconds since an arbitrary point in the past.
+ type MonotonicTime extends number
+
+ # HTTP request data.
+ type Request extends object
+ properties
+ string url
+ string method
+
+ # Returns content served for the given request.
+ command getResponseBody
+ parameters
+ # Identifier of the network request to get content for.
+ RequestId requestId
+ returns
+ # Response body.
+ string body
+
+ # Fired when page is about to send HTTP request.
+ event requestWillBeSent
+ parameters
+ # Request identifier.
+ RequestId requestId
+ # Request data.
+ Request request
+ # Timestamp.
+ MonotonicTime timestamp
+ # Timestamp.
+ TimeSinceEpoch wallTime
+
+ # Fired when HTTP response is available.
+ event responseReceived
+ parameters
+ # Request identifier.
+ RequestId requestId
+ # Timestamp.
+ MonotonicTime timestamp
+
+ event dataReceived
+ parameters
+ # Request identifier.
+ RequestId requestId
+ # Timestamp.
+ MonotonicTime timestamp
+ # Data chunk length.
+ integer dataLength
+
+ event loadingFinished
+ parameters
+ # Request identifier.
+ RequestId requestId
+ # Timestamp.
+ MonotonicTime timestamp
+ # Total number of bytes received for this request.
+ number encodedDataLength
+
 # Support for inspecting node process state.
 experimental domain NodeRuntime
  # Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.

src/inspector/node_string.cc

@@ -84,7 +84,7 @@ String StringViewToUtf8(v8_inspector::StringView view) {
 String fromDouble(double d) {
  std::ostringstream stream;
  stream.imbue(std::locale::classic()); // Ignore current locale
- stream << d;
+ stream << std::fixed << d;
  return stream.str();
 }