---
title: "Trace a request without traces | Speedscale Docs"
description: "Follow one customer's request across every service it touches in proxymock web — with no trace IDs, no OpenTelemetry, and no code changes — by filtering recorded traffic on a business identifier (an email) and reading the trace waterfall."
canonical: "https://docs.speedscale.com/proxymock/guides/trace-without-traces/"
---

[Documentation index](https://docs.speedscale.com/proxymock/llms.txt) | [Markdown](https://docs.speedscale.com/proxymock/guides/trace-without-traces/index.md) | [Canonical page](https://docs.speedscale.com/proxymock/guides/trace-without-traces/)

# Trace a request without traces

Distributed tracing is great when every service is instrumented, nothing is sampled away, and the request never crosses a system you don't own. When one of those isn't true — the trace was sampled out, a library dropped the context, or the hop went through a third party — you get a waterfall with a hole in it right where the bug is.

But the journey still happened on the wire, and proxymock already recorded it. This guide shows how to reconstruct one customer's full path across four services using the identifier that's _already in the traffic_ — their email — instead of a trace ID.

The result is a Grafana-style waterfall, scoped to a single person, built from real recorded requests:

![The Trace lens showing one customer's checkout journey as a nested waterfall across the gateway, auth, orders, and shipping services, with a service legend and per-span durations](https://docs.speedscale.com/assets/images/07-trace-waterfall-f8fc6d58fe9f550c8a003d604b3a53fe.png)

<a id="trace-one-checkout-across-services"></a>

## Trace one checkout across services

Filter recorded traffic by a customer email, then inspect the related requests in Trace view.

[Download the video](https://docs.speedscale.com/videos/guides/speedscale-trace-checkout-across-services.mp4)

<a id="what-youll-need"></a>

## What you'll need

*   proxymock installed ([installation](https://docs.speedscale.com/proxymock/getting-started/installation/)).
*   [Node.js](https://nodejs.org/) 18+ and `git`.
*   The **user-journey** demo from the [Speedscale demo repo](https://github.com/speedscale/demo), under `scenarios/otel-trace-replay-gate/user-journey/`. It's a four-service checkout app — `gateway → auth`, `gateway → orders`, `orders → shipping` — that threads the customer's email through an `X-User-Email` header, the request bodies, and the response bodies. Nothing in it uses OpenTelemetry.

<a id="step-1--get-the-demo"></a>

## Step 1 — Get the demo

Clone the demo repo and move into the `user-journey` scenario:

```bash
git clone https://github.com/speedscale/demo.git
cd demo/scenarios/otel-trace-replay-gate/user-journey
```

<a id="step-2--record-the-traffic"></a>

## Step 2 — Record the traffic

From that `user-journey/` directory:

```bash
npm install
./record-all.sh
```

`record-all.sh` starts one `proxymock record` per service into a single shared workspace and drives ~40 checkouts for five named customers (Ada Lovelace, Grace Hopper, Alan Turing, Katherine Johnson, and Margaret Hamilton). Every request and response on every hop is captured to disk as real traffic — no application code changes required.

<a id="step-3--open-the-recording"></a>

## Step 3 — Open the recording

```bash
proxymock web --in .
```

`proxymock web` opens on the whole recording — every customer's traffic, interleaved. This is the haystack: hundreds of requests across all four services.

![The proxymock web Requests grid showing 278 recorded requests from all customers across the gateway, auth, orders, and shipping services](https://docs.speedscale.com/assets/images/01-unfiltered-grid-03fba0728740fce17688e93dcb6f1855.png)

<a id="step-4--filter-to-one-customer"></a>

## Step 4 — Filter to one customer

You don't need a trace ID to find one person — you need something that travels with their requests. Here that's their email, and it shows up in different places on different hops: a header on one, a request body on another, a response body on a third. The **Full Text** filter matches against the entire request/response pair, so one filter catches all of them.

Open **Filters**, add a filter, choose the **Full Text** field with the **contains** comparator, and enter the customer's email:

![The Filters dialog configured with a Full Text filter, the contains comparator, and the value ada.lovelace@example.com](https://docs.speedscale.com/assets/images/02-full-text-filter-439b34eff0b11b0efa083a4023ea9938.png)

Apply it, and the grid collapses from every customer to just this one — matched across all four services:

![The Requests grid filtered to 35 rows, all belonging to ada.lovelace@example.com, spanning the gateway, auth, orders, and shipping services](https://docs.speedscale.com/assets/images/03-filtered-grid-2d281b757060b56f1385b0bbb84e5b5f.png)

<a id="step-5--see-where-the-identifier-was-found"></a>

## Step 5 — See where the identifier was found

Select any row and open the **Request** tab. On the checkout, the email is in the request **body**:

![The RRPair detail drawer's Request Body tab showing the checkout JSON body containing the email ada.lovelace@example.com](https://docs.speedscale.com/assets/images/04-request-body-39306789be8f6a74cd5fa7a91241cdf1.png)

On the **Headers** sub-tab, the same email rides the `X-User-Email` header (and a W3C `traceparent` is present too — more on that below):

![The Request Headers tab showing the X-User-Email header set to ada.lovelace@example.com alongside a traceparent header](https://docs.speedscale.com/assets/images/05-request-headers-50e92989f0509b579286ddc7436ed63a.png)

And on the **Response** tab, downstream services echo the email back in their response **bodies**:

![The Response Body tab showing the checkout response echoing the email ada.lovelace@example.com along with the order id, total, and ETA](https://docs.speedscale.com/assets/images/06-response-body-bbb99e96b0f0ef98c984aabe89ee6ee2.png)

Header, request body, response body — three different fields, across different services, all found by the single Full Text filter. That's the part a trace ID can't do: it only works if every service agreed to propagate it. A business identifier survives across systems that were never instrumented.

<a id="step-6--read-the-waterfall"></a>

## Step 6 — Read the waterfall

Switch the Requests view to the **Trace** lens. proxymock draws the filtered set as a time-ordered, nested waterfall — one customer's transaction across every service:

![The Trace lens waterfall for ada.lovelace@example.com: gateway /checkout nesting gateway to auth /whoami and gateway to orders /orders, which nests orders to shipping /ship, repeated for each of the customer's transactions](https://docs.speedscale.com/assets/images/07-trace-waterfall-f8fc6d58fe9f550c8a003d604b3a53fe.png)

You can read the whole journey top to bottom: the checkout hits the **gateway**, which calls **auth** to verify the customer and **orders** to place the order, and **orders** calls **shipping** for a delivery estimate — every hop, in order, with each span's duration and self-time. Because these are the real recorded requests, every bar is clickable and drills into the exact request and response for that customer on that transaction.

<a id="how-this-works"></a>

## How this works

*   **The filter does the correlation.** The Full Text filter narrows the Requests list, and the Trace lens is a pure renderer over that filtered set (see [the Trace view](https://docs.speedscale.com/proxymock/guides/trace-without-traces/#step-6--read-the-waterfall)). Change the email to `grace.hopper@example.com` and you get Grace's journey instead. Any value that travels with the request works — an order id, an account number, a session token.
*   **`traceparent` is only used for nesting, never for filtering.** The demo propagates a W3C `traceparent` so the waterfall can nest hops into a tree, but you never filter on it. The grouping key is business data, not a trace ID — which is exactly why this works when tracing is missing or incomplete.
*   **Nothing is instrumented.** proxymock recorded the wire, not the code. The same recording can also be [replayed](https://docs.speedscale.com/proxymock/getting-started/quickstart/local/) or turned into mocks — so the traffic that reconstructed this trace can also become a regression test.

<a id="related"></a>

## Related

*   [Topology and cluster visibility](https://docs.speedscale.com/proxymock/guides/observability/)
*   [Local quickstart](https://docs.speedscale.com/proxymock/getting-started/quickstart/local/)
