rabbitmq_client 0.0.0.pre → 0.0.1

data/lib/rabbitmq_client/plain_log_subscriber.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'log_subscriber_base'
+
+module RabbitmqClient
+  # Manage RabbitmqClient plain text logs
+  class PlainLogSubscriber < LogSubscriberBase
+    def publisher_created(event)
+      msg = 'The RabbitmqClient publisher is created ' \
+            "with the follwong configs #{event.payload.inspect}"
+      debug(msg)
+    end
+
+    def network_error(event)
+      payload = event.payload
+      msg = "Failed to publish a message (#{payload.fetch(:error).message}) " \
+            "to exchange (#{payload.dig(:options, :exchange_name)})"
+      error(msg)
+    end
+
+    def overriding_configs(event)
+      msg = 'Overriding the follwing configs for ' \
+            "the created publisher #{event.payload.inspect}"
+      debug(msg)
+    end
+
+    def publishing_message(event)
+      payload = event.payload
+      msg = 'Start>> Publishing a new message ' \
+            "(message_id: #{payload.fetch(:message_id, 'undefined')} ) " \
+            "to the exchange (#{payload.fetch(:exchange, 'undefined')})"
+      debug(msg)
+    end
+
+    def published_message(event)
+      payload = event.payload
+      msg = '<<DONE Published a message to ' \
+           "the exchange (#{payload.fetch(:exchange, 'undefined')}) " \
+           "with message_id: #{payload.fetch(:message_id, 'undefined')}"
+      info(msg)
+    end
+
+    def confirming_message(event)
+      msg = 'Start>> confirming a message ' \
+            "(message_id: #{event.payload.fetch(:message_id, 'undefined')})"
+      debug(msg)
+    end
+
+    def message_confirmed(event)
+      msg_id = event.payload.fetch(:message_id, 'undefined')
+      msg = '<<DONE confirmed a message ' \
+            "(message_id: #{msg_id}) Successfuly"
+      debug(msg)
+    end
+
+    def exhange_not_found(event)
+      error("The Exchange '#{event.payload.fetch(:name)}' cannot be found")
+    end
+
+    def created_exhange(event)
+      debug("The #{event.payload.fetch(:name)} exchange is created successfuly")
+    end
+  end
+end

data/lib/rabbitmq_client/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/class/attribute'
+
+module RabbitmqClient
+  # Custom Error thrown in case of defining a plugin without any callbacks
+  class EmptyPlugin < RuntimeError
+    def initialize(name)
+      super("The Plugin '#{name}' is empty")
+    end
+  end
+  # Plugin class is the base class for all Plugins that
+  # extends RabbitmqClient functionalty.
+  class Plugin
+    def initialize
+      callback_block.call(RabbitmqClient.lifecycle)
+    end
+
+    def callback_block
+      klass = self.class
+      klass.callback_block || (raise EmptyPlugin, klass.to_s)
+    end
+
+    class << self
+      attr_accessor :callback_block
+      def callbacks(&block)
+        @callback_block = block
+      end
+    end
+  end
+end

data/lib/rabbitmq_client/publisher.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'message_publisher'
+
+module RabbitmqClient
+  # Publisher class is responsible for publishing events to rabbitmq exhanges
+  class Publisher
+    def initialize(**config)
+      @config = config
+      @session_params = session_params
+      @exchange_registry = @config.fetch(:exchange_registry, nil)
+      @session_params.freeze
+      @session_pool = create_connection_pool
+      notify('publisher_created', @session_params)
+    end
+
+    def publish(data, options)
+      return nil unless @exchange_registry
+
+      handle_publish_event(data, options)
+    rescue StandardError => e
+      notify('network_error', error: e, options: options)
+      raise
+    end
+
+    private
+
+    def overwritten_config_notification
+      return unless overwritten_config?
+
+      notify('overriding_configs',
+             threaded: false,
+             automatically_recover: false)
+    end
+
+    def overwritten_config?
+      @config.dig(:session_params, :threaded) ||
+        @config.dig(:session_params, :automatically_recover)
+    end
+
+    def session_params
+      overwritten_config_notification
+      @config.fetch(:session_params, {})
+             .merge(threaded: false,
+                    automatically_recover: false,
+                    heartbeat: @config.dig(
+                      :session_params, :heartbeat_publisher
+                    ) || 0)
+    end
+
+    def handle_publish_event(data, options)
+      exchange = @exchange_registry.find(options.fetch(:exchange_name, nil))
+      @session_pool.with do |session|
+        session.start
+        channel = session.create_channel
+        channel.confirm_select
+        message = MessagePublisher.new(data, exchange, channel, options)
+        message.publish
+        message.wait_for_confirms
+        channel.close
+      end
+    end
+
+    def create_connection_pool
+      pool_size = @session_params.fetch(:session_pool, 1)
+      ConnectionPool.new(size: pool_size) do
+        Bunny.new(@config[:rabbitmq_url],
+                  { logger: RabbitmqClient.logger }.merge(@session_params))
+      end
+    end
+
+    def notify(event, payload = {})
+      ActiveSupport::Notifications.instrument(
+        "#{event}.rabbitmq_client",
+        payload
+      )
+    end
+  end
+end

