> ## Documentation Index
> Fetch the complete documentation index at: https://docs.vexlo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Inspect recorded values

> Read captured arguments, return values, exceptions and logs for a selected call.

Select a call in an [execution graph](https://docs.vexlo.ai/guides/execution-graphs.md), then use its details panel to
inspect what it received, returned or raised. Begin with the preview. Fetch a full value when
you need more detail and the action is available.

In the checkout example, `line_total` receives one order line and returns its price in cents.
The first invocation receives a notebook line with quantity two. Its `unit_price` child returns
1200 cents, and `line_total` returns 2400 cents. Together, these values explain how the line
contributed to the order total.

## Select a call and data category

Use the selected call's tabs:

| Tab | Recorded data |
| - | - |
| **Input** | Arguments supplied to the call. |
| **Output** | Its return value, when captured. |
| **Error** | Exception class and captured error data, when present. |
| **Logs** | Captured log entries associated with the attempt. |

Select **Info** when you need the attempt's status and timing. A missing output category is
not an empty return value: the UI distinguishes a missing slot from an attempt that has not
reported completion. An in-flight attempt has no reported value slots to fetch.

For example, the pricing call's **Input** tab contains its customer and order lines:

![Pricing call Input tab showing the customer and order line arguments.](https://mintcdn.com/vexlo-d15ac36e/rRJca0t154Rw5eS5/images/ui-value-input.png?fit=max\&auto=format\&n=rRJca0t154Rw5eS5\&q=85\&s=7445019d2b80aee70184445f061631f6)

Recorded arguments for price\_order.

[Open the full-size screenshot](https://docs.vexlo.ai/images/ui-value-input.png).

## Previews and full values

The trace response includes previews and capture metadata. Selecting **Input** or **Output**
does not itself retrieve all recorded bytes. Select **fetch full value** to request them.
The UI offers this action for `stored` and `pending` handles that have no fetched value yet.

Flat JSON objects are displayed as labeled fields. Nested objects, arrays and other values
use a text view. A preview can end before the full JSON value is complete; do not interpret a
cut-off preview as malformed application data.

![Output tab with discount, subtotal, tax and total fields for the pricing call.](https://mintcdn.com/vexlo-d15ac36e/rRJca0t154Rw5eS5/images/ui-value-output.png?fit=max\&auto=format\&n=rRJca0t154Rw5eS5\&q=85\&s=9a21567dfad3c724dabf201cb11f13f6)

The pricing call returned a total of 3208 cents.

[Open the full-size screenshot](https://docs.vexlo.ai/images/ui-value-output.png).

Selected input/output entries from the values response for the first `line_total` call:

```json theme={"system"}
{
  "values": [
    {
      "path": "AABAAAAAAA",
      "slot": "input",
      "state": "stored",
      "encoding": "json",
      "value": "{\"line\":{\"quantity\":2,\"sku\":\"notebook\"}}",
      "bytes_count": 40,
      "truncated": false
    },
    {
      "path": "AABAAAAAAA",
      "slot": "output",
      "state": "stored",
      "encoding": "json",
      "value": "2400",
      "bytes_count": 4,
      "truncated": false
    }
  ]
}
```

The HTTP response carries each `value` as a string. Interpret it using `encoding`:

* `json`: parse the string as JSON, such as the argument object or the number `2400` above.
* `text`: the value is captured text.
* `base64`: decode the value as binary bytes when using the HTTP API. The UI's generic viewer
  displays text; it does not reconstruct the original Python bytes object.

The response above returns readable bytes with `state: "stored"`. The server resolves a
`pending` capture to `stored` when its bytes are readable. A trace-detail response carries
previews and metadata; only a full-value request confirms whether a value reported as
`stored` remains readable.

## Errors and logs

In the checkout graph, `authorize_payment` fails against its modeled primary processor and
succeeds on the next attempt. Select the failed attempt and open **Error** to see its exception
class and error preview. The captured error value decodes to:

```json theme={"system"}
{
  "message": "primary processor unavailable",
  "stack": [
    "_markers.py:2949 in _make_wrapper.<locals>.wrapper",
    "order_service.py:93 in authorize_payment"
  ]
}
```

![Payment error preview with the Other attempts control pointing to the recovered attempt.](https://mintcdn.com/vexlo-d15ac36e/rRJca0t154Rw5eS5/images/ui-value-error.png?fit=max\&auto=format\&n=rRJca0t154Rw5eS5\&q=85\&s=ab6fc9e3110339cc9c58a1da7458e093)

A failed attempt with a successful other attempt.

[Open the full-size screenshot](https://docs.vexlo.ai/images/ui-value-error.png).

The exception belongs to that attempt, not necessarily to the entry point's final result.
The checkout root returns normally because the application handles the first payment failure.
A caller can also catch an exception and return a business rejection. Read root status and
attempt status separately.

Error messages and logs depend on the application's [capture controls](https://docs.vexlo.ai/instrumentation/capture.md).
The Python SDK's stack representation identifies file, line number and function, without source
text. A recorded line number refers to the code that produced the capture; it does not identify
the application revision on its own.

Logs require log capture to be enabled. After the log value is fetched, **Logs** displays each
entry's level, relative offset, logger name and message. A missing logs slot does not establish
that the application emitted no logs: log capture is a separate control.

## Values across attempts

Use **Info** or **Error** to select a numbered retry attempt. Status, timing and previews in the
trace are attached to individual attempts. In Table, clear **collapse retries** to select an
individual attempt directly.

Full-value retrieval has a different contract. `/v1/traces/{id}/values` selects a call by
`path` and a data category by `slot`; it has no attempt selector. Returned entries also have
no attempt number. For a retried call, repeated entries can share the same path and slot.
Switching attempts does not make a full-value fetch attempt-specific. Use the attempt-specific
previews to compare retries; the fetched bytes cannot identify a numbered attempt.

When a retained function example is available, its `attempt` identifies the execution.
`include=values` retrieves that example's input/output for the stored attempt. This lookup
does not provide arbitrary
access to every attempt of a trace. See [Understand function usage](https://docs.vexlo.ai/guides/function-usage.md)
and [HTTP search and metadata](https://docs.vexlo.ai/reference/http-search.md).

## Truncated, withheld and unavailable data

Captured values are bounded representations. A preview can be shorter than the stored value;
a capture can also be truncated before storage because of capture limits. Fetching full bytes
cannot restore data omitted during capture or reconstruct an object that was represented only
by type information. Check `truncated`, the captured representation and the relevant SDK limits.

Values can also be disabled, excluded by sampling, withheld by data controls or absent because
an attempt has no completion record. Do not infer which case occurred from an empty preview.
The HTTP handle does not report whether individual fields were withheld inside a captured
value; inspect the representation and the capture configuration.

A preview can remain after the server no longer has the full bytes. A value recorded as
`stored` becomes `expired` on a full-value read when its bytes are
unavailable. The store cannot distinguish bytes removed by retention from bytes that have not
arrived. `expired` does not prove that the server once held the value.

A `pending` capture becomes `stored` on a later read when its bytes are readable. If it
remains `pending`, the response does not establish why the bytes are unavailable or whether
they will become readable. Do not infer availability from recording completeness.
An unresolved value omits `encoding`, `bytes_count` and `truncated`. A readable zero-length
payload is different: it omits `value` and `bytes_count`, but keeps `encoding` and `truncated`.
Do not treat an empty text return value as unavailable data.

If a value is unavailable, preserve the distinction between missing data and a failed function.
Use [Retention](https://docs.vexlo.ai/deployment/retention.md) for storage lifetimes,
[Capture controls](https://docs.vexlo.ai/instrumentation/capture.md) for producer settings and
[HTTP traces and values](https://docs.vexlo.ai/reference/http-traces.md) for exact states and fields.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.