rabbit_messaging 0.7.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f1b038de91f05a992e1c8cd26cd2fbffc3eacff6876b53399ec48452dbdd57d
-  data.tar.gz: b1c5c72e4486dad8150b5c96e0e84dcd170362267addb5126a4b41a15442c7d1
+  metadata.gz: 4cad15ae9d132080bcf28a14883df7a97a5f010bc87e32b7904467d136404741
+  data.tar.gz: bd799cfe37ffd1ef3d8b139fae8440807efe44a10fe886d19b3a2cdfaac9426b
 SHA512:
-  metadata.gz: af0bdacb84ef30a921b8feb3037d0a09ad989ad869fed8b21a213e5be990181fe9c96367c3e5ca601935c9b135a0b3bb3ad1f2a021047df3ccc1548ce8452883
-  data.tar.gz: e1e4250eb88622b1c0f27aa8abac6d117cfd0672fc75750b2f6f76c357459298fd115a11cf45d29812bcc9decc032ab91dee00251d0dff7b52ef4d9efc0a92e1
+  metadata.gz: e417cacf4032d25f7452e77eb9f2bd966f5933f1d6fc0334c785b34ba482824d8920f548dc8ce848be7db969c75f0496d22e6554b2cf65cf59a60b7290046486
+  data.tar.gz: 4843680308d9d9c882fad903d003f4b973fc23860af14c8a3f29138187726cba6182974a91eed83cd723e73d9223b6d4b8710f0c05fe8d0af3223519296d77b9

data/.rubocop.yml

@@ -3,7 +3,7 @@ inherit_gem:
 
 AllCops:
   DisplayCopNames: true
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.5
   Include:
     - lib/**/*.rb
     - spec/**/*.rb

data/.travis.yml

@@ -2,10 +2,9 @@ language: ruby
 matrix:
   fast_finish: true
   include:
-  - rvm: 2.3
-  - rvm: 2.4
   - rvm: 2.5
   - rvm: 2.6
+  - rvm: 2.7
   - rvm: ruby-head
   allow_failures:
   - rvm: ruby-head

data/CHANGELOG.md

@@ -1,6 +1,28 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## [0.8.1] - 2020-11-05
+### Added
+- channels pool for manage channels on Publisher connection
+### Changed
+- Publisher use channels pool for access to channel
+
+## [0.8.0] - 2020-10-28
+### Added
+- class Rabbit::Recieving::Receive for message processing
+- class Rabbit::Recieving::Queue for queue name determination when receiving
+- message_id argument in published and received messages
+- before and after hooks when processing message
+- specs for new functionality
+- arguments attribute in received message and handler (contain raw message arguments with exchange and routing_key from the delivery_info)
+
+### Changed
+- Rabbit::Receiving::Worker refactoring (message processing moved to a separate class)
+- ruby version upped to 2.5
+- rubocop ruby target version set to 2.5
+- some fixes of updated rubocop and ruby warnings
+- heavy refactoring of old specs for receiving
+
 ## [0.7.1] - 2020-06-09
 ### Changed
 - (Partially Fixed) Support for pre-defined logger injection on Sneakers moudle;

data/README.md

@@ -71,6 +71,22 @@ require "rabbit_messaging"
       config.exception_notifier = proc { |e| MyCoolNotifier.notify!(e) }
     ```
 
+  * `before_receiving_hooks, after_receiving_hooks` (`Array of Procs`)
+
+    Before and after hooks with message processing in the middle. Where `before_receiving_hooks` and `after_receiving_hooks` are empty arrays by default.
+    
+    It's advised to NOT place procs with long execution time inside.
+
+    Setup:
+
+    ```ruby
+      config.before_receiving_hooks.append(proc { |message, arguments| do_stuff_1 })
+      config.before_receiving_hooks.append(proc { |message, arguments| do_stuff_2 })
+
+      config.after_receiving_hooks.append(proc { |message, arguments| do_stuff_3 })
+      config.after_receiving_hooks.append(proc { |message, arguments| do_stuff_4 })
+
+    ```
 ---
 
 ### Client
@@ -83,6 +99,7 @@ Rabbit.publish(
   exchange_name: 'fanout', # default is fine too
   confirm_select: true, # setting this to false grants you great speed up and absolutelly no guarantees
   headers: { "foo" => "bar" }, # custom arguments for routing, default is {}
+  message_id: "asdadsadsad", # A unique identifier such as a UUID that your application can use to identify the message.
 )
 ```
 

