banter 1.0.5 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cd09b360f3b05bd5eface4120f9d009441365f68
-  data.tar.gz: 29d94a28bcebce70d175d53e16ca6173b75b05f9
+  metadata.gz: 7eddb3c0d8d9801ac79fe7b7ca04c7f892a4cc0a
+  data.tar.gz: 03fd47b4fe7849b469ace3f1b94ca3640857cd6d
 SHA512:
-  metadata.gz: dc29fc38a2604b657ff4ff8e103cb33c591bfd15e0a58a96105d35f879a404e4a1b09aa26c1f93239b371829476cc62817ace3c1593120d8027f7901a736f7fb
-  data.tar.gz: 0f94f10f1627c52cbc79be446544311f722eb1dbbee5cac85276453f9e942619dda5e208d45b5c321b0f7a0247a0b69fd8fbd9af971e8bd5b5b49c03b04eacc9
+  metadata.gz: fb0cf4082a90fd66772bb400106d77a2898557984b67b25a2363234b2ee5959ea199b80b41397098dbb1488d449d6178268f6af24e48722c8a71716ddfe4c2f9
+  data.tar.gz: f70da6ed9736961564bb996489927b4d5835005b11d57ac8c2ace0c11915747a63bcf1e244fb0f49549c91af72d7ec86537a365b00db6c282c00eb00ae75f2f9

data/lib/banter/configuration.rb

@@ -6,7 +6,7 @@ module Banter
     # being either consumed or discarded.
     # @default 1 hour
     mattr_accessor :default_queue_ttl
-    @@default_queue_ttl = 1.hour
+    @@default_queue_ttl = 36000 # 10 hours in seconds
 
     # The exchange to publish (and subscribe) on RabbitMQ
     # @default true
@@ -44,6 +44,9 @@ module Banter
     mattr_accessor :web_enabled
     @@web_enabled = false
 
+    mattr_accessor :application_name
+    @@application_name = nil
+
     def self.configure_with(environment_name, yaml_file = nil)
       @@yaml_file = yaml_file.nil? ? "config/banter.yml" : yaml_file
       @@all_conf = Hashie::Mash.new(YAML.load_file(@@yaml_file) )
@@ -73,12 +76,5 @@ module Banter
       end
     end
 
-    def self.application_name
-      @application_name ||= if defined?(Rails)
-        Rails.application.class.name.to_s.gsub("::Application", '')
-      else
-        'banter'
-      end.downcase
-    end
   end
 end

data/lib/banter/publisher.rb

@@ -104,9 +104,11 @@ module Banter
     end
 
     def teardown
-      # FIX!!! -thl
-      # How can I check to see if the connection is valid quickly without trying a close on the connection?
-      @connection.close
+      begin
+        @connection.close
+      rescue => e
+        Banter::RabbitLogger.log(Logger::WARN, "RabbitMQ teardown failed: #{e.message}: #{e.backtrace}")
+      end
       @publisher = nil
     end
 

data/lib/banter/railtie.rb

@@ -13,6 +13,7 @@ module Banter
     config.after_initialize do
       Banter.logger = config.banter.logger if config.banter.logger
 
+      Banter::Configuration.application_name = Rails.application.class.name.to_s.gsub("::Application", '').downcase
       if Banter::Configuration.web_enabled
         require 'banter/web'
       end

data/lib/banter/server/client_queue_listener.rb

@@ -10,17 +10,17 @@ module Banter
 
       attr_reader :worker_class
 
-      def initialize(worker_class, request_key, queue, durable = true, topic = nil)
+      def initialize(worker_class, request_key, queue_name, durable = true, topic = nil)
         @topic        = topic || Banter::Configuration.topic_prefix
         @request_key  = request_key
         @worker_class = worker_class
-        @queue_name   = queue
         @durable      = durable
-        @subscriber   = ::Banter::Server::RabbitMQSubscriber.new(@request_key, worker_class.queue_ttl, @durable, @topic)
+        @queue_name   = queue_name
+        @subscriber   = ::Banter::Server::RabbitMQSubscriber.new(@request_key, @queue_name, worker_class.queue_ttl, @durable, @topic)
       end
 
       def start
