Skip to content
Blog

Why your error tracker keeps grouping unrelated bugs into one issue

Why an error tracker puts different bugs in one issue, how Sentry documents its grouping, and the fix: normalize messages, drop line numbers, hash in-app frames.

You open the issue list and one item has 4,000 events and a title like TypeError: Cannot read properties of undefined. You click in expecting one bug. Instead the stack traces underneath are three or four genuinely different failures that happen to throw the same exception type from nearby code. Somebody fixes the loudest one, the count keeps climbing, and the tracker looks broken even though it did exactly what it was built to do.

The behavior is not a bug in your error tracker. It is what "grouping" means, applied to code it has never seen, and it fails in the same handful of ways in every tool that does it. This post covers why. It uses Sentry's own public documentation as the worked example, since most people hit this problem there first. It also covers what a fingerprinting algorithm has to do to make the failure rarer.

Why does an error tracker group different bugs into one issue?

Because grouping is a fingerprint match, not an understanding of your code. No error tracker stores one row per bug. It stores one row per event (an occurrence) and decides, at ingest, which issue that event belongs to. The decision is a fingerprint: a string computed from the event, hashed, and matched against existing issues. Same fingerprint, same issue. Different fingerprint, a new issue is created.

Sentry's documentation on event grouping describes the default order plainly: check for a custom fingerprint first, then fall back to "stack trace, exception type and value," and finally the message if there is no usable stack. Every other tracker that groups events does some version of the same thing, because the alternative, one row per event with no grouping at all, makes an issue list useless within a day.

The failure mode follows directly from what the fingerprint is built from. Two things cause almost every case of "these are different bugs but they're one issue":

  • The call site is the same, the cause is not. A shared utility function called from a dozen places throws the same exception type with a similar message no matter which caller passed it bad data. If grouping weights the throw site over the caller, everything routed through that utility becomes one issue regardless of why it failed.
  • The message looks identical after normalization. Grouping deliberately treats "user 812 not found" and "user 4409 not found" as the same shape, because otherwise every distinct id would fork a new issue and the count would be meaningless. That normalization is correct for the case it targets and wrong the moment two different failures happen to produce structurally similar messages with different meanings.

Both are the tracker doing its job. The problem is that "the job" is a judgment call about what "the same bug" means, made by an algorithm with no idea what your code is supposed to do.

How do you stop an error tracker from over-grouping?

Set a custom fingerprint on the call sites that need to be told apart. Sentry's grouping and fingerprints documentation lists the escalating set of tools it gives you once the default gets it wrong: merge issues that were wrongly split, write a fingerprint rule that reassigns incoming events based on a matcher, write a stack trace rule, or set a fingerprint directly in the SDK call that reports the error. A custom fingerprint passed by your own code is the actual fix for the shared-utility case. You know that a payment failure and a signup failure are different bugs even though they both throw from the same validation helper. Tell the tracker that directly instead of hoping the algorithm infers it.

Every tracker that does automatic grouping ships some version of this escape hatch. The alternative is grouping too coarsely, which is this problem, or too finely, where a one-line code change starts a new issue for the same bug. There is no algorithm that gets both right on code it has never seen. The honest version of the product tells you the rule it used and lets you override it; the dishonest version hides the rule and asks you to trust the count.

How does RealUptime Errors fingerprint an event?

RealUptime Errors groups on three things. We can describe our own fingerprinting exactly, because it is a few hundred lines of deterministic code, not a proprietary black box, so the rules are short:

  1. The exception type, verbatim. TypeError and RangeError never group together.
  2. The message, normalized. Quoted strings become "?", UUIDs and long hex runs become #, and any remaining digit run becomes #. user 812 not found and user 4409 not found hash to the same normalized message; key "abc-123" is stale and key "def-456" is stale do too. This is the same trade Sentry describes: it collapses variable data on purpose, and it is the exact mechanism that can over-group two different failures that both happen to say "user # not found".
  3. The in-app stack frames, by file path and function name, with line numbers deliberately dropped. A one-line edit above the throw site should not start a new issue; that is also why a shared utility called from several places can pull unrelated failures into one issue when the top in-app frame is the utility itself rather than the caller.

The escape hatch is the same one Sentry documents: call the SDK with an explicit fingerprint: [...] array, and that value is hashed as given, bypassing the message and stack logic entirely. If a shared validator throws for five different reasons, pass a fingerprint that includes the actual failure reason and the five reasons become five issues instead of one.

When grouping has already gone wrong on history that already shipped, an issue merge repairs it after the fact. Existing events move from the wrong issue to the right one in one transaction, and future events with the old fingerprint are redirected automatically, so the fix does not require replaying data. A fingerprint change alone (a new custom fingerprint, a fix to the normalization) only affects events from that point forward; without a merge tool, the history stays split or stays wrongly combined.

Every issue also carries the version number of the fingerprint algorithm that created it. If the algorithm changes later, that is a new version, not a silent regrouping of history you already triaged. The version is the difference between "the count changed because of a real event" and "the count changed because we reshuffled the math," which is exactly the kind of quiet drift the honesty register we hold ourselves to does not allow.

Each failure has a matching fix:

Symptom Fix
Different bugs in one issue A custom fingerprint on the call sites that need to be told apart
One bug split across several issues An issue merge
Counts shifted after an algorithm change The fingerprint version on each issue shows which algorithm grouped it

How can you tell if your issues are over-grouped?

Open your loudest issue and read five events from it, not one. Specifically:

  • Do the stack traces share the exact same top in-app frame, or just the same exception type?
  • Does the message differ only in a number, id, or quoted value, or does it differ in the actual noun ("user not found" vs. "session not found" both normalizing to the same shape)?
  • If you have deploy or release data attached, did events with meaningfully different causes start on different releases but land in the same issue?

A yes to any of those means the issue is over-grouped. The fix is a custom fingerprint on the call sites that need to be told apart, not a bigger investigation into why the count is so high.

The honest limit

No fingerprinting scheme, ours included, can read intent. It can only read the shape of a message and a stack trace, and shape is a proxy for cause, not cause itself. The tools that help (custom fingerprints, merge, versioned algorithms so nothing regroups history silently) exist because the proxy is known to be imperfect, not because anyone found a way to make it perfect. Be skeptical of any tracker that claims its default grouping is always right. The honest claim is narrower: the default gets most cases right, tells you what it used, and gives you a way to correct the rest.

RealUptime Errors groups on exactly the algorithm described above. The free tier of 10,000 events a month lets you try it against your own noisy code before paying for anything. See how the free tier compares to Sentry's, or check the pricing page for what the paid tiers add on top.

Sources: Sentry, event grouping, read September 21, 2026.