data/lib/rabbit.rb

@@ -23,6 +23,8 @@ module Rabbit
     attribute :queue_name_conversion
     attribute :receiving_job_class_callable
     attribute :exception_notifier, default: -> { default_exception_notifier }
+    attribute :before_receiving_hooks, default: []
+    attribute :after_receiving_hooks, default: []
 
     attribute :receive_logger, default: lambda {
       Logger.new(Rails.root.join("log", "incoming_rabbit_messages.log"))

data/lib/rabbit/daemon.rb

@@ -28,7 +28,7 @@ module Rabbit
         Sneakers.logger = Logger.new(Rails.root.join("log", "sneakers.log"))
         Sneakers.logger.level = Logger::DEBUG
         Lamian.extend_logger(Sneakers.logger)
-      end  
+      end
 
       Sneakers.server = true
 

data/lib/rabbit/event_handler.rb

@@ -7,7 +7,9 @@ class Rabbit::EventHandler
   include Tainbox
 
   attribute :project_id
-  attr_accessor :data
+  attribute :data
+  attribute :message_info
+
   class_attribute :queue
   class_attribute :ignore_queue_conversion, default: false
 
@@ -20,8 +22,9 @@ class Rabbit::EventHandler
   end
 
   def initialize(message)
-    self.attributes = message.data
-    self.data       = message.data
-    self.project_id = message.project_id
+    self.attributes   = message.data
+    self.data         = message.data
+    self.project_id   = message.project_id
+    self.message_info = message.arguments
   end
 end

data/lib/rabbit/publishing.rb

@@ -5,39 +5,32 @@ require "rabbit/publishing/message"
 module Rabbit
   module Publishing
     autoload :Job, "rabbit/publishing/job"
+    autoload :ChannelsPool, "rabbit/publishing/channels_pool"
+    extend self
 
     MUTEX = Mutex.new
 
-    extend self
+    def publish(msg)
+      return if Rabbit.config.environment.in? %i[test development]
 
-    def publish(message)
-      return unless client
+      pool.with_channel msg.confirm_select? do |ch|
+        ch.basic_publish *msg.basic_publish_args
 
-      channel = channel(message.confirm_select?)
-      channel.basic_publish(*message.basic_publish_args)
+        raise MessageNotDelivered, "RabbitMQ message not delivered: #{msg}" \
+          if msg.confirm_select? && !ch.wait_for_confirms
 
-      if message.confirm_select? && !channel.wait_for_confirms
-        raise MessageNotDelivered, "RabbitMQ message not delivered: #{message}"
-      else
-        log(message)
+        log msg
       end
     rescue Timeout::Error
       raise MessageNotDelivered, <<~MESSAGE
-        Timeout while sending message #{message}. Possible reasons:
-          - #{message.real_exchange_name} exchange is not found
+        Timeout while sending message #{msg}. Possible reasons:
+          - #{msg.real_exchange_name} exchange is not found
           - RabbitMQ is extremely high loaded
       MESSAGE
     end
 
-    def client
-      MUTEX.synchronize { @client ||= create_client }
-    end
-
-    def channel(confirm)
-      Thread.current[:bunny_channels] ||= {}
-      channel = Thread.current[:bunny_channels][confirm]
-      Thread.current[:bunny_channels][confirm] = create_channel(confirm) unless channel&.open?
-      Thread.current[:bunny_channels][confirm]
+    def pool
+      MUTEX.synchronize { @pool ||= ChannelsPool.new(create_client) }
     end
 
     private
@@ -47,22 +40,10 @@ module Rabbit
     end
 
     def create_client
-      return if Rabbit.config.environment == :test
-
       config = Rails.application.config_for("sneakers") rescue {}
       config = config["bunny_options"].to_h.symbolize_keys
 
-      begin
-        Bunny.new(config).start
-      rescue
-        raise unless Rabbit.config.environment == :development
-      end
-    end
-
-    def create_channel(confirm)
-      channel = client.create_channel
-      channel.confirm_select if confirm
-      channel
+      Bunny.new(config).start
     end
 
     def log(message)

data/lib/rabbit/publishing/channels_pool.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Rabbit
+  module Publishing
+    class ChannelsPool
+      class BaseQueue < Queue
+        def initialize(session, max_size)
+          super()
+
+          @session    = session
+          @max_size   = max_size - 1
+          @ch_size    = 0
+          @create_mon = Mutex.new
+          @ch_dec_mon = Mutex.new
+        end
+
+        def pop
+          add_channel if size.zero?
+
+          super
+        end
+        alias_method :deq, :pop
+
+        def push(channel)
+          return @ch_dec_mon.synchronize { @ch_size -= 1 } unless channel&.open?
+
+          super
+        end
+        alias_method :enq, :push
+
+        def add_channel
+          @create_mon.synchronize do
+            return unless @ch_size < @max_size
+
+            push create_channel
+            @ch_size += 1
+          end
+        end
+
+        protected
+
+        def create_channel
+          @session.create_channel
+        end
+      end
+
+      class ConfirmQueue < BaseQueue
+        def create_channel
+          ch = @session.create_channel
+          ch.confirm_select
+
+          ch
+        end
+      end
+
+      def initialize(session)
+        max_size = session.channel_max
+
+        @pools = {
+          true => ConfirmQueue.new(session, max_size / 2),
+          false => BaseQueue.new(session, max_size / 2),
+        }.freeze
+      end
+
+      def with_channel(confirm)
+        pool = @pools[confirm]
+        ch = pool.deq
+        yield ch
+      ensure
+        pool.enq ch
+      end
+    end
+  end
+end

data/lib/rabbit/publishing/message.rb

@@ -6,13 +6,14 @@ module Rabbit::Publishing
   class Message
     include Tainbox
 
-    attribute :routing_key, String
-    attribute :event, String
-    attribute :data, default: {}
-    attribute :exchange_name, default: []
+    attribute :routing_key,    String
+    attribute :event,          String
+    attribute :data,           default: {}
+    attribute :exchange_name,  default: []
     attribute :confirm_select, default: true
-    attribute :realtime, default: false
+    attribute :realtime,       default: false
     attribute :headers
+    attribute :message_id
 
     alias_method :confirm_select?, :confirm_select
     alias_method :realtime?, :realtime
@@ -41,6 +42,7 @@ module Rabbit::Publishing
         content_type: "application/json",
         app_id: Rabbit.config.app_name,
         headers: headers,
+        message_id: message_id,
       }
 
       [JSON.dump(data), real_exchange_name, routing_key.to_s, options]

