Connections that stay open, read as they happen.
A WebSocket, a Socket.IO namespace, an event stream or a gRPC stream is an item in the project like a request is. Each one has a live log you can pause, filter and copy from, saved messages to send again, and a plain-words line saying why a connection dropped.
Shared by every live pane
One pane for every connection that stays open.
Whatever the protocol, the item opens the same way: a log that follows the connection as it happens — 1,000 events kept, paused when you scroll back, filtered to one topic, subject or event name — a composer with the messages you saved to send again, and a status line that says why the connection ended in words, not in a code.
A secret:// reference is resolved when the connection is made and never stored in the item. The Network page's CAs and client certificates apply to the handshake.
gRPC without a code generator.
Messages are built from descriptors at run time — from the server's reflection, or from your .proto files with their import folders and the well-known types. A skeleton of the request message is written for you; you fill it in and call. Unary, server streaming, client streaming and bidirectional, invoked as a batch or kept open as a live stream: one message at a time, half-close when you are done sending, cancel when you are not.
What comes back is all of it: response headers and trailers, the status code with its name and message, the time, every message sent and received, with a live sent / received counter.
WebSocket, Socket.IO, SSE, STOMP.
Four kinds of long-lived connection, each a first-class item with its own composer, log and settings.
WebSocket: the handshake, the frames, the close in words.
ws and wss, headers and auth on the handshake, subprotocols. Send text or binary, ping by hand, answer the server's pings. Binary frames shown as hex. The close code and its reason, and the messages you saved to send again.
Socket.IO: every event logged, every ack timed.
Socket.IO v4 and v5 over Engine.IO v4. Namespace, the auth payload, a custom path. Every server event logged without subscribing by name. Emit with arguments and ask for an acknowledgement — the round trip is timed. Answer the server's own ack requests. Binary attachments shown.
Server-sent events: parsed, reconnected the browser's way.
GET or POST with a body. Events, data, ids, retry and comment lines parsed. Browser-style reconnect with Last-Event-ID for GET only — a POST is never repeated. The server's retry honoured, 204 ends the stream, a non-2xx refusal is final. Filter by event name or data.
STOMP over WebSocket: frames named, receipts kept.
STOMP 1.2 on a WebSocket item: CONNECT with host, login and heart-beats; SUBSCRIBE with auto, client or client-individual acknowledgement; ACK and NACK; SEND with headers and a receipt; RECEIPT and ERROR frames named. For a STOMP broker over TCP, see Messaging.