banter 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b13b654e7432d2615637212aa89c5e2982132c4f
-  data.tar.gz: 7574a9284911946d6ea20f7dab4c5edb4f6cd132
+  metadata.gz: 07b71e3cd5e4d50cdbadff4bfc6aeb90cffa749c
+  data.tar.gz: 541920f865408bedb92d9b9bd0b0490adf7f13d1
 SHA512:
-  metadata.gz: 9b0e607a13ddfc3f25f018dc99c756c37969ed1cbd2054a297811e9aa87ed9d2d8377d97fad4bcb7fec4947aece16969d19ec1f6bd8a62ee016e115cf459fb85
-  data.tar.gz: b22048fb8320d300d739b46ad5cfb4b77a06bba4e80384824924ba105a574a82ac1ad92c2d8ff5db2f72c9de56da2642eb1b03842c6886621cb4c2fb14dd35fb
+  metadata.gz: 656c84442869c91309fcbb93c1303b527c4b03b107d53cc4354154928e7a0a0273e9e9ad5bdbeafc0b841141d8f7c94e40e5adb0b7cc43952db1a832cc8ade44
+  data.tar.gz: 943010a912bd147ca77ec5d5c6658b89688c74d2c4b194a9eee2bcbbd5777bbcf935e6cc19234a28c6ca7937dc4e500420b13891b59296371a0fb5b2adc17b53

data/lib/banter/rabbit_logger.rb

@@ -1,33 +1,32 @@
-# Internal log class that is used to log messages before sending, after receiving, and failure to send
+# encoding: utf-8
+# Internal log class that is used to log envelopes before sending, after receiving, and failure to send
 module Banter
 
   class RabbitLogger
+    @@log_map = [:debug, :info, :warn, :error, :fatal]
     def self.enabled?
-      Banter::Configuration.logging_enabled
+      true
+      # Banter::Configuration.logging_enabled
     end
 
-    def self.log_publish(routing_key, message)
-      return unless enabled?
-      tags = ["BANTER PUBLISH", message[:ts], message[:pub], message[:v], routing_key]
-      logger.tagged(tags) { logger.warn message[:payload].as_json }
+    def self.log_publish(routing_key, envelope)
+      internal_log(:warn, "BANTER PUBLISH", envelope, routing_key, envelope[:payload])
     end
 
-    def self.failed_publish(routing_key, properties, message)
-      return unless enabled?
-      tags = ["BANTER FAILED_SEND", message[:ts], message[:pub], message[:v], routing_key]
-      logger.tagged(tags) { logger.error( { properties: properties, payload:message[:payload] }.as_json ) }
+    def self.failed_publish(routing_key, properties, envelope)
+      internal_log(:error, "BANTER FAILED_SEND", envelope, routing_key, { properties: properties, payload:envelope[:payload] })
     end
 
-    def self.log_receive(routing_key, message)
-      return unless enabled?
-      tags = ["BANTER RECEIVED", message[:ts], message[:pub], message[:v], routing_key, Process::pid]
-      logger.tagged(tags) { logger.warn message[:payload].as_json }
+    def self.log_receive(routing_key, envelope)
+      internal_log(:warn, "BANTER RECEIVED", envelope, routing_key, envelope[:payload])
     end
 
-    def self.log_complete(routing_key, message)
-      return unless enabled?
-      tags = ["BANTER COMPLETED", message[:ts], message[:pub], message[:v], routing_key, Process::pid]
-      logger.tagged(tags) { logger.warn message[:payload].as_json }
+    def self.log_complete(routing_key, envelope)
+      internal_log(:warn, "BANTER COMPLETED", envelope, routing_key, envelope[:payload])
+    end
+
+    def self.log_subscriber_failed(routing_key, delivery_info, properties, envelope)
+      internal_log(:warn, "BANTER SUBSCRIBER FAILED", envelope, routing_key,  { delivery_info: delivery_info, properties: properties, contents: envelope[:payload]} )
     end
 
     def self.log_service(service_name, message)
@@ -36,15 +35,24 @@ module Banter
       logger.tagged(tags) { logger.info message.as_json}
     end
 
-    @@log_map = [:debug, :info, :warn, :error, :fatal]
     def self.log(log_level, message)
