philotic 0.2.4 → 0.3.0

data/lib/philotic/logging/logger.rb

@@ -6,6 +6,7 @@ module Philotic
     class Logger < ::Logger
 
       attr_writer :event_class
+      attr_accessor :connection
 
       def event_class
         @event_class ||= Philotic::Logging::Event
@@ -27,7 +28,8 @@ module Philotic
         end
         @logdev.write(format_message(format_severity(severity), Time.now, progname, message))
         begin
-          event_class.publish(severity, message, progname)
+          event = event_class.new(severity, message, progname)
+          connection.publish event if connection
         rescue => e
           @logdev.write(format_message(format_severity(Logger::ERROR), Time.now, progname, e.message))
         end

data/lib/philotic/publisher.rb

@@ -1,11 +1,21 @@
 require 'philotic/connection'
 
 module Philotic
-  module Publisher
-    extend self
+  class Publisher
+
+    attr_accessor :connection
+    attr_accessor :log_event_handler
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def logger
+      connection.logger
+    end
 
     def config
-      Philotic::Config
+      connection.config
     end
 
     def publish(event)
@@ -17,20 +27,20 @@ module Philotic
     private
     def _publish(payload, message_metadata = {})
       if config.disable_publish
-        Philotic.log_event_published(:warn,  message_metadata, payload, 'attempted to publish a message when publishing is disabled.')
+        log_event_published(:warn,  message_metadata, payload, 'attempted to publish a message when publishing is disabled.')
         return false
       end
-      Philotic.connect!
-      unless Philotic::Connection.connected?
-        Philotic.log_event_published(:error, message_metadata, payload, 'unable to publish event, not connected to RabbitMQ')
+      connection.connect!
+      unless connection.connected?
+        log_event_published(:error, message_metadata, payload, 'unable to publish event, not connected to RabbitMQ')
         return
       end
       message_metadata = merge_metadata(message_metadata)
 
       payload = normalize_payload_times(payload)
 
-      Philotic::Connection.exchange.publish(payload.to_json, message_metadata)
-      Philotic.log_event_published(:debug, message_metadata, payload, 'published event')
+      connection.exchange.publish(payload.to_json, message_metadata)
+      log_event_published(:debug, message_metadata, payload, 'published event')
     end
 
     def normalize_payload_times(payload)
@@ -53,5 +63,17 @@ module Philotic
       message_metadata[:headers] = {philotic_firehose: true}.merge(message_metadata[:headers])
       message_metadata
     end
+
+    def on_publish_event(&block)
+      @log_event_handler = block
+    end
+
+    def log_event_published(severity, metadata, payload, message)
+      if @log_event_handler
+        @log_event_handler.call(severity, metadata, payload, message)
+      else
+        logger.send(severity, "#{message}; message_metadata:#{metadata}, payload:#{payload.to_json}")
+      end
+    end
   end
 end

data/lib/philotic/routable.rb

@@ -61,10 +61,6 @@ module Philotic
         attr_routable_writers.concat(names)
         attr_accessor(*names)
       end
-
-      def publish(*args)
-        self.new(*args).publish
-      end
     end
 
     def payload
@@ -88,10 +84,6 @@ module Philotic
       @message_metadata.merge! options
     end
 
-    def publish
-      Philotic::Publisher.publish self
-    end
-
     private
 
     def _payload_or_headers(payload_or_headers)

data/lib/philotic/subscriber.rb

@@ -8,7 +8,17 @@ module Philotic
       end
     end
 
-    def self.subscription_callback
+    attr_accessor :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def logger
+      connection.logger
+    end
+
+    def subscription_callback
       lambda do |delivery_info, metadata, payload|
         hash_payload = JSON.parse payload
 
@@ -22,13 +32,13 @@ module Philotic
       end
     end
 
