Sorry for the slow response.

I see 70~90 mbyte/s with Chrome, 120~150 mbyte/s with Firefox, 70~80 mbyte/s with Safari.

It's slower than you expected but I don't see 10x~20x performance regression in my environment.

Could you measure the performance with other browsers?

I have managed to reproduce this bug, with both results. Running the script with DevTools open results in ~9 MB/s, while running the script without DevTools open results in >90 MB/s.

The problem is likely caused by the processing of the entire WebSocket message on the main browser thread. DevToolsClientMsg_DispatchOnInspectorFrontend seems to be the IPC-message triggering this.

DevTools are expected to slow down things. Is that a problem? Aren't you inspecting/debugging with DevTools open, and not exactly measuring performance?

I would say that DevTools are expected to make it easy to develop web pages (including profiling them). That some things become slow is an unfortunate side effect. In this case the performance hit is rather large so somebody might want to take a look that the performance hit is actually necessary.

I'm not sure why DevTools would have to slow down WebSockets this much. It seems like a bug to me, but then I'm not familiar with all the DevTools features.

I cannot run this code because it's a bit too large for me to read and ensure there's no security risks on our side. Is there a chance you could give me a simple script that I can run to repro this case?

I can say that this is likely not a bug, but a requirement. If you are sending megabytes of data, we will be holding a copy of all this data in devtools.

Here's a high overview of what happens here...
* Browser process receives data and IPCs it to the renderer process
* Renderer receives this data and sends it to inspector (if inspector exists)
* Inspector constructs a JSON message and sends it off to browser to send to devtools ui
* Browser receives JSON and does an IPC hop to devtools Main thread for V8 to parse
* V8 parses JSON message and executes some javascript for devtools to handle
* Devtools takes the raw data and stores it into memory just in case the user needs it

There are 3 IPC hops here and each one of these steps stores and transports at data that is at least the size of the received or sent frame. JSON'ifying is slow and V8 parsing the JSON is slow. If these start becoming a bottleneck it will put back-pressure on the entire chain.

This will currently happen regardless of if tracing or not.

I spoke to our TL and we recognize this as a pain point and we will see about coming up with a plan to speed this up a bit.

I have attached the test code I used a year ago to reproduce this. I hope it's at least a little helpful. server.py (python2) requires Flask, gevent.pywsgi and gevent-websocket.

Launch the server, open localhost:5000, and then press "Ping" to send a ~50 MB message over the websocket. It displays the current mouse position as a way to show when v8 is busy (mouse position won't update).

Deleted: websocket_test.zip 2.4 KB

websocket_test.zip 2.4 KB Download

Closing due to lack of priority / resources.

I am also affected by this issue. I understand it has been marked WontFix, but is there a way to disable that behavior (i.e. not record the websocket frames when devtools are open)? ? I want to debug other parts of our application, but the extreme slowdown of the devtools and the page itself makes it very difficult.

I would like to take a look.

 Issue 834436  has been merged into this issue.

 Issue 859803  has been merged into this issue.