> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.fabricgateway.ai/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.fabricgateway.ai/_mcp/server.

# Inspect traces

> Find and inspect distributed traces for LLM, MCP, and HTTP traffic.

**Traces** lists every distributed trace that the gateway records. Use it when you need to debug a specific request instead of looking at aggregate metrics. This topic shows you how to find a trace, inspect it, and check routing decisions.

## Prerequisites

Before you begin, make sure you have the following:

* A route that has received requests.
* Access to the organization that owns the route.

## Find a trace

To find a trace, do the following:

1. In the sidebar, select **Traces** to see the current namespace, or select **Admin** and then **Traces** to see your whole organization.
2. Optionally, select a time range: **24H**, **7D**, or **30D**. To look at a specific period, select **Custom**, set a **Start** and an **End** (or **Until now**), and then select **Apply**. A custom range can span up to 30 days, and times are in your time zone.
3. Optionally, add one or more filters: **Protocol**, **Route**, **Connection**, **User**, or **Status**. To find a specific operation, enter text in **Filter by operation**.
4. To change which columns appear, click **View**.

The page shows summary cards for total traces, P95 latency, and error rate over the selected range. A table follows, with the following columns:

| Column         | What it shows                                                                                                       |
| -------------- | ------------------------------------------------------------------------------------------------------------------- |
| **Trace ID**   | The unique identifier of the trace.                                                                                 |
| **Timestamp**  | When the request arrived.                                                                                           |
| **Protocol**   | The type of traffic: `HTTP`, `LLM`, or `MCP`.                                                                       |
| **Operation**  | What the request did. For LLM traffic, this is `chat` followed by a model name, for example `chat claude-sonnet-5`. |
| **Route**      | The route that received the request.                                                                                |
| **Connection** | The connection that handled the request.                                                                            |
| **User**       | The user the request belongs to.                                                                                    |
| **Status**     | The result, such as `200`.                                                                                          |
| **Duration**   | How long the request took.                                                                                          |

## Inspect a trace

Select a row in the traces table to open its span view.

Each trace has one or more spans. For example, an HTTP request through an imported connection has a gateway span and a nested span for the request to the upstream. Select a span to see its attributes, including the following:

* Plugin execution time and invocation count
* Upstream attempt count, body-read count, and duration
* Route match type and route name
* Tenant ID
* HTTP method and status code
* The originating user agent

The detail view also shows the request and response bodies. For agent traffic, the request body includes the system prompt and the tool definitions that the agent sends with each request.

## See what a request cost

For an LLM request, the span's attributes include what Fabric uses to work out its cost:

* **Tokens:** `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens`, and `gen_ai.usage.total_tokens`, plus `gen_ai.usage.reasoning_tokens` and the cache counts, `gen_ai.usage.cache_read.input_tokens` and `gen_ai.usage.cache_creation.input_tokens`.
* **Models:** `gen_ai.request.model` is the model the client asked for, and `gen_ai.response.model` is the model that answered. They can differ when a routing plugin changes the model.
* **Cost:** `gen_ai.usage.cost_usd` is the estimated cost in US dollars, and `gen_ai.usage.cost_status` says how reliable it is: `exact`, `partial`, `unpriced`, `dropped`, or `unavailable`. The cost can appear a few seconds after the response.

These are the numbers that spending budgets add up. For details, see [Control spend with budgets](/configure/access-and-limits/budgets).

## Check how plugins handled a request

When you attach a routing plugin to a route, the trace shows the extra requests that the plugin makes:

* A request that uses the Adaptive Model Router has its own request to the decision service, followed by the request to the provider. The decision changes the model identifier in the provider request.
* A request on a route without a routing plugin shows only the request to the provider.

To confirm which model answered, check the `model` field in the response body. The **Operation** column can show the model that the client requested instead of the model that the plugin chose.

For more information about the plugins, see [Route LLM requests across models and providers](/configure/routing).

## Next steps

* To see how plugin attributes relate to errors or latency, see [Control traffic with plugins](/configure/plugins).
* To review trends across many requests, see [Review analytics](/use/monitor/analytics).