-    def self.subscribe(subscription = {}, subscribe_options = Philotic::DEFAULT_SUBSCRIBE_OPTIONS, &block)
-      Philotic.connect!
-      @exchange = Philotic::Connection.exchange
+    def subscribe(subscription = {}, subscribe_options = Philotic::DEFAULT_SUBSCRIBE_OPTIONS, &block)
+      connection.connect!
+      @exchange = connection.exchange
 
       subscription_settings = get_subscription_settings subscription, subscribe_options
 
-      q = Philotic::Connection.channel.queue(subscription_settings[:queue_name], subscription_settings[:queue_options])
+      q = connection.channel.queue(subscription_settings[:queue_name], subscription_settings[:queue_options])
 
       q.bind(@exchange, arguments: subscription_settings[:arguments]) if subscription_settings[:arguments]
 
@@ -36,7 +46,7 @@ module Philotic
 
     end
 
-    def self.get_subscription_settings(subscription, subscribe_options)
+    def get_subscription_settings(subscription, subscribe_options)
 
       if subscription.is_a? String
         queue_name    = subscription
@@ -63,21 +73,21 @@ module Philotic
       }
     end
 
-    def self.acknowledge(message, up_to_and_including=false)
-      Philotic::Connection.channel.acknowledge(message[:delivery_info].delivery_tag, up_to_and_including)
+    def acknowledge(message, up_to_and_including=false)
+      connection.channel.acknowledge(message[:delivery_info].delivery_tag, up_to_and_including)
     end
 
-    def self.reject(message, requeue=true)
-      Philotic::Connection.channel.reject(message[:delivery_info].delivery_tag, requeue)
+    def reject(message, requeue=true)
+      connection.channel.reject(message[:delivery_info].delivery_tag, requeue)
     end
 
-    def self.subscribe_to_any(options = {})
+    def subscribe_to_any(options = {})
       if block_given?
-        self.subscribe(options.merge(:'x-match' => :any), &Proc.new)
+        subscribe(options.merge(:'x-match' => :any), &Proc.new)
       end
     end
 
-    def self.endure
+    def endure
       while true
         Thread.pass
       end

data/lib/philotic/tasks/init_queues.rb

@@ -3,16 +3,19 @@ namespace :philotic do
   task :init_queues, :filename do |t, args|
     raise "You must specify a file name for #{t.name}: rake #{t.name}[FILENAME] #yes, you need the brackets, no space." if !args[:filename]
 
-    # ENV['PHILOTIC_INITIALIZE_NAMED_QUEUE'] must equal 'true' to run Philotic.initialize_named_queue!
-    ENV['PHILOTIC_INITIALIZE_NAMED_QUEUE'] = 'true'
-
     require 'philotic'
 
+    philotic = Philotic::Connection.new
+
+    # philotic.config.initialize_named_queues must be truthy to run Philotic.initialize_named_queue!
+    philotic.config.initialize_named_queues = true
+
+
     @filename = args[:filename]
     queues    = YAML.load_file(@filename)
-    Philotic.connect!
+    philotic.connect!
     queues.each_pair do |queue_name, queue_options|
-      Philotic.initialize_named_queue!(queue_name, queue_options)
+      philotic.initialize_named_queue!(queue_name, queue_options)
     end
   end
 end

data/lib/philotic/version.rb

@@ -1,3 +1,3 @@
 module Philotic
-  VERSION = '0.2.4'
+  VERSION = '0.3.0'
 end

data/spec/philotic/config_spec.rb

@@ -1,40 +1,43 @@
 require 'spec_helper'
+require 'philotic/config'
+require 'philotic/connection'
 
 describe Philotic::Config do
 
-  describe '.defaults' do
+  describe '#defaults' do
   end
 
-  describe '.load' do
+  describe '#load' do
   end
 
-  describe '.load_file' do
+  describe '#load_file' do
   end
 
-  describe '.parse_rabbit_uri' do
+  describe '#parse_rabbit_uri' do
     let(:url) { 'amqp://user:pass@host:12345/vhost' }
+    let(:config) { Philotic::Connection.new.config }
     before do
-      Philotic::Config.rabbit_url = url
+      config.rabbit_url = url
     end