-        @subscriber.start(@queue_name, false) do |delivery_info, properties, envelope|
+        @subscriber.start(false) do |delivery_info, properties, envelope|
           message_received(delivery_info, properties, envelope)
           true
         end

data/lib/banter/server/rabbit_mq_subscriber.rb

@@ -7,7 +7,7 @@ module Banter
       attr_reader :channel
       attr_reader :ttl
 
-      def initialize(routing_key, ttl, durable = true, topic = Banter::Configuration.topic_prefix)
+      def initialize(routing_key, queue_name, ttl, durable = true, topic = Banter::Configuration.topic_prefix)
         @initial_key = routing_key
         @durable     = durable
         @topic       = topic
@@ -18,12 +18,13 @@ module Banter
         else
           @routing_key = "#{@topic}.#"
         end
+
+        @queue_name = queue_name
       end
 
-      # name - used to ensure that certain consumers are actually listening to an exchange
       # pass in a lambda for this method to work.  We might only want to expose the content instead of
       # all 3 chunks.
-      def start(name, blocking=false)
+      def start(blocking=false)
         @connection = Bunny.new(Configuration.connection)
         begin
           @connection.start
@@ -35,23 +36,29 @@ module Banter
         @channel  = @connection.create_channel
         @exchange = @channel.topic(@topic, :durable => @durable, :auto_delete => false)
 
-        # FIX!!! -thl
-        # Need to ensure that the ids for a server will be reproducible in case a server
-        # goes down and has to get restarted.
-        if @initial_key.present?
-          @queue = "#{@initial_key}.#{name}"
-        else
-          @queue = "#{name}"
-        end
-
         queue_arguments                           = {}
         queue_arguments["x-dead-letter-exchange"] = Configuration.dead_letter_queue if Configuration.dead_letter_queue.present?
         queue_arguments["x-message-ttl"]          = ttl * 1000
-        @listener                                 = @channel.queue(@queue, arguments: queue_arguments).bind(@exchange, routing_key: @routing_key, exclusive: false)
+
+        # FIX!!! -thl
+        # Something is wrong with basic_qos because the server cannot be quickly bounced when this happens, and for messages to be
+        # quickly picked up.  It seems sporadic.  It could be a timing thing but I am unsure.
+        # Only grab 1 message at a time, otherwise, we will have to write some extra conditions to reject
+        # all the other messages that they already pulled down, which then could make the subscriber
+        # run out of memory, etc
+        # @channel.basic_qos(1)
+
+        # Need to mark the queue as durable
+        rabbit_queue = @channel.queue(@queue_name, durable: @durable, exclusive: false, arguments: queue_arguments)
+        # rabbit_queue = @channel.queue(@queue_name, arguments: queue_arguments)
+
+        @listener                                 = rabbit_queue.bind(@exchange, routing_key: @routing_key, exclusive: false)
 
         # Parameters for subscribe that might be useful:
         # :block=>true - Used for long running consumer applications.  (backend servers?)
-        @consumer                                 = @listener.subscribe(consumer_tag: name, block: blocking)
+
+        @consumer = @listener.subscribe(consumer_tag: @queue_name,  manual_ack: true, block: blocking)
+        # @consumer = @listener.subscribe(consumer_tag: @queue_name, block: blocking)
 
         @consumer.on_delivery do |delivery_info, properties, contents|
           Banter::RabbitLogger.log(Logger::DEBUG, "Message delivery with contents: #{contents}")
@@ -63,13 +70,20 @@ module Banter
           Banter::RabbitLogger.log_receive(delivery_info[:routing_key], message)
           yield delivery_info, properties, message
           Banter::RabbitLogger.log_complete(delivery_info[:routing_key], message)
+          Banter::RabbitLogger.log(Logger::DEBUG, "Message acknowledged with tag #{delivery_info.delivery_tag}")
+          # Need to acknowledge the message for the next message to come down.
+          @channel.ack(delivery_info.delivery_tag)
           true
         end
       end
 
       def teardown
