philotic 0.0.1 → 0.1.0

data/lib/philotic/config.rb

@@ -2,6 +2,8 @@ require 'yaml'
 require 'json'
 require 'singleton'
 require 'forwardable'
+require 'cgi'
+require 'bunny/session'
 
 module Philotic
   module Config
@@ -11,33 +13,29 @@ module Philotic
 
     DEFAULT_DISABLE_PUBLISH = false
 
-
-    DEFAULT_RABBIT_HOST = 'localhost'
-    DEFAULT_RABBIT_PORT = 5672
-    DEFAULT_RABBIT_USER = 'guest'
-    DEFAULT_RABBIT_PASSWORD = 'guest'
-    DEFAULT_RABBIT_VHOST = '/'
-    DEFAULT_EXCHANGE_NAME = 'philotic.headers'
-    DEFAULT_CONNECTION_FAILED_HANDLER = Proc.new { |settings| Philotic.logger.error "RabbitMQ connection failure; host:#{rabbit_host}" }
-    DEFAULT_CONNECTION_LOSS_HANDLER = Proc.new { |conn, settings| Philotic.logger.warn "RabbitMQ connection loss; host:#{rabbit_host}"; conn.reconnect(false, 2) }
-    DEFAULT_MESSAGE_RETURN_HANDLER = Proc.new { |basic_return, metadata, payload| Philotic.logger.warn "Philotic message #{JSON.parse payload} was returned! reply_code = #{basic_return.reply_code}, reply_text = #{basic_return.reply_text} headers = #{metadata.properties}"; }
+    DEFAULT_RABBIT_HOST      = 'localhost'
+    DEFAULT_RABBIT_PORT      = 5672
+    DEFAULT_RABBIT_USER      = 'guest'
+    DEFAULT_RABBIT_PASSWORD  = 'guest'
+    DEFAULT_RABBIT_VHOST     = '%2f' # '/'
+    DEFAULT_RABBIT_URL       = "amqp://#{DEFAULT_RABBIT_USER}:#{DEFAULT_RABBIT_PASSWORD}@#{DEFAULT_RABBIT_HOST}:#{DEFAULT_RABBIT_PORT}/#{DEFAULT_RABBIT_VHOST}"
+    DEFAULT_EXCHANGE_NAME    = 'philotic.headers'
     DEFAULT_TIMEOUT = 2
-
-    DEFAULT_ROUTING_KEY = nil
-    DEFAULT_PERSISTENT = true
+    DEFAULT_ROUTING_KEY      = nil
+    DEFAULT_PERSISTENT       = true
     # DEFAULT_IMMEDIATE = false
-    DEFAULT_MANDATORY = true
-    DEFAULT_CONTENT_TYPE = nil
+    DEFAULT_MANDATORY        = true
+    DEFAULT_CONTENT_TYPE     = nil
     DEFAULT_CONTENT_ENCODING = nil
