Replacing ActiveRecord callbacks with Pub-Sub

As your application grows ActiveRecord callbacks can easily get out of hand - creating a chain of dependencies between your models and mixing in business logic where it doesn't belong.

On some recent projects, I've been using the 'wisper' gem to replace some callbacks with a simple publish/subscribe pattern decoupling callbacks from models.

I'd like talk about the benefits of using this approach and give a brief run through of how to go about it.

Transcript

1. Replacing ActiveRecord callbacks with Pub/Sub edenspiekermann_ March 2nd, 2017 Niall Burkley (Edenspiekermann_) @niallburkley | github.com/nburkley | niallburkley.com
2. Callbacks ACTIVE RECORD
3. What are callbacks?
4. Business logic that you want - before or after something happens - tied to the lifecycle of the model What are callbacks?
5. Business logic that you want - before or after something happens - tied to the lifecycle of the model class Post < ActiveRecord::Base after_commit :notify_editors, on: :create private def notify_editors EditorMailer.send_notification(self).deliver_later end end What are callbacks?
6. 4 Creating a record Updating a record Deleting a record BEFORE VALIDATION before_validation before_validation before_validation_on_create before_validation_on_update AFTER VALIDATION after_validation after_validation before_save before_save before_create before_update before_destroy AFTER CRUD ACTION after_create after_update after_destroy after_save after_save after_commit, on: :create after_commit, on: :update after_commit, on: :destroy
7. 4 Creating a record Updating a record Deleting a record BEFORE VALIDATION before_validation before_validation before_validation_on_create before_validation_on_update AFTER VALIDATION after_validation after_validation before_save before_save before_create before_update before_destroy AFTER CRUD ACTION after_create after_update after_destroy after_save after_save after_commit, on: :create after_commit, on: :update after_commit, on: :destroy
8. Unrelated Business Logic in your model - Violation of Single Responsibility Principle #1
9. 6 class Message < ActiveRecord::Base after_create :add_author_as_watcher after_create :send_notification private def add_author_as_watcher Watcher.create(watchable: self.root, user: author) end def send_notification if Setting.notified_events.include?('message_posted') Mailer.message_posted(self).deliver end end end
10. 7 class Message < ActiveRecord::Base after_create :add_author_as_watcher after_create :send_notification private def add_author_as_watcher Watcher.create(watchable: self.root, user: author) end def send_notification if Setting.notified_events.include?('message_posted') Mailer.message_posted(self).deliver end end end
11. 8 class Message < ActiveRecord::Base after_create :add_author_as_watcher after_create :send_notification private def add_author_as_watcher Watcher.create(watchable: self.root, user: author) end def send_notification if Setting.notified_events.include?('message_posted') Mailer.message_posted(self).deliver end end end
12. Tight Coupling & brittle tests #2
13. 10 class Post < ActiveRecord::Base after_commit :generate_feed_item, on: :create private def generate_feed_item FeedItemGenerator.create(self) end end
14. 10 class Post < ActiveRecord::Base after_commit :generate_feed_item, on: :create private def generate_feed_item FeedItemGenerator.create(self) end end describe Post do subject { Post.new(title: 'Hello RUG::B') } describe 'create' do it 'creates a new feed item' do expect { subject.save }.to change { FeedItem.count }.by(1) expect(FeedItem.last.title).to eq('Hello RUG::B') end end end
15. 11 class FeedItemGenerator def self.create(subject) FeedItem.create( subject: subject, owner: subject.user ) end end
16. 12 class FeedItemGenerator def self.create(subject, published) FeedItem.create( subject: subject, owner: subject.user, published: published ) end end
17. 13 class Post < ActiveRecord::Base after_commit :generate_feed_item, on: :create private def generate_feed_item FeedItemGenerator.create(self) end end
18. 13 class Post < ActiveRecord::Base after_commit :generate_feed_item, on: :create private def generate_feed_item FeedItemGenerator.create(self) end end
19. describe Post do subject { Post.new(title: 'Hello RUG::B') } describe 'create' do it 'creates a new feed item' do expect { subject.save }.to change { FeedItem.count }.by(1) expect(FeedItem.last.title).to eq('Hello RUG::B') end end end 13 class Post < ActiveRecord::Base after_commit :generate_feed_item, on: :create private def generate_feed_item FeedItemGenerator.create(self) end end
20. describe Post do subject { Post.new(title: 'Hello RUG::B') } describe 'create' do it 'creates a new feed item' do expect { subject.save }.to change { FeedItem.count }.by(1) expect(FeedItem.last.title).to eq('Hello RUG::B') end end end 13 class Post < ActiveRecord::Base after_commit :generate_feed_item, on: :create private def generate_feed_item FeedItemGenerator.create(self) end end
21. Your Models are going to grow #3
22. 15 class Post < ActiveRecord::Base after_commit :notify_users, on: :create private def notify_users PostMailer.send_notifications(self).deliver_later end end
23. 16 class Post < ActiveRecord::Base after_commit :notify_users, on: :create after_commit :generate_feed_item, on: :create after_commit :notify_editors, on: :create private def notify_users PostMailer.send_notifications(self).deliver_later end def generate_feed_item FeedItemGenerator.create(self) end def notify_editors EditorMailer.send_notification(self).deliver_later end end
24. 17 class Post < ActiveRecord::Base after_commit :notify_users, on: :create after_commit :generate_feed_item, on: :create after_commit :notify_editors, on: :create after_commit :add_user_points, on: :create private def notify_users PostMailer.send_notifications(self).deliver_later end def generate_feed_item FeedItemGenerator.create(self) end def notify_editors EditorMailer.send_notification(self).deliver_later end def add_user_points UserPointsService.recalculate_points(self.user) end end
25. Callbacks are Synchronous #4
26. 19 class Image < ActiveRecord::Base after_commit :generate_image_renditions, on: :create private def generate_image_renditions ImageService.create_renditions(self) end end
27. 20 Browser Controller Image ImageService POST /images create(params) create_renditions(image) image renditions image success after_create callback
28. 20 Browser Controller Image ImageService POST /images create(params) create_renditions(image) image renditions image success after_create callback
29. 20 Browser Controller Image ImageService POST /images create(params) create_renditions(image) image renditions image success after_create callback
30. 20 Browser Controller Image ImageService POST /images create(params) create_renditions(image) image renditions image success after_create callback
31. 20 Browser Controller Image ImageService POST /images create(params) create_renditions(image) image renditions image success after_create callback
32. 20 Browser Controller Image ImageService POST /images create(params) create_renditions(image) image renditions image success after_create callback
33. 20 Browser Controller Image ImageService POST /images create(params) create_renditions(image) image renditions image success after_create callback
34. 21 Browser Controller Image Feed Generator POST /images create(params) create_renditions(image) image success ImageService background process image renditions
35. 21 Browser Controller Image Feed Generator POST /images create(params) create_renditions(image) image success ImageService background process image renditions
36. 21 Browser Controller Image Feed Generator POST /images create(params) create_renditions(image) image success ImageService background process image renditions
37. 21 Browser Controller Image Feed Generator POST /images create(params) create_renditions(image) image success ImageService background process image renditions
38. 21 Browser Controller Image Feed Generator POST /images create(params) create_renditions(image) image success ImageService background process image renditions
39. 21 Browser Controller Image Feed Generator POST /images create(params) create_renditions(image) image success ImageService background process image renditions
40. 21 Browser Controller Image Feed Generator POST /images create(params) create_renditions(image) image success ImageService background process image renditions
41. Building a Social Platform → User feeds → Project feeds → User Notifications → Project Notifications → User Karma
42. 23 class Project < ActiveRecord::Base after_commit :add_user_points, on: :create private def add_user_points UserPointsService.recalculate_points(self.user) end end
43. 23 class Project < ActiveRecord::Base after_commit :add_user_points, on: :create private def add_user_points UserPointsService.recalculate_points(self.user) end end class Comment < ActiveRecord::Base after_commit :add_user_points, on: :create private def add_user_points UserPointsService.recalculate_points(self.user) end end
44. 24 module UpdatesUserPoints extend ActiveSupport::Concern included do after_commit :add_user_points, on: :create def add_user_points UserPointsService.recalculate_points(self.user) end end end class Project < ActiveRecord::Base include UpdatesUserPoints end class Comment < ActiveRecord::Base include UpdatesUserPoints end
45. Wisper
46. Wisper A library providing Ruby objects with Publish-Subscribe capabilities •Decouples core business logic from external concerns •An alternative to ActiveRecord callbacks and Observers in Rails apps •Connect objects based on context without permanence •React to events synchronously or asynchronously
47. 27 Project ProjectSubscriber UserSubscriber create User create Events project_created(self) user_created(self) user_created(user) project_ created(post) <broadcast> <broadcast>
48. 28 class Project < ActiveRecord::Base include Wisper::Publisher after_commit :publish_creation, on: :create private def publish_creation broadcast(:project_created, self) end end
49. 29 Project.subscribe(ProjectSubscriber.new)
50. 30 class ProjectSubscriber def project_created(project) UserPointsService.recalculate_points(project) end end
51. 30 class ProjectSubscriber def project_created(project) UserPointsService.recalculate_points(project) end end class Project < ActiveRecord::Base include Wisper::Publisher after_commit :publish_creation, on: :create private def publish_creation broadcast(:project_created, self) end end
52. 30 class ProjectSubscriber def project_created(project) UserPointsService.recalculate_points(project) end end class Project < ActiveRecord::Base include Wisper::Publisher after_commit :publish_creation, on: :create private def publish_creation broadcast(:project_created, self) end end
53. 30 class ProjectSubscriber def project_created(project) UserPointsService.recalculate_points(project) end end class Project < ActiveRecord::Base include Wisper::Publisher after_commit :publish_creation, on: :create private def publish_creation broadcast(:project_created, self) end end
54. 31 Too much boilerplate
55. Wisper::ActiveRecord
56. Wisper::ActiveRecord Broadcast Lifecycle Events after_create after_destroy create_<model_name>_{successful, failed} update_<model_name>_{successful, failed} destroy_<model_name>_{successful, failed} <model_name>_committed after_commit after_rollback
57. 34 class Project < ActiveRecord::Base include Wisper::Publisher after_commit :publish_creation, on: :create private def publish_creation broadcast(:project_created, self) end end
58. 35 class Project < ActiveRecord::Base include Wisper.model end
59. 35 class Project < ActiveRecord::Base include Wisper.model end Project.subscribe(ProjectSubscriber.new)
60. 35 class Project < ActiveRecord::Base include Wisper.model end class ProjectSubscriber def after_create(project) UserPointsService.recalculate_points(project) end end Project.subscribe(ProjectSubscriber.new)
61. 36 Make it Asynchronous
62. Wisper::ActiveJob
63. 38 Post.subscribe(ProjectSubscriber, async: true)
64. 38 Post.subscribe(ProjectSubscriber, async: true)
65. 38 class ProjectSubscriber def self.post_created(post) UserPointsService.recalculate_points(post) end end Post.subscribe(ProjectSubscriber, async: true)
66. 39 What about tests?
67. 40 class Message < ActiveRecord::Base after_create :add_author_as_watcher after_create :reset_counters! after_create :send_notification end
68. 41 class MessageTest < ActiveSupport::TestCase def test_create topics_count = @board.topics_count messages_count = @board.messages_count message = Message.new(board: @board, subject: 'Test message', content: 'Test message content', author: @user) assert message.save @board.reload # topics count incremented assert_equal topics_count + 1, @board[:topics_count] # messages count incremented assert_equal messages_count + 1, @board[:messages_count] assert_equal message, @board.last_message # author should be watching the message assert message.watched_by?(@user) end end
69. 42 class MessageTest < ActiveSupport::TestCase def test_create topics_count = @board.topics_count messages_count = @board.messages_count message = Message.new(board: @board, subject: 'Test message', content: 'Test message content', author: @user) assert message.save @board.reload # topics count incremented assert_equal topics_count + 1, @board[:topics_count] # messages count incremented assert_equal messages_count + 1, @board[:messages_count] assert_equal message, @board.last_message # author should be watching the message assert message.watched_by?(@user) end end
70. Wisper::Rspec
71. 44 describe Message do subject { Message.new(text: 'Hello RUG::B') } describe 'create' do it 'broadcasts message creation' do expect { subject.save }.to broadcast(:after_create, subject) end end end
72. 45 describe MessageSubscriber do let(:message) { Message.create(text: 'Hello RUG::B') } describe 'after_create' do it 'adds message author as watcher' do MessageSubscriber.after_create(message) expect(Watcher.last.user).to eq(message.author) end it 'adds updates the board counter' do expect { MessageSubscriber.after_create(message) } .to change { message.board.count }.by(1) end it 'sends a notification' do MessageSubscriber.after_create(message) expect(UserMailer).to receive(:send_notification).with(message.board.owner) end end end
73. 46 What have we achieved?
74. 46 What have we achieved? #1 - We’ve removed unrelated business logic from our classes
75. 46 What have we achieved? #1 - We’ve removed unrelated business logic from our classes #2 - Decoupled our callbacks, making them easier to test
76. 46 What have we achieved? #1 - We’ve removed unrelated business logic from our classes #2 - Decoupled our callbacks, making them easier to test #3 -DRY’d up and slimmed down our model code
77. 46 What have we achieved? #1 - We’ve removed unrelated business logic from our classes #2 - Decoupled our callbacks, making them easier to test #3 -DRY’d up and slimmed down our model code #4 - Moved our callback logic into background jobs
78. 47 Alternatives?
79. 48 Alternatives - Observers
80. 48 Alternatives - Observers class CommentObserver < ActiveRecord::Observer def after_save(comment) EditorMailer.comment_notification(comment).deliver end end
81. 49 Alternatives - Decorators
82. 49 Alternatives - Decorators class CommentDecorator < ApplicationDecorator decorates Comment def create save && send_notification end private def send_notification EditorMailer.comment_notification(comment).deliver end end
83. 50 Alternatives - Decorators class CommentController < ApplicationController def create @comment = CommentDecorator.new(Comment.new(comment_params)) if @comment.create # handle the success else # handle the success end end end
84. 51 Alternatives - Trailblazer
85. 51 Alternatives - Trailblazer class Comment::Create < Trailblazer::Operation callback :after_save, EditorNotificationCallback
86. 51 Alternatives - Trailblazer class EditorNotificationCallback def initialize(comment) @comment = comment end def call(options) EditorMailer.comment_notification(@comment).deliver end end class Comment::Create < Trailblazer::Operation callback :after_save, EditorNotificationCallback
87. 52 Wisper
88. 52 Wisper → Lightweight and clean integration
89. 52 Wisper → Lightweight and clean integration → Well tested and maintained
90. 52 Wisper → Lightweight and clean integration → Well tested and maintained → Plenty of integration options
91. 52 Wisper → Lightweight and clean integration → Well tested and maintained → Plenty of integration options → Not just for Rails or ActiveRecord
92. 52 Wisper → Lightweight and clean integration → Well tested and maintained → Plenty of integration options → Not just for Rails or ActiveRecord → Great for small to medium scale, and potentially more
93. 52 Wisper → Lightweight and clean integration → Well tested and maintained → Plenty of integration options → Not just for Rails or ActiveRecord → Great for small to medium scale, and potentially more → It’s the right tool for the job for us
94. ( & Thanks) unless questions? Niall Burkley (Edenspiekermann_) @niallburkley | github.com/nburkley | niallburkley.com