-        @consumer.cancel if @consumer.present?
-        @connection.close if @connection.present?
+        begin
+          @consumer.cancel if @consumer.present?
+          @connection.close if @connection.present?
+        rescue => e
+          Airbrake.notify(e, params: { error: e.message }, environment_name: ENV['RAILS_ENV'], backtrace: caller)
+        end
       end
     end
   end

data/lib/banter/server/subscriber_server.rb

@@ -88,7 +88,6 @@ module Banter
         Banter::CLI.instance.remove_pid
       end
 
-
       def set_information
         @process_name = $0
         @pid          = Process.pid
@@ -96,15 +95,13 @@ module Banter
       end
 
       def create_queue_listeners(subscriber)
-        routing_key           = subscriber.subscribed_key
-        subscribed_queue_name = subscriber.subscribed_queue
-
-        if subscribed_queue_name.blank?
-          raise ArgumentError.new("Queue Name must be provided in #{subscriber.name} using `subscribe_to routing_key, on: queue_name`")
-        end
+        application_name = Banter::Configuration.application_name
+        routing_key      = subscriber.subscribed_key
+        durable          = subscriber.durable
+        queue_name       = subscriber.generated_queue_name(routing_key, application_name)
 
-        STDOUT.puts "Setting up listener for request_key: #{routing_key} and queue:#{subscribed_queue_name}"
-        ClientQueueListener.new(subscriber, routing_key, subscribed_queue_name)
+        STDOUT.puts "Setting up listener for request_key: #{routing_key} and queue:#{application_name}"
+        ClientQueueListener.new(subscriber, routing_key, queue_name, durable)
       end
     end
   end

data/lib/banter/subscriber.rb

@@ -8,7 +8,7 @@ module Banter
   class Subscriber
     @@registered_subscribers = []
 
-    class_attribute :payload_validators, :error_handlers, :subscribed_key, :subscribed_queue, :queue_ttl
+    class_attribute :payload_validators, :error_handlers, :subscribed_key, :subscribed_queue, :queue_ttl, :application_name, :durable
     attr_accessor :delivery_routing_data, :delivery_properties, :context
 
     def self.inherited(klass)
@@ -18,18 +18,20 @@ module Banter
     # Specify the routing key that the subscriber class should listen to.
     # @param [String] routing_key_name The routing key to subscribe to. Must be characters only separated by periods (.)
     # @param [Hash] options subscription options
-    #   @option [String] :on Optionally specify a queue. If not provided, queue name is generated from the routing key
+    #   @option [String] :durable sets the subscriber to be a durable subscriber (one that survives reboots).  This currently defaults to true.
     #   @option [Integer] :queue_ttl Time, in seconds, that the message lives on the queue before being either consumer by a subscriber or being discarded.
     #                                If not specified, then Banter::Configuration.default_queue_ttl is used
 
     def self.subscribe_to(routing_key_name, options = {})
-      options.assert_valid_keys(:on, :queue_ttl)
+      options.assert_valid_keys(:durable, :queue_ttl)
       unless validate_routing_key_name(routing_key_name)
         raise ArgumentError.new("#{routing_key_name} is not supported. Only lower case characters separated by periods are allowed.")
       end
       self.subscribed_key   = routing_key_name
-      self.subscribed_queue = generated_queue_name(routing_key_name, options[:on])
+      self.application_name = generated_application_name(options[:on])
+      self.subscribed_queue = generated_queue_name(routing_key_name, self.application_name)
       self.queue_ttl        = options[:queue_ttl] || Banter::Configuration.default_queue_ttl
+      self.durable         = options.key?(:durable) ? options[:durable] : true
     end
 
     # Sets the validator for payload
@@ -113,9 +115,23 @@ module Banter
       key.match(/\A([a-z_]+\.?)*([a-z\_]+)\Z/).present?
     end
 
-    def self.generated_queue_name(routing_key, queue_name)
-      return queue_name if queue_name.present?
-      [Banter::Configuration.application_name.to_s.gsub(/[^\w\_]/, ''), routing_key.gsub(".", '_')].reject(&:blank?).join('_')
+    def self.generated_application_name(application_name)
+      return application_name if application_name.present?
+
+      Banter::Configuration.application_name.to_s.gsub(/[^\w\_ ]/, '')
+    end
+
+    def self.generated_queue_name(routing_key, application_name)
+      name = ""
+      if routing_key.present?
+        name = routing_key
+        if application_name
+          name += "_#{application_name}"
+        end
+      else
+        name = application_name
+      end
+      name
     end
 
   end