-      tags = ["BANTER LOG_LEVEL:#{@@log_map[log_level].capitalize.to_s}", Process::pid]
-      logger.tagged(tags) { logger.send(@@log_map[log_level], message.as_json ) }
+      tags = ["BANTER LOG_LEVEL:#{@@log_map[log_level].capitalize.to_s}", Process::pid.to_s].map{|x| utf(x)}
+      logger.tagged(tags) { logger.send(@@log_map[log_level], utf(message.as_json.to_s) ) }
+    end
+
+    def self.internal_log(log_level, log_type, envelope, routing_key, payload)
+      return unless enabled?
+      tags = [log_type, envelope[:ts].to_s, envelope[:pub], envelope[:v].to_s, routing_key].map{|x| utf(x)}
+      logger.tagged(tags) { logger.send(log_level, utf(payload.to_s)) }
     end
 
     def self.logger
       Banter.logger
     end
 
+    def self.utf(field)
+      field.force_encoding('utf-8')
+    end
+
   end
 end

data/lib/banter/server/client_queue_listener.rb

@@ -19,7 +19,7 @@ module Banter
       end
 
       def start
-        @subscriber.start(false) do |delivery_info, properties, envelope|
+        @subscriber.start do |delivery_info, properties, envelope|
           message_received(delivery_info, properties, envelope)
           true
         end

data/lib/banter/server/rabbit_mq_subscriber.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Banter
   module Server
 
@@ -23,15 +25,13 @@ module Banter
         @queue_name = queue_name
       end
 
-      # pass in a lambda for this method to work.  We might only want to expose the content instead of
-      # all 3 chunks.
-      def start(blocking=false)
+      def start(&block)
         @connection = Bunny.new(Configuration.connection)
         begin
           @connection.start
         rescue => e
           Banter::RabbitLogger.log(Logger::ERROR, "Cannot connect to rabbitmq")
-          Airbrake.notify(e, params: { message: e.message, what_happened: "RabbitMQ unreachable!" }, environment_name: ENV['RAILS_ENV'])
+          Airbrake.notify(e, params: { message: e.message, what_happened: "RabbitMQ unreachable!" }, environment_name: environment)
           raise e
         end
 
@@ -44,28 +44,52 @@ module Banter
 
         @channel.basic_qos(@pool_size) if @pool_size != 0
 
+        @channel.on_uncaught_exception(&method(:notify_error))
+
         rabbit_queue = @channel.queue(@queue_name, durable: @durable, exclusive: false, arguments: queue_arguments)
-        @listener                                 = rabbit_queue.bind(@exchange, routing_key: @routing_key, exclusive: false)
+        @listener    = rabbit_queue.bind(@exchange, routing_key: @routing_key, exclusive: false)
+
+        @callback_block = block
+        @consumer    = @listener.subscribe({ consumer_tag: @queue_name,  manual_ack: true, block: false}, &method(:process_message))
+        nil
+      end
 
-        # Parameters for subscribe that might be useful:
-        # :block=>true - Used for long running consumer applications.  (backend servers?)
+      def process_message(delivery_info, properties, contents)
+        token = delivery_info.delivery_tag
+        begin
+          envelope = ::Banter::Message.new.parse(contents)
+          Banter::RabbitLogger.log(Logger::DEBUG, "Message delivery with contents: #{token}: #{delivery_info[:routing_key]}, #{contents}, #{contents.encoding}")
 
-        @consumer = @listener.subscribe(consumer_tag: @queue_name,  manual_ack: true, block: blocking) do |delivery_info, properties, contents|
-          Banter::RabbitLogger.log(Logger::DEBUG, "Message delivery with contents: #{contents}")
           if delivery_info[:redelivered]
             e = StandardError.new("PubSub Message redelivery")
-            Airbrake.notify(e, params: { info: delivery_info, props: properties, contents: contents }, environment_name: ENV['RAILS_ENV'], backtrace: caller)
+            Airbrake.notify(e, params: { info: delivery_info, props: properties, contents: contents }, backtrace: caller)
           end
-          message = ::Banter::Message.new.parse(contents)
-          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}")
+
+          Banter::RabbitLogger.log_receive(delivery_info[:routing_key], envelope)
+          @callback_block.call( delivery_info, properties, envelope)
+          Banter::RabbitLogger.log_complete(delivery_info[:routing_key], envelope)
+
           # Need to acknowledge the message for the next message to come down.
