banter 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2c2033f430505bcb3c7b1fa84a2ec3f7da6a04a
-  data.tar.gz: 7feb51b107de61559c90540f4dea73fc104a5fb2
+  metadata.gz: 9d0f8fa6fb6efcc9befadeaac184560b989606f3
+  data.tar.gz: 55445f64eb387bacb905718ba61284d272d72db7
 SHA512:
-  metadata.gz: d611262dcb9921b58016ed4768547789c05736b5fd559d64b83f9d411c09c2099bf1d5e62b3eb4c6608d1af595ce7d354717c8555b9458c1b28274314664425c
-  data.tar.gz: 984f2b86a71ade2646d013d2dce99922c6beaaadd14f4e70eb8804904c7314a2ca753c23c1e23c2406e42a6032c3e465cd176199ee405f76bbb1c0d89b1c4a90
+  metadata.gz: 820d17a44fdb4b450f0d982c689ccc16883d589208c990db1b9e7279109876e55585c11404dc5dccf1839e823fe513ef59575c37d010784ec6f3f529e2195b6a
+  data.tar.gz: 5e74cca350d83ac11c6a8e32ca4fb771d931593616839b5086f4f25118a48d5e3a6f663dd7b3aea6833a7c3910b029687bca1c75afe8eb6850a9da57f7f1a209

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/README.md

@@ -2,7 +2,8 @@
 
 Simple Publishers and subscribers for Ruby using RabbitMQ
 