data/lib/banter/version.rb

@@ -1,3 +1,3 @@
 module Banter
-  VERSION = "1.0.5"
+  VERSION = "1.1.1"
 end

data/spec/banter/publisher_spec.rb

@@ -49,7 +49,7 @@ describe Banter::Publisher do
 
       specify {expect { result }.not_to raise_error }
     end
-    
+
     context "duplicate entries" do
       let(:result) { publisher.delay_messages { operations } }
 
@@ -88,4 +88,23 @@ describe Banter::Publisher do
     end
 
   end
+
+  describe "#teardown" do
+    context "should not fail" do
+      before do
+        allow(Banter::RabbitLogger).to receive(:log).with(Logger::WARN, /RabbitMQ teardown failed/)
+      end
+
+      it do
+        expect{publisher.send(:teardown)}.not_to raise_error
+      end
+
+      it do
+        publisher.send(:teardown)
+        expect(Banter::RabbitLogger).to have_received(:log).exactly(1).times
+      end
+    end
+
+  end
+
 end

data/spec/banter/server/client_queue_listener_spec.rb

@@ -15,6 +15,7 @@ describe Banter::Server::ClientQueueListener do
       Banter::Configuration.web_enabled = true
       allow(BanterWorker).to receive(:current).and_return(banter_worker)
     }
+    let!(:application_name) { "testapplication" }
     let(:banter_message) { BanterMessage.last }
 
     after(:each) { Banter::Configuration.web_enabled = false }
@@ -22,7 +23,7 @@ describe Banter::Server::ClientQueueListener do
     def self.banter_message_fields_are_correct(status, error_message = nil)
       it { expect(BanterMessage.count).to eq 1 }
       it { expect(banter_message.subscriber_class).to eq('Klass') }
-      it { expect(banter_message.queue_name).to eq('banter_test_foo') }
+      it { expect(banter_message.queue_name).to eq("test.foo_#{application_name}") }
       it { expect(banter_message.subscribed_key).to eq('test.foo') }
       it { expect(banter_message.payload).to eq({ "hello" => "moto" }) }
       it { expect(banter_message.started_at.to_s).to eq(Time.now.to_s) }
@@ -39,6 +40,7 @@ describe Banter::Server::ClientQueueListener do
     end
 
     before do
+      Banter::Configuration.application_name = application_name
       context_before
       Object.const_set :Klass, Class.new(Banter::Subscriber)
       validators.each do |validator|

data/spec/banter/server/rabbitmq_subscriber_spec.rb

@@ -1,5 +1,25 @@
 require 'spec_helper'
 
 describe Banter::Server::RabbitMQSubscriber do
-  subject { Banter::Server::RabbitMQSubscriber.new( routing_key ) }
+  let(:durable) { true }
+  let(:routing_key) { 'test.me' }
+  let(:application_name) { 'queue_spec'}
+  let(:queue_name) { "test.me_#{application_name}" }
+  let(:ttl) { 100000 }
+  subject { Banter::Server::RabbitMQSubscriber.new( routing_key, queue_name, ttl, durable) }
+
+  before do
+    Banter::Configuration.application_name = application_name
+  end
+
+  describe "#start" do
+    before do
+    end
+
+    context "mark queue as durable" do
+
+    end
+
+  end
+
 end

data/spec/banter/server/subscriber_server_spec.rb

@@ -5,15 +5,18 @@ require 'spec_helper'
 
 describe Banter::Server::SubscriberServer do
   subject { Banter::Server::SubscriberServer.instance }
+  let!(:application_name) { "testsubscriber" }
+  let!(:durable) { true }
   describe '#set_workers' do
     before {
+      Banter::Configuration.application_name = application_name
       allow(Banter::Server::ClientQueueListener).to receive(:new)
       subject.set_workers([MyTestSubscriber1, MyTestSubscriber2])
     }
 
     it "creates queue listeners" do
