Events. Events. Events!

My talk about event sourcing in ruby from wrocloverb (https://wrocloverb.com)

Transcript

3. 3 days of afterparty
6. Hello Wroclaw.rb
7. Fist time in Poland
10. What I know now
11. Pierogi
12. Pelmeni -> Pierogi z mięsem Varenyky -> Pierogi ruskie
13. Best state machine implementation
14. class State def method_missing(method, *args, &block) eval(method.to_s.capitalize).send(:new) end end class Created < State; end class Open < State; end class Closed < State; end
15. Event Sourcing is popular
17. Memes is not
19. Autoload is still
20. Awesome people and community
21. Anton Davydov github.com/davydovanton
 twitter.com/anton_davydov davydovanton.com
23. • Software developer at Hippo • OpenSource evangelist • Hanami core developer • Try to make own product • Technical consulting
24. Stickers
25. • Coffee • Beer • Psychology • SW-2039-0208-4228 • How to draw images for presentations • Bad stories
26. • Coffee • Beer • Psychology • SW-2039-0208-4228 • How to draw images for presentations • Bad stories
27. Tried to be writer and make a story
28. expectations
29. reality
30. But I got help from my friend
31. Meet George
32. He is quiet and love ask questions
35. Events
39. Git
40. Each commit - something which was happened
42. Each commit contain description and changes (payload)
44. What happened
45. Payload
46. List of cart items which user deleted and added
47. Activity audit
48. Don’t delete deleted data
49. deleted_at
50. But usually we’re working with current state of application
51. actions -> events data in DB -> current state
52. actions -> events data in DB -> current state
53. Knok knok ▼ George
54. … ▼ George
55. What will happen if we change it? ▼ George
56. Store events ▼ George
57. And calculate current state when we need it ▼ George
58. Event Sourcing
59. Store what was happened instead current state
60. And get state when you need
61. Where to store?
62. Event storage
63. Can be anything
65. Rules
66. Event was happened
67. Immutable events
68. Can’t delete or update event
72. Only valid data in the events
78. Data evolution
84. Stop ▼ George
85. We can break the app! ▼ George
86. >_< ▼ George
87. Pro tips: optional fields, binary data structures
88. more in the book
89. How to get state from event store?
90. We need to calculate it using current event list
91. Projections
92. project(projection, events, init_state) -> state
93. project(projection, events, init_state) -> state same as a block in ruby’s enumerator
94. project(projection, events, init_state) -> state pure function
107. We’re compile current state for all events each time
108. … ▼ George
109. We can’t store all data for last 10 years ▼ George
110. And will have a performance issues for getting current state ▼ George
111. How to fix it?
112. Streams!
114. Event bus#1 Event bus#1 Event bus#2 Event bus#1 Event bus#2 Event bus#2
115. Event stream: bus#1 Event stream: bus#1 Event stream: bus#2 Event stream: bus#1 Event stream: bus#2 Event stream: bus#2
116. Stream: bus#1
 Event stream: bus#1 Event stream: bus#1 Event stream: bus#1
117. Stream: bus#2
 Event stream: bus#2 Event stream: bus#2 Event stream: bus#2
118. Pros: less events for processing
119. Cons: one more abstraction
120. Add snapshot for the current data state!
121. project(function, events, state) -> state
122. project(function, events, state) -> state {}
123. project(function, events, state) -> state { users: […] }
130. You can use any DB as a cache
132. Idea: use more that one DB for cache
133. Relation DB for search and index page
134. Document oriented DB for show page
135. Real world
136. Where it can be useful
137. E-comerse systems
138. Order and checkout flow
139. Something where you need version control (wiki, docs, group editing)
140. Domain depends on events (tracking systems)
141. redux? ▼ George
142. Event sourcing and event driven architecture are different things
143. And they use events in different ways
144. ES -> event happened and I store it ED -> event happened and I say everyone it
145. Blockchain! ▼ George
146. pros
147. Easier to communicate with domain experts
148. • Logging out from box • Time traveling • Restore a state of system
149. • You don’t work with tables you work with events and changes • Experemental data structures • Easy to change database implementations
150. cons
151. • Hard for understand idea and complicated abstraction • Not popular in ruby • Developers need deprogramming
152. • Harder to get state than CRUD • Hard to understand the whole chain of events • Another architecture type
 with different DB structure
153. • Versions and versions compatibility • Updating or deleting events • Eventual Consistency
154. Advanced topics
155. How to display created data ASAP?
156. Solution 1
157. cheat user display real data
163. solution 2
164. WebSockets and Long Polling
165. How to make right events order?
170. distributed systems
171. more here
172. And here
173. How to delete user related data
174. Retroactive Event
176. Lose encrypted data key
177. How to use ES in ruby
178. Simple way
179. gems
181. github.com/zilverline/sequent
183. eventide-project.org
185. Brave way
186. Build all stuff by self
190. hanami-events
191. Event driven transport layer with event versions and types
192. Connection without global state
193. Hanami::Events.new(:memory_sync) Hanami::Events.new(:memory_async) Hanami::Events.new(:redis)
194. Hanami::Events::Adapter.register(:google_pubsub) do Google::PubSub end Hanami::Events.new(:google_pubsub) # => event instance with your google pubsub adapter
195. events = Hanami::Events.new(:memory_sync) events.broadcast('user.created', user: user) Broadcaster
196. events.subscribe('user.created') do |payload| puts payload end events.subscribe('user.*') do |payload| puts payload end events.subscribe(/\Auser\..*/) do |payload| puts payload end Subscriber
197. Event sourcing looks cool. ▼ George
198. But I have legacy app. How can I migrate? ▼ George
199. User add something to cart
200. module Web::Controllers::CartItem class Create include Web::Action def call(params) halt(400) unless params.valid? if cart_repo.item_exist?(params[:item]) item = CartItemRepository.new.create_copy(params[:item]) else item = CartItemRepository.new.create(params[:item]) end analytics.call('Item Added') redirect_to routes.order_path(params[:order_id]) end end end
201. Step 1: Event Storming
202. Why? Detect important business events in the system
203. Orders::Events::ItemAdded Orders::Events::CoppyItemAdded
204. Step 2: store (apply) event
205. module Web::Controllers::CartItem class Create include Web::Action def call(params) halt(400) unless params.valid? event_store.apply(Order::Events::ItemAdded.new(payload)) if cart_repo.item_exist?(params[:item]) item = CartItemRepository.new.create_copy(params[:item]) else item = CartItemRepository.new.create(params[:item]) end analytics.call('Item Added') redirect_to routes.order_path(params[:order_id]) end end end
206. How to validate item?
207. module Web::Controllers::CartItem class Create include Web::Action def call(params) halt(400) unless params.valid? event_store.apply(Orders::Events::ItemAdded.new(payload)) if cart_repo.item_exist?(params[:item]) item = CartItemRepository.new.create_copy(params[:item]) else item = CartItemRepository.new.create(params[:item]) end analytics.call('Item Added') redirect_to routes.order_path(params[:order_id]) end end end
208. Step 3: calculate state
209. module Web::Controllers::CartItem class Create include Web::Action def call(params) halt(400) unless params.valid? events = event_store.get_stream(params[:order_id]) items = @project.call(Order::Projections::ItemList, events) if items.include?(params[:item]) event_store.apply(Orders::Events::ItemAdded.new(payload)) else event_store.apply(Orders::Events::CoppyItemAdded.new(payload)) end analytics.call('Item Added') redirect_to routes.order_path(params[:order_id]) end end end
210. module Web::Controllers::CartItem class Create include Web::Action def call(params) halt(400) unless params.valid? events = event_store.get_stream(params[:order_id]) items = @project.call(Order::Projections::ItemList, events, {}) if items.include?(params[:item]) event_store.apply(Orders::Events::ItemAdded.new(payload)) else event_store.apply(Orders::Events::CoppyItemAdded.new(payload)) end analytics.call('Item Added') redirect_to routes.order_path(params[:order_id]) end end end
211. module Projections class AllTask def call(event, state) case event when Orders::Events::ItemAdded state[:orders] ||= [] state[:orders] << event.payload when Orders::Events::ItemRemoved # ... end state end end end
212. module Projections class AllTask def call(event, state) case event when Orders::Events::ItemAdded state[:orders] ||= [] state[:orders] << event.payload when Orders::Events::ItemRemoved # ... end state end end end
213. module Projections class AllTask def call(event, state) case event when Orders::Events::ItemAdded state[:orders] ||= [] state[:orders] << event.payload when Orders::Events::ItemRemoved # ... end state end end end
214. module Web::Controllers::CartItem class Create include Web::Action def call(params) halt(400) unless params.valid? events = event_store.get_stream(params[:order_id]) items = @project.call(Order::Projections::ItemList, events, {}) if items.include?(params[:item]) event_store.apply(Orders::Events::ItemAdded.new(payload)) else event_store.apply(Orders::Events::CoppyItemAdded.new(payload)) end analytics.call('Item Added') redirect_to routes.order_path(params[:order_id]) end end end
215. Step 4: subscribers
216. # analytics subscribers event_store.subscribe(Orders::Events::ItemAdded) do |event| analytics.call('Item removed', event.payload) end event_store.subscribe(Orders::Events::CoppyItemAdded) do |event| analytics.call(‘Copy of item added’, event.payload) end event_store.subscribe(Orders::Events::ItemRemoved) do |event| analytics.call(‘Item removed', event.payload) end
217. module Web::Controllers::CartItem class Create include Web::Action def call(params) halt(400) unless params.valid? events = event_store.get_stream(params[:order_id]) items = @project.call(Order::Projections::ItemList, events, {}) if items.include?(params[:item]) event_store.apply(Orders::Events::ItemAdded.new(payload)) else event_store.apply(Orders::Events::CoppyItemAdded.new(payload)) end redirect_to routes.order_path(params[:order_id]) end end end
218. Step 4: move logic to domain
219. PROFIT
220. pro tip: you can use ES only as a part of your system
221. What next?
224. SAGA PATTERN
225. Long business transactions
228. CQRS
 
 (Command Query Responsibility Segregation)
229. – Martin Fowler “You can use a different model to update information than the model you use to read information”
230. Looking outside ruby world
231. github.com/heynickc/ awesome-ddd
232. github.com/davydovanton/event_sourcing_ruby
233. DDD
234. Again? ▼ George
235. Detect and store business events
236. Split system by domains
240. Distributed systems
241. more here
242. Conclusions
243. Sometimes event base architecture win
244. Sometimes not
245. EventSourcing is simple as conception
246. But introduce a lot of practical problems
 (data evolution, event order, etc)
247. ES expensive
248. It’s not about distributed systems and communication across services
249. ES will be a trend in the future
250. Do you don’t trust?
251. ES will be a trend in the future
252. twitter.com/anton_davydov github.com/davydovanton mail@davydovanton.com davydovanton.com Thank you ❤