data/lib/rabbit/receiving/job.rb

@@ -11,14 +11,12 @@ require "rabbit/receiving/malformed_message"
 class Rabbit::Receiving::Job < ActiveJob::Base
   def perform(message, arguments)
     Lamian.run do
-      begin
-        message = Rabbit::Receiving::Message.build(message, arguments)
-        handler = Rabbit::Receiving::HandlerResolver.handler_for(message)
-        handler.new(message).call
-      rescue Rabbit::Receiving::MalformedMessage => error
-        raise if Rabbit.config.environment == :test
-        Rabbit.config.exception_notifier.call(error)
-      end
+      message = Rabbit::Receiving::Message.build(message, arguments)
+      handler = Rabbit::Receiving::HandlerResolver.handler_for(message)
+      handler.new(message).call
+    rescue Rabbit::Receiving::MalformedMessage => error
+      raise if Rabbit.config.environment == :test
+      Rabbit.config.exception_notifier.call(error)
     end
   end
 end

data/lib/rabbit/receiving/message.rb

@@ -10,16 +10,23 @@ module Rabbit::Receiving
 
     attribute :group_id
     attribute :project_id
+    attribute :message_id
     attribute :event
     attribute :data
+    attribute :arguments
     attribute :original_message
 
-    attr_accessor :original_message
-
-    def self.build(message, type:, app_id:, **)
-      group_id, project_id = app_id.split(".")
-
-      new(group_id: group_id, project_id: project_id, event: type, data: message)
+    def self.build(message, arguments)
+      group_id, project_id = arguments.fetch(:app_id).split(".")
+
+      new(
+        group_id: group_id,
+        project_id: project_id,
+        event: arguments.fetch(:type),
+        data: message,
+        message_id: arguments.fetch(:message_id, nil),
+        arguments: arguments,
+      )
     end
 
     def data=(value)

