pub_sub_model_sync 1.0.beta1 → 1.1.0

data/README.md

@@ -1,6 +1,10 @@
 # **PubSubModelSync**
-This gem permits to sync automatically model data, send custom notifications between multiple Rails applications by publishing notifications via pubsub (Google PubSub, RabbitMQ, or Apache Kafka). Out of the scope this gem includes transactions to keep Data consistency by processing notifications in the order they were delivered. 
-These notifications use JSON format to easily be decoded by subscribers (Rails applications and even other languages) 
+![Rails badge](https://img.shields.io/badge/Rails-4+-success.png)
+![Ruby badge](https://img.shields.io/badge/Ruby-2.4+-success.png)
+![Production badge](https://img.shields.io/badge/Production-ready-success.png)
+
+This gem permits to sync automatically models and custom data between multiple Rails applications by publishing notifications via pubsub (Google PubSub, RabbitMQ, or Apache Kafka) and automatically processed by all connected applications. Out of the scope, this gem includes transactions to keep Data consistency by processing notifications in the order they were delivered.     
+These notifications use JSON format to easily be decoded by subscribers (Rails applications and even other languages, soon for [Cristal-lang](https://crystal-lang.org/)) 
 
 - [**PubSubModelSync**](#pubsubmodelsync)
   - [**Features**](#features)
@@ -29,12 +33,12 @@ These notifications use JSON format to easily be decoded by subscribers (Rails a
   - [**Code of Conduct**](#code-of-conduct)
 
 ## **Features**
-- Sync model data between Rails apps: All changes made on App1, will be immediately reflected on App2, App3, etc.
+- Sync model data between Rails apps: All changes made on App1, will be immediately reflected on App2, App3, etc.    
     Example: If User is created on App1, this user will be created on App2, App3 too with the accepted attributes.
-- Ability to send class level communications
+- Ability to send instance and class level notifications    
     Example: If App1 wants to send emails to multiple users, this can be listened on App2, to deliver corresponding emails
 - Change pub/sub service at any time: Switch between rabbitmq, kafka, google pubsub  
-- Support for transactions: Permits to keep data consistency between applications by processing notifications in the same order they were delivered.
+- Support for transactions: Permits to keep data consistency between applications by processing notifications in the same order they were delivered (auto included in models transactions).
 - Ability to send notifications to a specific topic (single application) or multiple topics (multiple applications)
 
 ## **Installation**
@@ -56,7 +60,7 @@ And then execute: $ bundle install
     # initializers/pub_sub_config.rb
     PubSubModelSync::Config.service_name = :google
     PubSubModelSync::Config.project = 'google-project-id'
-    PubSubModelSync::Config.credentials = 'path-to-the-config'
+    PubSubModelSync::Config.credentials = 'path-to-google-config.json'
     PubSubModelSync::Config.topic_name = 'sample-topic' 
     PubSubModelSync::Config.subscription_name = 'my-app1'
     ```
@@ -85,12 +89,14 @@ And then execute: $ bundle install
 
 - Start subscribers to listen for publishers (Only in the app that has subscribers)
     ```bash
-    DB_POOL=20 bundle exec rake pub_sub_model_sync:start
+      DB_POOL=20 bundle exec rake pub_sub_model_sync:start
     ```
     Note: You need more than 15 DB pools to avoid "could not obtain a connection from the pool within 5.000 seconds". https://devcenter.heroku.com/articles/concurrency-and-database-connections
 
 - Check the service status with:
-  ```PubSubModelSync::MessagePublisher.publish_data('Test message', {sample_value: 10}, :create)```
+  ```ruby
+    PubSubModelSync::Payload.new({ my_data: 'here' }, { klass: 'MyClass', action: :sample_action }).publish!
+  ```
 
 - More configurations: [here](#extra-configurations)
 
@@ -98,14 +104,15 @@ And then execute: $ bundle install
 ![Diagram](/docs/notifications-diagram.png?raw=true)
 
 ## **Examples**
+See sample apps in [/samples](/samples/)   
 ### **Basic Example**
 ```ruby
 # App 1 (Publisher)
 class User < ActiveRecord::Base
   include PubSubModelSync::PublisherConcern
-  ps_on_crud_event(:create) { ps_publish(:create, mapping: %i[id name email]) }
-  ps_on_crud_event(:update) { ps_publish(:update, mapping: %i[id name email]) }
-  ps_on_crud_event(:destroy) { ps_publish(:destroy, mapping: %i[id]) }  
+  ps_after_action(:create) { ps_publish(:create, mapping: %i[id name email]) }
+  ps_after_action(:update) { ps_publish(:update, mapping: %i[id name email]) }
+  ps_after_action(:destroy) { ps_publish(:destroy, mapping: %i[id]) }  
 end
 
 # App 2 (Subscriber)
@@ -115,9 +122,9 @@ class User < ActiveRecord::Base
 end
 
 # CRUD syncs
-my_user = User.create(name: 'test user', email: 'sample@gmail.com') # Publishes `:create` notification (App 2 syncs the new user)
-my_user.update(name: 'changed user') # Publishes `:update` notification (App2 updates changes)
-my_user.destroy # Publishes `:destroy` notification (App2 destroys the corresponding user)
+my_user = User.create!(name: 'test user', email: 'sample@gmail.com') # Publishes `:create` notification (App 2 syncs the new user)
+my_user.update!(name: 'changed user') # Publishes `:update` notification (App2 updates changes on user with the same id)
+my_user.destroy! # Publishes `:destroy` notification (App2 destroys the corresponding user)
 ```
 
 ### **Advanced Example**
@@ -125,14 +132,16 @@ my_user.destroy # Publishes `:destroy` notification (App2 destroys the correspon
 # App 1 (Publisher)
 class User < ActiveRecord::Base
   include PubSubModelSync::PublisherConcern
-  ps_on_crud_event([:create, :update]) { ps_publish(:save, mapping: %i[id name:full_name email], as_klass: 'App1User', headers: { topic_name: %i[topic1 topic2] }) }
+  ps_after_action([:create, :update]) do |action| 
+    ps_publish(action, mapping: %i[name:full_name email], as_klass: 'App1User', headers: { topic_name: %i[topic1 topic2] })
+  end
 end
 
 # App 2 (Subscriber)
 class User < ActiveRecord::Base
   include PubSubModelSync::SubscriberConcern
-  ps_subscribe(:save, %i[full_name:customer_name], id: [:id, :email], from_klass: 'App1User')  
-  ps_subscribe(:send_welcome, %i[email], to_action: :send_email, if: ->(model) { model.email.present? })
+  ps_subscribe([:create, :update], %i[full_name:customer_name], id: :email, from_klass: 'App1User')  
+  ps_subscribe(:send_welcome, %i[email], id: :email, to_action: :send_email, if: ->(model) { model.email.present? })
   ps_class_subscribe(:batch_disable) # class subscription
   
   def send_email
@@ -143,9 +152,9 @@ class User < ActiveRecord::Base
     puts "disabling users: #{data[:ids]}"
   end
 end
-my_user = User.create(name: 'test user', email: 's@gmail.com') # Publishes `:save` notification as class name `App1User` (App2 syncs the new user)
+my_user = User.create!(name: 'test user', email: 's@gmail.com') # Publishes `:create` notification with classname `App1User` (App2 syncs the new user)
 my_user.ps_publish(:send_welcome, mapping: %i[id email]) # Publishes `:send_welcome` notification (App2 prints "sending email to...")
-PubSubModelSync::MessagePublisher.publish_data(User, { ids: [my_user.id] }, :batch_disable) # Publishes class notification (App2 prints "disabling users..")
+PubSubModelSync::Payload.new({ ids: [my_user.id] }, { klass: 'User', action: :batch_disable, mode: :klass }).publish! # Publishes class notification (App2 prints "disabling users..")
 ```
 
 ## **API**
@@ -167,8 +176,8 @@ PubSubModelSync::MessagePublisher.publish_data(User, { ids: [my_user.id] }, :bat
   - `settings` (Hash<:from_klass, :to_action, :id, :if, :unless>)    
     - `from_klass:` (String, default current class): Only notifications with this class name will be processed by this subscription    
     - `to_action:` (Symbol|Proc, default `action`):        
-      When Symbol: Model method to process the notification    
-      When Proc: Block to process the notification    
+      When Symbol: Model method to process the notification, sample: `def my_method(data)...end`    
+      When Proc: Block to process the notification, sample: `{|data| ... }`    
     - `id:` (Symbol|Array<Symbol|String>, default: `:id`) identifier attribute(s) to find the corresponding model instance (Supports for mapping format)    
       Sample: `id: :id` will search for a model like: `model_class.where(id: payload.data[:id])`       
       Sample: `id: [:id, :email:user_email]` will search for a model like: `model_class.where(id: payload.data[:id], user_email: payload.data[:email])`       
@@ -205,20 +214,20 @@ PubSubModelSync::MessagePublisher.publish_data(User, { ids: [my_user.id] }, :bat
 #### **Subscription helpers**
 - List all configured subscriptions
   ```ruby
-  PubSubModelSync::Config.subscribers
+    PubSubModelSync::Config.subscribers
   ```
-- Manually process or reprocess a notification (useful when failed)
+- Process or reprocess a notification
   ```ruby
-  payload = PubSubModelSync::Payload.new(data, attributes, headers)
-  payload.process!
+    payload = PubSubModelSync::Payload.new(data, attributes, headers)
+    payload.process!
   ```
 
 
 ### **Publishers**
 ```ruby
   class MyModel < ActiveRecord::Base
-    ps_on_crud_event([:create, :update, :destroy], :method_publisher_name) # using method callback
-    ps_on_crud_event([:create, :update, :destroy]) do |action| # using block callback
+    ps_after_action([:create, :update, :destroy], :method_publisher_name) # using method callback
+    ps_after_action([:create, :update, :destroy]) do |action| # using block callback
       ps_publish(action, data: {}, mapping: [], headers: {}, as_klass: nil)
       ps_class_publish({}, action: :my_action, as_klass: nil, headers: {})
     end
@@ -231,25 +240,13 @@ PubSubModelSync::MessagePublisher.publish_data(User, { ids: [my_user.id] }, :bat
 
 #### **Publishing notifications**
 
-- `ps_on_crud_event(crud_actions, method_name = nil, &block)` Listens for CRUD events and calls provided `block` or `method` to process event callback
+- `ps_after_action(crud_actions, method_name = nil, &block)` Listens for CRUD events and calls provided `block` or `method` to process event callback
   - `crud_actions` (Symbol|Array<Symbol>) Crud event(s) to be observed (Allowed: `:create, :update, :destroy`)
-  - `method_name` (Symbol, optional) method to be called to process action callback
-  - `block` (Proc, optional) Block to be called to process action callback
-  **Note1**: Due to rails callback ordering, this method uses `before_commit` callback when creating or updating models to ensure expected notifications order, sample:
-    ```ruby
-      user = User.create(name: 'asasas', posts_attributes: [{ title: 't1' }, { title: 't2' }])
-    ```
-    1: User notification     
-    2: First post notification     
-    3: Second post notification
-           
-  **Note2**: Due to rails callback ordering, this method uses `after_destroy` callback when destroying models to ensure the expected notifications ordering.
-    ```ruby
-      user.destroy
-    ```   
-    1: Second post notification     
-    2: First post notification     
-    3: User notification
+  - `method_name` (Symbol, optional) method to be called to process action callback, sample: `def my_method(action) ... end`
+  - `block` (Proc, optional) Block to be called to process action callback, sample: `{ |action| ... }`     
+  
+  **Note1**: Due to rails callback ordering, this method uses `after_commit on: action {...}` callback when creating or updating models to ensure expected notifications order (More details [**here**](#transactions)).    
+  **Note2**: Due to rails callback ordering, this method uses `after_destroy` callback when destroying models to ensure the expected notifications order.    
    
 - `ps_publish(action, data: {}, mapping: [], headers: {}, as_klass: nil)` Delivers an instance notification via pubsub
   - `action` (Sym|String) Action name of the instance notification. Sample: create|update|destroy|<any_other_key>
@@ -266,36 +263,23 @@ PubSubModelSync::MessagePublisher.publish_data(User, { ids: [my_user.id] }, :bat
     - When Proc: Block to be called to retrieve header values (must return a `hash`, receives `:model, :action` as args)
   - `as_klass:` (String, default current class name): Output class name used instead of current class name
   
-- `ps_class_publish` Delivers a  Class notification via pubsub
+- `ps_class_publish(data, action:, as_klass: nil, headers: {})` Delivers a  Class notification via pubsub
   - `data` (Hash): Data of the notification
   - `action` (Symbol): action  name of the notification
   - `as_klass:` (String, default current class name): Class name of the notification
   - `headers:` (Hash, optional): header settings (More in Payload.headers)
+
+- `ps_perform_publish(action = :create)` Permits to perform manually the callback of a specific `ps_after_action`
+  - `action` (Symbol, default: :create) Only :create|:update|:destroy
   
 #### **Publisher helpers**
-- Publish a class notification from anywhere
-  ```ruby 
-    PubSubModelSync::MessagePublisher.publish_data(klass, data, action, headers: )
-  ```
-  - `klass`: (String) Class name to be used
-  - Refer to `ps_class_publish` except `as_klass:`
-
-- Manually publish or republish a notification (useful when failed)
+- Publish or republish a notification
   ```ruby
-  payload = PubSubModelSync::Payload.new(data, attributes, headers)
-  payload.publish!
+    payload = PubSubModelSync::Payload.new(data, attributes, headers)
+    payload.publish!
   ```
 
 #### **Publisher callbacks**
-- Prevent delivering a notification (called before building payload)
-  If returns "true", will not publish notification
-    ```ruby
-    class MyModel < ActiveRecord::Base
-      def ps_skip_publish?(action)
-        # logic here
-      end
-    end
-    ```
 
 - Do some actions before publishing notification.
   If returns ":cancel", notification will not be delivered
@@ -328,7 +312,8 @@ Any notification before delivering is transformed as a Payload for a better port
     - `mode`: (Symbol: `:model`|`:class`) Kind of notification
   * `headers`: (Hash) Notification settings that defines how the notification will be processed or delivered. 
     - `key`: (String, optional) identifier of the payload, default: `<klass_name>/<action>` when class message, `<model.class.name>/<action>/<model.id>` when model message (Useful for caching techniques).
-    - `ordering_key`: (String, optional): messages with the same value are processed in the same order they were delivered, default: `klass_name` when class message, `<model.class.name>/<model.id>` when instance message
+    - `ordering_key`: (String, optional): messages with the same value are processed in the same order they were delivered, default: `klass_name` when class message, `<model.class.name>/<model.id>` when instance message.     
+      Note: Final `ordering_key` is calculated by this way: `payload.headers[:forced_ordering_key] || current_transaction&.key || payload.headers[:ordering_key]`
     - `topic_name`: (String|Array<String>, optional): Specific topic name (can be seen as a channel) to be used when delivering the message (default first topic from config).
     - `forced_ordering_key`: (String, optional): Will force to use this value as the `ordering_key`, even withing transactions. Default `nil`.
   
@@ -345,20 +330,38 @@ Any notification before delivering is transformed as a Payload for a better port
   * Crud syncs auto includes transactions which works as the following:
     ```ruby
     class User
-      ps_on_crud_event(:create) { ps_publish(:create, mapping: %i[id name]) }
-      has_many :posts
+      ps_after_action([:create, :update, :destroy]) { |action| ps_publish(action, mapping: %i[id name]) }
+      has_many :posts, dependent: :destroy
       accepts_nested_attributes_for :posts
     end
     
     class Post
       belongs_to :user
-      ps_on_crud_event(:create) { ps_publish(:create, mapping: %i[id title]) }
+      ps_after_action([:create, :update, :destroy]) { |action| ps_publish(action, mapping: %i[id user_id title]) }
     end
-    
-    User.create!(name: 'test', posts_attributes: [{ title: 'Post 1' }, { title: 'Post 2' }])
     ```
-    When user is created, `User`:`:save` notification is published with the ordering_key = `User/<user_id>`.   
-    Posts created together with the user model publishes `Post`:`:save` notification each one using its parents (user model) `ordering_key`.   
+    - When created (all notifications use the same ordering key to be processed in the same order)
+      ```ruby
+        user = User.create!(name: 'test', posts_attributes: [{ title: 'Post 1' }, { title: 'Post 2' }])
+        # notification #1 => <Payload data: {id: 1, name: 'sample'}, info: { klass: 'User', action: :create, mode: :model }, headers: { ordering_key = `User/1` }>
+        # notification #2 => <Payload data: {id: 1, title: 'Post 1', user_id: 1}, info: { klass: 'Post', action: :create, mode: :model }, headers: { ordering_key = `User/1` }>
+        # notification #3 => <Payload data: {id: 2, title: 'Post 2', user_id: 1}, info: { klass: 'Post', action: :create, mode: :model }, headers: { ordering_key = `User/1` }>
+      ```
+    - When updated (all notifications use the same ordering key to be processed in the same order)
+      ```ruby
+        user.update!(name: 'changed', posts_attributes: [{ id: 1, title: 'Post 1C' }, { id: 2, title: 'Post 2C' }])
+        # notification #1 => <Payload data: {id: 1, name: 'changed'}, info: { klass: 'User', action: :update, mode: :model }, headers: { ordering_key = `User/1` }>
+        # notification #2 => <Payload data: {id: 1, title: 'Post 1C', user_id: 1}, info: { klass: 'Post', action: :update, mode: :model }, headers: { ordering_key = `User/1` }>
+        # notification #3 => <Payload data: {id: 2, title: 'Post 2C', user_id: 1}, info: { klass: 'Post', action: :update, mode: :model }, headers: { ordering_key = `User/1` }>
+      ```
+    - When destroyed (all notifications use the same ordering key to be processed in the same order)   
+      **Note**: The notifications order were reordered in order to avoid inconsistency in other apps 
+      ```ruby
+      user.destroy!
+      # notification #1 => <Payload data: {id: 1, title: 'Post 1C', user_id: 1}, info: { klass: 'Post', action: :destroy, mode: :model }>
+      # notification #2 => <Payload data: {id: 2, title: 'Post 2C', user_id: 1}, info: { klass: 'Post', action: :destroy, mode: :model }>
+      # notification #3 => <Payload data: {id: 1, name: 'changed'}, info: { klass: 'User', action: :destroy, mode: :model }>
+      ```
     By this way parent notification and all inner notifications are processed in the same order they were published (includes notifications from callbacks like `ps_before_publish`).
         
     **Note**: When any error is raised when saving user or posts, the transaction is cancelled and thus all notifications wont be delivered (customizable by `PubSubModelSync::Config.transactions_use_buffer`).    
@@ -366,22 +369,20 @@ Any notification before delivering is transformed as a Payload for a better port
   - Manual transactions   
     `PubSubModelSync::MessagePublisher::transaction(key, max_buffer: , &block)`
     - `key` (String|nil) Key used as the ordering key for all inner notifications (When nil, will use `ordering_key` of the first notification)  
-    - `max_buffer:` (Boolean, default: `PubSubModelSync::Config.transactions_max_buffer`)     
-        If true: will save all notifications and deliver all them when transaction has successfully finished. If transaction has failed, then all saved notifications will be discarded (not delivered).    
-        If false: will deliver all notifications immediately (no way to rollback notifications if transaction has failed)  
+    - `max_buffer:` (Integer, default: `PubSubModelSync::Config.transactions_max_buffer`) Transaction buffer size (more details in #transactions_max_buffer).     
     Sample:
     ```ruby
       PubSubModelSync::MessagePublisher::transaction('my-custom-key') do
         user = User.create(name: 'test') # `User`:`:create` notification
         post = Post.create(title: 'sample') # `Post`:`:create` notification
-        PubSubModelSync::MessagePublisher.publish_data(User, { ids: [user.id] }, :send_welcome) # `User`:`:send_welcome` notification
+        PubSubModelSync::Payload.new({ ids: [user.id] }, { klass: 'User', action: :send_welcome, mode: :klass }).publish! # `User`:`:send_welcome` notification
       end
     ```
     All notifications uses `ordering_key: 'my-custom-key'` and will be processed in the same order they were published.
 
 ## **Testing with RSpec**
 - Config: (spec/rails_helper.rb)
-    ```ruby
+  ```ruby
 
       # when using google service
       require 'pub_sub_model_sync/mock_google_service'
@@ -404,51 +405,119 @@ Any notification before delivering is transformed as a Payload for a better port
         allow(Kafka).to receive(:new).and_return(kafka_mock)
       end
   
-      # 
+      # disable all models sync by default (reduces testing time) 
       config.before(:each) do
-        # **** disable payloads generation, sync callbacks to improve tests speed 
         allow(PubSubModelSync::MessagePublisher).to receive(:publish_data) # disable class level notif
         allow(PubSubModelSync::MessagePublisher).to receive(:publish_model) # disable instance level notif
-        
-        # **** when testing model syncs, it can be re enabled by:
-        # before do
-        #  allow(PubSubModelSync::MessagePublisher).to receive(:publish_data).and_call_original
-        #   allow(PubSubModelSync::MessagePublisher).to receive(:publish_model).and_call_original
-        # end
       end
-    ```
+    
+      # enable all models sync only for tests that includes 'sync: true'
+      config.before(:each, sync: true) do
+        allow(PubSubModelSync::MessagePublisher).to receive(:publish_data).and_call_original
+        allow(PubSubModelSync::MessagePublisher).to receive(:publish_model).and_call_original
+      end
+      
+      # Only when using database cleaner in old versions of rspec (enables after_commit callback)
+      # config.before(:each, truncate: true) do
+      #   DatabaseCleaner.strategy = :truncation
+      # end
+  ```
 - Examples:
+  - **Publisher**
     ```ruby
-    # Subscriber
-    it 'receive model notification' do
-      data = { name: 'name', id: 999 }
+      # Do not forget to include 'sync: true' to enable publishing pubsub notifications
+      describe 'When publishing sync', truncate: true, sync: true do
+        it 'publishes user notification when created' do
+          expect_publish_notification(:create, klass: 'User')
+          create(:user)
+        end
+        
+        it 'publishes user notification with all defined data' do
+          user = build(:user)
+          data = PubSubModelSync::PayloadBuilder.parse_mapping_for(user, %i[id name:full_name email])
+          data[:id] = be_a(Integer)
+          expect_publish_notification(:create, klass: 'User', data: data)
+          user.save!
+        end
+        
+        it 'publishes user notification when created' do
+          email = 'Newemail@gmail.com'
+          user = create(:user)
+          expect_publish_notification(:update, klass: 'User', data: { id: user.id, email: email })
+          user.update!(email: email)
+        end
+        
+        it 'publishes user notification when created' do
+          user = create(:user)
+          expect_publish_notification(:destroy, klass: 'User', data: { id: user.id })
+          user.destroy!
+        end
+        
+        private
+        
+        # @param action (Symbol)
+        # @param klass (String, default described_class name)
+        # @param data (Hash, optional) notification data
+        # @param info (Hash, optional) notification info
+        # @param headers (Hash, optional) notification headers
+        def expect_publish_notification(action, klass: described_class.to_s, data: {}, info: {}, headers: {})
+          publisher = PubSubModelSync::MessagePublisher
+          exp_data = have_attributes(data: hash_including(data),
+                                     info: hash_including(info.merge(klass: klass, action: action)),
+                                     headers: hash_including(headers))
+          allow(publisher).to receive(:publish!).and_call_original
+          expect(publisher).to receive(:publish!).with(exp_data)
+        end
+      end
+    ```   
+  - **Subscriber**    
+  ```ruby
+  
+  describe 'when syncing data from other apps' do
+    it 'creates user when received :create notification' do
+      user = build(:user)
+      data = user.as_json(only: %i[name email]).merge(id: 999)
       payload = PubSubModelSync::Payload.new(data, { klass: 'User', action: :create })
+      expect { payload.process! }.to change(described_class, :count)
+    end
+
+    it 'updates user when received :update notification' do
+      user = create(:user)
+      name = 'new name'
+      data = user.as_json(only: %i[id email]).merge(name: name)
+      payload = PubSubModelSync::Payload.new(data, { klass: 'User', action: :update })
+      payload.process!
+      expect(user.reload.name).to eq(name)
+    end
+
+    it 'destroys user when received :destroy notification' do
+      user = create(:user)
+      data = user.as_json(only: %i[id])
+      payload = PubSubModelSync::Payload.new(data, { klass: 'User', action: :destroy })
+      payload.process!
+      expect { user.reload }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  
+    
+    it 'receive custom model notification' do
+      user = create(:user)  
+      data = { id: user.id, custom_data: {} }
+      custom_action = :say_hello
+      expect_any_instance_of(User).to receive(custom_action).with(data)
+      payload = PubSubModelSync::Payload.new(data, { klass: 'User', action: custom_action })
       payload.process!
-      expect(User.where(id: data[:id])).to be_any
     end
 
     it 'receive class notification' do
       data = { msg: 'hello' }
       action = :greeting
+      expect(User).to receive(action).with(data)
+      # Do not forget to include `mode: :klass` for class notifications
       payload = PubSubModelSync::Payload.new(data, { klass: 'User', action: action, mode: :klass })
       payload.process!
-      expect(User).to receive(action)
     end
-
-    # Publisher
-    it 'publish model notification' do
-      publisher = PubSubModelSync::MessagePublisher
-      user = User.create(name: 'name', email: 'email')
-      expect(publisher).to receive(:publish_model).with(user, :create, anything)
-    end
-
-    it 'publish class notification' do
-      publisher = PubSubModelSync::MessagePublisher
-      user = User.create(name: 'name', email: 'email')
-      user.ps_class_publish({msg: 'hello'}, action: :greeting)
-      expect(publisher).to receive(:publish_data).with('User', data, :greeting)
-    end
-    ```
+  end
+  ```
 
 ## **Extra configurations**
 ```ruby
@@ -479,9 +548,10 @@ config.debug = true
     (Proc) => called after publishing a message
 - ```.on_error_publish = ->(exception, {payload:}) { payload.delay(...).publish! }```
     (Proc) => called when failed publishing a message (delayed_job or similar can be used for retrying)
-- ```.transactions_max_buffer = 100``` (Integer) Once this quantity of notifications is reached, then all notifications will immediately be delivered.    
-    Note: There is no way to rollback delivered notifications if current transaction fails
-- ```.enable_rails4_before_commit = true``` (true*|false) When false will disable rails 4 hack compatibility and then CRUD notifications will be prepared using `after_commit` callback instead of `before_commit` which will not rollback sql transactions if fails.
+- ```.transactions_max_buffer = 1``` (Integer, default 1) Controls the maximum quantity of notifications to be enqueued to the transaction-buffer before delivering them and thus adds the ability to rollback notifications if the transaction fails.        
+    Once this quantity of notifications is reached, then all notifications of the current transaction will immediately be delivered (can be customized per transaction).    
+    Note: There is no way to rollback delivered notifications if current transaction fails later.      
+    Note2: Only notifications from the buffer can be rollbacked if the current transaction has failed.     
 
 ## **TODO**
 - Auto publish update only if payload has changed (see ways to compare previous payload vs new payload)
@@ -490,8 +560,11 @@ config.debug = true
 - Add DB table to use as a shield to prevent publishing similar notifications and publish partial notifications (similar idea when processing notif)
 - Last notification is not being delivered immediately in google pubsub (maybe force with timeout 10secs and service.deliver_messages)
 - Update folder structure
-- Support for blocks in ps_publish and ps_subscribe
 - Services support to deliver multiple payloads from transactions
+- Fix deprecation warnings: pub_sub_model_sync/service_google.rb:39: warning: Splitting the last argument into positional and keyword parameters is deprecated
+- Add if/unless to ps_after_action
+- Add subscription liveness checker using thread without db connection to check periodically pending messages from google pubsub
+- Unify .stop() and 'Listener stopped' 
 
 ## **Q&A**
 - I'm getting error "could not obtain a connection from the pool within 5.000 seconds"... what does this mean?

data/lib/pub_sub_model_sync/base.rb

@@ -17,25 +17,5 @@ module PubSubModelSync
         config.debug
       end
     end
-
-    # @param errors (Array(Class|String))
-    def retry_error(errors, qty: 2, &block)
-      retries ||= 0
-      block.call
-    rescue => e
-      retries += 1
-      res = errors.find { |e_type| match_error?(e, e_type) }
-      raise if !res || retries > qty
-
-      sleep(qty * 0.1) && retry
-    end
-
-    private
-
-    # @param error (Exception)
-    # @param error_type (Class|String)
-    def match_error?(error, error_type)
-      error_type.is_a?(String) ? error.message.include?(error_type) : error.is_a?(error_type)
-    end
   end
 end

data/lib/pub_sub_model_sync/config.rb

@@ -8,8 +8,7 @@ module PubSubModelSync
     # customizable callbacks
     cattr_accessor(:debug) { false }
     cattr_accessor :logger # LoggerInst
-    cattr_accessor(:transactions_max_buffer) { 100 }
-    cattr_accessor(:enable_rails4_before_commit) { Rails::VERSION::MAJOR == 4 }
+    cattr_accessor(:transactions_max_buffer) { 1 }
 
     cattr_accessor(:on_before_processing) { ->(_payload, _info) {} } # return :cancel to skip
     cattr_accessor(:on_success_processing) { ->(_payload, _info) {} }
@@ -30,7 +29,7 @@ module PubSubModelSync
     def self.log(msg, kind = :info)
       msg = "PS_MSYNC ==> #{msg}"
       if logger == :raise_error
-        kind == :error ? raise(msg) : puts(msg)
+        kind == :error ? raise(StandardError, msg) : puts(msg)
       else
         logger ? logger.send(kind, msg) : puts(msg)
       end

data/lib/pub_sub_model_sync/message_processor.rb

@@ -16,13 +16,17 @@ module PubSubModelSync
     end
 
     def process!
-      filter_subscribers.each(&method(:run_subscriber))
+      subscribers = filter_subscribers
+      payload_info = { klass: payload.klass, action: payload.action, mode: payload.mode }
+      log("No subscribers found for #{payload_info}", :warn) if config.debug && subscribers.empty?
+      subscribers.each(&method(:run_subscriber))
     end
 
     def process
+      retries ||= 0
       process!
     rescue => e
-      notify_error(e)
+      retry_process?(e, retries += 1) ? retry : notify_error(e)
     end
 
     private
@@ -31,12 +35,10 @@ module PubSubModelSync
       processor = PubSubModelSync::RunSubscriber.new(subscriber, payload)
       return unless processable?(subscriber)
 
-      errors = [ActiveRecord::ConnectionTimeoutError, 'deadlock detected', 'could not serialize access']
-      retry_error(errors, qty: 5) do
-        processor.call
-        res = config.on_success_processing.call(payload, { subscriber: subscriber })
-        log "processed message with: #{payload.inspect}" if res != :skip_log
-      end
+      log("Processing message #{[subscriber, payload]}...") if config.debug
+      processor.call
+      res = config.on_success_processing.call(payload, { subscriber: subscriber })
+      log "processed message with: #{payload.inspect}" if res != :skip_log
     end
 
     def processable?(subscriber)
@@ -45,13 +47,34 @@ module PubSubModelSync
       !cancel
     end
 
-    # @param error (Error)
+    # @param error (StandardError)
     def notify_error(error)
       info = [payload, error.message, error.backtrace]
       res = config.on_error_processing.call(error, { payload: payload })
       log("Error processing message: #{info}", :error) if res != :skip_log
     end
 
+    def lost_db_connection?(error)
+      connection_lost_classes = %w[ActiveRecord::ConnectionTimeoutError PG::UnableToSend]
+      connection_lost_classes.include?(error.class.name) || error.message.match?(/lost connection/i)
+    end
+
+    def retry_process?(error, retries) # rubocop:disable Metrics/MethodLength
+      error_payload = [payload, error.message, error.backtrace]
+      return false unless lost_db_connection?(error)
+
+      if retries <= 5
+        sleep(retries)
+        log("Error processing message: (retrying #{retries}/5): #{error_payload}", :error)
+        ActiveRecord::Base.connection.reconnect! rescue nil # rubocop:disable Style/RescueModifier
+        true
+      else
+        log("Retried 5 times and error persists, exiting...: #{error_payload}", :error)
+        Process.exit!(true)
+      end
+    end
+
+    # @return (Array<PubSubModelSync::Subscriber>)
     def filter_subscribers
       config.subscribers.select do |subscriber|
         subscriber.from_klass == payload.klass && subscriber.action == payload.action && payload.mode == subscriber.mode