Live demo
Watch Spider decrypt live traffic across every protocol
A synthetic online store runs 24/7.
A bot places real orders that cross HTTPS (1.1, 2 & 3), gRPC, Redis, PostgreSQL, MySQL, MongoDB, Kafka, WebSocket and MQTT.
All communications are encrypted with TLS
Spider captures, decrypts it server-side with no instrumentation, and traces every order end-to-end.
What you are looking at
- 10 polyglot services (Go, Node.js, Kotlin, Rust and Python) behind a storefront.
- One order traverses HTTPS → gRPC → Redis → PostgreSQL → Kafka → MySQL → MongoDB.
- Every hop is TLS-encrypted; Spider decrypts it via eBPF.
- Two identifiers ride along: one Spider extracts with zero configuration, one you configure - and the gap between them is the point.
- A 24/7 bot keeps the system busy so there is always live traffic.
Watch the live system
Open a live view of the whole store - the map and the decrypted communications, streaming as the bot works.
You will enter your email and a one-time code to view.
Watch your own order
Open the store, place an order in two clicks, then follow your own order traced across every protocol.
You will enter your email and a one-time code to view.
A guided tour - what you are seeing, and what to look for
You clicked in above. Follow along here: this walkthrough maps the demo system, shows how Spider captures and decrypts it, then follows one order across every protocol - from raw packets to the business record - with real Spider screenshots and where to find each in the UI.
The storefront - this is what you are watching
A synthetic e-commerce store runs 24/7 in the demo environment. Real orders flow through it continuously, exercising the whole backend stack.
Every order you see placed here is about to travel through ten services in five languages - Go, Node.js, Kotlin, Rust and Python - and through HTTP/1.1, HTTP/2 and HTTP/3 side by side, gRPC, Redis, PostgreSQL, MySQL, MongoDB, Kafka, WebSocket and MQTT - plus GraphQL over HTTP and WebSocket, encrypted end to end.
What runs behind the store
Ten polyglot services sit behind the shop - four in Go (order, stock, catalog, courier), three in Node.js (storefront, payment, notify), one in Kotlin (shipping), one in Rust (fraud) and one in Python (user) - plus Redis, PostgreSQL, MySQL, MongoDB, a Redpanda (Kafka) broker and a Mosquitto (MQTT) broker.
storefront is the HTTPS entry point; order orchestrates the purchase over gRPC; stock holds the reservation in Redis; order persists to PostgreSQL and publishes an order.placed event to Redpanda, which payment and notify consume asynchronously. notify also records a customer and an invoice for each paid order in MySQL. Normally, following one order across all of this means stitching together logs from every service.
The HTTP hops are deliberately mixed. storefront talks to catalog and to order over HTTP/2, order calls catalog once per order over HTTP/3 (QUIC), while notify acknowledges the order back over HTTP/1.1 - on the same port order serves HTTP/2 on. Spider decides the framing per connection from the decrypted bytes, because a port cannot tell you: TLS 1.3 hides the ALPN negotiation inside EncryptedExtensions. Both show up in the grid with their own httpVersion, the same tags and the same templates, and catalog's product list even answers with an HTTP/2 trailer - a header that only exists once the body is finished.
Once notify acknowledges an order, order publishes a dispatch message over MQTT 5 / TLS to a Mosquitto broker (QoS 1, the trace context riding as a user property). courier answers with parcel statuses - Shipped, In transit, Delivered, or Delivery failed with a reason - and publishes Sparkplug B telemetry, a protobuf payload carrying the van's GPS position and the order id, which Spider decodes natively. order subscribes to the statuses at QoS 2 but the broker grants QoS 1: Spider's MQTT topic map flags that downgrade. The storefront order page shows the result as a live Delivery strip.
How Spider captures encrypted traffic - without touching your code
The whisperer is injected into a running pod as an ephemeral debug container - a tiny sidecar that Kubernetes attaches on demand. It shares the pod's network namespace and sniffs that pod's traffic. No image rebuild, no permanent sidecar, no code change.
Gocipher runs as a DaemonSet - one instance per node - and hooks OpenSSL through eBPF uprobes to extract TLS master secrets. Spider uses those keys to decrypt the captured packets after the fact.
Gocipher gets the keys a different way per runtime, and you configure none of them: Go services through a hook on the native crypto/tls key schedule, Node.js and other OpenSSL users through uprobes on OpenSSL, and the JVM through a small agent it loads into the running HotSpot JVM. Rust services on rustls are the one exception: rustls has no library to hook, so the service writes its key log to /dev/null (SSLKEYLOGFILE=/dev/null) and you tick the key-log fallback on the whisperer. Gocipher reads those writes in the kernel - nothing is written to disk.
Where Spider is watching from
This is Spider's own map of the running demo - every component it has discovered, grouped by Kubernetes namespace. The whole shop is here: storefront, catalog, order, stock, shipping, payment, fraud, notify, user and courier, plus Redis, PostgreSQL, MySQL, MongoDB, the Redpanda and Mosquitto brokers, the Traefik ingress, and the bot generating traffic.
The services drawn in pink are the ones a whisperer is attached to. Spider taps the application pods - not the datastores, not the broker - and still sees both sides of every conversation, which is all it needs to reconstruct the full cross-service story.
Proof: from TLS ciphertext to plaintext




