pheromone 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72824e89ef3425da33b45c276319f332728461b7
-  data.tar.gz: 5b5bba2271b1fbc069d06615fec68d66b6279cf2
+  metadata.gz: 2b05a50cd3b7e0e2ae796255cd635d6bca7f8d15
+  data.tar.gz: da4ec3b6dafb9146438c6886c969731dddf0c61e
 SHA512:
-  metadata.gz: bf9d4a27bb39fff06ee9fb98c0b501f3c0815330a73abfaf60d1f267588e523d9d550a5d645dd9d9f20a764f63375aba8a3a196aab1b39dc4be6907216f09061
-  data.tar.gz: 0c39091b06b7533f7c9989d9116f314c1badb813096e1e5ece4d0a675536b0eaba324e2f38584736bab54cc04bf8bd1f8543a8535364433889c71aae65d4af88
+  metadata.gz: f448a3bbcabb7f55143c77cc34dd2b6e6f3cc00ad5f1357ed621385ecd469b4d95ce7258b1ef1d771ca452cd74d2897cca6440a8f947b636ae03d5bb188a6858
+  data.tar.gz: 85ddb8a2a665d8c0d8c0011bf3ffa68ae06b6715b816cecead71bb7a90d97a2fa26cdc2d4239ca1f54c1f90515ad615718a617a1307a8b9e402f8ab50b749025

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/CONTRIBUTIONS.rst

@@ -0,0 +1,5 @@
+Contributions
+=============
+
+* `Ali Saifee <https://github.com/alisaifee>`_
+* `Junkai <https://github.com/junkaiii>`_

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pheromone.gemspec
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Ankita Gupta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -20,52 +20,106 @@ Or install it yourself as:
 
     $ gem install pheromone
 