data/lib/rabbitmq_client/tags_filter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RabbitmqClient
+  # ExchangeRegistry is a store for all managed exchanges and their details
+  class TagsFilter
+    def self.tags
+      config = RabbitmqClient.config
+      global_store = config.global_store
+      return unless global_store
+
+      global_store.store.select do |key, _value|
+        Array(config.whitelist).include? key.downcase.to_sym
+      end
+    end
+  end
+end

data/lib/rabbitmq_client/text_formatter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'English'
+
+module RabbitmqClient
+  # Formatter for text log messages
+  class TextFormatter < ::Logger::Formatter
+    def initialize
+      @datetime_format = nil
+      @severity_text = nil
+      @tags = nil
+      super
+    end
+
+    def call(severity, time, progname, msg)
+      create_instance_vars(severity)
+      format(Format,
+             @severity_text[0],
+             format_datetime(time),
+             $PID,
+             @severity_text,
+             progname,
+             "#{@tags}#{msg2str(msg)}")
+    end
+
+    private
+
+    def create_instance_vars(severity)
+      @severity_text = if severity.is_a?(Integer)
+                         Logger::Severity.constants(false).select do |level|
+                           Logger::Severity.const_get(level) == severity
+                         end.first.to_s
+                       else
+                         severity
+                       end
+      @tags = (TagsFilter.tags || {}).collect do |key, val|
+        "[#{key}: #{val}] "
+      end.join
+    end
+  end
+end

data/lib/rabbitmq_client/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# :nodoc:
 module RabbitmqClient
-  VERSION = '0.0.0.pre'
+  VERSION = '0.0.1'
 end

data/lib/rabbitmq_client.rb

@@ -1,8 +1,105 @@
 # frozen_string_literal: true
 
+require 'active_support'
+require 'bunny'
+require 'connection_pool'
+
 require 'rabbitmq_client/version'
+require 'rabbitmq_client/lifecycle'
+require 'rabbitmq_client/plugin'
+require 'rabbitmq_client/exchange_registry'
+require 'rabbitmq_client/publisher'
 
+# RabbitmqClient Module is used as a clinet library for Rabbitmq
+# This Module is supporting the following use cases
+# - Publish events to Rabbitmq server
 module RabbitmqClient
-  class Error < StandardError; end
-  # Your code goes here...
+  extend ActiveSupport::Autoload
+
+  include ActiveSupport::Configurable
+  include ActiveSupport::JSON
+
+  eager_autoload do
+    autoload :LoggerBuilder
+    autoload :PlainLogSubscriber
+    autoload :JsonLogSubscriber
+    autoload :JsonFormatter
+    autoload :TextFormatter
+    autoload :TagsFilter
+  end
+
+  @exchange_registry = ExchangeRegistry.new
+  # [url] url address of rabbitmq server
+  config_accessor(:rabbitmq_url, instance_accessor: false) do
+    'amqp://guest:guest@127.0.0.1:5672'
+  end
+
+  # [logger_configs] configs for teh used logger
+  # logs_format: json, plain
+  # logs_to_stdout: true, false
+  # logs_level: info, debug
+  # logs_filename: logs file name
+  config_accessor(:logger_configs, instance_accessor: false) do
+    {
+      logs_format: 'plain',
+      logs_level: :info,
+      logs_filename: nil,
+      logger: nil
+    }
+  end
+  # default rabbitmq configs
+  # heartbeat_publisher = 0
+  # session_pool = 1
+  config_accessor(:session_params, instance_accessor: false) do
+    {
+      heartbeat_publisher: 0,
+      session_pool: 1
+    }
+  end
+
+  config_accessor(:plugins, instance_accessor: false) { [] }
+  config_accessor(:global_store, instance_accessor: false) { nil }
+  config_accessor(:whitelist, instance_accessor: false) do
+    ['x-request-id'.to_sym]
+  end
+
+  class << self
+    def add_exchange(name, type, options = {})
+      @exchange_registry.add(name, type, options)
+    end
+
+    def publish(payload, options = {})
+      publisher.publish(payload, options)
+    end
+
+    def lifecycle
+      @lifecycle ||= setup_lifecycle
+    end
+
+    def logger
+      @logger ||= setup_logger
+    end
+
+    private
+
+    def setup_logger
+      LoggerBuilder.new(config[:logger_configs]).build_logger
+    end
+
+    def publisher
+      @publisher ||= init_publisher
+    end
+
+    def init_publisher
+      Publisher.new(config.merge(
+                      exchange_registry: @exchange_registry
+                    ))
+    end
+
+    def setup_lifecycle
+      @lifecycle = Lifecycle.new
+      plugins.each(&:new)
+      @lifecycle
+    end
+  end
 end

