Why streams handle event logs in Redis - Visual Breakdown

Concept Flow - Why streams handle event logs

Event Occurs

↓

Create Event Entry

↓

Append Entry to Stream

↓

Stream Stores Ordered Events

↓

Consumers Read Events in Order

↓

Process or Archive Events

Events happen and are recorded as entries appended to a stream. The stream keeps events in order so consumers can read and process them sequentially.

Execution Sample

Redis

XADD mystream * event_type login user_id 123
XADD mystream * event_type logout user_id 123
XRANGE mystream - +

Add two event entries to a Redis stream and then read all events in order.

Execution Table

Step	Command	Action	Stream State	Output
1	XADD mystream * event_type login user_id 123	Add login event	[{id: 1680000000000-0, event_type: login, user_id: 123}]	1680000000000-0
2	XADD mystream * event_type logout user_id 123	Add logout event	[{id: 1680000000000-0, ...}, {id: 1680000000001-0, event_type: logout, user_id: 123}]	1680000000001-0
3	XRANGE mystream - +	Read all events	[{id: 1680000000000-0, ...}, {id: 1680000000001-0, ...}]	[{id: 1680000000000-0, event_type: login, user_id: 123}, {id: 1680000000001-0, event_type: logout, user_id: 123}]
4	End	No more commands	[{id: 1680000000000-0, ...}, {id: 1680000000001-0, ...}]	Execution complete

💡 All events added and read; stream maintains order and stores event logs.

Variable Tracker

Variable	Start	After 1	After 2	Final
mystream	empty	[{1680000000000-0: login event}]	[{1680000000000-0: login event}, {1680000000001-0: logout event}]	[{1680000000000-0: login event}, {1680000000001-0: logout event}]

Key Moments - 2 Insights

Why does the stream keep events in order?

Because each event is appended with a unique increasing ID (timestamp-based), the stream stores events sequentially as shown in execution_table rows 1 and 2.

How do consumers know which events to read next?

Consumers read events by their IDs in order, as shown in execution_table row 3 where XRANGE reads all events from oldest to newest.

Visual Quiz - 3 Questions

Look at the execution_table, what is the stream state after the first XADD command?

A One event with event_type login

B Two events: login and logout

C Empty stream

D Stream deleted

💡 Hint

Check execution_table row 1 under Stream State

At which step does the stream contain two events?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at execution_table rows 1 and 2 Stream State column

If a new event is added after step 2, how would the stream state change?

A It would remain the same

B It would remove the first event

C It would have three ordered events

D It would overwrite the last event

💡 Hint

Streams append events, so new events add to the end as shown in variable_tracker

Concept Snapshot

Redis streams store event logs by appending entries with unique IDs.
Each event is kept in order for reliable processing.
Consumers read events sequentially using XRANGE or XREAD.
Streams are ideal for event logging and messaging.
They keep data immutable and ordered for audit and replay.

Full Transcript

Redis streams handle event logs by appending each event as a new entry with a unique timestamp-based ID. This keeps events in the order they occurred. When an event happens, it is added to the stream using the XADD command. Consumers can then read these events in order using commands like XRANGE. This ordered, append-only structure makes streams perfect for logging events reliably and processing them sequentially. The execution trace shows adding two events and reading them back, demonstrating how streams maintain order and store event data.