-## Waterdrop Setup
+## Pheromone Setup
 
 Pheromone depends on `waterdrop` to send messages to Kafka. `waterdrop` settings can be added by following the Setup step on [waterdrop](https://github.com/karafka/waterdrop/blob/master/README.md)
 
-WaterDrop has following configuration options:
+In order to setup `pheromone`, both `waterdrop` and `pheromone` need to be setup. Run this to generate `pheromone` configuration:
 
-| Option                  | Value type    | Description                      |
-|-------------------------|---------------|----------------------------------|
-| send_messages           | Boolean       | Should we send messages to Kafka |
-| kafka.hosts             | Array<String> | Kafka servers hosts with ports   |
-| connection_pool_size    | Integer       | Kafka connection pool size       |
-| connection_pool_timeout | Integer       | Kafka connection pool timeout    |
-| raise_on_failure        | Boolean       | Should we raise an exception when we cannot send message to Kafka - if false will silently ignore failures (will just ignore them) |
+    $ bundle exec rails generate pheromone:initializer
 
-To apply this configuration, you need to use a *setup* method:
+This will generate the following file in `config/initializers/pheromone.rb`
 
-```ruby
-WaterDrop.setup do |config|
-  config.send_messages = true
-  config.connection_pool_size = 20
-  config.connection_pool_timeout = 1
-  config.kafka.hosts = ['localhost:9092']
-  config.raise_on_failure = true
+```
+Pheromone.setup do |config|
+  #config.background_processor.name = ':resque / :sidekiq'
+  #config.background_processor.klass = 'BackgroundWorker'
+  config.timezone_format = 'UTC'
+  config.message_format = :json
+  WaterDrop.setup do |config|
+    config.send_messages = Rails.env.production?
+    config.connection_pool_size = 20
+    config.connection_pool_timeout = 1
+    config.kafka.hosts = [Rails.env.production? ? ENV['KAFKA_HOST'] : 'localhost:9092']
+    config.raise_on_failure = Rails.env.production?
+  end
 end
 ```
 
-This configuration can be placed in *config/initializers* and can vary based on the environment:
+Edit this file to modify the default config. The following configuration options are available:
 
-```ruby
-WaterDrop.setup do |config|
-  config.send_messages = Rails.env.production?
-  config.connection_pool_size = 20
-  config.connection_pool_timeout = 1
-  config.kafka.hosts = [Rails.env.production? ? 'prod-host:9091' : 'localhost:9092']
-  config.raise_on_failure = Rails.env.production?
+
+| Option                        | Value type    | Description                      | 
+|-------------------------------|---------------|----------------------------------|
+| background_processor.name     | Symbol        | Choose :sidekiq or :resque as the background processor only if messages need to be sent to kafka asynchronously |
+| background_processor.klass    | String        | Background processor class name that sends messages to kafka |
+| timezone_format               | String        | Valid timezone name for timestamps sent to kafka |
+| message_format                | Symbol        | Only supports :json format currently |
+| send_messages                 | Boolean       | Should we send messages to Kafka |
+| kafka.hosts                   | Array<String> | Kafka servers hosts with ports   |
+| connection_pool_size          | Integer       | Kafka connection pool size       |
+| connection_pool_timeout       | Integer       | Kafka connection pool timeout    |
+| raise_on_failure              | Boolean       | Should we raise an exception when we cannot send message to Kafka - if false will silently ignore failures (will just ignore them) |
+
+The timezone setting will transform any timestamp attributes in the message to the specified format.
+
+## Usage
+
+### 1. Sending messages to kafka asynchronously
+
+The underlying Kafka client used by `pheromone` is `ruby-kafka`. This client provides a normal producer that sends messages to Kafka synchronously, and an `async_producer` to send messages to Kafka asynchronously.
+
+It is advisable to use the normal producer in production systems because async producer provides no guarantees that the messages will be delivered. To read more on this, refer the `ruby-kafka` [documentation](https://github.com/zendesk/ruby-kafka#asynchronously-producing-messages)
+
+Even while using a synchronous producer, sometimes there might be a need to run send messages to Kafka in a background task. This is especially true for batch processing tasks that send a high message volume to Kafka. To allow for this, `pheromone` provides an `async` mode that can be specified as an option to `publish` by specifying `dispatch_method` as `:async`. By default, `dispatch_method` will be `:sync`. Specifying `:async` will still use the normal producer and NOT the async_producer.
+  
+```
+class PublishableModel < ActiveRecord::Base
+  include Pheromone::Publishable
+  publish [
+    {
+      event_types: [:create],
+      topic: :topic_test,
+      message: ->(obj) { { name: obj.name } },
+      dispatch_method: :async
+    }
+  ]
 end
 ```
+The background_processor can be set inside `Pheromone.config.background_processor.name` as either `:resque` or `sidekiq`.
 
-## Usage
+#### 1.a. Using `:resque`
+
+Create a new class and add the name under `Pheromone.config.background_processor.klass`. Implement a class method `perform(message)`, and invoke `message.send!` inside the method as shown below:
+
+```
+ class ResqueJob
+   @queue = :low
 
-### 1. Supported events
-#### 1.a. To send messages for model `create` event, add the following lines to your ActiveRecord model
+   def self.perform(message)
+     message.send!
+   end
+ end
+```
+#### 1.b. Using `:sidekiq`
+Create a new class and add the name under `Pheromone.config.background_processor.klass`. Implement an instance method `perform_async(message)`, and invoke `message.send!` inside the method as shown below:
+
+```
+ class SidekiqJob
+   include Sidekiq::Worker
+   def perform(message)
+     message.send!
+   end
+ end
+```
+`pheromone` will invoke the class name specified in the config with the message object. This mode can be used if you don't want to block a request that ends up sending messages to Kafka.
+
+### 2. Supported events
+#### 2.a. To send messages for model `create` event, add the following lines to your ActiveRecord model
 
 ```
 class PublishableModel < ActiveRecord::Base
-  include Pheromone
+  include Pheromone::Publishable
   publish [
     {
       event_types: [:create],
@@ -76,11 +130,11 @@ class PublishableModel < ActiveRecord::Base
 end
 ```
 
-#### 1.b. To send messages for model `update` event, specify `update` in the `event_types` array:
+#### 2.b. To send messages for model `update` event, specify `update` in the `event_types` array:
 
 ```
 class PublishableModel < ActiveRecord::Base
-  include Pheromone
+  include Pheromone::Publishable
   publish [
     {
       event_types: [:update],
@@ -93,13 +147,13 @@ end
 
 Messages can be published for multiple event types by defining `events_types: [:create, :update]`.
 
-### 2. Supported message formats
+### 3. Supported message formats
 
-#### 2.a. Using a proc in `message`
+#### 3.a. Using a proc in `message`
 
 ```
 class PublishableModel < ActiveRecord::Base
-  include Pheromone
+  include Pheromone::Publishable
   publish [
     {
       event_types: [:create],
@@ -110,11 +164,11 @@ class PublishableModel < ActiveRecord::Base
 end
 ```
 
-#### 2.b. Using a defined function in `message`
+#### 3.b. Using a defined function in `message`
 
 ```
 class PublishableModel < ActiveRecord::Base
-  include Pheromone
+  include Pheromone::Publishable
   publish [
     {
       event_types: [:update],
@@ -129,11 +183,11 @@ class PublishableModel < ActiveRecord::Base
 end
 ```
 
-#### 2.c. Using a serializer in `message`
+#### 3.c. Using a serializer in `message`
 
 ```
 class PublishableModel < ActiveRecord::Base
-  include Pheromone
+  include Pheromone::Publishable
   publish [
     {
       event_types: [:create],
@@ -145,13 +199,13 @@ end
 ```
 
 
-### 3. Sending messages conditionally
+### 4. Sending messages conditionally
 
-#### 3.a. Using a proc in `if`
+#### 4.a. Using a proc in `if`
 
 ```
 class PublishableModel < ActiveRecord::Base
-  include Pheromone
+  include Pheromone::Publishable
   publish [
     {
       event_types: [:update],
@@ -166,11 +220,11 @@ class PublishableModel < ActiveRecord::Base
   end
 end
 ```
-#### 3.b. Using a defined function in `if`
+#### 4.b. Using a defined function in `if`
 
 ```
 class PublishableModel < ActiveRecord::Base
-  include Pheromone
+  include Pheromone::Publishable
   publish [
     {
       event_types: [:update],
@@ -190,14 +244,14 @@ class PublishableModel < ActiveRecord::Base
 end
 ```
 
-### 4. Specifying the topic
+### 5. Specifying the topic
 
 The kafka topic can be specified in the `topic` option to `publish`. To publish to `topic_test`, use the following:
 
 
 ```
 class PublishableModel < ActiveRecord::Base
-  include Pheromone
+  include Pheromone::Publishable
   publish [
     {
       event_types: [:create],
@@ -208,7 +262,7 @@ class PublishableModel < ActiveRecord::Base
 end
 ```
 
-### 5. Specifying producer options
+### 6. Specifying producer options
 
 [Ruby-Kafka](https://github.com/zendesk/ruby-kafka) allows sending options to change the behaviour of Kafka Producer.
 

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/lib/generators/pheromone/initializer_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators'
+module Pheromone
+  # creates job depedency initializer
+  class InitializerGenerator < Rails::Generators::Base
+    def create_initializer
+      create_file(
+          'config/initializers/pheromone.rb',
+          "Pheromone.setup do |config|\n"\
+          "  # config.background_processor.name = ':resque / :sidekiq'\n"\
+          "  # config.background_processor.klass = 'BackgroundWorker'\n"\
+          "  # config.timezone = 'UTC'\n"\
+          "  config.message_format = :json\n"\
+          "  WaterDrop.setup do |config|\n"\
+          "    config.send_messages = Rails.env.production?\n"\
+          "    config.connection_pool_size = 20\n"\
+          "    config.connection_pool_timeout = 1\n"\
+          "    config.kafka.hosts = [Rails.env.production? ? ENV['KAFKA_HOST'] : 'localhost:9092']\n"\
+          "    config.raise_on_failure = Rails.env.production?\n"\
+          "  end\n"\
+          "end"\
+      )
+    end
+  end
+end

data/lib/pheromone/config.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'dry-configurable'
+module Pheromone
+  # configurator for setting up all the configurable settings for pheromone
+  class Config
+    extend Dry::Configurable
+    # accepts message format. Currently only accepts :json as the permitted value
+    setting :message_format, :json
+    setting :background_processor do
+      # accepts :sidekiq or :resque as a value
+      setting :name
+      # specify the background job handling message send to kafka
+      setting :klass
+    end
+    # timezone names should match a valid timezone defined here:
+    # http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html
+    # accepts a valid timezone name
+    setting :timezone, 'UTC'
+    class << self
+      def setup
+        configure do |config|
+          yield(config)
+        end
+      end
+    end
+  end
+end

data/lib/pheromone/exceptions/invalid_publish_options.rb

@@ -0,0 +1,9 @@
+module Pheromone
+  module Exceptions
+    class InvalidPublishOptions < StandardError
+      def initialize(msg = 'Message format not supported')
+        super
+      end
+    end
+  end
+end

data/lib/pheromone/exceptions/unsupported_message_format.rb

@@ -0,0 +1,9 @@
+module Pheromone
+  module Exceptions
+    class UnsupportedMessageFormat < StandardError
+      def initialize(msg = 'Message format not supported')
+        super
+      end
+    end
+  end
+end

data/lib/pheromone/messaging/message_dispatcher.rb

@@ -0,0 +1,56 @@
+require 'pheromone'
+require 'pheromone/messaging/message_formatter'
+require 'waterdrop'
+# This module is used for sending messages to Kafka
+# Dispatch method can be :sync or :async
+# When dispatch_method is async, the message object is passed to a job
+# the job needs to call `send!` on the WaterDrop::Message object
+module Pheromone
+  module Messaging
+    class MessageDispatcher
+      def initialize(message_parameters:, dispatch_method:)
+        @message_parameters = message_parameters
+        @dispatch_method = dispatch_method
+      end
+
+      def dispatch
+        if @dispatch_method == :sync
+          message.send!
+        elsif @dispatch_method == :async
+          send_message_asynchronously
+        end
+      end
+
+      private
+
+      # Allows sending messages via resque or sidekiq. WaterDrop::Message object
+      # is passed and calling `send!` on the object will trigger producing
+      # messages to Kafka
+      def send_message_asynchronously
+        if background_processor.name == :resque
+          Resque.enqueue(background_processor_klass, message)
+        elsif background_processor.name == :sidekiq
+          background_processor_klass.perform_async(message)
+        end
+      end
+
+      def message
+        ::WaterDrop::Message.new(
+          @message_parameters[:topic],
+          MessageFormatter.new(
+            @message_parameters[:message]
+          ).format,
+          @message_parameters[:producer_options] || {}
+        )
+      end
+
+      def background_processor
+        Pheromone.config.background_processor
+      end
+
+      def background_processor_klass
+        @klass ||= background_processor.klass.constantize
+      end
+    end
+  end
+end

data/lib/pheromone/messaging/message_formatter.rb

@@ -0,0 +1,47 @@
+require 'pheromone/exceptions/unsupported_message_format'
+module Pheromone
+  module Messaging
+    class MessageFormatter
+      SUPPORTED_MESSAGE_FORMATS = [:json].freeze
+
+      def initialize(message)
+        @message = message
+      end
+
+      def format
+        if Pheromone.config.message_format == :json
+          convert_to_time_format.to_json
+        elsif !SUPPORTED_MESSAGE_FORMATS.include?(Pheromone.config.message_format)
+          raise Pheromone::Exceptions::UnsupportedMessageFormat.new
+        end
+      end
+
+      private
+
+      # recursively converts time to the timezone set in configuration
+      def convert_to_time_format
+        deep_transform_values!(@message) do |value|
+          if value.is_a? Time
+            value.in_time_zone(Pheromone.config.timezone)
+          else
+            value
+          end
+        end
+      end
+
+      # recursively applies a block to a hash
+      def deep_transform_values!(object, &block)
+        case object
+          when Array
+            object.map! { |element| deep_transform_values!(element, &block) }
+          when Hash
+            object.each do |key, value|
+              object[key] = deep_transform_values!(value, &block)
+            end
+          else
+            yield object
+        end
+      end
+    end
+  end
+end

data/lib/pheromone/method_invoker.rb

@@ -0,0 +1,22 @@
+# calls a proc or method
+module Pheromone
+  module MethodInvoker
+    module InstanceMethods
+      # This method has the :reek:ManualDispatch smell,
+      # which is difficult to avoid since it handles
+      # either a lambda/Proc or a named method from the including
+      # class.
+      def call_proc_or_instance_method(proc_or_symbol)
+        return proc_or_symbol.call(self) if proc_or_symbol.respond_to?(:call)
+        unless respond_to? proc_or_symbol
+          raise "Method #{proc_or_symbol} not found for #{self.class.name}"
+        end
+        __send__(proc_or_symbol)
+      end
+    end
+
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+  end
+end

data/lib/pheromone/publishable.rb

@@ -0,0 +1,104 @@
+# Usage: For publishing messages to kafka, include this concern
+# in the model and then add
+#
+#  publish message_options: [
+#            {
+#              topic: :topic1,
+#              producer_options: {
+#                max_retries: 5,
+#                retry_backoff: 5,
+#                compression_codec: :snappy,
+#                compression_threshold: 10,
+#                required_acks: 1
+#              }
+#              event_types: [:create, :update],
+#              message: { a: 1, b: 2 }
+#              dispatch_method: :async
+#            },....
+#          ]
+#
+# Each entry in message_options will be registered as a potential
+# message to be published to kafka on the after_commit hook of the
+# including model. message_options can take an optional if: key which
+# accepts either a callback or an instance method name - which can be
+# used to decide if the message should be published or not.
+#
+# To control how the model is serialized before being published to kafka
+# either provide a Serializer via the `serializer` key or a callback or instance
+# method name via the `message` key
+require 'pheromone/validators/options_validator'
+require 'pheromone/exceptions/invalid_publish_options'
+require 'pheromone/method_invoker'
+require 'pheromone/messaging/message_dispatcher'
+module Pheromone
+  module Publishable
+    # class methods for the model including Publishable
+    module ClassMethods
+      def publish(message_options)
+        errors = Pheromone::Validators::OptionsValidator.new(
+          message_options
+        ).validate
+        raise Pheromone::Exceptions::InvalidPublishOptions.new(errors) unless errors.empty?
+        __send__(:after_commit, proc { dispatch_messages(message_options: message_options) })
+      end
+    end
+
+    module InstanceMethods
+      include Pheromone::MethodInvoker
+
+      def dispatch_messages(message_options:)
+        message_options.each do |options|
+          next unless check_conditions(options)
+          send_message(options)
+        end
+      end
+
+      private
+
+      def check_conditions(options)
+        condition_callback = options[:if]
+        result = check_event(options)
+        return result unless condition_callback
+        result && call_proc_or_instance_method(condition_callback)
+      end
+
+      def check_event(options)
+        options[:event_types].any? { |event| event == current_event }
+      end
+
+      def send_message(options)
+        Pheromone::Messaging::MessageDispatcher.new(
+          message_parameters: {
+            topic: options[:topic],
+            message: message_meta_data.merge!(blob: message_blob(options)),
+            producer_options: options[:producer_options]
+          },
+          dispatch_method: options[:dispatch_method] || :sync
+        ).dispatch
+      end
+
+      def message_meta_data
+        {
+          event: current_event,
+          entity: self.class.name,
+          timestamp: Time.now
+        }
+      end
+
+      def current_event
+        id_previously_changed? ? :create : :update
+      end
+
+      def message_blob(options)
+        message = options[:message]
+        return call_proc_or_instance_method(message) if message
+        options[:serializer].new(self, options[:serializer_options] || {}).serializable_hash
+      end
+    end
+
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+  end
+end

data/lib/pheromone/templates/resque_job.rb.example

@@ -0,0 +1,7 @@
+# class ResqueJob
+#   @queue = :low
+#
+#   def self.perform(message)
+#     message.send!
+#   end
+# end

data/lib/pheromone/templates/sidekiq_job.rb.example

@@ -0,0 +1,6 @@
+# class SidekiqJob
+#   include Sidekiq::Worker
+#   def perform(message)
+#     message.send!
+#   end
+# end

data/lib/pheromone/validators/options_validator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# validate message options provided to publish method in Publishable concern
+module Pheromone
+  module Validators
+    class OptionsValidator
+      ACCEPTED_EVENT_TYPES = %i(create update).freeze
+      ALLOWED_DISPATCH_METHODS = %i(sync async)
+
+      def initialize(message_options)
+        @errors = {}
+        @message_options = message_options
+      end
+
+      def validate
+        validate_message_options
+        return @errors if @errors.present?
+        validate_topic
+        validate_event_types
+        validate_message_attributes
+        validate_dispatch_method
+        @errors
+      end
+
+      private
+
+      def validate_message_options
+        return if @message_options.is_a?(Array)
+        add_error_message(:message_options, 'Message options should be an array')
+      end
+
+      def validate_topic
+        return if @message_options.all? { |options| options[:topic].present? }
+        add_error_message(:topic, 'Topic name missing')
+      end
+
+      # :reek:FeatureEnvy
+      def validate_event_types
+        return if @message_options.all? do |options|
+          event_types = options[:event_types]
+          next true unless event_types
+          event_types.present? &&
+            event_types.is_a?(Array) &&
+            (event_types - ACCEPTED_EVENT_TYPES).empty?
+        end
+
+        add_error_message(
+          :event_types,
+          "Event types must be a non-empty array with types #{ACCEPTED_EVENT_TYPES.join(',')}"
+        )
+      end
+
+      def validate_message_attributes
+        return if @message_options.all? do |options|
+          options[:serializer].present? || options[:message].present?
+        end
+
+        add_error_message(:message_attributes, 'Either serializer or message should be specified')
+      end
+
+      def validate_dispatch_method
+        dispatch_methods = @message_options.map{ |options| options[:dispatch_method] }
+        return if dispatch_methods.all? do |method|
+          method.nil? || ALLOWED_DISPATCH_METHODS.include?(method)
+        end
+        add_error_message(:dispatch_method, 'Invalid dispatch method')
+      end
+
+      def add_error_message(key, value)
+        @errors.merge!(key => value)
+      end
+    end
+  end
+end

data/lib/pheromone/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Pheromone
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/pheromone.rb

@@ -1,105 +1,17 @@
-require 'pheromone/version'
-require 'pheromone/options_validator'
-require 'active_support'
-require 'waterdrop'
-# Usage: For publishing messages to kafka, include this concern
-# in the model and then add
-#
-#  include Publishable
-#  publish message_options: [
-#            {
-#              topic: :topic1,
-#              producer_options: {
-#                max_retries: 5,
-#                retry_backoff: 5,
-#                compression_codec: :snappy,
-#                compression_threshold: 10,
-#                required_acks: 1
-#              }
-#              event_types: [:create, :update],
-#              message: { a: 1, b: 2 }
-#            },....
-#          ]
-#
-# Each entry in message_options will be registered as a potential
-# message to be published to kafka on the after_commit hook of the
-# including model. message_options can take an optional if: key which
-# accepts either a callback or an instance method name - which can be
-# used to decide if the message should be published or not.
-#
-# To control how the model is serialized before being published to kafka
-# either provide a Serializer via the `serializer` key or a callback or instance
-# method name via the `message` key
-module Pheromone
-  extend ActiveSupport::Concern
+require 'pheromone/publishable'
+require 'pheromone/config'
 
-  # class methods for the model including Publishable
-  module ClassMethods
-    def publish(message_options)
-      errors = OptionsValidator.new(message_options).validate
-      raise "Errors: #{errors}" unless errors.empty?
-      __send__(:after_commit, proc { dispatch_messages(message_options: message_options) })
-    end
-  end
-
-  def dispatch_messages(message_options:)
-    message_options.each do |options|
-      next unless check_conditions(options)
-      begin
-        send_message(options)
-      rescue => error
-        puts error
-      end
+module Pheromone
+  class << self
+    # return config
+    def config
+      Config.config
     end
-  end
-
-  private
-
-  def check_conditions(options)
-    condition_callback = options[:if]
-    return check_event(options) unless condition_callback
-    call_proc_or_instance_method(condition_callback)
-  end
-
-  def check_event(options)
-    options[:event_types].any? { |event| event == current_event }
-  end
-
-  def send_message(options)
-    WaterDrop::Message.new(
-      options[:topic],
-      message_meta_data.merge!(blob: message_blob(options)).to_json,
-      options[:producer_options] || {}
-    ).send!
-  end
-
-  def message_meta_data
-    {
-      event: current_event,
-      entity: self.class.name,
-      timestamp: Time.now
-    }
-  end
 
-  def current_event
-    id_previously_changed? ? :create : :update
-  end
-
-  def message_blob(options)
-    message = options[:message]
-    return call_proc_or_instance_method(message) if message
-    options[:serializer].new(self, options[:serializer_options] || {}).serializable_object
-  end
-
-  # This method has the :reek:ManualDispatch smell,
-  # which is difficult to avoid since it handles
-  # either a lambda/Proc or a named method from the including
-  # class.
-  def call_proc_or_instance_method(proc_or_symbol)
-    return proc_or_symbol.call(self) if proc_or_symbol.respond_to?(:call)
-    unless respond_to? proc_or_symbol
-      raise "Method #{proc_or_symbol} not found for #{self.class.name}"
+    # Provides a block to override default config
+    def setup(&block)
+      Config.setup(&block)
     end
-    __send__(proc_or_symbol)
   end
 end
+

data/pheromone.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pheromone/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pheromone'
+  spec.version       = Pheromone::VERSION
+  spec.authors       = ['Ankita Gupta']
+  spec.email         = ['ankitagupta12391@gmail.com']
+
+  spec.summary       = 'Transmits messages to kafka from active record'
+  spec.description   = 'Sends messages to kafka using different formats and strategies'
+  spec.homepage      = 'https://github.com/ankitagupta12/pheromone'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec)/}) }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'active_model_serializers', '~> 0.9'
+  spec.add_dependency 'activerecord', '>= 4.2.5'
+  spec.add_dependency 'bundler', '>= 0'
+  spec.add_dependency 'dry-configurable', '~> 0.6'
+  spec.add_dependency 'waterdrop', '~> 0.3.2.1'
+
+  spec.add_development_dependency 'activesupport', '>= 4.2.5'
+  spec.add_development_dependency 'generator_spec', '~> 0.9.3'
+  spec.add_development_dependency 'rake', '~> 0'
+  spec.add_development_dependency 'resque', '~> 1.26'
+  spec.add_development_dependency 'rspec-rails', '~> 3.5'
+  spec.add_development_dependency 'sidekiq'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'timecop', '~> 0.8'
+  spec.add_development_dependency 'with_model', '~> 1.2'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pheromone
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Ankita Gupta
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2017-08-03 00:00:00.000000000 Z
+date: 2017-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.3
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.3
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -39,19 +39,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 4.2.5
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.5
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.5
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: waterdrop
   requirement: !ruby/object:Gem::Requirement
@@ -67,33 +81,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.3.2.1
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: 4.2.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: 4.2.5
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: generator_spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.9.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.9.3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +178,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: with_model
   requirement: !ruby/object:Gem::Requirement
@@ -153,17 +209,36 @@ dependencies:
 description: Sends messages to kafka using different formats and strategies
 email:
 - ankitagupta12391@gmail.com
-executables: []
+executables:
+- console
+- setup
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rspec"
 - CODE_OF_CONDUCT.md
+- CONTRIBUTIONS.rst
+- Gemfile
+- LICENSE.txt
 - README.md
+- Rakefile
 - bin/console
 - bin/setup
+- lib/generators/pheromone/initializer_generator.rb
 - lib/pheromone.rb
-- lib/pheromone/options_validator.rb
+- lib/pheromone/config.rb
+- lib/pheromone/exceptions/invalid_publish_options.rb
+- lib/pheromone/exceptions/unsupported_message_format.rb
+- lib/pheromone/messaging/message_dispatcher.rb
+- lib/pheromone/messaging/message_formatter.rb
+- lib/pheromone/method_invoker.rb
+- lib/pheromone/publishable.rb
+- lib/pheromone/templates/resque_job.rb.example
+- lib/pheromone/templates/sidekiq_job.rb.example
+- lib/pheromone/validators/options_validator.rb
 - lib/pheromone/version.rb
+- pheromone.gemspec
 homepage: https://github.com/ankitagupta12/pheromone
 licenses:
 - MIT

data/lib/pheromone/options_validator.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-# validate message options provided to publish method in Publishable concern
-class OptionsValidator
-  ACCEPTED_EVENT_TYPES = %i(create update).freeze
-
-  def initialize(message_options)
-    @errors = {}
-    @message_options = message_options
-  end
-
-  def validate
-    validate_message_options
-    return @errors if @errors.present?
-    validate_topic
-    validate_event_types
-    validate_message_attributes
-    @errors
-  end
-
-  private
-
-  def validate_message_options
-    return if @message_options.is_a?(Array)
-    add_error_message(:message_options, 'Message options should be an array')
-  end
-
-  def validate_topic
-    return if @message_options.all? { |options| options[:topic].present? }
-    add_error_message(:topic, 'Topic name missing')
-  end
-
-  # :reek:FeatureEnvy
-  def validate_event_types
-    return if @message_options.all? do |options|
-      event_types = options[:event_types]
-      next true unless event_types
-      event_types.present? &&
-        event_types.is_a?(Array) &&
-        (event_types - ACCEPTED_EVENT_TYPES).empty?
-    end
-
-    add_error_message(
-      :event_types,
-      "Event types must be a non-empty array with types #{ACCEPTED_EVENT_TYPES.join(',')}"
-    )
-  end
-
-  def validate_message_attributes
-    return if @message_options.all? do |options|
-      options[:serializer].present? || options[:message].present?
-    end
-
-    add_error_message(:message_attributes, 'Either serializer or message should be specified')
-  end
-
-  def add_error_message(key, value)
-    @errors.merge!(key => value)
-  end
-end