-    subject { lambda { Philotic::Config.parse_rabbit_uri } }
+    subject { lambda { config.parse_rabbit_uri } }
 
     it do
       should change {
-        [
-            Philotic::Config.rabbit_user,
-            Philotic::Config.rabbit_password,
-            Philotic::Config.rabbit_host,
-            Philotic::Config.rabbit_port,
-            Philotic::Config.rabbit_vhost,
-        ]
-      }
-             .to [
-                     'user',
-                     'pass',
-                     'host',
-                     12345,
-                     'vhost',
-                 ]
+               [
+                   config.rabbit_user,
+                   config.rabbit_password,
+                   config.rabbit_host,
+                   config.rabbit_port,
+                   config.rabbit_vhost,
+               ]
+             }
+                 .to [
+                         'user',
+                         'pass',
+                         'host',
+                         12345,
+                         'vhost',
+                     ]
     end
   end
 end

data/spec/philotic/connection_spec.rb

@@ -2,11 +2,9 @@ require 'spec_helper'
 
 describe Philotic::Connection do
 
-  describe '.config' do
-    its(:config) { should eq Philotic::Config }
-  end
 
-  describe '.connect!' do
+  describe '#connect!' do
+    subject { Philotic::Connection.new }
     context 'not connected' do
       context 'success' do
         specify do
@@ -23,7 +21,7 @@ describe Philotic::Connection do
           expect(subject).to receive(:connected?).and_return(false, false)
           expect(subject).to receive(:start_connection!)
           expect(subject).not_to receive(:set_exchange_return_handler!)
-          expect(Philotic.logger).to receive(:error)
+          expect(subject.logger).to receive(:error)
 
           subject.connect!
         end
@@ -43,25 +41,109 @@ describe Philotic::Connection do
     end
   end
 
-  describe '.start_connection!' do
+  describe '#start_connection!' do
     let(:connection) { double }
+    subject { Philotic::Connection.new }
     specify do
-      expect(Bunny).to receive(:new).with(Philotic::Config.rabbit_url, Philotic::Connection.connection_settings).and_return(connection)
+      expect(Bunny).to receive(:new).with(subject.config.rabbit_url, subject.connection_settings).and_return(connection)
       expect(connection).to receive(:start)
 
-      Philotic::Connection.start_connection!
+      subject.start_connection!
     end
   end
 
-  describe '.close' do
+  describe '#close' do
     let(:connection) { double }
+    subject { Philotic::Connection.new }
     specify do
-      allow(Philotic::Connection).to receive(:connection).and_return(connection)
+      allow(subject).to receive(:connection).and_return(connection)
       expect(connection).to receive(:connected?).and_return(true)
       expect(connection).to receive(:close)
