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

# Find which release introduced a production error

> Trace a production error to the release and commits that introduced it with forge obs issue, then resolve it in the next release so a recurrence reopens it.

By the end of this guide you will know which release introduced an error, which commits in that release are likely to blame, and you will have marked the issue resolved so that it reopens if the error comes back.

This works because every hosted release is recorded with its commit range, and every error event carries the build that produced it. Forge can therefore join an error to the release it first appeared in, and your local git history narrows that release down to suspect commits ([how errors are grouped](https://docs.reliantlabs.io/hosting/observability/dashboards-and-alerts.md#how-errors-are-grouped)).

## Before you begin

* A Forge project deployed to a hosted environment, with at least two releases ([deploy a static site](https://docs.reliantlabs.io/guides/forge/deploy-static-site-cdn.md) or [a Go API](https://docs.reliantlabs.io/guides/hosting/deploy-go-api-managed-postgres.md)).
* The project's git checkout, with the commits those releases were cut from. Suspect commits are read from your local history.
* The `obs:triage` permission to resolve issues ([credentials](https://docs.reliantlabs.io/hosting/observability/forge-obs.md#credentials)).

The example below is a static site: release v8.1.0 already threw a `RangeError`, and release v8.2.0 added a price formatter that throws a `TypeError` for a plan with no price.

**1. List what the newest release opened**

`obs issues` lists the open issues. `--since-release` keeps only those first seen in one release:

```bash terminal theme={null}
reliant forge obs issues prod --since-release v8.2.0
```

```text theme={null}
ISSUE                                 STATUS  EVENTS  AFFECTED    LAST SEEN       SERVICE                     TITLE
889fe12d-8e62-4a22-ac69-86932879ce62  new     5       5 sessions  11-20 09:17:56  guides-sandbox-culprit-web  TypeError: Cannot destructure property <str> of <str> as it is undefi…
```

Without the flag, the older `RangeError` is listed too, as `unresolved`. It predates v8.2.0, so this release did not cause it.

**2. Read the issue**

Run this from your checkout, so forge can read the suspect commits from git:

```bash terminal theme={null}
reliant forge obs issue 889fe12d-8e62-4a22-ac69-86932879ce62 prod
```

```text theme={null}
889fe12d-8e62-4a22-ac69-86932879ce62  new  TypeError: Cannot destructure property <str> of <str> as it is undefined.
  at src/features/pricing.ts in formatPrice
  5 events, 5 sessions affected; first 2026-11-20T09:16:42Z (82c75e9f4099), last 2026-11-20T09:17:56Z (82c75e9f4099)
  live when last seen: v8.2.0 (promoted 2026-11-20T09:13:02Z)
  first release v8.2.0 (1102620d02c6fa15f38e7695995cf9f8170859bb..c291389709343bffb815ac173301c84d8a2ccc1a)

frames:
  formatPrice  src/features/pricing.ts:6
    src/App.tsx:19

by version:
VERSION       EVENTS  AFFECTED
82c75e9f4099  5       5 sessions

suspect commits:
  c2913897  2026-11-20  copy: new home page tagline
  6d656dae  2026-11-20  pricing: show plan prices on the home page
```

* **at** is the culprit: the function and file the error was raised in, after source maps resolved the minified stack.
* **first release** names the release and the commit range it shipped. This line answers the question.
* **by version** counts events per build. A browser error reports its frontend build id, so read it against the **first release** line.
* **suspect commits** are the commits in that range that touched the culprit's files and frames. Here both touched `src/App.tsx`, but only `6d656dae` touched `pricing.ts`.

Add `--json` to hand the whole document, including the latest trace id, to an agent.

**3. Line it up with what changed**

`obs changes` puts promotions, issues and alerts on one timeline, newest first:

```bash terminal theme={null}
reliant forge obs changes prod
```

```text theme={null}
TIME            KIND       WHAT                                                                              BY
11-20 09:17:21  activity   open alert NewIssue                                                               reliant
11-20 09:16:42  activity   issue opened issue TypeError: Cannot destructure property <str> of <str> as it …  reliant
11-20 09:13:02  promotion  promoted v8.2.0                                                                   you@example.com
11-20 09:10:36  activity   open alert NewIssue                                                               reliant
11-20 09:09:16  activity   issue opened issue RangeError: banner width must be positive                      reliant
11-20 09:04:30  promotion  promoted v8.1.0                                                                   you@example.com
```

The `TypeError` opened four minutes after v8.2.0 was promoted, and the `NewIssue` alert followed.

**4. Fix it and resolve it in the next release**

Commit the fix, then mark the issue resolved as of the next release:

```bash terminal theme={null}
reliant forge obs issue resolve 889fe12d-8e62-4a22-ac69-86932879ce62 prod --in next
```

```text theme={null}
889fe12d-8e62-4a22-ac69-86932879ce62 is now resolved
```

`--in next` dates the resolve to now. Events from the release that is live now are the bug you are fixing, so they do not reopen the issue. An event from any release promoted after now reopens it as **regressed**. If the fix already shipped, `--in v8.3.0` dates the resolve to just before that release reached the environment.

**5. Ship the fix and check the issue**

Build and promote the fixed release ([promote a release](https://docs.reliantlabs.io/guides/hosting/promote-release-staging-to-production.md)):

```bash terminal theme={null}
reliant forge env build prod --release v8.3.0
reliant forge env deploy prod v8.3.0 --yes
```

After users load the new release, only the older error is still open, and the fixed one is listed as resolved:

```bash terminal theme={null}
reliant forge obs issues prod
reliant forge obs issues prod --status resolved
```

```text theme={null}
ISSUE                                 STATUS      EVENTS  AFFECTED     LAST SEEN       SERVICE                     TITLE
22116262-6de6-4e48-b10c-97021a638a9e  unresolved  14      14 sessions  11-20 09:25:44  guides-sandbox-culprit-web  RangeError: banner width must be positive

ISSUE                                 STATUS    EVENTS  AFFECTED    LAST SEEN       SERVICE                     TITLE
889fe12d-8e62-4a22-ac69-86932879ce62  resolved  7       7 sessions  11-20 09:20:32  guides-sandbox-culprit-web  TypeError: Cannot destructure property <str> of <str> as it is undefi…
```

The resolved issue counts 7 events, not 5. Two page loads of v8.2.0 arrived after the resolve and did not reopen it. Its timeline in `obs issue` shows who resolved it and when.

## What this does not do

* It does not roll anything back. To get back to a good state fast, deploy an earlier release ([recover from a bad deploy](https://docs.reliantlabs.io/guides/hosting/recover-from-bad-deploy.md)), then fix forward.
* Suspect commits are a narrowing aid, not blame: they are the commits in the release's range that touched the files in the stack. A commit that broke a caller in another file is not listed.
* Resolving an issue changes its state only. It does not open a fix. To have an agent investigate new errors, see [alerts to GitHub issues](https://docs.reliantlabs.io/guides/workflows/production-alerts-to-github-issues.md): an agent files an investigated issue, and a person decides what happens next.

## Troubleshooting

> [accordion] note: suspect commits unavailable: not inside a git checkout
>
> Run `obs issue` from the project's checkout. The issue and its other fields are still printed.

> [accordion] suspect commits unavailable: the culprit file (…) is not tracked in this checkout
>
> Your checkout does not track the file named in the stack, for example because it is a different repository. Run it from the checkout the release was cut from.

> [accordion] The by-version table shows a hex id instead of a release
>
> Browser errors report the frontend's build id. The **first release** line maps the issue to the release that shipped that build.

> [accordion] obs check reports INCONCLUSIVE no\_request\_telemetry for a frontend-only release
>
> For a release of a static site with no backend, `obs check` can return this even though the release opened an issue. Use `obs issues --since-release` to see what the release introduced.

## Next steps

> [card] [Go from an error to a reviewed fix](https://docs.reliantlabs.io/guides/workflows/production-error-to-fix.md)
>
> Turn the issue into an agent-written pull request, with a person approving at each step.

> [card] [Debug production with an AI agent](https://docs.reliantlabs.io/guides/observability/debug-production-with-ai-agent.md)
>
> Give an agent the same `obs` documents, plus logs and traces.

> [card] [How release verdicts work](https://docs.reliantlabs.io/deep-dives/how-release-verdicts-work.md)
>
> How `obs check` judges a promotion before and after.

> [card] [Send OpenTelemetry from any app](https://docs.reliantlabs.io/guides/observability/send-opentelemetry-from-any-app.md)
>
> Get the same issues for an app Forge does not deploy.

> [card] [Dashboards and alerts](https://docs.reliantlabs.io/hosting/observability/dashboards-and-alerts.md)
>
> Source maps, issue states and the `NewIssue` and `IssueRegressed` alerts.

> [card] [Querying with forge obs](https://docs.reliantlabs.io/hosting/observability/forge-obs.md)
>
> Every `obs` verb, its JSON output and exit codes.


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