What is event sourcing?

How does event sourcing work?

In a system based on Event Sourcing:

• Commands (Commands): Incoming commands (state change intentions) are validated by the aggregator.
• Event generation: If the command is correct, the aggregator generates one or more domain events describing the fact that a state change has occurred (e.g. OrderSubmitted, DeliveryAddressChanged, ProductAddedToCart). The events are past facts and are immutable.
• Event Store: Generated events are stored in a special event store (Event Store) in the order in which they occur. The Event Store works like an append-only log.
• Aggregate state update: The aggregate updates its internal state by applying the logic contained in the handling of the newly generated event.
• State playback: To get the current state of an aggregate (e.g., when handling the next command), the system reads all events related to that aggregate from the Event Store and replays them one by one, applying state changes. For optimization purposes, snapshots mechanisms are often used, saving the full state of the aggregate periodically.
• Event publication: Recorded events can be published to other parts of the system (e.g., through a message broker), which can respond to them (e.g., by updating reading models in the CQRS architecture).

Benefits of event sourcing

There are a number of benefits to using the Event Sourcing pattern:

• Full History of Changes (Audit Log): Keeping a full history of events provides a natural audit log to track exactly how the state of the aggregate has changed over time and why.
• Ability to recreate past state: It is easy to recreate the state of the system from any point in the past, which is useful for debugging, analysis or testing.
• Flexibility in creating read models: Recorded events can be used to build many different read models (projections), optimized for different analytical needs or views in the application, without affecting the write model.
• High write performance: Writing events to the append-only log is usually a very fast operation.
• Natural support for event-driven architecture (EDA): Event Sourcing fits perfectly with EDA, where events are the primary communication mechanism.
• Facilitated debugging and error cause analysis: Full event history makes it easier to understand what led to the erroneous condition.

Challenges and complexities of event sourcing

The implementation of Event Sourcing also comes with some challenges:

• Conceptual complexity: It is a more complex pattern to understand and implement than the traditional approach based on storing the current state.
• Status playback: Recreating state from a long history of events can be time-consuming. This requires the use of optimizations such as snapshots.
• Versioning of events and patterns: As the system evolves, the structure of events may change. It is necessary to implement mechanisms for handling different versions of events (event schema versioning).
• Event Store Management: The event store is becoming a key component of the system and requires proper management, scaling and backup.
• Eventual Consistency: In distributed systems where events are propagated asynchronously, reading models can be updated with some delay (eventual consistency).

When to use event sourcing?

Event Sourcing is particularly valuable in systems where:

• It is crucial to have a complete history of state changes (audit).
• There is a need to recreate the state of the past.
• A great deal of flexibility is required to create different views of the data (reading models).
• The system architecture is event-driven (EDA).
• We are dealing with complex business logic and the need for cause-and-effect analysis.

It is often used in conjunction with the CQRS template.

Summary

Event Sourcing is a powerful architectural pattern that changes the way we think about application state management by focusing on recording the history of events rather than just the current state. It offers unique benefits in terms of auditing, flexibility and analysis, but it also introduces additional complexity. It is an advanced technique that can provide significant benefits in properly selected applications.