data/rabbitmq_client.gemspec

@@ -32,6 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rubycritic-small-badge', '~> 0.2.1'
   spec.add_development_dependency 'simplecov', '~> 0.17.1'
   spec.add_development_dependency 'simplecov-small-badge', '~> 0.2.4'
+  spec.add_development_dependency 'solargraph', '~> 0.37.2'
   spec.add_development_dependency 'timecop', '~> 0.9.1'
 
   spec.files         = `git ls-files`.split("\n")

data/script/travis.sh

@@ -13,6 +13,8 @@ if [ -z "$QUICK" ]; then
     echo "Pushing badges upstream"
     [ -d badges ] || mkdir badges
     cp coverage/coverage_badge* badges/ 2>/dev/null || true
+    cp -r coverage coverage_info 2>/dev/null || true
+    cp -r tmp/rubycritic rubycritic 2>/dev/null || true
   fi
 
 fi

data/spec/callback_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative 'support/dummy_rabbitmq_client_plugin'
+
+describe RabbitmqClient::Callback do
+  subject { described_class.new }
+
+  let(:callback) { ->(*_args) {} }
+
+  it 'initialize with emprty events' do
+    expect(subject.instance_variable_get(:@before).count).to eq 0
+    expect(subject.instance_variable_get(:@after).count).to eq 0
+  end
+
+  it 'raises for unsupported events' do
+    expect do
+      subject.add(:execute, &callback)
+    end.to raise_error(
+      RabbitmqClient::InvalidCallback, /Invalid callback type: execute/
+    )
+  end
+
+  it 'add before and after events' do
+    expect { subject.add(:before, &callback) }.not_to raise_error
+    expect { subject.add(:after, &callback) }.not_to raise_error
+
+    expect(subject.instance_variable_get(:@before).count).to eq 1
+    expect(subject.instance_variable_get(:@after).count).to eq 1
+  end
+end

data/spec/exchange_registry_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RabbitmqClient::ExchangeRegistry do
+  let(:registry) { described_class.new }
+
+  let(:exchange_name) { 'tmp_exchange' }
+  let(:exchange_type) { 'test' }
+  let(:exchange_opt) { { opt: false } }
+
+  it 'initialize with emprty registry' do
+    expect(registry.instance_variable_get(:@exchanges)).to be_empty
+  end
+
+  it 'add and find exchanges' do
+    expect do
+      registry.add(exchange_name, exchange_type, exchange_opt)
+    end.not_to raise_error
+
+    exchange = registry.find(exchange_name)
+    expect(exchange.name).to eq exchange_name
+    expect(exchange.type).to eq exchange_type
+    expect(exchange.options).to eq exchange_opt
+  end
+
+  it 'raise error for unknown exchanges' do
+    expect do
+      registry.find(exchange_name)
+    end.to raise_error(described_class::ExchangeNotFound)
+  end
+end

data/spec/json_formatter_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RabbitmqClient::JsonFormatter do
+  subject { described_class.new }
+  let(:message) { 'Test loG message' }
+  let(:global_store) { double('Store') }
+  let(:time) { Time.now }
+  let(:formated_time) { time.strftime('%Y-%m-%dT%H:%M:%S.%6N ') }
+
+  before do
+    RabbitmqClient.config.global_store = global_store
+  end
+
+  after do
+    RabbitmqClient.config.global_store = nil
+  end
+  describe '.call' do
+    it 'formatt the log message' do
+      allow(global_store).to receive(:store).and_return({})
+      log_line = subject.call('DEBUG', time, nil, message)
+      json_log = JSON.parse(log_line[0...-1])
+      expect(json_log).to eq(
+        'level' => 'DEBUG',
+        'message' => 'Test loG message',
+        'timestamp' => formated_time
+      )
+    end
+
+    it 'add tags to the log message' do
+      allow(global_store).to receive(:store).and_return('x-request-id': '10')
+      log_line = subject.call('DEBUG', time, nil, message)
+      json_log = JSON.parse(log_line[0...-1])
+      expect(json_log).to eq(
+        'level' => 'DEBUG',
+        'message' => 'Test loG message',
+        'timestamp' => formated_time,
+        'x-request-id' => '10'
+      )
+    end
+  end
+end

