{"canonical_url":"https://engineer.company/da/glossary/event-sourcing/","content_markdown":"# Event sourcing\n\n## Hvad det er\n\nEvent sourcing er en måde at gemme data på, hvor beretningen om, hvad der er\nsket, er selve dataene. De fleste systemer har den aktuelle tilstand af en ordre\neller en konto liggende i en række og overskriver den ved hver ændring. Et\nsystem bygget med event sourcing gemmer i stedet ændringerne: hver af dem føjes\ntil en log som en hændelse, og den aktuelle tilstand regnes ud fra loggen, når\nder er brug for den. Martin Fowler, der beskrev mønstret i 2005, sammenfatter\ndet i én linje: »Capture all changes to an application state as a sequence of\nevents.«\n\nEn hændelse beskriver noget, der allerede er sket. Greg Youngs CQRS Documents\nkræver, at hver hændelse navngives med et udsagnsord i datid, for eksempel\n`CustomerRelocated` eller `CargoShipped`, fordi navnet er en del af det sprog,\nforretningen selv taler om sit arbejde med. Det, der er sket, kan ikke gøres\nugjort, så hændelser rettes og slettes aldrig. Young sammenligner loggen med en\nbogholders regnskabsbog: en forkert postering viskes ikke ud, den modposteres,\nog samme regel gælder for sletning. Lægger en kunde to par sokker i kurven og\ntager dem ud igen, får loggen en hændelse om, at de blev fjernet. Young kalder\nden slags en modpostering (reversal transaction): kurven ender, som om sokkerne\naldrig var lagt i, mens loggen stadig viser, at de var der.\n\nHændelserne ligger i strømme, én for hver ting, hvis tilstand de beskriver.\nYoung bygger på domænedrevet design og kalder tingen et aggregat. Hver hændelse\nbærer strømmens id og et versionsnummer, der er entydigt og fortløbende inden\nfor strømmen, så rækkefølgen aldrig er til diskussion. For at indlæse en ordre\nlæser systemet ordrens hændelser efter version og anvender dem én ad gangen.\nYoung gør opmærksom på, hvor lidt selve lageret skal kunne: i sin enkleste form\nhar det to operationer, nemlig at læse alle hændelser i én strøm i rækkefølge og\nat tilføje nye hændelser til den.\n\nDermed er loggen det autoritative register. Fowler skriver, at både loggen og\nden aktuelle tilstand kan være den officielle optegnelse. Med event sourcing er\ndet loggen, og alt andet, en tabel med aktuelle saldi, et søgeindeks, en\nrapport, er kopier afledt af den, som kan smides væk og bygges forfra.\n\n## Hvorfor det betyder noget\n\nFowler nævner tre ting, som en komplet log gør mulige. Fuld genopbygning: hele\napplikationens tilstand kan kasseres og genskabes ved at afspille alle hændelser\npå en tom applikation. Tidsforespørgsler: tilstanden på et vilkårligt tidspunkt\ner resultatet af at afspille hændelserne frem til dette tidspunkt. Og\ngenafspilning: viser en hændelse sig at være forkert, kan systemet rulle den og\nalle senere hændelser tilbage og afspille den rettede rækkefølge. Den samme log\ner desuden et revisionsspor, som ingen skulle huske at skrive, og Fowler peger\npå support og fejlfinding som oplagte anvendelser: supporten kan se præcis, hvad\nen bruger gjorde, og en udvikler kan afspille hændelserne fra produktion i et\ntestmiljø.\n\nYoung viser gevinsten med to teams hos en stor netbutik. Begge får til opgave at\nlave en rapport over varer, som kunderne lægger i kurven og tager ud igen.\nTeamet, der kun gemmer den aktuelle tilstand, begynder at registrere den slags\nnu, og rapporten har data fra den dag. Teamet, der gemmer hændelser, skriver den\nsamme rapportlogik og kører den over loggen fra begyndelsen, så den første\nrapport rækker flere år tilbage. Et spørgsmål, ingen tænkte på, da systemet blev\nbygget, kan stadig besvares, fordi systemet har gemt, hvad der skete, og ikke\nkun, hvad det endte med.\n\nHændelser er også den måde, andre systemer hører om en ændring på. Young\nbemærker, at mange systemer gemmer deres tilstand og derefter sender en hændelse\ntil en kø, hvilket strengt taget kræver en tofasecommit mellem de to, for går\nsystemet ned midt imellem, er de uenige. Hans alternativ er at lade\nhændelseslageret selv være køen: et løbenummer på hver hændelse lader en separat\nproces sende hændelserne videre i rækkefølge, så der kun er én skrivning. Og\nfordi lageret kun tilføjer, skalerer det lettere. Young påpeger, at et lager,\nder kun tilføjer, har langt færre låse at holde styr på end et, der opdaterer på\nstedet, og at aggregatets id er den eneste nøgle, et hændelseslager nogensinde\nskal partitioneres efter.\n\nOmkostningerne er reelle, og Fowler nævner dem selv. At pakke hver ændring ind\nsom en hændelse er en programmeringsstil, som ikke alle er trygge ved, og\nmønstret er meget svært at indføre bagefter i et system, der ikke er bygget til\ndet. Lageret svarer desuden kun på én slags spørgsmål, nemlig »giv mig denne\nstrøm«. Youngs eget eksempel er, at et hændelseslager ikke kan fortælle, hvilke\nbrugere der hedder Greg til fornavn. Den slags spørgsmål kræver en separat\nlæsemodel, bygget ud fra hændelserne, og derfor behandler Young event sourcing\nog CQRS, adskillelsen af modellerne til skrivning og læsning, som et par.\n\n## Sådan ser det ud i praksis\n\nDet mindste hændelseslager, der virker, er én tabel i PostgreSQL, tæt på det\nlayout, Young beskriver: et aggregat-id, hændelsens data og en version. Her\nholder den lagerbeholdningen for én vare til salg. Hver hændelse bærer en\nændring i antallet af enheder til salg og ikke det nye samlede antal, for den form er\nifølge Fowler den nemmeste at rulle tilbage: »læg ti til« fortrydes ved at\ntrække ti fra, mens »sæt til 110« har mistet den værdi, den erstattede.\n\n```sql\nCREATE TABLE stock_events (\n    item_id  text    NOT NULL,\n    version  integer NOT NULL,\n    event    text    NOT NULL,\n    order_id text,\n    units    integer NOT NULL,  -- ændring i enheder til salg\n    PRIMARY KEY (item_id, version)\n);\n\nINSERT INTO stock_events VALUES\n    ('item-881', 1, 'ItemStocked',   NULL,   100),\n    ('item-881', 2, 'UnitsHeld',     'A-17',  -2),\n    ('item-881', 3, 'HoldExpired',   'A-17',   2),\n    ('item-881', 4, 'UnitsHeld',     'B-02',  -1),\n    ('item-881', 5, 'HoldConfirmed', 'B-02',   0);\n\n-- aktuel tilstand: læg hele strømmen sammen\nSELECT sum(units) AS on_sale FROM stock_events\nWHERE item_id = 'item-881';                    -- 99\n\n-- tidsforespørgsel: varen, som den stod efter version 2\nSELECT sum(units) AS on_sale FROM stock_events\nWHERE item_id = 'item-881' AND version \u003c= 2;   -- 98\n```\n\nPrimærnøglen klarer det, Young kalder et optimistisk samtidighedstjek. To\ncheckout-forløb, der begge har læst strømmen ved version 5 og begge vil\nreservere en enhed, forsøger hver at tilføje version 6:\n\n```sql\nINSERT INTO stock_events VALUES ('item-881', 6, 'UnitsHeld', 'C-40', -1);\nINSERT INTO stock_events VALUES ('item-881', 6, 'UnitsHeld', 'D-11', -1);\n-- den anden fejler: (item-881, 6) findes allerede\n```\n\nPostgreSQL-dokumentationen beskriver en primærnøgle over flere kolonner som et\nkrav om, at kombinationen er entydig, og en indsættelse, der ville gentage den,\ngiver en fejl. Det forløb, der tabte, indlæser strømmen igen, ser efter, om der\nstadig er en enhed til salg, og prøver igen som version 7. Ingen af dem har\nsolgt en enhed, der ikke fandtes, og loggen viser begge beslutninger i den\nrækkefølge, de blev truffet.\n\nNoten\n[At sælge den sidste billet præcis én gang](/da/notes/selling-limited-stock-without-overselling/)\narbejder med det samme lagerproblem og viser, hvor denne form kommer under pres.\nDens første svar holder tallet i én række og ændrer det med én betinget\n`UPDATE`, og den fraråder optimistisk låsning på en varm tæller, fordi en\nversionskolonne gør kamp om rækken til gentagne forsøg. Til den mest\nefterspurgte vare lægger den hver forespørgsel på én Kafka-partition, som læses\naf en enkelt forbruger, der holder tallet i hukommelsen og gemmer sine\nafgørelser i batches, og den kalder det LMAX-formen. Fowlers artikel om\nLMAX-arkitekturen, som noten henviser til, beskriver event sourcing i sin\nreneste form: en handelsmotor helt uden database, hvis samlede tilstand kan\nudledes af de hændelser, den modtager, og som en journalfører gemmer varigt, så\nde kan afspilles igen. Notens checkout bruger hændelser af en anden slags. Hvert\ntrin skriver en besked i en outbox-tabel, change data capture sender den videre,\nog tabellerne er fortsat det autoritative register. Her annoncerer hændelserne\nændringer; i event sourcing er hændelserne registret.\n\n## Hvor det går galt\n\n**Genafspilning gentager sideeffekterne.** En handler, der sender en\nordrebekræftelse eller trækker et beløb på et kort, gør det igen, når loggen\nafspilles, og Fowler påpeger, at eksterne systemer ikke kan kende forskel på en\ngenafspilning og ægte behandling. En genopbygget læsemodel kan så sende hver\nkunde sidste års mails. Læg hvert eksternt system bag en gateway, der ved,\nhvornår applikationen afspiller, og som dropper udgående kald imens, så\ndomænelogikken aldrig behøver at vide det. Forespørgsler kræver samme omhu:\nFowlers eksempel er en valutaomregning, hvor en genafspillet hændelse skal bruge\nkursen fra sin egen dag og ikke dagens, så gatewayen bør gemme de svar, den fik,\nog levere dem igen under en genafspilning.\n\n**En travl strøm drukner i nye forsøg.** Optimistisk samtidighed forudsætter, at\nkonflikter er sjældne. Når mange skriver til den samme strøm samtidig, betyder\nhver konflikt, at strømmen skal indlæses igen, og ved en pludselig trafikstigning bliver de\ngentagne forsøg selve belastningen, som noten ovenfor advarer om. Skær\nstrømmene, så én sjældent har to skrivere på samme tid: én strøm pr. ordre frem\nfor én for en hel varegruppe. Hvor en enkelt strøm reelt er varm, så giv den én\nskriver, som i LMAX-designet, så der ikke er noget tilbage at kollidere om.\n\n**Lange strømme indlæses langsomt.** At afspille tusindvis af hændelser for at\nindlæse ét objekt koster tid ved hver forespørgsel, og Fowler nævner netop den\nlangsomme genopbygning som grunden til at gemme en kopi af den aktuelle\ntilstand. Youngs svar er det rullende øjebliksbillede (rolling snapshot): den\nserialiserede tilstand af en strøm ved en kendt version, lagt i sin egen tabel\nog skrevet i baggrunden af en separat proces, så indlæsning betyder det nyeste\nøjebliksbillede plus hændelserne efter dets version. Hold øjebliksbillederne ude\naf selve hændelsesloggen: Young beskriver, hvordan processen, der tager dem, på\nen travl strøm fejler sit samtidighedstjek igen og igen. Han anbefaler også at\nudvikle uden øjebliksbilleder, fordi de altid kan tilføjes senere for at gøre\nindlæsningen hurtigere.\n\n**Læsemodellerne halter efter.** Hver læsemodel bygges ud fra hændelserne, efter\nde er skrevet, så den ligger bag loggen. Fowler advarer om, at systemer, der\nlæser loggen, let kommer ud af trit med den, og en bruger, der sender en\nformular og derefter ser en liste uden ændringen, sender den igen. Lad hver\nlæsemodel registrere den seneste hændelse, den har anvendt, så forsinkelsen kan\nmåles og modellen kan bygges forfra, og vis brugeren resultatet af vedkommendes egen\nkommando ud fra kommandoens svar frem for fra en læsemodel, der kan være et\nskridt bagud.\n\n## Læs mere\n\n- [Event Sourcing](https://martinfowler.com/eaaDev/EventSourcing.html)\n  — Martin Fowlers beskrivelse af mønstret: fuld genopbygning,\n  tidsforespørgsler, genafspilning og gateways, der holder genafspilninger væk\n  fra andre systemer.\n- [CQRS Documents by Greg Young](https://cqrs.wordpress.com/wp-content/uploads/2010/11/cqrs_documents.pdf)\n  — hændelser som fakta i datid, modpostering i stedet for sletning, et\n  hændelseslager i to tabeller, rullende øjebliksbilleder og lageret som kø.\n- [The LMAX Architecture](https://martinfowler.com/articles/lmax.html)\n  — en handelsmotor i hukommelsen, hvis samlede tilstand udledes af journalførte\n  inputhændelser.\n- [PostgreSQL: Constraints](https://www.postgresql.org/docs/current/ddl-constraints.html)\n  — entydigheds- og primærnøglebegrænsninger over flere kolonner, databasens\n  halvdel af et optimistisk samtidighedstjek.\n\n\u003chttps://engineer.company/da/glossary/event-sourcing/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvordan event sourcing gemmer hver ændring som en hændelse og udleder tilstanden af loggen, hvad det giver et team, og fire måder, det går galt på.","formats":{"gemtext":"https://engineer.company/da/glossary/event-sourcing/index.gmi","gopher":"https://engineer.company/da/glossary/event-sourcing/gophermap","html":"https://engineer.company/da/glossary/event-sourcing/","json":"https://engineer.company/da/glossary/event-sourcing/index.json","markdown":"https://engineer.company/da/glossary/event-sourcing/index.md","pdf":"https://engineer.company/da/glossary/event-sourcing/index.pdf"},"kind":"page","language":"da","title":"Hvad er event sourcing?","url":"https://engineer.company/da/glossary/event-sourcing/","version":1}