-      expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber1, "foo.bar.one", 'banter_foo_bar_one')
-      expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber2, "foo.bar.two", 'banter_foo_bar_two')
+      expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber1, "foo.bar.one", "foo.bar.one_#{application_name}", durable)
+      expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber2, "foo.bar.two", "foo.bar.two_#{application_name}", durable)
     end
   end
 

data/spec/banter/subscriber_spec.rb

@@ -3,6 +3,11 @@ require 'spec_helper'
 describe Banter::Subscriber do
   before(:each) { Object.const_set :Klass, Class.new(Banter::Subscriber) }
   after(:each) { Object.send :remove_const, :Klass }
+  let!(:application_name) { "app_name"}
+
+  before do
+    Banter::Configuration.application_name = application_name
+  end
 
   describe "#routing_key" do
     subject { Banter::Subscriber.new(routing_data, properties, {}).routing_key }
@@ -205,44 +210,42 @@ describe Banter::Subscriber do
   end
 
   describe "#generated_queue_name" do
-    before(:each) { allow(Banter::Configuration).to receive(:application_name).and_return("app_name")}
 
-    it { expect(Klass.send(:generated_queue_name, 'abcdef', 'queue_name')).to eq('queue_name') }
-    it { expect(Klass.send(:generated_queue_name, 'abcdef', nil)).to eq('app_name_abcdef') }
-    it { expect(Klass.send(:generated_queue_name, 'abcdef.abcd', nil)).to eq('app_name_abcdef_abcd') }
-    it { expect(Klass.send(:generated_queue_name, 'a.b.c', nil)).to eq('app_name_a_b_c') }
+    it { expect(Klass.send(:generated_queue_name, 'abcdef', 'queue_name')).to eq('abcdef_queue_name') }
+    it { expect(Klass.send(:generated_queue_name, 'abcdef', nil)).to eq('abcdef') }
+    it { expect(Klass.send(:generated_queue_name, 'abcdef.abcd', nil)).to eq('abcdef.abcd') }
+    it { expect(Klass.send(:generated_queue_name, 'a.b.c', nil)).to eq('a.b.c') }
   end
 
   describe '.subscribe_to' do
-    before(:each) { allow(Banter::Configuration).to receive(:application_name).and_return("app_name")}
     context 'routing_key without queue_name' do
       before { Klass.subscribe_to 'a.b.c' }
       it 'sets the routing key and queue name' do
         expect(Klass.subscribed_key).to eq('a.b.c')
-        expect(Klass.subscribed_queue).to eq('app_name_a_b_c')
+        expect(Klass.subscribed_queue).to eq('a.b.c_app_name')
       end
     end
 
     context 'routing_key with queue_name' do
-      before { Klass.subscribe_to 'a.b.c', on: 'foo_bar' }
+      before { Klass.subscribe_to 'a.b.c' }
       it 'sets the routing key and queue name' do
         expect(Klass.subscribed_key).to eq('a.b.c')
-        expect(Klass.subscribed_queue).to eq('foo_bar')
+        expect(Klass.subscribed_queue).to eq('a.b.c_app_name')
       end
     end
 
     context 'underscore in routing key' do
-      before { Klass.subscribe_to 'a_b.c', on: 'foo_bar' }
+      before { Klass.subscribe_to 'a_b.c' }
       it 'is allowed' do
         expect(Klass.subscribed_key).to eq('a_b.c')
-        expect(Klass.subscribed_queue).to eq('foo_bar')
+        expect(Klass.subscribed_queue).to eq('a_b.c_app_name')
       end
     end
 
     context 'invalid routing key' do
       it 'sets the routing key and queue name' do
         expect {
-          Klass.subscribe_to 'a.b.c.', on: 'foo_bar'
+          Klass.subscribe_to 'a.b.c.'
         }.to raise_error(ArgumentError)
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: banter
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.1
 platform: ruby
 authors:
 - The Honest Company
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-28 00:00:00.000000000 Z
+date: 2014-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -288,7 +288,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.3.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Library for pub-sub (Message Bus)