data/lib/rabbit/receiving/queue.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rabbit"
+require "rabbit/receiving/message"
+require "rabbit/receiving/handler_resolver"
+
+class Rabbit::Receiving::Queue
+  attr_reader :message, :arguments, :handler, :queue_name, :ignore_conversion
+
+  delegate :queue, to: :handler
+
+  def initialize(raw_message, arguments)
+    @message           = Rabbit::Receiving::Message.build(raw_message, arguments)
+    @handler           = Rabbit::Receiving::HandlerResolver.handler_for(message)
+    @arguments         = arguments
+    @queue_name        = resolved_queue_name
+    @ignore_conversion = handler.ignore_queue_conversion
+  end
+
+  def name
+    if queue_name
+      calculated_queue_name
+    else
+      Rabbit.default_queue_name(ignore_conversion: ignore_conversion)
+    end
+  rescue
+    Rabbit.default_queue_name
+  end
+
+  private
+
+  def resolved_queue_name
+    queue.is_a?(Proc) ? queue.call(message, arguments) : queue
+  end
+
+  def calculated_queue_name
+    Rabbit.queue_name(queue_name, ignore_conversion: ignore_conversion)
+  end
+end

data/lib/rabbit/receiving/receive.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "tainbox"
+
+require "rabbit"
+require "rabbit/receiving/queue"
+
+class Rabbit::Receiving::Receive
+  autoload :Job, "rabbit/receiving/job"
+
+  include Tainbox
+
+  attribute :message
+  attribute :delivery_info
+  attribute :arguments
+
+  def call
+    log!
+    call_hooks(before_hooks)
+    process_message
+    call_hooks(after_hooks)
+  end
+
+  def log!
+    Rabbit.config.receive_logger.debug(
+      [message, delivery_info, arguments].join(" / "),
+    )
+  end
+
+  def process_message
+    job_class
+      .set(queue: queue)
+      .perform_later(message, message_info)
+  end
+
+  def call_hooks(hooks)
+    hooks.each do |hook_proc|
+      hook_proc.call(message, message_info)
+    end
+  end
+
+  def before_hooks
+    Rabbit.config.before_receiving_hooks || []
+  end
+
+  def after_hooks
+    Rabbit.config.after_receiving_hooks || []
+  end
+
+  def message_info
+    arguments.merge(
+      delivery_info.slice(:exchange, :routing_key),
+    )
+  end
+
+  def queue
+    Rabbit::Receiving::Queue.new(message, arguments).name
+  end
+
+  def job_class
+    Rabbit.config.receiving_job_class_callable&.call || Rabbit::Receiving::Job
+  end
+end

data/lib/rabbit/receiving/worker.rb

@@ -3,52 +3,29 @@
 require "sneakers"
 
 require "rabbit"
-require "rabbit/receiving/message"
-require "rabbit/receiving/malformed_message"
-require "rabbit/receiving/handler_resolver"
+require "rabbit/receiving/receive"
 
-module Rabbit::Receiving
-  autoload :Job, "rabbit/receiving/job"
+class Rabbit::Receiving::Worker
+  include Sneakers::Worker
 