-          @channel.ack(delivery_info.delivery_tag)
-          true
+          Banter::RabbitLogger.log(Logger::DEBUG, "Message acknowledged with tag #{token}")
+          @channel.ack(token)
+        rescue => e
+          Banter::RabbitLogger.log(Logger::WARN, "Error in message: #{e}")
+          e.backtrace.each{|line| Banter::RabbitLogger.log(Logger::WARN, "-- #{line}") }
+          Banter::RabbitLogger.log(Logger::WARN, "contents: #{contents}")
+          Banter::RabbitLogger.log(Logger::WARN, { routing_key: delivery_info[:routing_key], delivery_info: delivery_info, properties: properties, envelope: envelope} )
+          Banter::RabbitLogger.log_subscriber_failed(delivery_info[:routing_key], delivery_info, properties, envelope)
+
+          # Does not get put back on the queue, and instead, will need to be processed either by the log parser
+          # later or by dead letter exchange
+          @channel.reject(token, false)
+          Airbrake.notify(e, params: { delivery_info: delivery_info, properties: properties, contents: contents, error: e.message }, environment_name: environment)
         end
-        nil
+      end
+
+      def notify_error(error, consumer)
+        Banter::RabbitLogger.log(Logger::WARN, "Error with the message: #{error.message}: #{consumer}")
+        Banter::RabbitLogger.log(Logger::WARN, "#{caller.inspect}")
+        Airbrake.notify(error, params: { consumer: consumer, error: error.message }, environment_name: environment)
       end
 
       def teardown
@@ -73,9 +97,13 @@ module Banter
           @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)
+          Airbrake.notify(e, params: { error: e.message }, environment_name: environment)
         end
       end
+
+      def environment
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      end
     end
   end
 end

data/lib/banter/version.rb

@@ -1,3 +1,3 @@
 module Banter
-  VERSION = "1.2.3"
+  VERSION = "1.2.4"
 end

data/spec/banter/publisher_spec.rb

@@ -5,10 +5,11 @@ describe Banter::Publisher do
   let(:routing_key) { "test/logger" }
   let(:publisher) { Banter::Publisher.new }
   let(:context) { {unique_id: "1234", orig_ip_address: "127.0.0.1"}}