-      expect(Philotic::Connection.instance_variable_get(:@channel)).to eq(nil)
-      expect(Philotic::Connection.instance_variable_get(:@exchange)).to eq(nil)
-      Philotic::Connection.close
+      expect(subject.instance_variable_get(:@channel)).to eq(nil)
+      expect(subject.instance_variable_get(:@exchange)).to eq(nil)
+      subject.close
+    end
+  end
+
+  describe '#initialize_named_queue!' do
+    let(:test_queues) do
+      {
+          app_live_feed: {
+              exchange: 'philotic.headers.test_app.feed.live',
+              options:  {
+                  arguments: {
+                      :'x-dead-letter-exchange' => 'philotic.headers.test_app.feed.delayed',
+                      :'x-message-ttl'          => 600000 # ms
+                  }},
+              bindings:
+                        [
+                            {
+                                philotic_product:   'test_app',
+                                philotic_component: 'app_component',
+                                :'x-match:'         => 'all'
+                            },
+                        ],
+          }
+      }
+    end
+    subject { Philotic::Connection.new }
+    
+    it 'should throw an error when Philotic::Config.initialize_named_queues is falsey' do
+      allow(subject.config).to receive(:initialize_named_queues).and_return(nil)
+      queue_name = test_queues.keys.first
+      config     = test_queues[queue_name]
+      expect(subject).not_to receive(:connect!)
+      expect { subject.initialize_named_queue! queue_name, config }.to raise_error
+
+    end
+
+    it 'should log a warning when Philotic::Config.delete_existing_queues is falsey and the queue already exists' do
+      allow(subject.config).to receive(:initialize_named_queues).and_return(true)
+      allow(subject.config).to receive(:delete_existing_queues).and_return(nil)
+
+      test_queues.each_pair do |queue_name, config|
+
+        connection = double
+
+        expect(subject).to receive(:connect!)
+        expect(subject).to receive(:connection).and_return(connection)
+        expect(connection).to receive(:queue_exists?).and_return(true)
+
+        expect(subject.logger).to receive(:warn)
+
+        subject.initialize_named_queue! queue_name, config
+      end
+    end
+
+    it 'should delete the queue first when Philotic::Config.delete_existing_queues is truthy and the queue already exists' do
+      allow(subject.config).to receive(:initialize_named_queues).and_return(true)
+      allow(subject.config).to receive(:delete_existing_queues).and_return(true)
+
+      test_queues.each_pair do |queue_name, config|
+
+        queue_options = Philotic::DEFAULT_NAMED_QUEUE_OPTIONS.dup
+        queue_options.merge!(config[:options] || {})
+
+        channel    = double
+        queue      = double
+        exchange   = double
+        connection = double
+
+        expect(subject).to receive(:connect!)
+        expect(subject).to receive(:connection).and_return(connection)
+        expect(connection).to receive(:queue_exists?).and_return(true)
+        expect(subject).to receive(:channel).and_return(channel).exactly(3).times
+        expect(channel).to receive(:queue).with(queue_name, {passive: true}).and_return(queue)
+        expect(queue).to receive(:delete)
+        expect(channel).to receive(:queue).with(queue_name, queue_options).and_return(queue)
+        expect(channel).to receive(:headers).with(config[:exchange], durable: true) { exchange }
+        expect(queue).to receive(:name).and_return(queue_name).exactly(2).times
+
+        config[:bindings].each do |arguments|
+          expect(queue).to receive(:bind).with(exchange, {arguments: arguments})
+        end
+        subject.initialize_named_queue! queue_name, config
+      end
     end
   end
 end

data/spec/philotic/logging/logger_spec.rb

@@ -3,19 +3,26 @@ require 'spec_helper'
 module Philotic
   module Logging
     describe Logger do
-      let (:device) { double }
+      let(:device) do
+        fd = IO.sysopen('/dev/null', 'w')
+        IO.new(fd, 'w')
+
+      end
       let(:logger) { Philotic::Logging::Logger.new(device) }
       let(:message) { 'Hey!' }
       let(:error_message) { "These are not the droids you're looking for" }
+
+      before do
+        logger.connection = Philotic::Connection.new
+      end
       specify do
 
-        expect(Philotic::Publisher).to receive(:publish) do |event|
+        expect(logger.connection).to receive(:publish) do |event|
           expect(event.message).to eq message
           expect(event.severity).to eq Logger::INFO
 
         end
-        expect(device).to receive(:respond_to?).with(:write).and_return(true)
-        expect(device).to receive(:respond_to?).with(:close).and_return(true)
+
         expect(device).to receive(:write) do |log_message|
           expect(log_message).to match /#{message}/
         end
@@ -24,11 +31,10 @@ module Philotic
       end
 
       it "should not die if it can't log to RabbitMQ" do
-        expect(Philotic::Publisher).to receive(:publish) do |event|
+        expect(logger.connection).to receive(:publish) do |event|
           raise error_message
         end
-        expect(device).to receive(:respond_to?).with(:write).and_return(true)
-        expect(device).to receive(:respond_to?).with(:close).and_return(true)
+
         expect(device).to receive(:write) do |log_message|
           expect(log_message).to match /#{message}/
         end