Event sourcing is een architecturale benadering waarbij de volledige geschiedenis van alle wijzigingen in een systeem wordt opgeslagen als een opeenvolging van gebeurtenissen. In plaats van de huidige status direct op te slaan, wordt elke wijziging vastgelegd als een gebeurtenis, waardoor je de volledige geschiedenis kunt reconstrueren en auditeren. **Structuur van gebeurtenisopslag** - **Events**: Kleine, onveranderlijke objecten die een specifieke actie of verandering representeren, bijvoorbeeld `GebruikerAangemaakt`, `GebruikerLogIn`, `ProfielGewijzigd`. - **Event Store**: Een database (bijvoorbeeld een NoSQL-database, een relationele database met een tabel voor gebeurtenissen, of een gespecialiseerde event store zoals EventStoreDB) waarin alle gebeurtenissen worden opgeslagen. Elk event bevat: - Een unieke ID - Een timestamp - Het type gebeurtenis - De payload met gegevens - Een referentie naar de aggregate (bijvoorbeeld gebruikers-ID) **Hoe gebeurtenissen te modelleren** - Definieer duidelijke event-structuren, bijvoorbeeld in Go: ```go type Gebeurtenis interface { GetType() string GetTijdstip() time.Time } type GebruikerAangemaakt struct { GebruikerID string Naam string Email string Tijdstip time.Time } func (e GebruikerAangemaakt) GetType() string { return "GebruikerAangemaakt" } func (e GebruikerAangemaakt) GetTijdstip() time.Time { return e.Tijdstip } ``` - Events moeten alle benodigde informatie bevatten om de status te kunnen reconstrueren. **Status reconstrueren uit gebeurtenissen** - Om de actuele status van een gebruiker te krijgen, haal je alle gebeurtenissen op die relevant zijn voor die gebruiker. - Pas deze gebeurtenissen in de juiste volgorde toe op een initiële lege toestand: ```go type GebruikerStatus struct { GebruikerID string Naam string Email string Actief bool } func RebuildGebruikerStatus(events []Gebeurtenis) GebruikerStatus { status := GebruikerStatus{} for _, event := range events { switch e := event.(type) { case GebruikerAangemaakt: status.GebruikerID = e.GebruikerID status.Naam = e.Naam status.Email = e.Email status.Actief = true case GebruikerUitgeschakeld: status.Actief = false // Voeg andere cases toe voor meer gebeurtenissen } } return status } ``` - Door deze methode te gebruiken, kun je altijd de actuele toestand afleiden uit de volledige gebeurtenishistorie. **Implementatie in je Go-toepassing** - Implementeer een event store (bijvoorbeeld met een database als PostgreSQL of MongoDB). - Maak functies om gebeurtenissen te registreren (persisten) en op te halen. - Gebruik aggregaten die gebeurtenissen verwerken en de status bepalen. - Bij elke gebruikersactie wordt een nieuwe gebeurtenis gecreëerd en opgeslagen. - Voor het lezen van de huidige status, haal alle relevante gebeurtenissen op en rebuild de status. **Kort samengevat** - Event sourcing legt alle wijzigingen vast als gebeurtenissen. - De opslag is een chronologische lijst van gebeurtenissen. - Gebeurtenissen modelleren voor elke actie. - De actuele status wordt gereconstrueerd door gebeurtenissen toe te passen in volgorde. - In een webapplicatie voor het volgen van gebruikersacties zorgt dit voor volledige traceerbaarheid en flexibiliteit. Als je meer specifieke codevoorbeelden of implementatietips wilt, vraag gerust!