Every capture is a TCP session, and Spider keeps the whole thing. Here is one between the order service and postgres:5432 - 69 packets over 39 seconds, the full pipe, downloadable as raw PCAP.
Spider identifies the handshake - TLS 1.3, cipher TLS_AES_256_GCM_SHA384 - and reports what it parsed (TLS and PostgreSQL, both COMPLETED). Open the Details tab and you see exactly what crossed the wire: encrypted TLS records, pure ciphertext.
Now switch to Content with the PostgreSQL decoder. Spider peels back each TLS record and decodes the Postgres protocol underneath - the Bind and Execute messages, the prepared statement, and the real parameters: the order UUID, sku-webcam, the buyer's email, the PLACED status. That is the headline claim, proven end to end - encrypted on the wire, readable in Spider, with nothing instrumented.
Proof per language: Kotlin and Rust
Decrypting a call proves little when the caller is already covered: order is written in Go and payment in Node.js, so their keys alone decrypt the calls they make. So the demo runs two extra whisperers. Demo JVM watches only the Kotlin shipping service and Demo Rust only the Rust fraud service.
Spider uses a TLS key only for traffic captured by the same whisperer. The copy of each call seen by Demo JVM can therefore be decrypted only with keys taken from the shipping JVM, and the copy seen by Demo Rust only with keys from rustls. Both are decrypted - open them from the live link and check.
What it takes: nothing for the JVM, as long as it is HotSpot (not OpenJ9) and uses the JDK TLS stack (not netty-tcnative). For rustls, one environment variable, SSLKEYLOGFILE=/dev/null, and the key-log fallback ticked on the whisperer.
The journey of a single order - by design
storefront takes the HTTPS request and calls order over gRPC. order checks the price with catalog (HTTP/3, which reads PostgreSQL), asks shipping (Kotlin) for a quote, has stock reserve the item in Redis, writes the row to PostgreSQL and produces an order.placed event to Redpanda (Kafka).
payment consumes it, has fraud (Rust) assess the order and produces payment.completed. notify consumes that, reads the customer's preferences from the Python user service (MongoDB), acks back to order over HTTP, and records the invoice in MySQL. The ack moves the order to ACKNOWLEDGED and publishes the change over Redis; order then dispatches the parcel over MQTT to courier, which answers with statuses and GPS telemetry. Meanwhile the client has opened a WebSocket on the order and gets each status as a frame.
Afterwards the bot sometimes reviews the product. storefront checks the order, upserts the customer's profile through user, and posts the review to catalog, which stores it in MongoDB together with the product's rating counter, in one transaction. Every hop is TLS-encrypted; Spider captures all of it from the network and reassembles the whole path.
…and the same journey, actually captured
The diagram above is the design. This one is real: Spider drew it from the decrypted packets of one specific order - every hop between the services, whatever the protocol, with real timestamps and durations down to the millisecond.
Nothing was instrumented to produce it. Spider reconstructed the entire cross-protocol sequence - including the asynchronous payment.completed round-trip - purely from captured traffic.
Every call for one order, in a single list
Spider's grid lists every captured call that belongs to one order, side by side, whatever the protocol: the HTTP POST /api/orders, the gRPC PlaceOrder and Reserve, the Redis HSET/EXPIRE and PUBLISH/MESSAGE, the PostgreSQLINSERT/SELECT/UPDATE, the Kafka order.placed and payment.completed, and the WebSocket status frames.
Each row carries a readable template name (Place order, Reserve stock, Create order…), the real request, sizes, status and duration - and the extracted orderId on the right, the same value on every row. That shared ID is what ties the list together.
Open a gRPC call and read the decrypted payload
gRPC is binary and TLS-encrypted - normally a black box. Click any call and Spider shows the whole thing: the method (demo.order.v1.OrderService/PlaceOrder), the timing, request and response sizes, status, and the client and server pods.
Flip on Transcoded in the Request tab and the raw protobuf becomes readable JSON - the orderId, the productId, the quantity, the customer's email. Spider decrypted the packets, reassembled the gRPC frames and decoded the protobuf for you.
MySQL: a transaction, prepared statements and a real error
notify keeps a ledger in MySQL 8.4, over TLS. For each paid order it opens a transaction, upserts the customer, inserts the invoice and commits, then reads the customer's last five invoices with a JOIN. Every data statement is prepared, so the wire carries PREPARE, EXECUTE and CLOSE - and Spider pairs each EXECUTE with the statement text it was prepared from, bound parameters included.
Open the history read and Spider has already analysed it: the tables it touched and the fields it filtered on.
Now and then notify replays an invoice it already wrote - the way a redelivered message would - and MySQL refuses it with a genuine error 1062, SQLSTATE 23000, before the transaction rolls back. Nothing simulated it on the Spider side; it is decoded straight from the server's reply.
How Spider pulls the order ID out of the traffic
This is where the linking comes from. Each whisperer carries a parsing configuration. For PostgreSQL, Spider is given the query templates that matter - Create order is ^INSERT INTO orders, Read order status is ^SELECT status FROM orders - so raw SQL gets a human name.
More importantly, a request tag maps orderId to the orders.id column. Spider parses the query, understands which field is which, and extracts the value - and does the same across the other protocols, so the one order ID is recovered wherever it travels: HTTP body, gRPC message, Redis key, SQL row, Kafka event.
MySQL gets the same treatment: orderId is mapped to invoices.order_id, and the invoice insert's bound parameter supplies the value.
HTTP/3 is enabled per whisperer too: UDP session tracking plus parseHttp3 on port 8443, where order calls catalog once per order. Spider decrypts it from the QUIC keys Gocipher captures, and tags it with orderId from the X-Order-Id header.
MongoDB is enabled per whisperer through server.mongo: the orderId tag is read from the command's $comment or from the document's own orderId field, and correlationId from the traceparent in the comment. catalog and user are attached; the database itself is not.
MQTT parsing is per whisperer as well: server.mqtt lists ports 1883 and 8883 and the templates for the dispatch, status and Sparkplug topics. The orderId tag comes from the topic, the JSON payload or a Sparkplug metric, and correlationId from the traceparent user property. The broker is never attached; order and courier are, so each exchange is captured once.
Two identifiers, and the difference is the whole point
Every order carries two identifiers. correlationId is technical: the W3C traceparent injected by OpenTelemetry in the services. Spider extracts it with nothing configured, and it follows one request across HTTP, gRPC, Kafka and the database hops - SQL and Mongo carry it as a comment. It is absent where nothing propagates it: the reservation's Redis commands, and everything the customer's own client does.
orderId is business: the order UUID, pulled out of wherever it already lives on each hop - a protobuf field, a Redis key, a SQL column, a Kafka record, the WebSocket URI - by tag rules you write once. It costs ten minutes of configuration, and it reaches the hops no header could.
The two slice the traffic differently: a correlationId groups what followed from one request, while orderId groups everything that ever touched one order - the later webhook, the nightly job, the live feed that opens its own trace. The technical one proves the request happened; the business one answers what happened to this order.
In the grid, a communication carrying either one gets a button in the Links column: click for the whole chain, shift-click for its sequence diagram.
A plugin turns the UUID into business meaning
The extracted order ID is a UUID - correct, but not friendly. A small tag-enrichment plugin, the Demo order resolver, loaded in Spider's settings, turns eachorderId tag into something a human reads: here, "2026-07-06 HD Webcam ×3", built from the order's date and product.
The plugin also carries a link back to the store - so the tag is not just a label, it is a doorway to the business system.
One click from a packet to the business record
Click the enriched tag and Spider sends you straight to that order in the store's own back office - the Spider Tech Store order page, showing the same order: ACKNOWLEDGED, the customer, the product, the total.
That is the whole promise in one gesture. You started from raw, encrypted packets on the wire and landed on the business record they represent - no instrumentation anywhere, just capture, decode, and the identifiers already living in your data.
That was one order through one lens. Spider also gives you dashboards, statistics and pivot tables, waterfall timing, time-travel from days to microseconds, communication diffing and shareable analysis links - across every protocol it captures.
See all features →