-[![Gem Version](https://badge.fury.io/rb/banter.svg)](http://badge.fury.io/rb/banter)
+[![Build Status](https://travis-ci.org/honest/banter.svg?branch=master)](https://travis-ci.org/honest/banter)
+![Gem Version](https://badge.fury.io/rb/banter.svg?foo=bar)
 
 Developed & maintained by [The Honest Company](https://www.honest.com). We are always looking for the best talent, find your next opportunity at [Honest Careers](https://www.honest.com/careers)
 
@@ -61,8 +62,8 @@ You can declare a subscriber class as follows
 
 ```ruby
 class UserWelcomeSubscriber < Banter::Subscriber
-  subscribe_to "user_created" # The message prefix that you're subscribing to
-  # subscribe_to "user_created", on: 'welcome_emails_queue' # If you want to specify the queue name
+  subscribe_to "user_created"
+  # Message prefix that you're subscribing to. You can also specify options for queue_name and queue_ttl
 
   def perform(payload)
     # My awesome logic goes here...

data/Rakefile

@@ -1 +1,7 @@
 require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+end

data/lib/banter.rb

@@ -5,9 +5,8 @@ require "airbrake"
 
 require "banter/configuration"
 require "banter/context"
-require "banter/db_logger"
-require "banter/logger"
-require "banter/logging"
+# require "banter/db_logger"
+require "banter/rabbit_logger"
 require "banter/message"
 require "banter/publisher"
 require "banter/server/rabbit_mq_subscriber"
@@ -23,10 +22,6 @@ end
 
 module Banter
 
-  def self.root
-    File.expand_path '../..', __FILE__
-  end
-
 # This method publishes payload to rabbitmq.  All listeners with appropriate
 # routing keys will receive the payload.
 # @param [String] routing_key Identifier of the message type
@@ -36,12 +31,14 @@ module Banter
     Publisher.instance.publish(Banter::Context.instance, routing_key, payload)
   end
 
+  # @return [Logger] Logger used for logging through the Banter gem
   def self.logger
-    Banter::Logging.logger
+    return Banter::Configuration.logger if Banter::Configuration.logger
+    @logger ||= ActiveSupport::TaggedLogging.new(Logger.new($stdout))
   end
 
-  # @param [Logger] logger Logger used by Banter
+  # @param [Logger] logger Logger for publish, message received and error events
   def self.logger=(logger)
-    Banter::Logging.logger = logger
+    Banter::Configuration.logger = ActiveSupport::TaggedLogging.new(logger)
   end
 end

data/lib/banter/cli.rb

@@ -71,6 +71,7 @@ module Banter
 
       if File.directory?(require_path)
         require 'rails'
+        require 'banter/railtie'
         require File.expand_path("#{require_path}/config/environment.rb")
         ::Rails.application.eager_load!
       else

data/lib/banter/configuration.rb

@@ -1,9 +1,41 @@
 module Banter
-  class Configuration
+  module Configuration
     @@conf = nil
 
+    # Configuration setting to specify the number of seconds a message will live in the queue before
+    # being either consumed or discarded.
+    # @default 1 hour
+    mattr_accessor :default_queue_ttl
+    @@default_queue_ttl = 1.hour
+
+    # The exchange to publish (and subscribe) on RabbitMQ
+    # @default true
+    mattr_accessor :exchange_name
+    @@exchange_name = "banter"
+
+    # The topic prefix for RabbitMQ
+    # @default banter
+    mattr_accessor :topic_prefix
+    @@topic_prefix = "banter"
+
+    mattr_accessor :logger
+
+    # RabbitMQ push and subscribe logging toggle
+    # @default true
+    mattr_accessor :logging_enabled
+    @@logging_enabled = true
+
+    # RabbitMQ push enabled
+    # @default true
+    mattr_accessor :push_enabled
+    @@push_enabled = true
+
+    # Dead letter queue name
+    # @default nil
+    mattr_accessor :dead_letter_queue
+
     def self.configure_with(environment_name, yaml_file = nil)
-      @@yaml_file = yaml_file.nil? ? "config/pubsub.yml" : yaml_file
+      @@yaml_file = yaml_file.nil? ? "config/banter.yml" : yaml_file
       @@all_conf = Hashie::Mash.new(YAML.load_file(@@yaml_file) )
       @@conf = @@all_conf[environment_name.to_sym]
       self
@@ -14,6 +46,10 @@ module Banter
       @@conf
     end
 
+    def self.connection
+      configuration[:connection]
+    end
+
     def self.environment
       val = ENV["RAILS_ENV"] || ENV["RACK_ENV"]
       val = if val.present?
@@ -27,10 +63,6 @@ module Banter
       end
     end
 
-    def self.default_queue_ttl
-      24.hours * 1000
-    end
-
     def self.application_name
       @application_name ||= if defined?(Rails)
         Rails.application.class.name.to_s.gsub("::Application", '')

data/lib/banter/publisher.rb

@@ -12,14 +12,9 @@ module Banter
       @@publisher
     end
 
-    def initialize(exchange="honest")
-      @exchange = exchange
+    def initialize(exchange = nil)
+      @exchange = exchange || Banter::Configuration.exchange_name
       @disabled = false
-      @logger = ::Banter::Logger.new()
-
-      @config = Configuration.configuration
-
-      self
     end
 
     def enable(value)
@@ -28,47 +23,47 @@ module Banter
     end
 
     def start
-      if !@config[:enabled].nil? && @config[:enabled] == false
+      unless Configuration.push_enabled
         @disabled = true
         return
       end
 
       # grab server configuration from initialization file somewhere
       begin
-        @connection = Bunny.new(Configuration.configuration[:connection])
+        @connection = Bunny.new(Configuration.connection)
         @connection.start
 
-        @channel = @connection.create_channel
-        @publisher = @channel.topic(@exchange, :durable=>true, :auto_delete=>false)
+        @channel   = @connection.create_channel
+        @publisher = @channel.topic(@exchange, :durable => true, :auto_delete => false)
 
       rescue => e
-        Airbrake.notify(e, parameters: {message: e.message}, environment_name: ENV['RAILS_ENV'] )
+        Airbrake.notify(e, parameters: { message: e.message }, environment_name: ENV['RAILS_ENV'])
         return
       end
 
 
       @publisher.on_return do |return_info, properties, content|
         # contents are already transformed into message that we want to send
-        @logger.failed_publish(return_info[:routing_key], properties, content)
+        Banter::RabbitLogger.failed_publish(return_info[:routing_key], properties, content)
       end
 
     end
 
     def publish(context, key, payload, enabled = true)
       routing_key = "#{@exchange}.#{key}"
-      envelope = ::Banter::Message.new.serialize(context, key, payload)
+      envelope    = ::Banter::Message.new.serialize(context, key, payload)
 
       if @publisher.nil?
         start
       end
 
       if @disabled || @publisher.nil? || !enabled
-        @logger.failed_publish(routing_key, {}, envelope)
+        Banter::RabbitLogger.failed_publish(routing_key, {}, envelope)
       else
         tries = 2
         begin
-          @publisher.publish(envelope.to_json, :persistent=>true, :mandatory=>true, :timestamp=>envelope[:ts], :content_type=>"application/json", :routing_key =>routing_key )
-          @logger.log_publish(routing_key, envelope)
+          @publisher.publish(envelope.to_json, :persistent => true, :mandatory => true, :timestamp => envelope[:ts], :content_type => "application/json", :routing_key => routing_key)
+          Banter::RabbitLogger.log_publish(routing_key, envelope)
         rescue => e
           tries -= 1
           teardown
@@ -76,7 +71,7 @@ module Banter
           if tries > 0 && @publisher
             retry
           else
-            @logger.failed_publish(routing_key, {}, envelope)
+            Banter::RabbitLogger.failed_publish(routing_key, {}, envelope)
           end
         end
 

data/lib/banter/rabbit_logger.rb

@@ -0,0 +1,32 @@
+# Internal log class that is used to log messages before sending, after receiving, and failure to send
+module Banter
+  class RabbitLogger
+    def self.enabled?
+      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]
+      Banter.logger.tagged(tags) { Banter.logger.debug message[:payload].as_json }
+    end
+
+    def self.failed_publish(routing_key, properties, message)
+      return unless enabled?
+      tags = ["BANTER FAILED_SEND", message[:ts], message[:pub], message[:v], routing_key]
+      Banter.logger.tagged(tags) { Banter.logger.error message[:payload].as_json }
+    end
+
+    def self.log_receive(routing_key, message)
+      return unless enabled?
+      tags = ["BANTER RECEIVED", message[:ts], message[:pub], message[:v], routing_key, Process::pid]
+      Banter.logger.tagged(tags) { Banter.logger.debug message[:payload].as_json }
+    end
+
+    def self.log_service(service_name, message)
+      return unless enabled?
+      tags = ["BANTER SERVICE", service_name, Process::pid]
+      Banter.logger.tagged(tags) {Banter.logger.info message[:payload].as_json}
+    end
+  end
+end

data/lib/banter/railtie.rb

@@ -1,11 +1,19 @@
 # This railtie provides Rails engine hooks
+require 'banter/middleware'
+require 'banter/configuration'
 
 module Banter
   class Railtie < ::Rails::Railtie
+    config.banter = Banter::Configuration
+
     initializer "banter.insert_middleware" do |app|
       app.config.middleware.use Banter::Middleware
     end
 
+    config.after_initialize do
+      Banter.logger = Rails.logger
+    end
+
     console do
       # Set up basic context to identify messages getting generated from console
       Banter::Context.setup_context(
@@ -23,5 +31,7 @@ module Banter
         unique_id: Digest::SHA1.new.to_s
       )
     end
+
+
   end
 end

data/lib/banter/server/client_queue_listener.rb

@@ -10,13 +10,13 @@ module Banter
 
       attr_reader :worker_class
 
-      def initialize(worker_class, request_key, queue, durable = true, topic = "honest")
-        @topic        = topic
+      def initialize(worker_class, request_key, queue, 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, @durable, @topic)
+        @subscriber   = ::Banter::Server::RabbitMQSubscriber.new(@request_key, worker_class.queue_ttl, @durable, @topic)
       end
 
       def start

data/lib/banter/server/rabbit_mq_subscriber.rb

@@ -5,27 +5,26 @@ module Banter
       attr_reader :listener
       attr_reader :exchange
       attr_reader :channel
+      attr_reader :ttl
 
-      def initialize(routing_key, durable = true, topic="honest")
+      def initialize(routing_key, ttl, durable = true, topic = Banter::Configuration.topic_prefix)
         @initial_key = routing_key
         @durable     = durable
         @topic       = topic
+        @ttl         = ttl
 
         if @initial_key.present?
           @routing_key = "#{@topic}.#{@initial_key}.#"
         else
           @routing_key = "#{@topic}.#"
         end
-        @logger = ::Banter::Logger.new
-
-        self
       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)
-        @connection = Bunny.new(Configuration.configuration[:connection])
+        @connection = Bunny.new(Configuration.connection)
         begin
           @connection.start
         rescue => e
@@ -46,8 +45,8 @@ module Banter
         end
 
         queue_arguments                           = {}
-        queue_arguments["x-dead-letter-exchange"] = Configuration.configuration[:dead_letter] if Configuration.configuration[:dead_letter].present?
-        queue_arguments["x-message-ttl"]          = Configuration.default_queue_ttl
+        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)
 
         # Parameters for subscribe that might be useful:
@@ -60,7 +59,7 @@ module Banter
             Airbrake.notify("PubSub Message redelivery", params: { info: delivery_info, props: properties, contents: contents }, environment_name: ENV['RAILS_ENV'])
           end
           message = ::Banter::Message.new.parse(contents)
-          @logger.log_receive(delivery_info[:routing_key], message)
+          Banter::RabbitLogger.log_receive(delivery_info[:routing_key], message)
           yield delivery_info, properties, message
           true
         end

data/lib/banter/server/subscriber_server.rb

@@ -38,15 +38,15 @@ module Banter
 
         Thread.stop
 
-        ::Banter::Logger.new.log_service("all_services", :warn, "Starting shutdown of all services")
+        ::Banter::RabbitLogger.log_service("all_services", "Starting shutdown of all services")
 
         @workers.each do |worker|
-          ::Banter::Logger.new.log_service("all_services", :warn, "Tearing down worker: #{worker.worker_class.name}")
+          ::Banter::RabbitLogger.log_service("all_services", "Tearing down worker: #{worker.worker_class.name}")
           begin
             STDOUT.puts "Tearing down subscriber for #{worker.worker_class.name}"
             worker.shutdown
           rescue => e
-            ::Banter::Logger.new.log_service("all_services", :warn, "#{worker.worker_class.name} - did not tear down correctly.  Error - #{e.message}")
+            ::Banter::RabbitLogger.log_service("all_services", "#{worker.worker_class.name} - did not tear down correctly.  Error - #{e.message}")
           end
         end
       ensure

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
+    class_attribute :payload_validators, :error_handlers, :subscribed_key, :subscribed_queue, :queue_ttl
     attr_accessor :delivery_routing_data, :delivery_properties, :context
 
     def self.inherited(klass)
@@ -17,14 +17,19 @@ 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 Allowed option is :on to optionally specify a queue. If not provided, queue name is generated from the routing key
+    # @param [Hash] options subscription options
+    #   @option [String] :on Optionally specify a queue. If not provided, queue name is generated from the routing key
+    #   @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)
+      options.assert_valid_keys(:on, :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.queue_ttl        = options[:queue_ttl] || Banter::Configuration.default_queue_ttl
     end
 
     # Sets the validator for payload
@@ -59,7 +64,7 @@ module Banter
         raise ::Banter::PayloadValidationError.new("Invalid Payload for #{self.class.name}")
       end
 
-      perform(context, payload)
+      perform(payload)
     end
 
     # Actual subscribers need to implement perform method. This is the method where the message is actually processed.

data/lib/banter/version.rb

@@ -1,3 +1,3 @@
 module Banter
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/generators/banter/install_generator.rb

@@ -0,0 +1,13 @@
+module Banter
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+    def copy_config_file
+      copy_file "banter.yml", "config/banter.yml"
+    end
+
+    def add_config_parameters
+      application "config.banter.default_queue_ttl = 1.hour"
+      application "config.banter.logger = Rails.logger"
+    end
+  end
+end

data/lib/generators/banter/templates/banter.yml

@@ -0,0 +1,38 @@
+development:
+
+  # Documentation for parameters for rabbit and bunny is located here: http://rubybunny.info/articles/connecting.html
+  connection:
+    host: localhost
+    port: 5672
+    # username: rabbit
+    # password: rabbit
+    heartbeat: 60 # in seconds
+    log_level: 0
+#    log_file: log/rabbit.log
+    network_recovery_interval: 10 # in seconds
+    continuation_timeout: 4000 # in milliseconds
+
+test:
+  # Documentation for parameters for rabbit and bunny is located here: http://rubybunny.info/articles/connecting.html
+  connection:
+    host: localhost
+    port: 5672
+    # username: rabbit
+    # password: rabbit
+    heartbeat: 60 # in seconds
+    log_level: 0
+#    log_file: log/rabbit.log
+    network_recovery_interval: 10 # in seconds
+    continuation_timeout: 4000 # in milliseconds
+
+production:
+  connection:
+    host: localhost
+    port: 5672
+    # username: rabbit
+    # password: rabbit
+    heartbeat: 60 # in seconds
+    log_level: 0
+#    log_file: log/rabbit.log
+    network_recovery_interval: 10 # in seconds
+    continuation_timeout: 4000 # in milliseconds

data/spec/banter/configuration_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Banter::Configuration do
+  context "default_queue_ttl" do
+    context 'value overridden' do
+      before { Banter::Configuration.default_queue_ttl = 2.hour }
+      it { expect(Banter::Configuration.default_queue_ttl).to eq 2.hour }
+    end
+  end
+end

data/spec/banter/rabbit_logger_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Banter::RabbitLogger do
+  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(: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(:warning)
+    allow(Banter.logger).to receive(:error)
+  end
+
+  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 write a row to the log" do
+      expect(Banter.logger).to have_received(:debug).with(anything)
+    end
+
+  end
+
+  describe "#failed_publish" do
+    let!(:result) { subject.failed_publish(routing_key, {}, message)}
+
+    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(:debug).with(anything)
+    end
+  end
+
+  describe "#log_service" do
+    let(:service_name) { "test" }
+    let!(:result) { subject.log_service(service_name, 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)
+      end
+    end
+  end
+end

data/spec/banter/server/client_queue_listener_spec.rb

@@ -31,18 +31,17 @@ describe Banter::Server::ClientQueueListener do
     context "Normal execution" do
       let!(:klass_instance){
         instance = Klass.new({},{}, {})
-        allow(instance).to receive(:perform)
+        allow(instance).to receive(:perform!)
         instance
       }
 
       context "test exception" do
         let(:no_call) { true }
-
         it { should_not raise_exception }
       end
 
       context "call" do
-        it { expect(klass_instance).to have_received(:perform).with({}, payload) }
+        it { expect(klass_instance).to have_received(:perform!).with(payload) }
       end
     end
 

data/spec/banter/{server/client_worker_spec.rb → subscriber_spec.rb}

@@ -150,12 +150,28 @@ describe Banter::Subscriber do
     end
 
     context 'invalid routing key' do
-      before {  }
       it 'sets the routing key and queue name' do
         expect {
           Klass.subscribe_to 'a.b.c.', on: 'foo_bar'
         }.to raise_error(ArgumentError)
       end
     end
+
+    context "queue_ttl" do
+      context "option provided" do
+        before { Klass.subscribe_to "a.b", queue_ttl: 4 }
+        it 'sets the ttl' do
+          expect(Klass.queue_ttl).to eq(4)
+        end
+      end
+
+      context "option not provided" do
+        before { Klass.subscribe_to "a.b" }
+        it 'uses default' do
+          expect(Klass.queue_ttl).to eq(Banter::Configuration.default_queue_ttl)
+        end
+      end
+
+    end
   end
 end

data/spec/spec_helper.rb

@@ -26,7 +26,8 @@ RSpec.configure do |config|
   config.order = 'random'
 end
 
-Banter::Configuration.configure_with("test", File.join(Banter.root,"spec/config.yml") )
+Banter::Configuration.configure_with("test", File.expand_path("../config.yml", __FILE__))
+Banter::Configuration.logger = ActiveSupport::TaggedLogging.new(Logger.new(nil))
 
 # Some test subscriber classes to make testing easier
 class MyTestSubscriber1 < Banter::Subscriber

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: banter
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - The Honest Company
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-01 00:00:00.000000000 Z
+date: 2014-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -193,24 +193,23 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .ruby-version
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - banter.gemspec
 - bin/start_subscribers
-- config/pubsub.yml
 - lib/banter.rb
 - lib/banter/cli.rb
 - lib/banter/configuration.rb
 - lib/banter/context.rb
 - lib/banter/db_logger.rb
 - lib/banter/exceptions/payload_validation_error.rb
-- lib/banter/logger.rb
-- lib/banter/logging.rb
 - lib/banter/message.rb
 - lib/banter/middleware.rb
 - lib/banter/publisher.rb
+- lib/banter/rabbit_logger.rb
 - lib/banter/railtie.rb
 - lib/banter/server.rb
 - lib/banter/server/client_queue_listener.rb
@@ -218,13 +217,16 @@ files:
 - lib/banter/server/subscriber_server.rb
 - lib/banter/subscriber.rb
 - lib/banter/version.rb
+- lib/generators/banter/install_generator.rb
+- lib/generators/banter/templates/banter.yml
 - spec/banter/cli_spec.rb
+- spec/banter/configuration_spec.rb
+- spec/banter/message_spec.rb
+- spec/banter/rabbit_logger_spec.rb
 - spec/banter/server/client_queue_listener_spec.rb
-- spec/banter/server/client_worker_spec.rb
 - spec/banter/server/rabbitmq_subscriber_spec.rb
+- spec/banter/subscriber_spec.rb
 - spec/config.yml
-- spec/logger_spec.rb
-- spec/message_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/honest/banter
 licenses:
@@ -252,10 +254,11 @@ specification_version: 4
 summary: Library for pub-sub (Message Bus)
 test_files:
 - spec/banter/cli_spec.rb
+- spec/banter/configuration_spec.rb
+- spec/banter/message_spec.rb
+- spec/banter/rabbit_logger_spec.rb
 - spec/banter/server/client_queue_listener_spec.rb
-- spec/banter/server/client_worker_spec.rb
 - spec/banter/server/rabbitmq_subscriber_spec.rb
+- spec/banter/subscriber_spec.rb
 - spec/config.yml
-- spec/logger_spec.rb
-- spec/message_spec.rb
 - spec/spec_helper.rb

data/config/pubsub.yml

@@ -1,17 +0,0 @@
-development:
-  # Documentation for parameters for rabbit and bunny is located here: http://rubybunny.info/articles/connecting.html
-  connection:
-    host: localhost
-    port: 5672
-    # username: rabbit
-    # password: rabbit
-    heartbeat: 60 # in seconds
-    log_level: 0
-    log_file: rabbit.log
-    network_recovery_interval: 10 # in seconds
-    continuation_timeout: 4000 # in milliseconds
-
-  logger:
-    enabled: true
-    level: warn
-    file: pubsub.log

data/lib/banter/logger.rb

@@ -1,49 +0,0 @@
-# Internal log class that is used to log messages before sending, after receiving, and failure to send
-module Banter
-  class Logger
-    def initialize(enable_publish_logging = true)
-      @enabled = Banter::Configuration.configuration[:logger][:enabled]
-      @enabled = enable_publish_logging if @enabled.nil?
-    end
-
-    def log_publish(routing_key, message)
-      return unless @enabled
-      # generate tags needed
-      tags = ["PUBLISH", message[:ts], message[:pub], message[:v], routing_key]
-
-      # FIX!!! -thl
-      # Could logging like this be too slow?
-      # Or should it be threaded?
-      # We'll need to benchmark, as we don't want this to get too slow.
-      logger.tagged(tags) { logger.warn message[:payload].as_json }
-
-      # TODO: -thl
-      # Log it into mongo as well?
-    end
-
-    def failed_publish(routing_key, properties, message)
-      tags = ["FAILED_SEND", message[:ts], message[:pub], message[:v], routing_key]
-      logger.tagged(tags) { logger.warn message[:payload].as_json }
-    end
-
-    def log_receive(routing_key, message)
-      tags = ["RECEIVED", message[:ts], message[:pub], message[:v], routing_key, Process::pid]
-      logger.tagged(tags) { logger.warn message[:payload].as_json }
-    end
-
-    def log_service(service_name, log_level, message)
-      tags = ["SERVICE", service_name, Process::pid]
-      log_method = log_level.to_sym.to_proc
-      logger.tagged(tags) { log_method.call(logger) { message.as_json } }
-    end
-
-    def teardown
-      logger.close
-    end
-
-    private
-    def logger
-      @logger ||= ActiveSupport::TaggedLogging.new(Banter.logger)
-    end
-  end
-end

data/lib/banter/logging.rb

@@ -1,42 +0,0 @@
-require 'logger'
-
-# Manages a logger that can be used throughout the pubsub gem
-# The logger can be set to any object that quacks like a logger including the
-# Rails logger if so desired
-#
-# The logger can be set in the initializer of a program or anywhere throughout as
-# Banter.logger = Rails.logger for example
-
-module Banter
-  module Logging
-    # Sets the logger
-    #
-    # @param logger The logger to use throughout the pubsub gem
-    # @return The logger we use throughout the gem
-    def self.logger=(logger)
-      raise StandardError("Can't set logger to nil") unless logger.present?
-      @logger = logger
-    end
-
-    # Gets the logger
-    # If no logger is defined when this method is called it will return a standard
-    # ruby logger
-    #
-    # @return The logger we use throughout the gem
-    def self.logger 
-      config = Banter::Configuration.configuration[:logger]
-      @logger ||= create_logger( {}.
-        merge( config[:level].present? ? { log_level: ::Logger::Severity.const_get(config[:level].upcase) } : {} ).
-        merge( config[:file].present? ? { log_target: config[:file] } : {} ) )
-    end
-
-    # Builds a standard ruby Logger
-    #
-    # @return Returns the logger at the end of the method
-    def self.create_logger( options = {} )
-      @logger = ::Logger.new(options.fetch(:log_target){ STDOUT })
-      @logger.level = options.fetch(:log_level){ ::Logger::INFO }
-      @logger
-    end
-  end
-end

data/spec/logger_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-describe Banter::Logger do
-  let(:routing_key) { "test/logger" }
-  let(:subject) { Banter::Logger.new }
-  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(:config_override) { {} }
-  let(:context) { {unique_id: "1234", orig_ip_address: "127.0.0.1"}}
-
-  before do
-    Banter::Logging.instance_variable_set(:"@logger", nil)
-    directory = File::dirname(__FILE__)
-    full_name = File.join(directory, "config.yml")
-    @config_data = HashWithIndifferentAccess.new( YAML.load_file(full_name)[ENV["RAILS_ENV"]] )
-    @config_data.merge!(config_override)
-    @config_data[:logger][:file] = config_buffer
-    allow(Banter::Configuration).to receive(:configuration).at_least(1).and_return(@config_data)
-  end
-
-  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 write a row to the log" do
-      result
-      expect(output_string.length).not_to eq(0)
-    end
-
-  end
-
-  describe "#failed_publish" do
-    let(:result) { subject.failed_publish(routing_key, {}, message)}
-
-    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
-        result
-        expect(output_string.length).not_to eq(0)
-      end
-    end
-
-    context "fatal log level" do
-      let(:config_override) { { 'logger'=> { 'level'=>'fatal' } } }
-
-      it "should not fail" do
-        expect{ result }.not_to raise_error()
-      end
-
-      it "should respect the log level of the file" do
-        result
-        expect(output_string.length).to eq(0)
-      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
-      result
-      expect(output_string.length).not_to eq(0)
-    end
-  end
-
-  describe "#log_service" do
-    let(:service_name) { "test" }
-    let(:result) { subject.log_service(service_name, log_level, message)}
-
-    context "debugger log" do
-      let(:log_level) { :debug }
-      it "should not fail" do
-        expect{ result }.not_to raise_error()
-      end
-
-      it "should respect the log level of the file" do
-        result
-        expect(output_string.length).to eq(0)
-      end
-    end
-
-    context "warn log" do
-      let(:log_level) { :warn }
-      it "should not fail" do
-        expect{ result }.not_to raise_error()
-      end
-
-      it "should respect the log level of the file" do
-        result
-        expect(output_string.length).not_to eq(0)
-      end
-    end
-
-  end
-
-end