Zeker, ik leg het concept van event sourcing uit en hoe je dit kunt implementeren in een Go-toepassing voor het volgen van gebruikersacties. ## Wat is Event Sourcing? Event Sourcing is een architectuurpatroon waarbij state veranderingen worden opgeslagen als een reeks gebeurtenissen (events) in plaats van alleen de huidige state. Elke gebeurtenis vertegenwoordigt een state mutatie en de huidige state kan worden gereconstrueerd door alle gebeurtenissen in volgorde af te spelen. ## Gebeurtenisopslag Structuur ```go package main import ( "encoding/json" "time" ) // Gebeurtenis interface type Event interface { GetAggregateID() string GetType() string GetTimestamp() time.Time GetVersion() int } // Basis gebeurtenis struct type BaseEvent struct { AggregateID string `json:"aggregate_id"` Type string `json:"type"` Timestamp time.Time `json:"timestamp"` Version int `json:"version"` } func (b BaseEvent) GetAggregateID() string { return b.AggregateID } func (b BaseEvent) GetType() string { return b.Type } func (b BaseEvent) GetTimestamp() time.Time { return b.Timestamp } func (b BaseEvent) GetVersion() int { return b.Version } // Event Store interface type EventStore interface { Save(events []Event) error Load(aggregateID string) ([]Event, error) LoadAll() ([]Event, error) } ``` ## Gebeurtenissen Modelleren ```go // Specifieke gebeurtenissen voor gebruikersacties type UserRegistered struct { BaseEvent UserID string `json:"user_id"` Email string `json:"email"` Username string `json:"username"` } type UserLoggedIn struct { BaseEvent UserID string `json:"user_id"` IPAddress string `json:"ip_address"` UserAgent string `json:"user_agent"` } type UserProfileUpdated struct { BaseEvent UserID string `json:"user_id"` Field string `json:"field"` OldValue string `json:"old_value"` NewValue string `json:"new_value"` } type UserActionPerformed struct { BaseEvent UserID string `json:"user_id"` Action string `json:"action"` Resource string `json:"resource"` Metadata map[string]interface{} `json:"metadata"` } ``` ## Implementatie van Event Store ```go package main import ( "encoding/json" "fmt" "sort" "sync" "time" ) // In-memory event store (voor demo, in productie gebruik database) type InMemoryEventStore struct { events map[string][]Event mu sync.RWMutex } func NewInMemoryEventStore() *InMemoryEventStore { return &InMemoryEventStore{ events: make(map[string][]Event), } } func (store *InMemoryEventStore) Save(events []Event) error { store.mu.Lock() defer store.mu.Unlock() for _, event := range events { aggregateID := event.GetAggregateID() store.events[aggregateID] = append(store.events[aggregateID], event) } return nil } func (store *InMemoryEventStore) Load(aggregateID string) ([]Event, error) { store.mu.RLock() defer store.mu.RUnlock() events, exists := store.events[aggregateID] if !exists { return []Event{}, nil } // Sorteer events op timestamp sortedEvents := make([]Event, len(events)) copy(sortedEvents, events) sort.Slice(sortedEvents, func(i, j int) bool { return sortedEvents[i].GetTimestamp().Before(sortedEvents[j].GetTimestamp()) }) return sortedEvents, nil } func (store *InMemoryEventStore) LoadAll() ([]Event, error) { store.mu.RLock() defer store.mu.RUnlock() var allEvents []Event for _, events := range store.events { allEvents = append(allEvents, events...) } // Sorteer alle events op timestamp sort.Slice(allEvents, func(i, j int) bool { return allEvents[i].GetTimestamp().Before(allEvents[j].GetTimestamp()) }) return allEvents, nil } ``` ## Application State en Reconstructie ```go // User aggregate type User struct { ID string `json:"id"` Email string `json:"email"` Username string `json:"username"` LastLogin time.Time `json:"last_login"` LoginCount int `json:"login_count"` Profile map[string]string `json:"profile"` Actions []UserAction `json:"actions"` Version int `json:"version"` } type UserAction struct { Action string `json:"action"` Resource string `json:"resource"` Timestamp time.Time `json:"timestamp"` Metadata map[string]interface{} `json:"metadata"` } // User projection (state reconstructie) type UserProjection struct { eventStore EventStore } func NewUserProjection(eventStore EventStore) *UserProjection { return &UserProjection{ eventStore: eventStore, } } func (p *UserProjection) ReconstructUserState(userID string) (*User, error) { events, err := p.eventStore.Load(userID) if err != nil { return nil, err } user := &User{ ID: userID, Profile: make(map[string]string), Actions: []UserAction{}, } for _, event := range events { p.applyEvent(user, event) } return user, nil } func (p *UserProjection) applyEvent(user *User, event Event) { switch e := event.(type) { case *UserRegistered: user.ID = e.UserID user.Email = e.Email user.Username = e.Username user.Version = e.Version case *UserLoggedIn: user.LastLogin = e.Timestamp user.LoginCount++ user.Version = e.Version case *UserProfileUpdated: user.Profile[e.Field] = e.NewValue user.Version = e.Version case *UserActionPerformed: userAction := UserAction{ Action: e.Action, Resource: e.Resource, Timestamp: e.Timestamp, Metadata: e.Metadata, } user.Actions = append(user.Actions, userAction) user.Version = e.Version } } ``` ## Gebruiksvoorbeeld ```go package main import ( "fmt" "time" ) func main() { // Initialisatie eventStore := NewInMemoryEventStore() userProjection := NewUserProjection(eventStore) // Gebruiker registratie registerEvent := &UserRegistered{ BaseEvent: BaseEvent{ AggregateID: "user-123", Type: "UserRegistered", Timestamp: time.Now(), Version: 1, }, UserID: "user-123", Email: "gebruiker@voorbeeld.nl", Username: "johndoe", } // Gebruiker login loginEvent := &UserLoggedIn{ BaseEvent: BaseEvent{ AggregateID: "user-123", Type: "UserLoggedIn", Timestamp: time.Now().Add(5 * time.Minute), Version: 2, }, UserID: "user-123", IPAddress: "192.168.1.100", UserAgent: "Mozilla/5.0...", } // Profiel update profileEvent := &UserProfileUpdated{ BaseEvent: BaseEvent{ AggregateID: "user-123", Type: "UserProfileUpdated", Timestamp: time.Now().Add(10 * time.Minute), Version: 3, }, UserID: "user-123", Field: "name", OldValue: "", NewValue: "John Doe", } // Gebruikersactie actionEvent := &UserActionPerformed{ BaseEvent: BaseEvent{ AggregateID: "user-123", Type: "UserActionPerformed", Timestamp: time.Now().Add(15 * time.Minute), Version: 4, }, UserID: "user-123", Action: "VIEW_PRODUCT", Resource: "product-456", Metadata: map[string]interface{}{ "product_name": "Laptop", "category": "Electronics", }, } // Events opslaan events := []Event{registerEvent, loginEvent, profileEvent, actionEvent} eventStore.Save(events) // State reconstrueren user, err := userProjection.ReconstructUserState("user-123") if err != nil { panic(err) } // Resultaat tonen fmt.Printf("Gebruiker: %s\n", user.Username) fmt.Printf("Email: %s\n", user.Email) fmt.Printf("Aantal logins: %d\n", user.LoginCount) fmt.Printf("Laatste login: %s\n", user.LastLogin.Format(time.RFC3339)) fmt.Printf("Profiel naam: %s\n", user.Profile["name"]) fmt.Printf("Aantal acties: %d\n", len(user.Actions)) for _, action := range user.Actions { fmt.Printf("Actie: %s op %s\n", action.Action, action.Resource) } } ``` ## Voordelen voor Gebruikersacties Tracking 1. **Compleet audit trail**: Elke gebruikersactie wordt permanent vastgelegd 2. **Tijdreizen**: Je kunt de state van elk moment in de tijd reconstrueren 3. **Debugging**: Makkelijk te traceren welke acties tot welke state hebben geleid 4. **Flexibiliteit**: Nieuwe projecties kunnen worden toegevoegd zonder bestaande data te wijzigen ## Productie-aanbevelingen - Gebruik een persistente database (PostgreSQL, MongoDB) voor event storage - Implementeer snapshotting voor grote aggregates - Gebruik versioning voor schema evolutie - Overweeg CQRS voor lees- en schrijfoptimalisaties Deze implementatie biedt een solide basis voor het tracken van gebruikersacties met event sourcing in Go.