pub_sub_model_sync 1.0.beta → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 906ba0cfabbe20b6043f277795255a587f4e3f6c535f602ffb6be1dbca6e7d1f
-  data.tar.gz: 27e291f2bd5054cb1d3b9724d0e3a7e228ff29a833c0905af9ead58b93f84e6c
+  metadata.gz: 6e73c2af5a62d4b0ae32ea40f3c3c369a049edfd47360a50386eeb5e4ff97cd1
+  data.tar.gz: 5d1892ee41ada21c9bf70bcc3601e435edfdf55d7b51b443369bf3307da60436
 SHA512:
-  metadata.gz: 6982c9ad491fcba5967a42e26e922d9d19aa6e03ca48ea84c174301ca133e5890dffdf6ce138624610c341b7fb26bb2131495f7617b9fbe819ef28e8d10324b3
-  data.tar.gz: 75274215f707809a35f44d26c31ec6543a8487924c8e28b860dd27422348a5071874dc969c36fb9ce6f5a4d197872e2470b97f5983ae199d900438d2e8602178
+  metadata.gz: 962defddfdc780ce185d01e9069485207bdf66be9b3554a1003b5ec71211c467223c288fbb6c6a59ae819a9ba37ff118a470942bdef9e69c68e94f34ff899c9a
+  data.tar.gz: c6e771a40a96dcdf00161aa49fbe7c1b5f283709d5b42b87421c6655e4cb9972e9f7d3bb7d203d47c9757dc681f8c755c7026447f6582ffa1f43a553ba90197a

data/.github/workflows/release.yml

@@ -0,0 +1,43 @@
+on:
+  push:
+    tags: # triggered once a git tag is published
+      - '*'
+
+name: Create Release
+
+jobs:
+  build:
+    name: Create Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      # Changelog action adaptations
+      - name: Create required package.json
+        run: test -f package.json || echo '{}' >package.json
+      - name: Detect Previous Tag (action not detecting very well)
+        run: echo "::set-output name=previous_tag::$(git describe --abbrev=0 --tags `git rev-list --tags --skip=1 --max-count=1`)"
+        id: tag_checker
+
+      - name: Generate Changelog
+        uses: scottbrenner/generate-changelog-action@master
+        id: Changelog
+        with:
+          from-tag: ${{steps.tag_checker.outputs.previous_tag}}
+          to-tag: HEAD
+
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@latest
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ github.ref }}
+          body: |
+            ${{ steps.Changelog.outputs.changelog }}
+          draft: false
+          prerelease: false

data/.rubocop.yml

@@ -7,8 +7,7 @@ AllCops:
     - 'Gemfile'
     - 'Rakefile'
     - 'bin/*'
-    - 'blog/*'
-    - 'blog/**/*'
+    - 'samples/**/*'
 
 Metrics/BlockLength:
   Exclude:

data/CHANGELOG.md

@@ -1,20 +1,27 @@
 # Change Log
 
-# 1.0.beta (May 13, 2021)
+# 1.0.1 (August 20, 2021)
+- refactor: improve service exit when running in k8s
+
+# 1.0 (June 13, 2021)
+This version includes many changes that was refactored from previous version, and thus it needs manual changes to migrate into this version. 
 - Refactor: Subscribers param renamed `from_action` into `to_action` and added support for block or lambda 
 - Feat: Improved `ps_subscribe` to accept new arguments and support for property mappings
 - Refactor: Refactored `ps_publish` to be called manually (removes notification assumptions) and accept for new arguments
-- Feat: Added `ps_on_crud_event` to listen CRUD events to send notifications in the expected order
+- Feat: Added `ps_after_action` to listen CRUD events to send notifications in the expected order
 - Feat: Added `config.default_topic_name` to define default topic name whe publishing (by default `config.topic_name`)
 - Refactor: Refactored PubSub Transactions to support rollbacks (any exception inside transactions can automatically cancel all pending notifications: configurable through `config.transactions_use_buffer`)
 - Feat: Improved CRUD transactions to deliver inner notifications in the expected order to keep data consistency
 - System refactor: Added subscriber runner
 - Fix: Class notifications can only be listened by class subscriptions
 - Refactor: Removed `publish_model_data` to have a unique model publisher `ps_publish`
-- Refactor: Renamed `ps_before_sync` into `ps_before_publish`, `ps_skip_sync` into `ps_skip_publish`, `ps_after_sync` into `ps_after_publish`
+- Refactor: Renamed `ps_before_sync` into `ps_before_publish`, `ps_after_sync` into `ps_after_publish`
 - Refactor: Renamed `payload.attributes` into `payload.info`
 - Feat: Support for plain Ruby Objects (Non ActiveRecord models)
-- Fix: Retry errors for 5 times before exiting notifications listener 
+- Fix: Retry errors for 5 times before exiting notifications listener
+- Feat: Added transactions max_buffer
+- Feat: add `ps_perform_publish` to perform the callback for a specific action 
+- Feat: Removed `ps_skip_sync` callback
 
 # 0.6.0 (March 03, 2021)
 - feat: add support to include custom payload headers

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pub_sub_model_sync (1.0.beta)
+    pub_sub_model_sync (1.0.1)
       rails
 
 GEM
@@ -115,6 +115,7 @@ GEM
       gapic-common (~> 0.3)
       google-cloud-errors (~> 1.0)
       grpc-google-iam-v1 (>= 0.6.10, < 2.0)
+    google-protobuf (3.17.0)
     google-protobuf (3.17.0-x86_64-linux)
     googleapis-common-protos (1.3.11)
       google-protobuf (~> 3.14)
@@ -129,6 +130,9 @@ GEM
       multi_json (~> 1.11)
       os (>= 0.9, < 2.0)
       signet (~> 0.14)
+    grpc (1.37.1)
+      google-protobuf (~> 3.15)
+      googleapis-common-protos-types (~> 1.0)
     grpc (1.37.1-x86_64-linux)
       google-protobuf (~> 3.15)
       googleapis-common-protos-types (~> 1.0)
@@ -152,7 +156,7 @@ GEM
     multi_json (1.15.0)
     multipart-post (2.1.1)
     nio4r (2.5.7)
-    nokogiri (1.11.3-x86_64-linux)
+    nokogiri (1.11.3-x86_64-darwin)
       racc (~> 1.4)
     os (1.1.1)
     parallel (1.20.1)
@@ -244,6 +248,7 @@ GEM
     zeitwerk (2.4.2)
 
 PLATFORMS
+  ruby
   x86_64-linux
 
 DEPENDENCIES

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 `before_commit` 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,28 +330,46 @@ 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`).    
   
   - Manual transactions   
-    `PubSubModelSync::MessagePublisher::transaction(key, use_buffer: , &block)`
+    `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)  
-    - `use_buffer:` (Boolean, default: `PubSubModelSync::Config.transactions_use_buffer`)     
+    - `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)  
     Sample:
@@ -374,14 +377,14 @@ Any notification before delivering is transformed as a Payload for a better port
       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 +407,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,7 +550,9 @@ 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_use_buffer = true``` (true*|false) Default value for `use_buffer` in transactions.
+- ```.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` (used in `ps_after_action(...)`) which will not rollback sql transactions if failed when publishing pubsub notification.
 
 ## **TODO**
 - Auto publish update only if payload has changed (see ways to compare previous payload vs new payload)
@@ -488,8 +561,9 @@ 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
 
 ## **Q&A**
 - I'm getting error "could not obtain a connection from the pool within 5.000 seconds"... what does this mean?