-  class Worker
-    include Sneakers::Worker
-
-    def self.logger
-      @logger ||= Rabbit.config.receive_logger
-    end
-
-    def work_with_params(message, delivery_info, arguments)
-      message = message.dup.force_encoding("UTF-8")
-      self.class.logger.debug([message, delivery_info, arguments].join(" / "))
-      job_class.set(queue: queue(message, arguments)).perform_later(message, arguments.to_h)
-      ack!
-    rescue => error
-      raise if Rabbit.config.environment == :test
-      Rabbit.config.exception_notifier.call(error)
-      requeue!
-    end
-
-    private
-
-    def queue(message, arguments)
-      message           = Rabbit::Receiving::Message.build(message, arguments)
-      handler           = Rabbit::Receiving::HandlerResolver.handler_for(message)
-      queue_name        = handler.queue
-      ignore_conversion = handler.ignore_queue_conversion
-
-      return Rabbit.default_queue_name(ignore_conversion: ignore_conversion) unless queue_name
-
-      calculated_queue = begin
-        queue_name.is_a?(Proc) ? queue_name.call(message, arguments) : queue_name
-      end
+  def work_with_params(message, delivery_info, arguments)
+    receive_message(message, delivery_info, arguments)
+    ack!
+  rescue => error
+    handle_error!(error)
+  end
 
-      Rabbit.queue_name(calculated_queue, ignore_conversion: ignore_conversion)
-    rescue
-      Rabbit.default_queue_name
-    end
+  def receive_message(message, delivery_info, arguments)
+    Rabbit::Receiving::Receive.new(
+      message: message.dup.force_encoding("UTF-8"),
+      delivery_info: delivery_info,
+      arguments: arguments,
+    ).call
+  end
 
-    def job_class
-      Rabbit.config.receiving_job_class_callable&.call || Job
-    end
+  def handle_error!(error)
+    raise if Rabbit.config.environment == :test
+    Rabbit.config.exception_notifier.call(error)
+    requeue!
   end
 end

data/lib/rabbit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rabbit
-  VERSION = "0.7.1"
+  VERSION = "0.8.1"
 end

data/rabbit_messaging.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "rabbit/version"
 
 Gem::Specification.new do |spec|
-  spec.required_ruby_version = ">= 2.3.8"
+  spec.required_ruby_version = ">= 2.5"
 
   spec.name    = "rabbit_messaging"
   spec.version = Rabbit::VERSION
@@ -22,13 +22,13 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "bunny", "~> 2.0"
   spec.add_runtime_dependency "exception_notification"
   spec.add_runtime_dependency "lamian"
-  spec.add_runtime_dependency "rails"
+  spec.add_runtime_dependency "rails", ">= 5.2"
   spec.add_runtime_dependency "sneakers", "~> 2.0"
   spec.add_runtime_dependency "tainbox"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "bundler-audit"
-  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "coveralls", ">=0.8"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabbit_messaging
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.1
 platform: ruby
 authors:
 - Umbrellio
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-09 00:00:00.000000000 Z
+date: 2020-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: sneakers
   requirement: !ruby/object:Gem::Requirement
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -244,6 +244,7 @@ files:
 - lib/rabbit/event_handler.rb
 - lib/rabbit/extensions/bunny/channel.rb
 - lib/rabbit/publishing.rb
+- lib/rabbit/publishing/channels_pool.rb
 - lib/rabbit/publishing/job.rb
 - lib/rabbit/publishing/message.rb
 - lib/rabbit/receiving.rb
@@ -251,6 +252,8 @@ files:
 - lib/rabbit/receiving/job.rb
 - lib/rabbit/receiving/malformed_message.rb
 - lib/rabbit/receiving/message.rb
+- lib/rabbit/receiving/queue.rb
+- lib/rabbit/receiving/receive.rb
 - lib/rabbit/receiving/worker.rb
 - lib/rabbit/test_helpers.rb
 - lib/rabbit/version.rb
@@ -259,7 +262,7 @@ files:
 homepage: https://github.com/umbrellio/rabbit_messaging
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -267,15 +270,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.8
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.0.rc.1
+signing_key:
 specification_version: 4
 summary: Rabbit (Rabbit Messaging)
 test_files: []