reliant forge env up dev runs, the browser’s console sits in a file next to your API’s log. A scaffolded frontend forwards every console call, uncaught error and unhandled promise rejection to its dev server, and env up writes each service’s output to .forge/logs/dev/. So “what did the browser do” becomes a grep, and a failed call’s trace id leads straight to the backend lines for the same request. Your coding agent can read the same files, with no browser and no screenshot.
Where the telemetry goes describes the directory and the forwarder in detail.
Before you begin
- A Forge project with a scaffolded web frontend, running locally with
reliant forge env up dev: Build a Go and React app. - Forge v1.6.1 or later in the project (
reliant forge --version).
shop app with a bug added on purpose: clicking a product row reads a field the product does not have.
1
Find the log files
env up names each service’s log file in its summary:Output (trimmed)
frontend_<name>.log holds the dev server’s output, with each browser line prefixed [browser:<level>]. Each env up starts the files afresh.2
Grep the browser's errors
Reproduce the problem in the browser, then search every frontend’s file at once:The first line is an uncaught
terminal
Output
TypeError. It makes no console call anywhere in your code, so searching the source for it finds nothing. The stack follows it in the file; with Next.js the dev server also prints the line that threw:terminal
Output
3
Follow a failed call into the backend
The second line is a failed RPC, and it carries the trace id the browser sent with the request. The backend logged the same id:The browser reports any failed call as an error. The backend logs a
terminal
Output (trimmed)
not_found at INFO with error_class=user, because the caller asked for something that does not exist; a server fault is logged at ERROR.4
Query the same errors in the local store
The local stack also keeps backend logs and browser errors in a queryable store, and keeps them across restarts while the files start afresh. Browser errors are stored as error spans of the frontend’s service (For
obs logs reads backend logs, by trace or by query:terminal
Output
<project>-<frontend>):terminal
Output
dev these verbs read the local store without any flag. --backend local forces it, which is only useful when an env’s declaration routes elsewhere.5
Fix it and confirm the errors stop
After the fix, the dev server reloads the page. Click a row again and search once more:The row now opens
terminal
Output
/products/view. To watch while you click, run tail -f .forge/logs/dev/frontend_web.log, or reliant forge obs logs dev --follow --severity error for the backend. Browser lines arrive in batches every 250 ms, and errors are sent at once.What this does not do
- The browser file is development only. The receiving endpoint exists only on the dev server, so a deployed frontend writes nothing there. Deployed browser errors become issues with source-mapped stacks: Debug frontend errors with session timelines.
- Browser console lines are not in
obs logs. Only the file has them. The store holds browser errors, page loads and failed requests as spans. - It does not record sessions. Session replay is opt-in per environment, and masked: Session timelines.
Troubleshooting
No [browser: lines in frontend_web.log
No [browser: lines in frontend_web.log
The forwarder is ordinary scaffolded code: one
installDevLogging() call in src/main.tsx (Vite) or src/app/providers.tsx (Next.js), and one dev-server receiver. If you adopted an existing app or removed either, add them back. Also check that the page was opened through the dev server env up started, not a production build.[browser:warn] [forge-devlog] this dev server's /__forge/log endpoint predates batched posts; update it
[browser:warn] [forge-devlog] this dev server's /__forge/log endpoint predates batched posts; update it
The page’s runtime batches lines but the dev server’s receiver is older. Update the receiver from a current scaffold, or the lines arrive empty.
Next steps
Find your slowest endpoints
Rank every RPC by p95, locally or in production.
Debug production with an AI agent
Give an agent the same evidence for a deployed app.
Where the telemetry goes
The log directory, the local store and hosted telemetry.
Querying with forge obs
Every obs verb and its flags.