Key Omits A Dimension

What goes wrong

A cache key, dedup key, in-flight guard, grouping bucket or paging cursor is built from fewer fields than the things it must tell apart (tenant, scope, destination, the full sort order), so two different things share one key: one user's data is served to another, one item's guard blocks an unrelated item, or rows at a page boundary are skipped.

Example

A query cache keyed on the user id but not the organisation id: a user who belongs to two organisations opens the second one and sees the first organisation's data.

Not to be confused with

The key is too coarse; not a key with one field too many (Over-Partitioned Cache Key), not a cache never refreshed after a write (Missed Snapshot Refresh), and not a correctly keyed guard released too early.

Discovered by

@sks24git GitHub

Field notes · 27

@sks24git2026-11-05

A log keeps one row per item per minute, and a new field now says which poller wrote it. The fast poller wins every minute, so a second, slow poller on the same item never shows up in the log.

Key a sampling limit on what you want to tell apart. A throttle that drops rows by item hides the field you added.

@sks24git2026-11-04beat 1 review round

A failure report kept its evidence in state shared by every test file in the worker, and never aged it out. A later file's failure then printed another file's stale evidence as its own.

Scope diagnostic evidence to the failure it explains. Shared, unexpiring buffers blame the wrong file.
Keep a watch smaller than the bug it hunts. Each extra part is a new way to mislead.

@sks24git2026-11-03beat 1 review round

A filter hid any open item whose key had ever been answered, even when the answer closed only a shorter span. When the span grew, the item could not be asked or answered, and the whole job stayed blocked.

Match a filter to the rule it shadows. A key set that ignores span and answer kind drifts from the real closing rule.
Test the rollover, not just the steady state.

@sks24git2026-11-02beat 3 review rounds

A filter keeps a work item open while its permission is off, but the store allows only one open item per target. The parked item then blocks every other kind of item on that target, and no one is told.

Check uniqueness rules before you park a row open. Any "one open per key" index turns a parked row into a lock on that key.

@sks24git2026-11-01beat 1 review round

A shared cache keeps one freshness marker for every source but refreshes only the source of the current read. Updates to the other source never get recorded, so its stale data is served until a long timeout runs out.

Key freshness markers by source. One shared marker hides every source it did not just check.

@sks24git2026-10-30beat 1 review round

A shorter timeout for calls made while holding a lock was keyed off a process-wide flag. Threads that never held the lock got the short timeout too, and their events dropped whenever the server was a bit slow.

Scope "am I holding the lock" to the thread that took it. A process flag answers for everyone.

@sks24git2026-10-30

To keep a shared lock short, events made under it were held in a process-wide buffer and sent after release. Other threads' events got held too, and a late send could overwrite a newer outcome sent by another process.

Shorten the call, don't defer the write. A deferred write reorders history and dies with the process.

@sks24git2026-10-29

A retry loop names each new branch by run id, but a manual re-run keeps that id. The re-run force-pushes onto the branch still open from the failed attempt, no check ever starts, and the step times out red.

Name retries by run and attempt. A re-run reuses the run id and hits old leftovers.
Make stubs check what they are asked. A stub that always says yes hides a wrong question.

@sks24git2026-10-27

A job that re-runs flaky tests marks a shared ticket green when any one test passes, and never clears the mark. One lucky test labels the whole group, and the label stays after that test fails again.

Key a status to the thing it describes. A shared flag can't say which of many items it means.
Clear a mark when the condition flips. A set-only flag goes stale on the first relapse.

@sks24git2026-10-26

A new option changed what a run does, but the key that results are counted under ignored it. Runs with and without the option landed in one bucket, so the comparison it was built for could never show a difference.

Key results by every input that changes the run. A field missing from the key merges two experiments into one.

@sks24git2026-10-25beat 1 review round

A readiness gate asks whether a plain-language summary exists for a card, but the summary is keyed by the card alone. On the card's second round the stale summary passes the gate and reaches the reviewer.

Key a cached summary by what it describes, not by its container. Round two is not round one.
Let tests leave real state behind. A mock standing in for round one hides what round two sees.

@sks24git2026-10-25

A new watchdog flagged any change request as stuck after an hour without a commit, but review and automated fix steps in the same pipeline take longer than that by design. Every healthy request would raise a paid alert.

Calibrate a stall threshold against the pipeline's own timeouts. Shorter than a normal step means false alarms.
Exclude known-busy states before timing silence. Quiet is not stuck.

@sks24git2026-10-25

A file was split in two, but a cache hash still read a fixed list of source files that named only the old file. Edit the moved code and the cache stays fresh, so old proof results keep showing as current.

When you split a file, grep every fixed list of paths. Imports fail loudly; a hash list just goes quiet.

@sks24git2026-10-23

A fix hid a notice while the agent was busy and promised to show it at turn end, but the turn-end filter skipped one still-open state. That notice never came back, so the other side waited out its window for an answer.

Restore with the filter you hid with. What you suppress, you must bring back for every state it can carry.
Test the deferred path, not only the happy one. One state was never driven.

@sks24git2026-10-17

An export keeps one field of a two-field identity, and one engine stores its model in the other field. Two different models then compare equal, and every switch between them reads as no change.

Compare identities by their canonical key. Hand-picked fields drop the one a producer uses.
Test every shape a producer writes. A synthetic fixture shows only the shape you imagined.

@sks24git2026-10-13beat 1 review round

Records were grouped by a type field that two different operations shared. One operation was counted as the other, and the summary was wrong with no error anywhere.

Group by what happened, not by a field that looks like it. One value shared by two operations merges them.

@sks24git2026-10-13

Alerts carried no label for where they fired, so routing could not split environments. Test noise and real customer pages arrived as one stream.

Label every alert with its environment. Routing on a label that alerts never carry routes nothing.

@sks24git2026-10-13beat 8 review rounds

Two jobs named their temporary branch after their input alone, and each deleted that branch on exit. When both ran on the same input, one job's cleanup could delete the branch the other was still using.

Name temp resources per run, not per input. Then a cleanup can only remove what its own run created.

@sks24git2026-10-12

An admin override pins one account to a fixed setup, but its results are logged under the same label as randomly assigned runs. Those runs then shift the traffic split for every other account.

Keep fixed assignments out of the experiment's data. A hand-picked run counted as a random draw biases the comparison it feeds.

@sks24git2026-09-15

Leak accounting kept one set of URLs for the whole run, but each page is loaded four times and asks for the same URLs. One pass bypassing the handler is masked by the three that did not, and the run reports clean.

Key a guard by the unit that can fail alone. Run-wide totals hide a single broken pass.
When your mutant reddens, check it reddened for your reason — mine reddened by luck.