Testbevinding 002 — /full-read is niet consistent op het formele leesmoment
| Veld | Waarde |
|---|---|
| Datum | 2026-09-21 |
| Gevonden in | loadtest sc 33 (lezen terwijl er geregistreerd wordt), direct na de merge van main + fix/enkelvoudige-hub-afvoer in chore/be-code-review |
| Test | TestLoadNpLoc (regressie_load_test.go), LOAD_SCENARIO=33, standaardinstellingen (1 schrijver, 12 lezers, kleine seed) |
| Ernst | Hoog. De opgeslagen data is correct, maar een lezer kan een antwoord krijgen dat op géén enkel moment de werkelijke toestand van het register was. Voor een bitemporeel register is "wat gold er op het moment van lezen" de kern van de belofte |
| Status | Open, geparkeerd tot na de merge van chore/be-code-review naar main (besluit Mark, 2026-09-21). Oorzaak vastgesteld, richting gekozen, nog niet gebouwd |
| Gemeld door | Claude-sessie (BE-review, 2026-09-21) |
Waarneming
Ongeveer 1% van de GET /full/natuurlijk_personen/{id}-requests faalt op de verwachting
"er is een actieve naam met actieve data", uitsluitend terwijl een schrijver op dat moment dezelfde
NP corrigeert:
3827 requests · fouten 10 (0,26%) · alle 10 op stap «NP full» (720 requests)
json-pad "namen[afvoer=null].data[afvoer=null].achternaam" niet gevonden
Het namen-deel van zo'n antwoord:
[{"natuurlijkpersoon_id":5,"rel_id":1,"opvoer":"2026-01-01T10:00:00.00001Z",
"data":[{"rel_id":1,"versie":1,"achternaam":"Meijer",
"opvoer":"2026-01-01T10:00:00.00001Z","afvoer":"2026-01-02T00:00:00.000024Z"}]}]
De hub (rel 1) staat als actief in het antwoord (geen afvoer), maar zijn data is al
afgevoerd, en de nieuwe hub met de nieuwe naam ontbreekt. Volgens dit antwoord heeft de persoon
op dit moment geen naam. Dat is nooit waar geweest: vóór de correctie gold "Meijer", erna de nieuwe
naam.
Analyse
- De schrijver doet alles in één transactie (
RegistreerCore): oude hub afvoeren, diens data afvoeren, nieuwe hub + data opvoeren. Dat is atomair en correct; na afloop is de invariant (precies één actieve hub met één actief data-record) intact. De data is dus goed. - De lezer bouwt
/fullop uit meerdere losse queries (entiteit, hubs, data per hub), zonder transactie. Postgres draait standaard inREAD COMMITTED: elke query ziet de stand van het moment waarop díe query start. Commit de schrijver tússen de hub-query en de data-query van de lezer, dan komen de hubs uit de oude wereld en de data uit de nieuwe. Dit heet een torn read of leesscheefheid. - Het is geen regressie van de merge. Het lezen is nooit op één moment gefixeerd geweest. Het
bleef onzichtbaar omdat vóór
fix/enkelvoudige-hub-afvoerde oude data bij "Wijzigen" stil actief bleef: de lezer vond dan altijd nog íets actiefs. Nu de engine oude data correct afsluit, wordt de scheefheid zichtbaar. - Het raakt vermoedelijk alle samengestelde reads:
/full/{padnaam}(lijst en detail), de publicatieweergave, en GraphQL-queries die hub + data in aparte stappen laden. Alleen/full/natuurlijk_personen/{id}is gemeten. - Ook bij tijdreizen (
?t=) speelt het, in mildere vorm: het peilmoment ligt dan vast, maar een registratie met een tijdstip vóórtdie pas tíjdens het lezen commit, kan tussen twee queries in beeld komen. Dat kan ook in klokmodus, omdat het tijdstip bij de start van de registratie wordt gezet en de registratie pas bij de commit zichtbaar wordt (zie het aandachtspunt verderop). De momentopname per opvraging lost ook dit op voor één opvraging.
Reproductie
- Suite-editor → Load & performance → sc 33 → Loadtest starten (standaardinstellingen).
- Of:
LOAD_SCENARIO=33 go test -tags integration -run '^TestLoadNpLoc$' -v -count=1 . - Verwacht: enkele fouten op «NP full», steeds met een actieve hub waarvan de enige data een
afvoerheeft. Het aantal wisselt per run (timing); op de kleine seed 5 tot 10 van 720.
Twee dingen die niet door elkaar moeten lopen
Uit het gesprek van 2026-09-21; dit onderscheid bepaalt de oplossing.
- A. Afgeleide actuele toestand. Het register schrijft bij elke registratie, correctie en
ongedaanmaking de actuele toestand weg als afgeleide
opvoer/afvoerin de records. Daardoor is "geef de actuele stand" een goedkope query opafvoer IS NULL, zonder tijdreislogica. Dit blijft zo. - B. Opvragen op een tijdstip. Dat is een tijdreisquery, ook als het tijdstip 0,02 s oud is. Als élke opvraging een tijdreis wordt, lijdt de performance. Dat willen we niet.
De oplossing moet dus de scheefheid wegnemen zonder van een actuele opvraging een tijdreis te maken.
Gekozen richting: één momentopname per opvraging
Een opvraagtransactie bestaat wel degelijk. Postgres bewaart van elke rij meerdere versies en
bepaalt per query welke versie zichtbaar is. Standaard (READ COMMITTED) kiest elke query een
eigen momentopname; daar komt de scheefheid vandaan. In een read-only transactie met
isolatieniveau REPEATABLE READ kiest Postgres bij de eerste query één momentopname en houdt
die vast voor alle volgende queries van die transactie.
tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelRepeatableRead, ReadOnly: true})
// alle queries van deze ene opvraging via tx; aan het eind tx.Commit() (of Rollback: gelijkwaardig bij read-only)
- De queries zelf veranderen niet: nog steeds goedkoop, op
afvoer IS NULL(A blijft intact). Ze kijken alleen allemaal naar dezelfde versie van de database. - Kosten: een
BEGINen eenCOMMITper opvraging. Zo'n transactie blokkeert geen schrijvers, wordt zelf nooit geblokkeerd en kan niet op een serialisatiefout stuklopen (dat kan alleen bij schrijvende transacties). De momentopname wordt milliseconden vastgehouden. - Verwachting: geen meetbaar verschil in doorvoer. Meten, niet aannemen: sc 32 (alleen lezen) en sc 33 (lezen onder schrijflast) vóór en na, op de dikke seed.
Aanvulling: het antwoord zegt wat er gelezen is
Lees binnen dezelfde momentopname ook het hoogste zichtbare registratie-id
(SELECT max(id) FROM registratie) en geef dat mee in het antwoord (header, bv.
X-Register-Stand: <registratie-id>, eventueel met het bijbehorende tijdstip). De client weet dan
"dit is de stand tot en met registratie N" en kan die later met een echte tijdreis (?t=N)
reproduceren. Kost één lichte query; het filteren blijft op de afgeleide velden. Dit is wat er
overblijft van het eerdere idee "elke read een expliciet formeel leesmoment": wel benoemen,
niet erop filteren.
Overwogen en afgevallen
| Idee | Waarom niet |
|---|---|
| Elke read filtert op een expliciet moment t (eerste voorstel in deze bevinding) | Maakt van elke opvraging een tijdreis (B); precies wat we niet willen. Teruggetrokken |
| Na het lezen de geldigheden vergelijken met het opvraagmoment; "verdacht dichtbij" → opnieuw opvragen | Betrapt alleen scheefheid die sporen achterlaat in het resultaat. Is er tussen twee queries iets afgevoerd zónder opvolger, dan geeft de tweede query niets terug en valt er niets te vergelijken. In de synthetische tijdmodus loopt het registratietijdstip niet gelijk met de klok, dus "dichtbij" betekent daar niets. Blijft een vermoeden met herkansing, geen garantie |
| Bij het lezen in de mutatietabel kijken of er een registratie gaande is; dan wachten, fout geven, of wachten-met-timeout | Een lopende registratie is voor andere sessies onzichtbaar tot de commit; in de tabellen valt dus niet te zien dat er iets gaande is. Het kan alleen via locks, en dan worden het lezers die op schrijvers wachten: kost doorvoer en geeft nieuwe kansen op deadlocks. De rijversies van Postgres bestaan juist om dat te vermijden |
| Optimistische variant: hoogste registratie-id van deze entiteit vóór en na de opvraging lezen; verschilt het → opnieuw | Sluitend en zonder locks, dus een bruikbare terugvaloptie. Maar twee extra queries per opvraging en herkansingen onder schrijflast, waar de transactie nul extra queries kost |
| De verwachting in sc 32 versoepelen | Dan verdwijnt de melding, niet het probleem |
Aandachtspunt bij tijdreizen dicht bij nu (hoort bij B, niet bij deze fix)
In klokmodus wordt het registratietijdstip aan het begin van de registratie gezet, maar de
registratie wordt pas zichtbaar bij de commit. Een tijdreis naar een moment van een fractie
geleden kan daardoor later een ander antwoord geven: een trage registratie met een eerder tijdstip
moest nog committen. Het gevoel dat "heel dicht tegen nu" verdacht is, klopt dus, maar geldt voor
tijdreizen, niet voor de actuele opvraging. Mogelijke regels voor later: tijdreizen naar
t > nu − marge weigeren of markeren als voorlopig; of het tijdstip pas vlak vóór de commit
zetten. Apart beoordelen; niet nodig om bevinding 002 te sluiten.
Plan van aanpak (na de merge)
- Inventariseren welke handlers een samengesteld antwoord uit meerdere queries opbouwen:
/full/{padnaam}(detail en lijst,handlers/full_handlers.go: 7Relation()-ladingen plus de formele-tijdcache), de publicatieweergave, GraphQL-queries (dynql/query_resolvers.go), en enkelvoudige reads die daarna nog iets bijladen. - Eén helper, bv.
metLeesMomentopname(ctx, db, func(tx bun.Tx) error), die de transactie opent, het registratie-id van de stand leest en afsluit. Handlers geventxdoor in plaats vandb(bun.IDBdekt beide, dus de queryfuncties hoeven nauwelijks te veranderen). - Header
X-Register-Standzetten vanuit die helper. - Gerichte test die de scheefheid afdwingt: tussen twee queries van één opvraging een commit laten plaatsvinden (haak in de helper of een tweede verbinding in de test) en borgen dat het antwoord volledig oud óf volledig nieuw is.
- Meten met sc 32 en sc 33 op de dikke seed, vóór en na; resultaten in
docs/REGRESSIETEST.md(referentiecijfers). - Let op de connectiepool (bevinding 001): een opvraging houdt één verbinding vast voor de duur van de read. Dat is nu feitelijk ook zo, maar controleer sc 33 met 100 lezers.
Acceptatiecriteria na fix
- Sc 33 met standaardinstellingen: 0 fouten op «NP full», in ten minste 10 opeenvolgende runs.
- Zelfde met meerdere schrijvers op de dikke seed (
npTot=2000, 6 schrijvers, 16 lezers). - De gerichte test uit stap 4 slaagt, en faalt aantoonbaar zonder de transactie.
- Geen meetbare terugval in de lees-p95 van sc 32 (referentie: ~23 ms op 2000 NP's, ~2100 req/s).
- De queries filteren nog steeds op de afgeleide velden; er is geen tijdreislogica in het actuele leespad bijgekomen (A blijft intact).
- Het antwoord noemt de stand (registratie-id), en een tijdreis naar die stand geeft hetzelfde antwoord.
- De inventarisatie uit stap 1 is vastgelegd, met per read of hij is aangepast.
Verwant
test/2026-09-18-bevinding-001-…(connectiepool): één verbinding per read-transactie telt mee inDB_MAX_OPEN_CONNS.docs/plans/2026-09-21 Merge-notitie — …§3D: de fix die dit zichtbaar maakte.- Nog open uit dezelfde sessie: de hub-guard (
controleerBovenliggendeHubActief) geeft500bij opvoer onder een niet-actieve hub; hoort409of422te zijn (ziehandlers/db_conflict.govoor het patroon).