-    DEFAULT_PRIORITY = nil
-    DEFAULT_MESSAGE_ID = nil
-    DEFAULT_CORRELATION_ID = nil
-    DEFAULT_REPLY_TO = nil
-    DEFAULT_TYPE = nil
-    DEFAULT_USER_ID = nil
-    DEFAULT_APP_ID = nil
-    DEFAULT_TIMESTAMP = nil
-    DEFAULT_EXPIRATION = nil
+    DEFAULT_PRIORITY         = nil
+    DEFAULT_MESSAGE_ID       = nil
+    DEFAULT_CORRELATION_ID   = nil
+    DEFAULT_REPLY_TO         = nil
+    DEFAULT_TYPE             = nil
+    DEFAULT_USER_ID          = nil
+    DEFAULT_APP_ID           = nil
+    DEFAULT_TIMESTAMP        = nil
+    DEFAULT_EXPIRATION       = nil
 
     def defaults
       @defaults ||= Hash[Config.constants.select { |c| c.to_s.start_with? 'DEFAULT_' }.collect do |c|
@@ -62,6 +60,47 @@ module Philotic
       end
     end
 
+    attr_reader :connection_failed_handler, :connection_loss_handler, :message_return_handler
+
+    def connection_failed_handler
+      @connection_failed_handler ||= lambda do |settings|
+        Philotic.logger.error "RabbitMQ connection failure; host:#{rabbit_host}"
+      end
+    end
+
+    def connection_loss_handler
+      @connection_loss_handler ||= lambda do |conn, settings|
+        Philotic.logger.warn "RabbitMQ connection loss; host:#{rabbit_host}"; conn.reconnect(false, 2)
+      end
+    end
+
+    def message_return_handler
+      @message_return_handler ||= lambda do |basic_return, metadata, payload|
+        puts "Philotic message #{JSON.parse payload} was returned! reply_code = #{basic_return.reply_code}, reply_text = #{basic_return.reply_text} headers = #{metadata[:headers]}"
+      end
+    end
+
+    def self.parse_rabbit_uri
+      settings            = Bunny::Session.parse_uri(@rabbit_url || defaults[:rabbit_url])
+      settings[:password] = settings.delete(:pass)
+
+      %w[host port user password vhost].each do |setting|
+        setting       = setting.to_sym
+        current_value = send("rabbit_#{setting}")
+
+        # only use the value from the URI if the existing value is nil or the default
+        if settings[setting] && [const_get("default_rabbit_#{setting}".upcase), nil].include?(current_value)
+          send("rabbit_#{setting}=", settings[setting])
+        end
+      end
+
+    end
+
+    def self.rabbit_url
+      self.parse_rabbit_uri
+      "amqp://#{rabbit_user}:#{rabbit_password}@#{rabbit_host}:#{rabbit_port}/#{CGI.escape rabbit_vhost}"
+    end
+
     def load(config)
       Philotic.logger # ensure the logger can be created, so we crash early if it can't
 

data/lib/philotic/connection.rb

@@ -1,8 +1,8 @@
 require 'singleton'
 require 'json'
-require 'amqp'
-require "amqp/extensions/rabbitmq"
-require 'amqp/utilities/event_loop_helper'
+require 'bunny'
+
+require 'philotic/config'
 
 module Philotic
   module Connection
@@ -13,70 +13,54 @@ module Philotic
       Philotic::Config
     end
 
-    def connect! &block
-      if connected?
-        Philotic.logger.info "already connected to RabbitMQ; host:#{config.rabbit_host}"
-        block.call if block
-        return
-      end
-
-      AMQP::Utilities::EventLoopHelper.run do
-        connection_settings = {
-            host: config.rabbit_host,
-            port: config.rabbit_port,
-            user: config.rabbit_user,
-            password: config.rabbit_password,
-            vhost: config.rabbit_vhost,
-            timeout: config.timeout,
-            on_tcp_connection_failure: config.connection_failed_handler,
-        }
-
-        AMQP.start(connection_settings, logging: true) do |connection, connect_ok|
-          @connection = connection
+    def connect!
+      return if connected?
 
-          if connected?
-            Philotic.logger.info "connected to RabbitMQ; host:#{config.rabbit_host}"
-          else
-            Philotic.logger.warn "failed connected to RabbitMQ; host:#{config.rabbit_host}"
-          end
+      start_connection!
 
+      if connected?
+        Philotic.logger.info "connected to RabbitMQ: #{config.rabbit_host}:#{config.rabbit_port}"
+        set_exchange_return_handler!
+        true
+      else
+        Philotic.logger.error "failed connected to RabbitMQ; host:#{config.rabbit_host}"
+        false
+      end
+    end
 
-          AMQP.channel.auto_recovery = true
-
-          @connection.on_tcp_connection_loss do |cl, settings|
-            config.method(:connection_loss_handler).call.call(cl, settings)
-          end
-
-          @connection.after_recovery do |conn, settings|
-            Philotic.logger.info "Connection recovered, now connected to #{config.rabbit_host}"
-          end
-
-          setup_exchange_handler!
-          block.call if block
+    def start_connection!
+      @connection = Bunny.new(config.rabbit_url, connection_settings)
+      @connection.start
+    end
 
-        end #AMQP.start
-      end
+    def connection_settings
+      {
+          timeout:                   config.timeout.to_i,
+          automatically_recover:     true,
+          on_tcp_connection_failure: config.connection_failed_handler,
+      }
     end
 
-    def close &block
-      if connected?
-        connection.close &block
-      else
-        block.call
-      end
+    def close
+      Philotic.logger.info "closing connection to RabbitMQ; host:#{config.rabbit_host}"
+      connection.close if connected?
     end
 
     def connected?
       connection && connection.connected?
     end
 
+    def channel
+      @channel ||= connection.create_channel
+    end
+
     def exchange
-      AMQP.channel.headers(config.exchange_name, durable: true)
+      @exchange ||= channel.headers(config.exchange_name, durable: true)
     end
 
-    def setup_exchange_handler!
+    def set_exchange_return_handler!
       exchange.on_return do |basic_return, metadata, payload|
-        config.method(:message_return_handler).call.call(basic_return, metadata, payload)
+        config.message_return_handler.call(basic_return, metadata, payload)
       end
     end
   end

data/lib/philotic/constants.rb

@@ -0,0 +1,49 @@
+module Philotic
+
+  CONNECTION_OPTIONS = [
+      :rabbit_host,
+      :connection_failed_handler,
+      :connection_loss_handler,
+      :timeout,
+  ]
+  EXCHANGE_OPTIONS   = [
+      :exchange_name,
+      :message_return_handler,
+  ]
+  MESSAGE_OPTIONS    = [
+      :routing_key,
+      :persistent,
+      # :immediate,
+      :mandatory,
+      :content_type,
+      :content_encoding,
+      :priority,
+      :message_id,
+      :correlation_id,
+      :reply_to,
+      :type,
+      :user_id,
+      :app_id,
+      :timestamp,
+      :expiration,
+  ]
+
+  PHILOTIC_HEADERS = [
+      :philotic_firehose,
+      :philotic_product,
+      :philotic_component,
+      :philotic_event_type,
+  ]
+
+  DEFAULT_NAMED_QUEUE_OPTIONS     = {
+      auto_delete: false,
+      durable:     true
+  }
+  DEFAULT_ANONYMOUS_QUEUE_OPTIONS = {
+      auto_delete: true,
+      durable:     false
+  }
+
+  DEFAULT_SUBSCRIBE_OPTIONS = {}
+
+end

data/lib/philotic/event.rb

@@ -1,4 +1,6 @@
+require 'philotic/constants'
 require 'philotic/connection'
+require 'philotic/routable'
 
 module Philotic
   class Event
@@ -36,25 +38,36 @@ module Philotic
         if self.respond_to?(:"#{key}=")
           send(:"#{key}=", value)
         elsif self.class == Philotic::Event
-          self.class.send("attr_#{type}_readers").concat([key])
-          self.class.send("attr_#{type}_writers").concat([:"#{key}="])
-
-          setter = Proc.new do |v|
-            instance_variable_set(:"@#{key}", v)
-          end
-          getter = Proc.new do
-            instance_variable_get(:"@#{key}")
-          end
-          self.class.send :define_method, :"#{key}=", setter
-          self.send(:"#{key}=", value)
-          self.class.send :define_method, :"#{key}", getter
+          set_event_attribute(type, key, value)
         end
       end
     end
 
+    def set_event_attribute(type, key, value)
+      set_event_attribute_setter(key, type, value)
+      set_event_attribute_getter(key, type)
+    end
+
+    def set_event_attribute_getter(key, type)
+      self.class.send("attr_#{type}_readers").concat([key])
+      getter = lambda do
+        instance_variable_get(:"@#{key}")
+      end
+      self.class.send :define_method, :"#{key}", getter
+    end
+
+    def set_event_attribute_setter(key, type, value)
+      self.class.send("attr_#{type}_writers").concat([:"#{key}="])
+      setter = lambda do |v|
+        instance_variable_set(:"@#{key}", v)
+      end
+      self.class.send :define_method, :"#{key}=", setter
+      self.send(:"#{key}=", value)
+    end
+
     def initialize(routables={}, payloads=nil)
-      payloads ||= {}
-      self.timestamp = Time.now.to_i
+      payloads               ||= {}
+      self.timestamp         = Time.now.to_i
       self.philotic_firehose = true
 
       # dynamically insert any passed in routables into both attr_routable

data/lib/philotic/logging.rb

@@ -0,0 +1,8 @@
+require 'philotic/logging/event'
+require 'philotic/logging/logger'
+
+module Philotic
+  module Logging
+
+  end
+end

data/lib/philotic/logging/event.rb

@@ -0,0 +1,18 @@
+require 'philotic/event'
+
+module Philotic
+  module Logging
+    class Event < Philotic::Event
+      attr_routable :severity, :progname
+      attr_payload :message
+
+      def initialize(severity, message = nil, progname = nil)
+        super({})
+        self.severity = severity
+        self.message  = message
+        self.progname = progname
+
+      end
+    end
+  end
+end

data/lib/philotic/logging/logger.rb

@@ -0,0 +1,39 @@
+require 'logger'
+require 'philotic/logging/event'
+
+module Philotic
+  module Logging
+    class Logger < ::Logger
+
+      attr_writer :event_class
+
+      def event_class
+        @event_class ||= Philotic::Logging::Event
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        severity ||= UNKNOWN
+        if @logdev.nil? or severity < @level
+          return true
+        end
+        progname ||= @progname
+        if message.nil?
+          if block_given?
+            message = yield
+          else
+            message  = progname
+            progname = @progname
+          end
+        end
+        @logdev.write(
+            format_message(format_severity(severity), Time.now, progname, message))
+        event_class.publish(severity, message, progname)
+
+        true
+      end
+
+      alias log add
+
+    end
+  end
+end

data/lib/philotic/publisher.rb

@@ -1,4 +1,5 @@
 require 'philotic/connection'
+
 module Philotic
   module Publisher
     extend self
@@ -7,52 +8,48 @@ module Philotic
       Philotic::Config
     end
 
-    def publish(event, &block)
+    def publish(event)
       message_metadata = {headers: event.headers}
       message_metadata.merge!(event.message_metadata) if event.message_metadata
-      raw_publish(event.payload, message_metadata, &block)
+      _publish(event.payload, message_metadata)
     end
 
-    def raw_publish(payload, message_metadata = {}, &block)
+    private
+    def _publish(payload, message_metadata = {})
+      Philotic.connect!
+      unless Philotic::Connection.connected?
+        Philotic.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)
 
