{"canonical_url":"https://engineer.company/sv/glossary/event-sourcing/","content_markdown":"# Event sourcing\n\n## Vad det är\n\nEvent sourcing är ett sätt att lagra data där berättelsen om vad som har hänt är\nsjälva datan. De flesta system har det aktuella tillståndet för en order eller\nett konto i en rad och skriver över det vid varje ändring. Ett system byggt med\nevent sourcing sparar i stället ändringarna: var och en läggs till i en logg som\nen händelse, och det aktuella tillståndet räknas fram ur loggen när det behövs.\nMartin Fowler, som beskrev mönstret 2005, sammanfattar det på en rad: ”Capture\nall changes to an application state as a sequence of events.”\n\nEn händelse beskriver något som redan har hänt. Greg Youngs CQRS Documents\nkräver att varje händelse namnges med ett verb i preteritum, till exempel\n`CustomerRelocated` eller `CargoShipped`, eftersom namnet är en del av det språk\nverksamheten själv använder om sitt arbete. Det som har hänt går inte att göra\nogjort, så händelser ändras och raderas aldrig. Young jämför loggen med en\nbokförares huvudbok: en felaktig post suddas inte ut utan rättas med en ny, och\nsamma regel gäller för radering. Lägger en kund två par strumpor i varukorgen\noch tar ut dem igen, får loggen en händelse om att de togs bort. Young kallar en\nsådan post en reversering (reversal transaction): korgen blir som om strumporna\naldrig hade lagts i, medan loggen fortfarande visar att de fanns där.\n\nHändelserna ligger i strömmar, en för varje sak vars tillstånd de beskriver.\nYoung bygger på domändriven design och kallar saken ett aggregat. Varje händelse\nbär strömmens id och ett versionsnummer som är unikt och löpande inom strömmen,\nså att ordningen aldrig är oklar. För att läsa in en order läser systemet\norderns händelser efter version och tillämpar dem en i taget. Young påpekar hur\nlite själva lagret behöver kunna: i sin enklaste form har det två operationer,\natt läsa alla händelser i en ström i ordning och att lägga till nya händelser i\nden.\n\nDärmed är loggen det auktoritativa registret. Fowler skriver att både loggen och\ndet aktuella tillståndet kan vara den officiella uppteckningen. Med event\nsourcing är det loggen, och allt annat, en tabell med aktuella saldon, ett\nsökindex, en rapport, är kopior härledda ur den som kan kastas och byggas upp\nigen.\n\n## Varför det spelar roll\n\nFowler nämner tre saker som en fullständig logg gör möjliga. Fullständig\nåteruppbyggnad: hela applikationens tillstånd kan kastas och återskapas genom\natt alla händelser spelas upp på en tom applikation. Tidsfrågor: tillståndet vid\nvilken tidpunkt som helst är resultatet av att spela upp händelserna fram till\nden tidpunkten. Och omspelning: visar sig en händelse vara fel kan systemet\nbacka den och alla senare händelser och sedan spela upp den rättade\nordningsföljden. Samma logg är dessutom ett revisionsspår som ingen behövde\nkomma ihåg att skriva, och Fowler lyfter fram support och felsökning som\nsjälvklara användningar: supporten kan se exakt vad en användare gjorde, och en\nutvecklare kan spela upp händelserna från produktion i en testmiljö.\n\nYoung visar vinsten med två team på en stor näthandel. Båda får i uppdrag att ta\nfram en rapport över varor som kunderna lägger i varukorgen och tar ut igen.\nTeamet som bara sparar aktuellt tillstånd börjar registrera sådant nu, och\nrapporten har data från den dagen. Teamet som sparar händelser skriver samma\nrapportlogik och kör den över loggen från början, så den första rapporten\nsträcker sig flera år bakåt. En fråga som ingen tänkte på när systemet byggdes\ngår ändå att besvara, eftersom systemet sparade vad som hände och inte bara vad\ndet slutade med.\n\nHändelser är också sättet som andra system får veta om en ändring på. Young\nkonstaterar att många system sparar sitt tillstånd och sedan skickar en händelse\ntill en kö, vilket strängt taget kräver en tvåfascommit mellan de två, för går\nsystemet ner mittemellan är de oense. Hans alternativ är att låta händelselagret\nsjälvt vara kön: ett löpnummer på varje händelse låter en separat process skicka\nvidare händelserna i ordning, så att det bara blir en skrivning. Och eftersom\nlagret bara lägger till skalar det lättare. Young påpekar att ett lager som bara\nlägger till har betydligt färre lås att hålla reda på än ett som uppdaterar på\nplats, och att aggregatets id är den enda nyckel ett händelselager någonsin\nbehöver partitioneras efter.\n\nKostnaderna är verkliga, och Fowler nämner dem själv. Att paketera varje ändring\nsom en händelse är en programmeringsstil som inte alla känner sig bekväma med,\noch mönstret är mycket svårt att införa i efterhand i ett system som inte är\nbyggt för det. Lagret svarar dessutom bara på en sorts fråga, nämligen ”ge mig\nden här strömmen”. Youngs eget exempel är att ett händelselager inte kan tala om\nvilka användare som heter Greg i förnamn. Sådana frågor kräver en separat\nläsmodell, byggd ur händelserna, och därför behandlar Young event sourcing och\nCQRS, uppdelningen av modellerna för skrivning och läsning, som ett par.\n\n## Så ser det ut i praktiken\n\nDet minsta händelselager som fungerar är en tabell i PostgreSQL, nära den\nuppställning Young beskriver: ett aggregat-id, händelsens data och en version.\nHär håller den lagersaldot för en vara som säljs. Varje händelse bär en ändring\nav antalet enheter till försäljning och inte den nya summan, eftersom den formen\nenligt Fowler är den enklaste att backa: ”lägg till tio” upphävs genom att dra\nifrån tio, medan ”sätt till 110” har tappat värdet det ersatte.\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 av enheter till salu\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-- aktuellt tillstånd: summera hela strömmen\nSELECT sum(units) AS on_sale FROM stock_events\nWHERE item_id = 'item-881';                    -- 99\n\n-- tidsfråga: varan 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ärnyckeln gör det jobb som Young ger en optimistisk samtidighetskontroll.\nTvå kassaflöden som båda har läst strömmen vid version 5 och båda vill reservera\nen enhet försöker vart och ett lägga till 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 andra misslyckas: (item-881, 6) finns redan\n```\n\nPostgreSQL-dokumentationen beskriver en primärnyckel över flera kolumner som ett\nkrav på att kombinationen är unik, och en insättning som skulle upprepa den ger\nett fel. Kassaflödet som förlorade läser in strömmen igen, kontrollerar att det\nfortfarande finns en enhet till salu och försöker på nytt som version 7. Inget\nav dem har sålt en enhet som inte fanns, och loggen visar båda besluten i den\nordning de fattades.\n\nAnteckningen\n[Att sälja den sista biljetten exakt en gång](/sv/notes/selling-limited-stock-without-overselling/)\narbetar med samma lagerproblem och visar var den här formen blir trång. Dess\nförsta svar håller antalet i en rad och ändrar det med en enda villkorad\n`UPDATE`, och den avråder från optimistisk låsning på en het räknare, eftersom\nen versionskolumn gör kampen om raden till nya försök. För den mest efterfrågade\nvaran lägger den varje förfrågan på en Kafka-partition, som läses av en enda\nkonsument som håller antalet i minnet och sparar sina beslut i omgångar, och den\nkallar det LMAX-formen. Fowlers artikel om LMAX-arkitekturen, som anteckningen\nhänvisar till, beskriver event sourcing i dess renaste form: en handelsmotor\nhelt utan databas, vars hela tillstånd kan härledas ur de händelser den tar emot\noch som en journalförare sparar beständigt så att de kan spelas upp igen.\nAnteckningens kassaflöde använder händelser av ett annat slag. Varje steg\nskriver ett meddelande i en outbox-tabell, change data capture skickar det\nvidare, och tabellerna förblir det auktoritativa registret. Där meddelar\nhändelserna ändringar; i event sourcing är händelserna registret.\n\n## Var det går fel\n\n**Omspelning upprepar sidoeffekterna.** En hanterare som skickar en\norderbekräftelse eller drar pengar från ett kort gör det igen när loggen spelas\nupp, och Fowler påpekar att externa system inte kan skilja en omspelning från\nverklig behandling. En återuppbyggd läsmodell kan då skicka förra årets mejl\ntill varje kund. Lägg varje externt system bakom en gateway som vet när\napplikationen spelar upp och som stoppar utgående anrop under tiden, så att\ndomänlogiken aldrig behöver veta om det. Frågor kräver samma omsorg: Fowlers\nexempel är en valutaomräkning, där en omspelad händelse måste använda kursen\nfrån sin egen dag och inte dagens, så gatewayen bör spara svaren den fick och\nlämna dem igen under en omspelning.\n\n**En livlig ström drunknar i nya försök.** Optimistisk samtidighet förutsätter\natt konflikter är sällsynta. När många skriver till samma ström samtidigt\nbetyder varje konflikt att strömmen måste läsas in igen, och vid en plötslig trafikökning blir\nde nya försöken själva belastningen, precis som anteckningen ovan varnar för.\nDela upp strömmarna så att en sällan har två skribenter samtidigt: en ström per\norder snarare än en för en hel varugrupp. Där en enskild ström verkligen är het,\nge den en enda skribent, som i LMAX-designen, så att det inte finns något kvar\natt krocka om.\n\n**Långa strömmar läses in långsamt.** Att spela upp tusentals händelser för att\nläsa in ett objekt kostar tid vid varje anrop, och Fowler nämner just den\nlångsamma återuppbyggnaden som skälet att spara en kopia av det aktuella\ntillståndet. Youngs svar är den rullande ögonblicksbilden (rolling snapshot):\ndet serialiserade tillståndet för en ström vid en känd version, lagt i en egen\ntabell och skrivet i bakgrunden av en separat process, så att inläsning betyder\nden senaste ögonblicksbilden plus händelserna efter dess version. Håll\nögonblicksbilderna utanför själva händelseloggen: Young beskriver hur processen\nsom tar dem misslyckas med sin samtidighetskontroll om och om igen på en livlig\nström. Han rekommenderar också att bygga utan ögonblicksbilder, eftersom de\nalltid kan läggas till senare för att göra inläsningen snabbare.\n\n**Läsmodellerna släpar efter.** Varje läsmodell byggs ur händelserna efter att\nde har skrivits, så den ligger efter loggen. Fowler varnar för att system som\nläser loggen lätt kommer i otakt med den, och en användare som skickar ett\nformulär och sedan ser en lista utan ändringen skickar det igen. Låt varje\nläsmodell registrera den senaste händelse den har tillämpat, så att\neftersläpningen kan mätas och modellen kan byggas om från början, och visa\nanvändaren resultatet av användarens eget kommando utifrån kommandots svar snarare än\nfrån en läsmodell som kanske inte har hunnit ikapp.\n\n## Läs mer\n\n- [Event Sourcing](https://martinfowler.com/eaaDev/EventSourcing.html)\n  — Martin Fowlers beskrivning av mönstret: fullständig återuppbyggnad,\n  tidsfrågor, omspelning och gatewayer som håller omspelningar borta från andra\n  system.\n- [CQRS Documents by Greg Young](https://cqrs.wordpress.com/wp-content/uploads/2010/11/cqrs_documents.pdf)\n  — händelser som fakta i preteritum, reversering i stället för radering, ett\n  händelselager i två tabeller, rullande ögonblicksbilder och lagret som kö.\n- [The LMAX Architecture](https://martinfowler.com/articles/lmax.html)\n  — en handelsmotor i minnet vars hela tillstånd härleds ur journalförda\n  indatahändelser.\n- [PostgreSQL: Constraints](https://www.postgresql.org/docs/current/ddl-constraints.html)\n  — unikhets- och primärnyckelvillkor över flera kolumner, databasens halva av\n  en optimistisk samtidighetskontroll.\n\n\u003chttps://engineer.company/sv/glossary/event-sourcing/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur event sourcing sparar varje ändring som en händelse och härleder tillståndet ur loggen, vad det ger ett team och fyra sätt det går fel på.","formats":{"gemtext":"https://engineer.company/sv/glossary/event-sourcing/index.gmi","gopher":"https://engineer.company/sv/glossary/event-sourcing/gophermap","html":"https://engineer.company/sv/glossary/event-sourcing/","json":"https://engineer.company/sv/glossary/event-sourcing/index.json","markdown":"https://engineer.company/sv/glossary/event-sourcing/index.md","pdf":"https://engineer.company/sv/glossary/event-sourcing/index.pdf"},"kind":"page","language":"sv","title":"Vad är event sourcing?","url":"https://engineer.company/sv/glossary/event-sourcing/","version":1}