How error tracking works
Crashes and the errors you already log, grouped by cause and joined to the same user's funnel — with no capture calls to write.
Your errors and your funnel end up in one place, keyed to the same user. Click an issue, see who hit it; click a user, see what they did before it happened. That join is the part a standalone crash reporter structurally can't do.
You don't write capture calls
| Python | Node | React Native | |
|---|---|---|---|
| Crashes | ASGI middleware | uncaughtException | global error handler |
| Failed awaits | — | unhandledRejection | promise rejection tracking |
| Errors you log | logger.error(...) | console.error(...) with an Error among its arguments | console.error(err) with the Error first |
| Explicit | capture_exception(e) | captureException(e) | Growth.captureError(e) |
The third row is the one that matters most. Most real failures — a vendor API timing out, a database call that fails over — are caught, logged, and never re-thrown, so a crash handler alone never sees them. If you already log errors when you catch them, you already have error tracking. On Node and React Native a plain-text console.error line is kept as a breadcrumb on the next error rather than sent as an issue, because most of those lines are other libraries logging; captureConsole (Node) and captureConsoleErrors (React Native) send them too. Setup cost: a few lines for a Python or Node backend, zero for a React Native app that already calls Growth.init().
How issues are grouped
Grouping happens on our side, from the raw stack. An issue is exception type + the two deepest app frames. Line numbers are excluded, so editing code doesn't split an issue in two; dependency frames (site-packages, node_modules) are excluded, so one bug doesn't fragment into an issue per library that touched it. The route is not part of the key, so the same crash on two screens is one issue. Log lines with no exception group on the logger and the message template instead, as Sentry does: the Python SDK (0.6.0 and later) sends the message before its %-arguments are filled in, so logger.error("payment %s failed", order_id) is one issue for every order, and moving the call to another line keeps it. Older SDKs, and lines with no template, group on the call site. A stack with no usable frames, and a plain console line, group on the exception type and the message with its ids and numbers masked.
Status and alerts
Issues move through new → ongoing → escalating, and you can resolve, ignore, discard or merge them, one at a time or several selected on the Issues page. Resolve can be plain, in the next release (events from the release it was last seen in don't reopen it; the first from a newer release does) or in the latest release the app has sent. Ignore can be forever, for a time, until a number of further events or users, or until it escalates. One with no events for 14 days resolves itself by default.
The Issues page searches every issue's title and culprit (or a short id such as HOUSEAI-42), filters by status, source, level, release and environment, sorts by last seen, events, users or newest, and loads more as you go, so nothing past the first page is out of reach.
Until you add your own alert rules, you're alerted on six things: an issue nobody has ever seen, an issue that comes back after you resolved it, an issue being resolved, an ignored issue coming back, one that spikes past its own 7-day baseline, and 5 crashed sessions on one issue within an hour. A spike means, in the last full hour, at least 10 events, at least 3× the hourly average and at least 2 users; an issue under a day old has no baseline yet, so it needs 5 users in an hour. Not on every occurrence. A performance issue doesn't send the new-issue alert by default, because detectors file many of them on their first pass; it still alerts when it escalates. One rule of your own replaces all six: see Slack.
The Alerts tab on the Issues page lists every alert fired: when, which rule, the issue and the channels. One with nowhere to go says Not delivered, so you can tell a quiet app from an alert nobody received.
Reading an issue
An issue shows its latest event in full, as much as its SDK sent. Click the time of any row under its occurrences to open that event in full instead:
- The message, in full, when the issue's title (the first 200 characters) cut it.
- The stack, with your own frames first. From a backend SDK, frames open to their source lines and local variables.
- What caused it (
raise X from e, or an error raised while handling another), each cause with its own frames, and from the Python SDK their source lines and variables. - The request: URL, query string, method, headers and body, with a note when the body was cut.
- Every tag and context: runtime, browser or app, client OS, device, trace, and any you add. Installed packages sit folded below them.
- Breadcrumbs: up to 100 things that happened first, each with its level, type, time and data.
- Logs from the same trace, from Logs.
- The session around it, what its events have in common, and similar issues.
A performance issue shows the calls behind it and the time you could save.
Rules and settings
All of these are on the Issues page:
- Alert rules — when something happens to an issue and it matches your conditions, alert the channels you pick, with a throttle. It can be a new issue, a regression, a resolved issue, an ignored one coming back, an escalation, or a count in a window.
- Inbound filters — drop matching errors before they are stored, by error type, message (
*for anything), environment or release. Dropped errors are counted, never stored, grouped or alerted on, and the filters work on app builds already out. Use the environmentsdevelopmentandpreviewto keep test builds out, andsimulatorfor any build running on a simulator or emulator, whatever its environment. - Grouping rules — send new errors that match into one issue. The first match wins, and existing issues stay as they are.
- Owner rules — assign issues by rule, or import a CODEOWNERS file.
- Issue settings — auto-resolve days, built-in noise rules, a crash-free alert threshold, an email digest, how long events are kept, the repository stack frames link to, and whether MCP keys may change issues.
On an issue, Copy fix prompt copies a brief for your coding agent.
Releases and deploys
Sessions and crash-free rates per release are on the Releases page. Record deploys from CI with npx fictura-sdk deploy --release <release> --api-base https://<your Fictura API> (from @fictura/sdk, with the SDK key or a data API key with releases:write in FICTURA_DEPLOY_TOKEN) to list them there and get suspect commits on issues. The commits come from your git history, and an issue names the ones that touched the files in its stack.
Cron jobs
Wrap a scheduled job in fictura.monitor("nightly-sync", schedule="0 3 * * *") (Python) and every run is a trace, a run that raises is marked failed, and Performance → Jobs shows a cron that missed its usual gap as late. See Cron monitors.
Uptime rides along
Point Fictura at one URL and it's pinged every 60 seconds; three consecutive failures flag it down, and the down/recovered alerts fire exactly once each through your alert connections. The Issues page shows 7-day uptime beside your error feed.
What we don't do
- No profiling or session replay. Different products.
- No application metrics, event attachments or user feedback forms.
- No AI-detected issues. Performance issues come from fixed rules over your traces: N+1 Query, Consecutive DB Queries, Slow DB Query, Consecutive HTTP, N+1 API Call, Large HTTP Payload, Endpoint Regression and Web Vitals. Their thresholds are on Monitors. Detectors that need profiles (main-thread work, frame drops) aren't there.
- Minified stacks aren't readable without a source map. Release-build JS errors group by normalized message instead — coarser, but stable across releases. Upload maps to fix that: see Source maps.
Native crashes are covered on Native crashes. Request and screen timings are on the Performance page, and your backend's log lines on Logs.
Running alongside an existing tool is fine and expected — our crash handlers always chain to whatever was installed before them. The one exception is unhandled promise rejections on Hermes, which allow a single tracker: see React Native.
Server-side gating
Ask Fictura whether a user is entitled instead of maintaining your own billing table — one GET, derived from the same webhooks that feed everything else.
Python
pip install fictura, two lines in main.py, and crashes, the errors you already log, the request behind them and your logs arrive with no capture calls to write.