data/spec/json_log_subscriber_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RabbitmqClient::JsonLogSubscriber do
+  class DummyEvent < ActiveSupport::Notifications::Event
+    def initialize(event_type, payload = {})
+      super(event_type, Time.now, Time.now, 1, payload)
+    end
+  end
+
+  let(:error) { double('error') }
+
+  before do
+    allow(error).to receive(:message).and_return('error')
+  end
+
+  describe '#publisher_created' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug).with(
+        action: 'publisher_created',
+        message: 'The RabbitmqClient publisher is created',
+        publisher_configs: {},
+        source: 'rabbitmq_client'
+      )
+      subject.publisher_created(DummyEvent.new(
+                                  'publisher_created.rabbitmq_client',
+                                  {}
+                                ))
+    end
+  end
+
+  describe '#network_error' do
+    let(:payload) { { error: error, options: { exchange_name: 'exchange' } } }
+    it 'send logger a error message' do
+      expect(subject.logger).to receive(:error).with(
+        action: 'network_error',
+        error_message: 'error',
+        exchange_name: 'undefined',
+        message: 'Failed to publish a message',
+        message_id: 'undefined', source: 'rabbitmq_client'
+      )
+      subject.network_error(
+        DummyEvent.new('network_error.rabbitmq_client', payload)
+      )
+    end
+  end
+  describe '#overriding_configs' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug).with(
+        action: 'overriding_configs',
+        message: 'Overriding publisher configs',
+        publisher_configs: {},
+        source: 'rabbitmq_client'
+      )
+      subject.overriding_configs(
+        DummyEvent.new('overriding_configs.rabbitmq_client', {})
+      )
+    end
+  end
+  describe '#publishing_message' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug).with(
+        action: 'publishing_message',
+        exchange_name: 'undefined',
+        message: 'Publishing a new message',
+        message_id: 'undefined',
+        source: 'rabbitmq_client'
+      )
+      subject.publishing_message(
+        DummyEvent.new('publishing_message.rabbitmq_client', {})
+      )
+    end
+  end
+  describe '#published_message' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:info).with(
+        action: 'published_message',
+        exchange_name: 'undefined',
+        message: 'Published a message',
+        message_id: 'undefined',
+        source: 'rabbitmq_client'
+      )
+      subject.published_message(
+        DummyEvent.new('published_message.rabbitmq_client', {})
+      )
+    end
+  end
+  describe '#confirming_message' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug).with(
+        action: 'confirming_message',
+        exchange_name: 'undefined',
+        message: 'Confirming a message',
+        message_id: 'undefined',
+        source: 'rabbitmq_client'
+      )
+      subject.confirming_message(
+        DummyEvent.new('confirming_message.rabbitmq_client', {})
+      )
+    end
+  end
+  describe '#message_confirmed' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug).with(
+        action: 'message_confirmed',
+        exchange_name: 'undefined',
+        message: 'Confirmed a message',
+        message_id: 'undefined',
+        source: 'rabbitmq_client'
+      )
+      subject.message_confirmed(
+        DummyEvent.new('message_confirmed.rabbitmq_client', {})
+      )
+    end
+  end
+  describe '#exhange_not_found' do
+    let(:payload) { { name: 'exchange' } }
+    it 'send logger a error message' do
+      expect(subject.logger).to receive(:error).with(
+        action: 'exhange_not_found',
+        exchange_name: 'exchange',
+        message: 'Exhange Not Found',
+        source: 'rabbitmq_client'
+      )
+      subject.exhange_not_found(
+        DummyEvent.new('exhange_not_found.rabbitmq_client', payload)
+      )
+    end
+  end
+  describe '#created_exhange' do
+    let(:payload) { { name: 'exchange' } }
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug).with(
+        action: 'created_exhange',
+        exchange_name: 'exchange',
+        message: 'Exhange is created successfuly',
+        source: 'rabbitmq_client'
+      )
+      subject.created_exhange(
+        DummyEvent.new('created_exhange.rabbitmq_client', payload)
+      )
+    end
+  end
+end