pub_sub_model_sync 0.5.8 → 0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14095a129de1a44dd2f51051e3ee768217eae9ddbaa69b2e9bb3979d857dde5a
-  data.tar.gz: eeff964335f21b2bc5db23048cf0a09cb8e4d385333f72cf431d9201e107737b
+  metadata.gz: c3cb9b467f173cf208d051aead1d069868b9dfd6cc319311aac4fdaa3431d05f
+  data.tar.gz: b5f6dad938ee545ab4f99c6cd51b84e574856c63f044f5a46e784ca17a01076c
 SHA512:
-  metadata.gz: 3f85d85ac9f5de88af18848c8511e113a2359c5135b4dba8904e4bbc2b1f72b7be526c9fcdd221761202e9ef8d4630d84e08e9a5d8aa0c2753f98046a514fb70
-  data.tar.gz: 4788d133e2eaf6b302d34898d5f0d7002556edb357c907f280df137d686c71d7280503a763180f7fb61dece830c41f1263a7d569a868fad0082d13062e7caccd
+  metadata.gz: c548cd499bfde36a4d0db4a8dc75e8ad3cadc389cfffb55c95db9ab306ecc7ce338274603e66ebb1f45932fd1de61cc5f6d4ad123c6ed0931ad3284cbdc957f3
+  data.tar.gz: 62ced05bba4175c69d4453e35f5c9fa3414b1d2f123d40ada555e75bc876488d78f388e87a20a01c1bf895ab2991eeb1a0f2287cbd593aaec8d0429aec7519ee

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Change Log
 
+# 0.5.10 (February 13, 2021)
+- feat: remove duplicated callback :ps_before_save_sync (same result can be achieved with :ps_before_save_sync)
+- feat: improve message starter to retry when failed or exit system when persists
+- feat: fix and retry when database connection error (PG::UnableToSend)
+- feat: add method to save processed payload (:ps_processed_payload) when saving sync
+- chore: improved readme (Thanks @CharlieIGG)
+
+# 0.5.9.1 (February 10, 2021)
+- feat: move :key into headers
+
+# 0.5.9 (February 10, 2021)
+- feat: reformat :publish and :process methods to include non silence methods
+- feat: add notification key to payloads (can be used for caching strategies)
+
+# 0.5.8.2 (February 05, 2021)
+- fix: restore google pubsub topic settings
+
+# 0.5.8.1 (February 05, 2021)
+- fix: keep message ordering with google pubsub
+
 # 0.5.8 (January 29, 2021)
 - fix: keep message ordering with google pubsub
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pub_sub_model_sync (0.5.8)
+    pub_sub_model_sync (0.5.10)
       rails
 
 GEM

data/README.md