-      if Philotic.connected?
-        _raw_publish payload, message_metadata, &block
-      else
-        Philotic.connect! do
-          _raw_publish payload, message_metadata, &block
+      return if config.disable_publish
+
+      Philotic::Connection.exchange.publish(payload.to_json, message_metadata)
+      Philotic.log_event_published(:debug, message_metadata, payload, 'published event')
+    end
+
+    def normalize_payload_times(payload)
+      payload.each do |k, v|
+        if v.respond_to?(:utc)
+          payload[k] = v.utc
+        elsif v.respond_to?(:to_utc)
+          payload[k] = v.to_utc
         end
       end
     end
 
-    private
-    def _raw_publish(payload, message_metadata = {}, &block)
-
+    def merge_metadata(message_metadata)
       publish_defaults = {}
       Philotic::MESSAGE_OPTIONS.each do |key|
         publish_defaults[key] = config.send(key.to_s)
       end
-      message_metadata = publish_defaults.merge message_metadata
+      message_metadata           = publish_defaults.merge message_metadata
       message_metadata[:headers] ||= {}
       message_metadata[:headers] = {philotic_firehose: true}.merge(message_metadata[:headers])
-
-
-      payload.each { |k, v| payload[k] = v.utc if v.is_a? ActiveSupport::TimeWithZone }
-
-      callback = Proc.new do
-        Philotic.log_event_published(:debug, message_metadata, payload, 'published event')
-        block.call if block
-      end
-
-      if config.disable_publish
-        EventMachine.next_tick(&callback)
-        return
-      end
-
-      unless Philotic::Connection.connected?
-        Philotic.log_event_published(:error, message_metadata, payload, 'unable to publish event, not connected to amqp broker')
-        return
-      end
-      Thread.new { Philotic::Connection.exchange.publish(payload.to_json, message_metadata, &callback) }
+      message_metadata
     end
   end
 end