+  let(:contents) { Message::new.serialize(context, routing_key, {"a"=>"b"})}
   let(:channel_mocker) {
     topic = double("::Bunny::Exchange", :publish=> true )
     if publish_fails
-      topic.stub(:on_return).and_yield({routing_key: 'a.b.c'}, {some: 'property'}, '{"a":"b"}').and_return(false)
+      topic.stub(:on_return).and_yield({routing_key: 'a.b.c'}, {some: 'property'}, contents).and_return(false)
     else
       topic.stub(:on_return).and_return true
     end

data/spec/banter/rabbit_logger_spec.rb

@@ -1,98 +1,117 @@
+#encoding: utf-8
 require 'spec_helper'
 
 describe Banter::RabbitLogger do
-  let(:routing_key) { "test/logger" }
+  let(:routing_key) { "test.logger" }
   let(:subject) { Banter::RabbitLogger }
   let(:payload) { {"hit"=>"me"} }
   let(:message) { Banter::Message.new.serialize(context, routing_key, payload) }
   let(:config_buffer) { StringIO.new }
   let(:output_string) { config_buffer.string }
+  let(:delivery_info) { {empty: true}}
+  let(:properties) { {empty: true}}
   let(:context) { {unique_id: "1234", orig_ip_address: "127.0.0.1"}}
 
-  before do
-    allow(Banter.logger).to receive(:debug)
-    allow(Banter.logger).to receive(:info)
-    allow(Banter.logger).to receive(:warn)
-    allow(Banter.logger).to receive(:error)
-    allow(Banter.logger).to receive(:log)
-  end
+  context "standard character set" do
+    before do
+      allow(Banter.logger).to receive(:debug)
+      allow(Banter.logger).to receive(:info)
+      allow(Banter.logger).to receive(:warn)
+      allow(Banter.logger).to receive(:error)
+      allow(Banter.logger).to receive(:log)
+    end
 
-  describe "#log_publish" do
-    let!(:result) { subject.log_publish(routing_key, message)}
+    describe "#log_publish" do
+      let!(:result) { subject.log_publish(routing_key, message)}
 
-    it "should not fail" do
-      expect{ result }.not_to raise_error
-    end
+      it "should not fail" do
+        expect{ result }.not_to raise_error
+      end
+
+      it "should write a row to the log" do
+        expect(Banter.logger).to have_received(:warn).with(anything)
+      end
 
-    it "should write a row to the log" do
-      expect(Banter.logger).to have_received(:warn).with(anything)
     end
 
-  end
+    describe "#failed_publish" do
+      let!(:result) { subject.failed_publish(routing_key, {}, message)}
 
-  describe "#failed_publish" do
-    let!(:result) { subject.failed_publish(routing_key, {}, message)}
+      context "warning log level" do
 
-    context "warning log level" do
+        it "should not fail" do
+          expect{ result }.not_to raise_error()
+        end
+
+        it "should respect the log level of the file" do
+          expect(Banter.logger).to have_received(:error).with(anything)
+        end
+      end
+    end
+
+    describe "#log_receive" do
+      let!(:result) { subject.log_receive(routing_key, message)}
 
       it "should not fail" do
         expect{ result }.not_to raise_error()
       end
 
       it "should respect the log level of the file" do
-        expect(Banter.logger).to have_received(:error).with(anything)
+        expect(Banter.logger).to have_received(:warn).with(anything)
       end
     end
-  end
 
-  describe "#log_receive" do
-    let!(:result) { subject.log_receive(routing_key, message)}
+    describe "#log_complete" do
+      let!(:result) { subject.log_complete(routing_key, message)}
 
-    it "should not fail" do
-      expect{ result }.not_to raise_error()
-    end
+      it "should not fail" do
+        expect{ result }.not_to raise_error()
+      end
 
-    it "should respect the log level of the file" do
-      expect(Banter.logger).to have_received(:warn).with(anything)
+      it "should respect the log level of the file" do
+        expect(Banter.logger).to have_received(:warn).with(anything)
+      end
     end
-  end
 
-  describe "#log_complete" do
-    let!(:result) { subject.log_complete(routing_key, message)}
+    describe "#log" do
+      let!(:result) { subject.log(::Logger::DEBUG, message)}
 
-    it "should not fail" do
-      expect{ result }.not_to raise_error()
-    end
+      it "should not fail" do
+        expect{ result }.not_to raise_error()
+      end
 
-    it "should respect the log level of the file" do
-      expect(Banter.logger).to have_received(:warn).with(anything)
+      it "should respect the log level of the file" do
+        expect(Banter.logger).to have_received(:debug).with(anything)
+      end
     end
-  end
 
-  describe "#log" do
-    let!(:result) { subject.log(::Logger::DEBUG, message)}
+    describe "#log_service" do
+      let(:service_name) { "test" }
+      let!(:result) { subject.log_service(service_name, message)}
 
-    it "should not fail" do
-      expect{ result }.not_to raise_error()
-    end
+      context "debugger log" do
+        it "should not fail" do
+          expect{ result }.not_to raise_error()
+        end
 
-    it "should respect the log level of the file" do
-      expect(Banter.logger).to have_received(:debug).with(anything)
+        it "should respect the log level of the file" do
+          expect(Banter.logger).to have_received(:info).with(anything)
+        end
+      end
     end
-  end
 
-  describe "#log_service" do
-    let(:service_name) { "test" }
-    let!(:result) { subject.log_service(service_name, message)}
+    describe "#log_subscriber_failed" do
+      let!(:result) { subject.log_subscriber_failed(routing_key, delivery_info, properties, message)}
 
-    context "debugger log" do
       it "should not fail" do
         expect{ result }.not_to raise_error()
       end
 
       it "should respect the log level of the file" do
-        expect(Banter.logger).to have_received(:info).with(anything)
+        expect(Banter.logger).to have_received(:warn).with(anything)
       end
+
     end
   end
+
 end

data/spec/banter/server/rabbitmq_subscriber_spec.rb

@@ -1,5 +1,126 @@
 require 'spec_helper'
 
 describe Banter::Server::RabbitMQSubscriber do
-  subject { Banter::Server::RabbitMQSubscriber.new( routing_key ) }
-end
+  let(:routing_key) { "fake.route"}
+  let(:subscriber){ Banter::Server::RabbitMQSubscriber.new( routing_key, "queue_name", 100 ) }
+  let(:delivery_info) { Hashie::Mash.new({ :delivery_tag=>1, :routing_key=> routing_key}) }
+  let(:properties) { {} }
+  let(:contents) { File.read( File.join(File.dirname(__FILE__), "../../fixtures/utf_message.json")) }
+
+
+  def do_nothing(delivery, props, content)
+  end
+
+  def raise_method(delivery, props, content)
+    raise StandardError.new("Bad Subscriber")
+  end
+
+  describe "#process_message" do
+    let(:result) {
+      subscriber.process_message(delivery_info, properties, contents)
+    }
+
+    before do
+      subscriber.instance_variable_set(:@channel, double("channel", :ack=>true, :reject=>true))
+      allow(subscriber.channel).to receive(:ack)
+      allow(subscriber.channel).to receive(:reject)
+      allow(Airbrake).to receive(:notify)
+    end
+
+
+    context "subscriber has an error" do
+      before do
+        subscriber.instance_variable_set(:@callback_block, method(:raise_method) )
+      end
+
+
+      it "should not raise any errors" do
+        expect{ result }.not_to raise_error
+      end
+
+      it "should have rejected the message" do
+        result
+        expect(subscriber.channel).to have_received(:reject).with(1, false)
+      end
+
+      it "should have generated an airbrake" do
+        result
+        expect(Airbrake).to have_received(:notify).exactly(1).times
+      end
+    end
+
+    context "subscriber works correctly" do
+      before do
+        subscriber.instance_variable_set(:@callback_block, method(:do_nothing) )
+      end
+
+      it "should not raise any errors" do
+        expect{ result }.not_to raise_error
+      end
+
+      it "should have acknowledged the message" do
+        result
+        expect(subscriber.channel).to have_received(:ack).with(1)
+      end
+
+      it "should not have generated an airbrake" do
+        result
+        expect(Airbrake).not_to have_received(:notify)
+      end
+    end
+
+    context "logger has problems" do
+
+      before do
+        subscriber.instance_variable_set(:@callback_block, method(:do_nothing) )
+        allow(Banter::RabbitLogger).to receive(:log_receive).and_raise("Cannot log")
+        allow(Banter::RabbitLogger).to receive(:log_complete)
+      end
+
+      it "should not raise any errors" do
+        expect{ result }.not_to raise_error
+      end
+
+      it "should have rejected the message" do
+        result
+        expect(subscriber.channel).to have_received(:reject).with(1, false)
+      end
+
+      it "should not have logged a complete message" do
+        result
+        expect(Banter::RabbitLogger).not_to have_received(:log_complete)
+      end
+
+
+      it "should have generated an airbrake" do
+        result
+        expect(Airbrake).to have_received(:notify).exactly(1).times
+      end
+
+
+    end
+
+  end
+
+  describe "#notify_error" do
+    let(:error) { StandardError.new("Error Message")}
+    let(:consumer) { Object.new}
+    let(:result) { subscriber.notify_error(error, consumer)}
+
+    before do
+      allow(Airbrake).to receive(:notify)
+    end
+
+    it "should not raise any errors" do
+      expect{result}.not_to raise_error
+    end
+
+    it "should inform airbrake of the problem" do
+      result
+      expect(Airbrake).to have_received(:notify).exactly(1).times
+    end
+
+  end
+
+
+end

data/spec/fixtures/utf_message.json

@@ -0,0 +1,8 @@
+{
+  "ts":123,
+  "pub":"order.state_changed.delivered",
+  "v":"1",
+  "payload": {
+    "jp" : "\xa1\xa1"
+  }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: banter
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.4
 platform: ruby
 authors:
 - The Honest Company
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-23 00:00:00.000000000 Z
+date: 2014-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -229,6 +229,7 @@ files:
 - spec/config.yml
 - spec/factories/banter_messages.rb
 - spec/factories/banter_workers.rb
+- spec/fixtures/utf_message.json
 - spec/mongoid.yml
 - spec/spec_helper.rb
 - web/assets/javascripts/banter.js
@@ -294,5 +295,6 @@ test_files:
 - spec/config.yml
 - spec/factories/banter_messages.rb
 - spec/factories/banter_workers.rb
+- spec/fixtures/utf_message.json
 - spec/mongoid.yml
 - spec/spec_helper.rb