@@ -1,16 +1,40 @@
-# PubSubModelSync
-Permit to sync models data and make calls between rails apps using google or rabbitmq or apache kafka pub/sub service. 
-
-Note: This gem is based on [MultipleMan](https://github.com/influitive/multiple_man) which for now looks unmaintained.
-
-## Features
+# **PubSubModelSync**
+Automatically sync Model data and make calls between Rails applications using Google PubSub, RabbitMQ, or Apache Kafka Pub/Sub services.
+
+Note: This gem is based on [MultipleMan](https://github.com/influitive/multiple_man) is now unmaintained.
+
+- [**PubSubModelSync**](#pubsubmodelsync)
+  - [**Features**](#features)
+  - [**Installation**](#installation)
+  - [**Usage**](#usage)
+  - [**Examples**](#examples)
+  - [**Advanced Example**](#advanced-example)
+  - [**API**](#api)
+    - [**Subscribers**](#subscribers)
+      - [**Registering Subscription Callbacks**](#registering-subscription-callbacks)
+      - [**Class Methods**](#class-methods)
+      - [**Instance Methods**](#instance-methods)
+    - [**Publishers**](#publishers)
+      - [**Registering Publishing Callbacks**](#registering-publishing-callbacks)
+      - [**Instance Methods**](#instance-methods-1)
+      - [**Class Methods**](#class-methods-1)
+      - [**Payload actions**](#payload-actions)
+  - [**Testing with RSpec**](#testing-with-rspec)
+  - [**Extra configurations**](#extra-configurations)
+  - [**TODO**](#todo)
+  - [**Q&A**](#qa)
+  - [**Contributing**](#contributing)
+  - [**License**](#license)
+  - [**Code of Conduct**](#code-of-conduct)
+
+## **Features**
 - Sync CRUD operations between Rails apps. So, all changes made on App1, will be reflected on App2, App3.
     Example: If User is created on App1, this user will be created on App2 too with the accepted attributes.
 - Ability to make class level communication
     Example: If User from App1 wants to generate_email, this can be listened on App2, App3, ... to make corresponding actions
 - Change pub/sub service at any time
 
-## Installation
+## **Installation**
 Add this line to your application's Gemfile:
 ```ruby
 gem 'pub_sub_model_sync'
@@ -22,12 +46,12 @@ gem 'ruby-kafka' # to use apache kafka pub/sub service
 And then execute: $ bundle install
 
 
-## Usage
+## **Usage**
 
 - Configuration for google pub/sub (You need google pub/sub service account)
     ```ruby
     # initializers/pub_sub_config.rb
-    PubSubModelSync::Config.service_name = :google 
+    PubSubModelSync::Config.service_name = :google
     PubSubModelSync::Config.project = 'google-project-id'
     PubSubModelSync::Config.credentials = 'path-to-the-config'
     PubSubModelSync::Config.topic_name = 'sample-topic'
@@ -50,7 +74,7 @@ And then execute: $ bundle install
     PubSubModelSync::Config.kafka_connection = [["kafka1:9092", "localhost:2121"], { logger: Rails.logger }]
     PubSubModelSync::Config.topic_name = 'sample-topic'
     ```
-    See details here: https://github.com/zendesk/ruby-kafka    
+    See details here: https://github.com/zendesk/ruby-kafka
 
 - Add publishers/subscribers to your models (See examples below)
 
@@ -58,21 +82,21 @@ And then execute: $ bundle install
     ```ruby
     rake pub_sub_model_sync:start
     ```
-    Note: Publishers do not need todo this    
+    Note: Publishers do not need todo this
     Note2 (Rails 6+): Due to Zeitwerk, you need to load listeners manually when syncing without mentioned task (like rails console)
-    ```ruby 
+    ```ruby
       # PubSubModelSync::Config.subscribers ==> []
       PubSubModelSync::Runner.preload_listeners
       # PubSubModelSync::Config.subscribers ==> [#<PubSubModelSync::Subscriber:0x000.. @klass="Article", @action=:create..., ....]
-    ``` 
+    ```
 
-- Check the service status with:    
+- Check the service status with:
   ```PubSubModelSync::MessagePublisher.publish_data('Test message', {sample_value: 10}, :create)```
 
-## Examples
+## **Examples**
 ```ruby
 # App 1 (Publisher)
-# attributes: name email age 
+# attributes: name email age
 class User < ActiveRecord::Base
   include PubSubModelSync::PublisherConcern
   ps_publish(%i[id name email])
@@ -97,18 +121,18 @@ User.ps_class_publish({ msg: 'Hello' }, action: :greeting) # User.greeting metho
 PubSubModelSync::MessagePublisher.publish_data(User, { msg: 'Hello' }, :greeting) # similar to above when not included publisher concern
 ```
 
-## Advanced Example
+## **Advanced Example**
 ```ruby
 # App 1 (Publisher)
 class User < ActiveRecord::Base
   self.table_name = 'publisher_users'
   include PubSubModelSync::PublisherConcern
   ps_publish(%i[id:client_id name:full_name email], actions: %i[update], as_klass: 'Client')
-  
+
   def ps_skip_callback?(_action)
     false # here logic with action to skip push message
   end
-  
+
   def ps_skip_sync?(_action)
       false # here logic with action to skip push message
     end
@@ -121,92 +145,133 @@ class User < ActiveRecord::Base
   ps_subscribe(%i[name], actions: %i[update], from_klass: 'Client', id: %i[client_id email])
   ps_class_subscribe(:greeting, from_action: :custom_greeting, from_klass: 'CustomUser')
   alias_attribute :full_name, :name
-  
+
   def self.greeting(data)
     puts 'Class message called through custom_greeting'
   end
-  
+
   # def self.ps_find_model(data)
-  #   where(email: data[:email], ...).first_or_initialize 
+  #   where(email: data[:email], ...).first_or_initialize
   # end
 end
 ```
 
 Note: Be careful with collision of names
 ```
-  # ps_publish %i[name_data:name name:key] # key will be replaced with name_data 
+  # ps_publish %i[name_data:name name:key] # key will be replaced with name_data
   ps_publish %i[name_data:name key_data:key] # use alias to avoid collision
-``` 
-
-## API
-### Subscribers
-- Permit to configure class level subscriptions
-  ```ps_class_subscribe(action_name, from_action: nil, from_klass: nil)```
-  * from_action: (Optional) Source method name
-  * from_klass: (Optional) Source class name
-  
-- Permit to configure instance level subscriptions (CRUD)
-  ```ps_subscribe(attrs, from_klass: nil, actions: nil, id: nil)```
-  * attrs: (Array/Required) Array of all attributes to be synced
-  * from_klass: (String/Optional) Source class name (Instead of the model class name, will use this value) 
-  * actions: (Array/Optional, default: create/update/destroy) permit to customize action names
-  * id: (Sym|Array/Optional, default: id) Attr identifier(s) to find the corresponding model
-
-- Permit to configure a custom model finder
-  ```ps_find_model(data)```
-  * data: (Hash) Data received from sync
+```
+
+## **API**
+### **Subscribers**
+
+#### **Registering Subscription Callbacks**
+
+- Configure model-level subscriptions
+  ```ruby
+  class MyModel < ActiveRecord::Base
+    ps_class_subscribe(action_name, from_action: nil, from_klass: nil)
+  end
+  ```
+  * `from_action`: (Optional) Source method name
+  * `from_klass`: (Optional) Source class name
+
+- Configure instance-level subscriptions (CRUD)
+  ```ruby
+  class MyModel < ActiveRecord::Base
+    ps_subscribe(attrs, from_klass: nil, actions: nil, id: nil)
+  end
+  ```
+  * `attrs`: (Array/Required) Array of all attributes to be synced
+  * `from_klass`: (String/Optional) Source class name (Instead of the model class name, will use this value)
+  * `actions`: (Array/Optional, default: create/update/destroy) permit to customize action names
+  * `id`: (Sym|Array/Optional, default: id) Attr identifier(s) to find the corresponding model
+
+- Configure a custom model finder
+  ```ruby
+  class MyModel < ActiveRecord::Base
+    ps_find_model(data)
+  end
+  ```
+  * `data`: (Hash) Data received from sync
   Must return an existent or a new model object
 
-- Get crud subscription configured for the class   
-  ```User.ps_subscriber(action_name)```  
-  * action_name (default :create, :sym): can be :create, :update, :destroy
+#### **Class Methods**
+- Configure CRUD subscription for the class
+  ```ruby
+  MyModel.ps_subscriber(action_name)
+  ```
+  * `action_name` (default :create, :sym): can be :create, :update, :destroy
 
-- Inspect all configured subscribers   
-  ```PubSubModelSync::Config.subscribers```    
+- Inspect all configured subscribers
+  ```ruby
+  PubSubModelSync::Config.subscribers
+  ```
+
+#### **Instance Methods**
+
+- Perform custom actions before saving sync of the model (On-demand, `:cancel` can be returned to skip sync)
+  ```ruby
+  my_instance.ps_before_save_sync(payload)
+  ```
+
+### **Publishers**
 
-- Permit to customize the way to detect if the subscribed model was changed (Only for update action).   
-  ```.ps_subscriber_changed?(data)```    
-  By default: ```model.changed?```
+#### **Registering Publishing Callbacks**
+- You can register Model-level lifecycle callbacks (CRUD) that will trigger publishing events like this:
+  ```ruby
+  ps_publish(attrs, actions: nil, as_klass: nil)
+  ```
+  * `attrs`: (Array/Required) Array of attributes to be published
+  * `actions`: (Array/Optional, default: create/update/destroy) permit to customize action names
+  * `as_klass`: (String/Optional) Output class name (Instead of the model class name, will use this value)
 
-- Permit to perform custom actions before saving sync of the model (:cancel can be returned to skip sync)   
-  ```.ps_before_save_sync(payload)```    
 
-### Publishers
-- Permit to configure crud publishers
-  ```ps_publish(attrs, actions: nil, as_klass: nil)```
-  * attrs: (Array/Required) Array of attributes to be published
-  * actions: (Array/Optional, default: create/update/destroy) permit to customize action names
-  * as_klass: (String/Optional) Output class name (Instead of the model class name, will use this value)
+#### **Instance Methods**
 
-- Permit to cancel sync called after create/update/destroy (Before initializing sync service)
-  ```model.ps_skip_callback?(action)```    
-  Default: False  
+- **Prevent PS-related callback** (On-demand, before the callback gets triggered)
+  ```ruby
+  model_instance.ps_skip_callback?(action)
+  ```
+  Default: False
   Note: Return true to cancel sync
-  
-- Callback called before preparing data for sync (Permit to stop sync)
-  ```model.ps_skip_sync?(action)```     
-  Note: return true to cancel sync
-  
-- Callback called before sync (After preparing data)
-  ```model.ps_before_sync(action, data_to_deliver)```  
+
+-  **Prevent sync after create/update/destroy action** (On-demand, before the sync gets triggered)
+    ```ruby
+    model_instance.ps_skip_sync?(action)
+    ```
+     Note: return true to cancel sync
+
+- **Execute a callback before sync** (On-demand, before sync is executed, but after payload is received )
+  ```ruby
+  model_instance.ps_before_sync(action, data_to_deliver)
+  ```
   Note: If the method returns ```:cancel```, the sync will be stopped (message will not be published)
 
-- Callback called after sync
-  ```model.ps_after_sync(action, data_delivered)```  
-
-- Perform sync on demand (:create, :update, :destroy):   
-  The target model will receive a notification to perform the indicated action  
-  ```my_model.ps_perform_sync(action_name, custom_settings = {})```  
-  * custom_settings: override default settings defined for action_name ({ attrs: [], as_klass: nil })
-    
-- Publish a class level notification:     
-  ```User.ps_class_publish(data, action: action_name, as_klass: custom_klass_name)```
-  Target class ```User.action_name``` will be called when message is received    
-  * data: (required, :hash) message value to deliver    
-  * action_name: (required, :sim) Action name    
-  * as_klass: (optional, :string) Custom class name (Default current model name)
-      
-- Payload actions  
+- **Execute a callback after sync**
+  ```ruby
+  model_instance.ps_after_sync(action, data_delivered)
+  ```
+
+- **Trigger a sync on-demand** (:create, :update, :destroy):
+  The target model will receive a notification to perform the indicated action
+  ```ruby
+  model_instance.ps_perform_sync(action_name, custom_settings = {})
+  ```
+  * `custom_settings`: override default settings defined for action_name ({ attrs: [], as_klass: nil })
+
+#### **Class Methods**
+
+- **Publish a class level notification**:
+  ```ruby
+  User.ps_class_publish(data, action: action_name, as_klass: custom_klass_name)
+  ```
+  Target class ```User.action_name``` will be called when message is received
+  * `data`: (required, :hash) message value to deliver
+  * `action_name`: (required, :sim) Action name
+  * `as_klass`: (optional, :string) Custom class name (Default current model name)
+
+#### **Payload actions**
   ```ruby
     payload = PubSubModelSync::Payload.new({ title: 'hello' }, { action: :greeting, klass: 'User' })
     payload.publish! # publishes notification data. It raises exception if fails and does not call ```:on_error_publishing``` callback
@@ -214,36 +279,38 @@ Note: Be careful with collision of names
     payload.process! # process a notification data. It raises exception if fails and does not call ```.on_error_processing``` callback
     payload.publish # process a notification data. It does not raise exception if fails but calls ```.on_error_processing``` callback
   ```
-  
-- Get crud publisher configured for the class   
-  ```User.ps_publisher(action_name)```  
-  * action_name (default :create, :sym): can be :create, :update, :destroy
-  
-## Testing with RSpec
+
+- Get crud publisher configured for the class
+  ```ruby
+  User.ps_publisher(action_name)
+  ```
+  * `action_name` (default :create, :sym): can be :create, :update, :destroy
+
+## **Testing with RSpec**
 - Config: (spec/rails_helper.rb)
     ```ruby
-      
+
       # when using google service
       require 'pub_sub_model_sync/mock_google_service'
       config.before(:each) do
         google_mock = PubSubModelSync::MockGoogleService.new
         allow(Google::Cloud::Pubsub).to receive(:new).and_return(google_mock)
       end
-      
+
       # when using rabbitmq service
-      require 'pub_sub_model_sync/mock_rabbit_service' 
+      require 'pub_sub_model_sync/mock_rabbit_service'
       config.before(:each) do
         rabbit_mock = PubSubModelSync::MockRabbitService.new
         allow(Bunny).to receive(:new).and_return(rabbit_mock)
       end
-    
+
       # when using apache kafka service
-      require 'pub_sub_model_sync/mock_kafka_service' 
+      require 'pub_sub_model_sync/mock_kafka_service'
       config.before(:each) do
         kafka_mock = PubSubModelSync::MockKafkaService.new
         allow(Kafka).to receive(:new).and_return(kafka_mock)
       end
-  
+
     ```
 - Examples:
     ```ruby
@@ -254,7 +321,7 @@ Note: Be careful with collision of names
       payload.process!
       expect(User.where(id: data[:id]).any?).to be_truth
     end
-      
+
     it 'receive class message' do
       data = { msg: 'hello' }
       action = :greeting
@@ -262,16 +329,16 @@ Note: Be careful with collision of names
       payload.process!
       expect(User).to receive(action)
     end
-  
+
     # Publisher
     it 'publish model action' do
-      publisher = PubSubModelSync::MessagePublisher  
+      publisher = PubSubModelSync::MessagePublisher
       user = User.create(name: 'name', email: 'email')
       expect(publisher).to receive(:publish_model).with(user, :create, anything)
     end
-       
+
     it 'publish class message' do
-      publisher = PubSubModelSync::MessagePublisher  
+      publisher = PubSubModelSync::MessagePublisher
       data = {msg: 'hello'}
       action = :greeting
       User.ps_class_publish(data, action: action)
@@ -279,78 +346,80 @@ Note: Be careful with collision of names
     end
     ```
 
-## Extra configurations
+## **Extra configurations**
 ```ruby
 config = PubSubModelSync::Config
 config.debug = true
 ```
 
-- ```.subscription_name = 'app-2'```    
+- ```.subscription_name = 'app-2'```
     Permit to define a custom consumer identifier (Default: Rails application name)
-- ```.debug = true```    
+- ```.debug = true```
     (true/false*) => show advanced log messages
-- ```.logger = Rails.logger```   
+- ```.logger = Rails.logger```
     (Logger) => define custom logger
-- ```.disabled_callback_publisher = ->(_model, _action) { false }```   
-    (true/false*) => if true, does not listen model callbacks for auto sync (Create/Update/Destroy) 
-- ```.on_before_processing = ->(payload, {subscriber:}) { puts payload }```    
-    (Proc) => called before processing received message (:cancel can be returned to skip processing)   
-- ```.on_success_processing = ->(payload, {subscriber:}) { puts payload }```    
+- ```.disabled_callback_publisher = ->(_model, _action) { false }```
+    (true/false*) => if true, does not listen model callbacks for auto sync (Create/Update/Destroy)
+- ```.on_before_processing = ->(payload, {subscriber:}) { puts payload }```
+    (Proc) => called before processing received message (:cancel can be returned to skip processing)
+- ```.on_success_processing = ->(payload, {subscriber:}) { puts payload }```
     (Proc) => called when a message was successfully processed
-- ```.on_error_processing = ->(exception, {payload:, subscriber:}) { payload.delay(...).process! }```    
+- ```.on_error_processing = ->(exception, {payload:, subscriber:}) { payload.delay(...).process! }```
     (Proc) => called when a message failed when processing (delayed_job or similar can be used for retrying)
-- ```.on_before_publish = ->(payload) { puts payload }```    
-    (Proc) => called before publishing a message (:cancel can be returned to skip publishing)    
-- ```.on_after_publish = ->(payload) { puts payload }```    
+- ```.on_before_publish = ->(payload) { puts payload }```
+    (Proc) => called before publishing a message (:cancel can be returned to skip publishing)
+- ```.on_after_publish = ->(payload) { puts payload }```
     (Proc) => called after publishing a message
-- ```.on_error_publish = ->(exception, {payload:}) { payload.delay(...).publish! }```    
+- ```.on_error_publish = ->(exception, {payload:}) { payload.delay(...).publish! }```
     (Proc) => called when failed publishing a message (delayed_job or similar can be used for retrying)
-    
-## TODO
+
+## **TODO**
 - Add alias attributes when subscribing (similar to publisher)
 - Add flag ```model.ps_process_payload``` to retrieve the payload used to process the pub/sub sync
 - Auto publish update only if payload has changed
 - On delete, payload must only be composed by ids
 - Feature to publish multiple message at a time with the ability to exclude similar messages by klass and action (use the last one)
     PubSubModelSync::MessagePublisher.batch_publish({ same_keys: :use_last_as_first|:use_last|:use_first_as_last|:keep*, same_data: :use_last_as_first*|:use_last|:use_first_as_last|:keep })
+- Add DB table to use as a shield to skip publishing similar notifications or publish partial notifications (similar idea when processing notif)
+- add callback: on_message_received(payload)
 
-## Q&A
-- Error "could not obtain a connection from the pool within 5.000 seconds"    
-  This problem occurs because pub/sub dependencies (kafka, google-pubsub, rabbitmq) use many threads to perform notifications where the qty of threads is greater than qty of DB pools ([Google pubsub info](https://github.com/googleapis/google-cloud-ruby/blob/master/google-cloud-pubsub/lib/google/cloud/pubsub/subscription.rb#L888))     
+## **Q&A**
+- I'm getting error "could not obtain a connection from the pool within 5.000 seconds"... what does this mean?
+  This problem occurs because pub/sub dependencies (kafka, google-pubsub, rabbitmq) use many threads to perform notifications where the qty of threads is greater than qty of DB pools ([Google pubsub info](https://github.com/googleapis/google-cloud-ruby/blob/master/google-cloud-pubsub/lib/google/cloud/pubsub/subscription.rb#L888))
   To fix the problem, edit config/database.yml and increase the quantity of ```pool: 10```
-- Google pubsub: How to process notifications parallely and not sequentially (default 1 thread)?    
-  ```ruby  PubSubModelSync::ServiceGoogle::LISTEN_SETTINGS = { threads: { callback: qty_threads } } ```    
+- Google pubsub: How to process notifications parallely and not sequentially (default 1 thread)?
+  ```ruby  PubSubModelSync::ServiceGoogle::LISTEN_SETTINGS = { threads: { callback: qty_threads } } ```
   Note: by this way some notifications can be processed before others thus missing relationship errors can appear
 - How to retry failed syncs with sidekiq?
   ```ruby
     # lib/initializers/pub_sub_config.rb
-  
+
     class PubSubRecovery
       include Sidekiq::Worker
       sidekiq_options queue: :pubsub, retry: 2, backtrace: true
-  
+
       def perform(payload_data, action)
         payload = PubSubModelSync::Payload.from_payload_data(payload_data)
         payload.send(action)
       end
     end
-  
+
     PubSubModelSync::Config.on_error_publish = lambda do |_e, data|
       PubSubRecovery.perform_async(data[:payload].to_h, :publish!)
     end
     PubSubModelSync::Config.on_error_processing = lambda do |_e, data|
       PubSubRecovery.perform_async(data[:payload].to_h, :process!)
     end
-  ``` 
+  ```
 
-## Contributing
+## **Contributing**
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/owen2345/pub_sub_model_sync. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-## License
+## **License**
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-## Code of Conduct
+## **Code of Conduct**
 
 Everyone interacting in the PubSubModelSync project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/pub_sub_model_sync/blob/master/CODE_OF_CONDUCT.md).

data/lib/pub_sub_model_sync/base.rb

@@ -15,10 +15,10 @@ module PubSubModelSync
     end
 
     def retry_error(error_klass, qty: 2, &block)
-      @retries ||= 0
+      retries ||= 0
       block.call
     rescue error_klass => _e
-      (@retries += 1) <= qty ? retry : raise
+      (retries += 1) <= qty ? retry : raise
     end
   end
 end

data/lib/pub_sub_model_sync/message_processor.rb

@@ -2,7 +2,7 @@
 
 module PubSubModelSync
   class MessageProcessor < PubSubModelSync::Base
-    attr_accessor :payload, :raise_error
+    attr_accessor :payload
 
     # @param payload (Payload): payload to be delivered
     # @Deprecated: def initialize(data, klass, action)
@@ -15,10 +15,16 @@ module PubSubModelSync
       @payload = PubSubModelSync::Payload.new(payload, { klass: klass, action: action })
     end
 
-    def process
+    def process!
       filter_subscribers.each(&method(:run_subscriber))
     end
 
+    def process
+      process!
+    rescue => e
+      notify_error(e)
+    end
+
     private
 
     def run_subscriber(subscriber)
@@ -29,8 +35,6 @@ module PubSubModelSync
         res = config.on_success_processing.call(payload, { subscriber: subscriber })
         log "processed message with: #{payload.inspect}" if res != :skip_log
       end
-    rescue => e
-      raise_error ? raise : print_subscriber_error(e, subscriber)
     end
 
     def processable?(subscriber)
@@ -40,9 +44,9 @@ module PubSubModelSync
     end
 
     # @param error (Error)
-    def print_subscriber_error(error, subscriber)
+    def notify_error(error)
       info = [payload, error.message, error.backtrace]
-      res = config.on_error_processing.call(error, { payload: payload, subscriber: subscriber })
+      res = config.on_error_processing.call(error, { payload: payload })
       log("Error processing message: #{info}", :error) if res != :skip_log
     end
 

data/lib/pub_sub_model_sync/message_publisher.rb

@@ -7,14 +7,20 @@ module PubSubModelSync
         @connector ||= PubSubModelSync::Connector.new
       end
 
+      # Publishes any value to pubsub
+      # @param klass (String): Class name
+      # @param data (Hash): Data to be delivered
+      # @param action (:symbol): action name
       def publish_data(klass, data, action)
-        payload = PubSubModelSync::Payload.new(data, { klass: klass.to_s, action: action.to_sym })
+        attrs = { klass: klass.to_s, action: action.to_sym }
+        payload = PubSubModelSync::Payload.new(data, attrs)
         publish(payload)
       end
 
-      # @param model: ActiveRecord model
-      # @param action: (Sym) Action name
-      # @param publisher: (Publisher, optional) Publisher to be used
+      # Publishes model info to pubsub
+      # @param model (ActiveRecord model)
+      # @param action (Sym): Action name
+      # @param publisher (Publisher, optional): Publisher to be used
       def publish_model(model, action, publisher = nil)
         return if model.ps_skip_sync?(action)
 
@@ -27,7 +33,10 @@ module PubSubModelSync
         model.ps_after_sync(action, payload.data)
       end
 
-      def publish(payload, raise_error: false)
+      # Publishes payload to pubsub
+      # @attr payload (PubSubModelSync::Payload)
+      # Raises error if exist
+      def publish!(payload)
         if config.on_before_publish.call(payload) == :cancel
           log("Publish message cancelled: #{payload}") if config.debug
           return
@@ -36,8 +45,14 @@ module PubSubModelSync
         log("Publishing message: #{[payload]}")
         connector.publish(payload)
         config.on_after_publish.call(payload)
+      end
+
+      # Similar to :publish! method
+      # Notifies error via :on_error_publish instead of raising error
+      def publish(payload)
+        publish!(payload)
       rescue => e
-        raise_error ? raise : notify_error(e, payload)
+        notify_error(e, payload)
       end
 
       private

data/lib/pub_sub_model_sync/payload.rb

@@ -6,7 +6,8 @@ module PubSubModelSync
     attr_reader :data, :attributes, :headers
 
     # @param data (Hash: { any value }):
-    # @param attributes (Hash: { klass: string, action: :sym }):
+    # @param attributes (Hash: { klass*: string, action*: :sym }):
+    # @param headers (Hash: { key?: string, ...any_key?: anything }):
     def initialize(data, attributes, headers = {})
       @data = data
       @attributes = attributes
@@ -31,16 +32,14 @@ module PubSubModelSync
     # Process payload data
     #   (If error will raise exception and wont call on_error_processing callback)
     def process!
-      process do |publisher|
-        publisher.raise_error = true
-      end
+      publisher = PubSubModelSync::MessageProcessor.new(self)
+      publisher.process!
     end
 
     # Process payload data
     #   (If error will call on_error_processing callback)
     def process
       publisher = PubSubModelSync::MessageProcessor.new(self)
-      yield(publisher) if block_given?
       publisher.process
     end
 
@@ -48,7 +47,7 @@ module PubSubModelSync
     #   (If error will raise exception and wont call on_error_publish callback)
     def publish!
       klass = PubSubModelSync::MessagePublisher
-      klass.publish(self, raise_error: true)
+      klass.publish!(self)
     end
 
     # Publish payload to pubsub
@@ -70,6 +69,7 @@ module PubSubModelSync
     def build_headers
       headers[:uuid] ||= SecureRandom.uuid
       headers[:app_key] ||= PubSubModelSync::Config.subscription_key
+      headers[:key] ||= [klass.to_s, action].join('/')
     end
 
     def validate!

data/lib/pub_sub_model_sync/publisher.rb

@@ -11,8 +11,10 @@ module PubSubModelSync
       @as_klass = as_klass || klass
     end
 
+    # Builds the payload with model information defined for :action (:create|:update|:destroy)
     def payload(model, action)
-      PubSubModelSync::Payload.new(payload_data(model), payload_attrs(model, action))
+      headers = { key: [model.class.name, action, model.id].join('/') }
+      PubSubModelSync::Payload.new(payload_data(model), payload_attrs(model, action), headers)
     end
 
     private
@@ -29,7 +31,10 @@ module PubSubModelSync
     end
 
     def payload_attrs(model, action)
-      { klass: (as_klass || model.class.name).to_s, action: action.to_sym }
+      {
+        klass: (as_klass || model.class.name).to_s,
+        action: action.to_sym
+      }
     end
   end
 end

data/lib/pub_sub_model_sync/service_base.rb

@@ -24,21 +24,32 @@ module PubSubModelSync
 
     # @param (String: Payload in json format)
     def process_message(payload_info)
+      retries ||= 0
       payload = parse_payload(payload_info)
-      log("Received message: #{[payload]}") if config.debug
-      if same_app_message?(payload)
-        log("Skip message from same origin: #{[payload]}") if config.debug
+      return payload.process unless same_app_message?(payload)
+
+      log("Skipping message from same origin: #{[payload]}") if config.debug
+    rescue => e
+      retry if can_retry_process_message?(e, payload, retries += 1)
+    end
+
+    def can_retry_process_message?(error, payload, retries)
+      error_payload = [payload, error.message, error.backtrace]
+      if retries == 1
+        log("Error while starting to process message (retrying...): #{error_payload}", :error)
+        rescue_database_connection if lost_db_connection_err?(error)
       else
-        payload.process
+        log("Retried 1 time and error persists, exiting...: #{error_payload}", :error)
+        Process.exit!(true)
       end
-    rescue => e
-      error = [payload, e.message, e.backtrace]
-      log("Error parsing received message: #{error}", :error)
+      retries == 1
     end
 
     def parse_payload(payload_info)
       info = JSON.parse(payload_info).deep_symbolize_keys
-      ::PubSubModelSync::Payload.new(info[:data], info[:attributes], info[:headers])
+      payload = ::PubSubModelSync::Payload.new(info[:data], info[:attributes], info[:headers])
+      log("Received message: #{[payload]}") if config.debug
+      payload
     end
 
     # @param payload (Payload)
@@ -46,5 +57,19 @@ module PubSubModelSync
       key = payload.headers[:app_key]
       key && key == config.subscription_key
     end
+
+    def lost_db_connection_err?(error)
+      return true if error.class.name == 'PG::UnableToSend' # rubocop:disable Style/ClassEqualityComparison
+
+      error.message.match?(/lost connection/i)
+    end
+
+    def rescue_database_connection
+      log('Lost DB connection. Attempting to reconnect...', :warn)
+      ActiveRecord::Base.connection.reconnect!
+    rescue
+      log('Cannot reconnect to database, exiting...', :error)
+      Process.exit!(true)
+    end
   end
 end

data/lib/pub_sub_model_sync/service_google.rb

@@ -7,8 +7,8 @@ end
 
 module PubSubModelSync
   class ServiceGoogle < ServiceBase
-    LISTEN_SETTINGS = { threads: { callback: 1 } }.freeze
-    TOPIC_SETTINGS = { async: { threads: { publish: 1, callback: 1 } } }.freeze
+    LISTEN_SETTINGS = { threads: { callback: 1 }, message_ordering: true }.freeze
+    TOPIC_SETTINGS = {}.freeze
     SUBSCRIPTION_SETTINGS = { message_ordering: true }.freeze
     attr_accessor :service, :topic, :subscription, :subscriber
 
@@ -45,7 +45,7 @@ module PubSubModelSync
     private
 
     def message_headers
-      { SERVICE_KEY => true, ordering_key: Time.current.to_i }.merge(PUBLISH_SETTINGS)
+      { SERVICE_KEY => true, ordering_key: SERVICE_KEY }.merge(PUBLISH_SETTINGS)
     end
 
     def subscribe_to_topic

data/lib/pub_sub_model_sync/subscriber.rb

@@ -36,18 +36,23 @@ module PubSubModelSync
     # support for: create, update, destroy
     def run_model_message
       model = find_model
-      return if model.ps_before_save_sync(payload) == :cancel
+      model.ps_processed_payload = payload
 
       if action == :destroy
-        model.destroy!
+        model.destroy! if ensure_sync(model)
       else
         populate_model(model)
-        return if action == :update && !model.ps_subscriber_changed?(payload.data)
-
-        model.save!
+        model.save! if ensure_sync(model)
       end
     end
 
+    def ensure_sync(model)
+      config = PubSubModelSync::Config
+      cancelled = model.ps_before_save_sync(payload) == :cancel
+      config.log("Cancelled sync with ps_before_save_sync: #{[payload]}") if cancelled && config.debug
+      !cancelled
+    end
+
     def find_model
       model_class = klass.constantize
       return model_class.ps_find_model(payload.data) if model_class.respond_to?(:ps_find_model)

data/lib/pub_sub_model_sync/subscriber_concern.rb

@@ -4,12 +4,7 @@ module PubSubModelSync
   module SubscriberConcern
     def self.included(base)
       base.extend(ClassMethods)
-    end
-
-    # check if model was changed to skip nonsense .update!()
-    def ps_subscriber_changed?(_data)
-      validate
-      changed?
+      base.send(:attr_accessor, :ps_processed_payload)
     end
 
     # permit to apply custom actions before applying sync

data/lib/pub_sub_model_sync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PubSubModelSync
-  VERSION = '0.5.8'
+  VERSION = '0.5.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pub_sub_model_sync
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.10
 platform: ruby
 authors:
 - Owen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-29 00:00:00.000000000 Z
+date: 2021-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails