# Issues and grouping

How events become issues, which fingerprint decides it, what an issue's status means, and how short ids and affected users are counted.

An issue is every event of a project with the same fingerprint. The fingerprint is computed when
the event arrives, after source maps are applied, so two builds of the same code (with different
chunk hashes and minified names) form one issue.

## How the fingerprint is computed

The first rule that applies wins:

1. **Your fingerprint**, when the event sets one (`scope.setFingerprint([...])` or `fingerprint` in
   `beforeSend`). Its parts may be `{{ default }}` (the fingerprint the rules below would compute),
   `{{ transaction }}`, `{{ type }}`, `{{ value }}`, `{{ function }}`, `{{ module }}`,
   `{{ level }}`, `{{ message }}` or `{{ tags.<name> }}`; anything else is taken literally.
2. **The exception**: for each exception of the event, its type and the frames of your own code
   (module or file, and function). When the SDK marks frames as in-app, only those count; when it
   marks none, frames from `node_modules`, Next.js internals, the webpack runtime and Node.js
   internals are left out. When that leaves no frame, every frame counts; an exception without
   frames counts by its type and its message, with the variable parts replaced as in rule 4. At
   most the 50 frames nearest the error count. A frame of a minified bundle that no source map
   translated counts by its file alone.
3. **The stack of a thread**: the crashed one, else the current one, else the only one; or the
   stack attached to a message.
4. **The message**, with URLs, paths, email and IP addresses, UUIDs, quoted strings, hex strings
   and numbers replaced, so `user 123 not found` and `user 456 not found` are one issue.

An issue's **Grouping** tab shows the rule that applied and the components its fingerprint was
computed from.

A source map uploaded after an event arrived does not change that event or its issue.

## Status

| Status     | Meaning                                                                                                                                      |
| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| Unresolved | Open. Shown as _regressed_ after a resolved issue came back, _escalating_ after an ignored one did.                                          |
| Resolved   | Closed. A new event reopens it as _regressed_; resolved in the next release, only an event of a newer release does.                          |
| Ignored    | Closed until its condition passes (a time or a number of further events); then it reopens as _escalating_. Ignored forever, it stays closed. |

A new issue, a regression and an escalation each raise the project's default alerts (see
[Set the default alerts](set-default-alerts.md)).

"Newer release" compares the dates the releases were created. A release that was never created
(no `sentry-cli` or bundler-plugin upload) counts as newer; an event without any release never
reopens an issue resolved in the next release.

## Short ids

An issue is named `<PROJECT SLUG>-<number in base 36>`, such as `WEB-1A`. The console, alert mails
and webhooks show it, and the console URL (`/errors/issues/WEB-1A`), the API and the CLI accept it.
The plain issue number (`46`) works too. A short id of another project's slug does not resolve.

## Users affected

An issue's **Users** counts distinct users of its events. A user is the event's `user.id`, else
its email, else its username, else its IP address when the project keeps addresses. An event that
names none of these counts by a key derived from the sender's address, the project and the day,
so the same anonymous sender counts again the next day. The address itself is not stored unless
**Keep client IP addresses** is on (see [Change project settings](change-project-settings.md)).

## Related

- [Find and triage issues](triage-issues.md)
- [Read an issue's events](read-events.md)
