hutch 0.21.0-java → 0.25.0-java

data/lib/hutch/error_handlers/airbrake.rb

@@ -1,25 +1,53 @@
 require 'hutch/logging'
 require 'airbrake'
+require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
-    class Airbrake
-      include Logging
+    class Airbrake < Base
 
-      def handle(message_id, payload, consumer, ex)
-        prefix = "message(#{message_id || '-'}): "
-        logger.error prefix + "Logging event to Airbrake"
-        logger.error prefix + "#{ex.class} - #{ex.message}"
-        ::Airbrake.notify_or_ignore(ex, {
-          :error_class => ex.class.name,
-          :error_message => "#{ ex.class.name }: #{ ex.message }",
-          :backtrace => ex.backtrace,
-          :parameters => {
-            :payload => payload,
-            :consumer => consumer,
-          },
-          :cgi_data => ENV.to_hash,
-        })
+      def handle(properties, payload, consumer, ex)
+        message_id = properties.message_id
+        prefix = "message(#{message_id || '-'}):"
+        logger.error "#{prefix} Logging event to Airbrake"
+        logger.error "#{prefix} #{ex.class} - #{ex.message}"
+
+        if ::Airbrake.respond_to?(:notify_or_ignore)
+          ::Airbrake.notify_or_ignore(ex, {
+            error_class: ex.class.name,
+            error_message: "#{ ex.class.name }: #{ ex.message }",
+            backtrace: ex.backtrace,
+            parameters: {
+              payload: payload,
+              consumer: consumer,
+            },
+            cgi_data: ENV.to_hash,
+          })
+        else
+          ::Airbrake.notify(ex, {
+            payload: payload,
+            consumer: consumer,
+            cgi_data: ENV.to_hash,
+          })
+        end
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Airbrake"
+        logger.error "#{ex.class} - #{ex.message}"
+
+        if ::Airbrake.respond_to?(:notify_or_ignore)
+          ::Airbrake.notify_or_ignore(ex, {
+            error_class: ex.class.name,
+            error_message: "#{ ex.class.name }: #{ ex.message }",
+            backtrace: ex.backtrace,
+            cgi_data: ENV.to_hash,
+          })
+        else
+          ::Airbrake.notify(ex, {
+            cgi_data: ENV.to_hash,
+          })
+        end
       end
     end
   end

data/lib/hutch/error_handlers/base.rb

@@ -0,0 +1,15 @@
+module Hutch
+  module ErrorHandlers
+    class Base
+      include Logging
+
+      def handle(properties, payload, consumer, ex)
+        raise NotImplementedError.new
+      end
+
+      def handle_setup_exception(ex)
+        raise NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/hutch/error_handlers/honeybadger.rb

@@ -1,27 +1,42 @@
 require 'hutch/logging'
 require 'honeybadger'
+require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
-    class Honeybadger
-      include Logging
+    # Error handler for the Honeybadger.io service
+    class Honeybadger < Base
 
-      def handle(message_id, payload, consumer, ex)
-        prefix = "message(#{message_id || '-'}): "
-        logger.error prefix + "Logging event to Honeybadger"
-        logger.error prefix + "#{ex.class} - #{ex.message}"
-        ::Honeybadger.notify_or_ignore(
-          :error_class => ex.class.name,
-          :error_message => "#{ ex.class.name }: #{ ex.message }",
-          :backtrace => ex.backtrace,
-          :context => {
-            :message_id => message_id,
-            :consumer => consumer
-          },
-          :parameters => {
-            :payload => payload
-          }
-        )
+      def handle(properties, payload, consumer, ex)
+        message_id = properties.message_id
+        prefix = "message(#{message_id || '-'}):"
+        logger.error "#{prefix} Logging event to Honeybadger"
+        logger.error "#{prefix} #{ex.class} - #{ex.message}"
+        notify_honeybadger(error_class: ex.class.name,
+                           error_message: "#{ex.class.name}: #{ex.message}",
+                           backtrace: ex.backtrace,
+                           context: { message_id: message_id,
+                                      consumer: consumer },
+                           parameters: { payload: payload })
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Honeybadger"
+        logger.error "#{ex.class} - #{ex.message}"
+        notify_honeybadger(error_class: ex.class.name,
+                           error_message: "#{ex.class.name}: #{ex.message}",
+                           backtrace: ex.backtrace)
+      end
+
+      # Wrap API to support 3.0.0+
+      #
+      # @see https://github.com/honeybadger-io/honeybadger-ruby/blob/master/CHANGELOG.md#300---2017-02-06
+      def notify_honeybadger(message)
+        if ::Honeybadger.respond_to?(:notify_or_ignore)
+          ::Honeybadger.notify_or_ignore(message)
+        else
+          ::Honeybadger.notify(message)
+        end
       end
     end
   end

data/lib/hutch/error_handlers/logger.rb

@@ -1,14 +1,20 @@
 require 'hutch/logging'
+require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
-    class Logger
-      include Logging
+    class Logger < ErrorHandlers::Base
 
-      def handle(message_id, payload, consumer, ex)
-        prefix = "message(#{message_id || '-'}): "
-        logger.error prefix + "error in consumer '#{consumer}'"
-        logger.error prefix + "#{ex.class} - #{ex.message}"
+      def handle(properties, payload, consumer, ex)
+        message_id = properties.message_id
+        prefix = "message(#{message_id || '-'}):"
+        logger.error "#{prefix} error in consumer '#{consumer}'"
+        logger.error "#{prefix} #{ex.class} - #{ex.message}"
+        logger.error (['backtrace:'] + ex.backtrace).join("\n")
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "#{ex.class} - #{ex.message}"
         logger.error (['backtrace:'] + ex.backtrace).join("\n")
       end
     end

data/lib/hutch/error_handlers/opbeat.rb

@@ -0,0 +1,30 @@
+require 'hutch/logging'
+require 'opbeat'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    class Opbeat < Base
+
+      def initialize
+        unless ::Opbeat.respond_to?(:report)
+          raise "The Opbeat error handler requires Opbeat >= 3.0"
+        end
+      end
+
+      def handle(properties, payload, consumer, ex)
+        message_id = properties.message_id
+        prefix = "message(#{message_id || '-'}):"
+        logger.error "#{prefix} Logging event to Opbeat"
+        logger.error "#{prefix} #{ex.class} - #{ex.message}"
+        ::Opbeat.report(ex, extra: { payload: payload })
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Opbeat"
+        logger.error "#{ex.class} - #{ex.message}"
+        ::Opbeat.report(ex)
+      end
+    end
+  end
+end

data/lib/hutch/error_handlers/sentry.rb

@@ -1,10 +1,10 @@
 require 'hutch/logging'
 require 'raven'
+require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
-    class Sentry
-      include Logging
+    class Sentry < Base
 
       def initialize
         unless Raven.respond_to?(:capture_exception)
@@ -12,12 +12,20 @@ module Hutch
         end
       end
 
-      def handle(message_id, payload, consumer, ex)
-        prefix = "message(#{message_id || '-'}): "
-        logger.error prefix + "Logging event to Sentry"
-        logger.error prefix + "#{ex.class} - #{ex.message}"
+      def handle(properties, payload, consumer, ex)
+        message_id = properties.message_id
+        prefix = "message(#{message_id || '-'}):"
+        logger.error "#{prefix} Logging event to Sentry"
+        logger.error "#{prefix} #{ex.class} - #{ex.message}"
+        Raven.capture_exception(ex, extra: { payload: payload })
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Sentry"
+        logger.error "#{ex.class} - #{ex.message}"
         Raven.capture_exception(ex)
       end
+
     end
   end
 end

data/lib/hutch/logging.rb

@@ -9,12 +9,12 @@ module Hutch
       end
     end
 
-    def self.setup_logger(target = $stdout)
+    def self.setup_logger
       require 'hutch/config'
-      @logger = Logger.new(target)
-      @logger.level = Hutch::Config.log_level
-      @logger.formatter = HutchFormatter.new
-      @logger
+      @logger = Logger.new($stdout).tap do |l|
+        l.level = Hutch::Config.log_level
+        l.formatter = HutchFormatter.new
+      end
     end
 
     def self.logger

data/lib/hutch/publisher.rb

@@ -0,0 +1,75 @@
+require 'securerandom'
+require 'hutch/logging'
+require 'hutch/exceptions'
+
+module Hutch
+  class Publisher
+    include Logging
+    attr_reader :connection, :channel, :exchange, :config
+
+    def initialize(connection, channel, exchange, config = Hutch::Config)
+      @connection = connection
+      @channel    = channel
+      @exchange   = exchange
+      @config     = config
+    end
+
+    def publish(routing_key, message, properties = {}, options = {})
+      ensure_connection!(routing_key, message)
+
+      serializer = options[:serializer] || config[:serializer]
+
+      non_overridable_properties = {
+        routing_key:  routing_key,
+        timestamp:    connection.current_timestamp,
+        content_type: serializer.content_type,
+      }
+      properties[:message_id]   ||= generate_id
+
+      payload = serializer.encode(message)
+
+      log_publication(serializer, payload, routing_key)
+
+      response = exchange.publish(payload, {persistent: true}.
+        merge(properties).
+        merge(global_properties).
+        merge(non_overridable_properties))
+
+      channel.wait_for_confirms if config[:force_publisher_confirms]
+      response
+    end
+
+    private
+
+    def log_publication(serializer, payload, routing_key)
+      logger.info {
+        spec =
+          if serializer.binary?
+            "#{payload.bytesize} bytes message"
+          else
+            "message '#{payload}'"
+          end
+        "publishing #{spec} to #{routing_key}"
+      }
+    end
+
+    def raise_publish_error(reason, routing_key, message)
+      msg = "unable to publish - #{reason}. Message: #{JSON.dump(message)}, Routing key: #{routing_key}."
+      logger.error(msg)
+      raise PublishError, msg
+    end
+
+    def ensure_connection!(routing_key, message)
+      raise_publish_error('no connection to broker', routing_key, message) unless connection
+      raise_publish_error('connection is closed', routing_key, message) unless connection.open?
+    end
+
+    def generate_id
+      SecureRandom.uuid
+    end
+
+    def global_properties
+      Hutch.global_properties.respond_to?(:call) ? Hutch.global_properties.call : Hutch.global_properties
+    end
+  end
+end

data/lib/hutch/tracers.rb

@@ -2,5 +2,6 @@ module Hutch
   module Tracers
     autoload :NullTracer, 'hutch/tracers/null_tracer'
     autoload :NewRelic,   'hutch/tracers/newrelic'
+    autoload :Opbeat,     'hutch/tracers/opbeat'
   end
 end

data/lib/hutch/tracers/opbeat.rb

@@ -0,0 +1,37 @@
+require 'opbeat'
+
+module Hutch
+  module Tracers
+    # Tracer for Opbeat, which traces each message processed.
+    class Opbeat
+      KIND = 'messaging.hutch'.freeze
+
+      # @param klass [Consumer] Consumer instance (!)
+      def initialize(klass)
+        @klass = klass
+      end
+
+      # @param message [Message]
+      def handle(message)
+        ::Opbeat.transaction(sig, KIND, extra: extra_from(message)) do
+          @klass.process(message)
+        end.done(true)
+      end
+
+      private
+
+      def sig
+        @klass.class.name
+      end
+
+      def extra_from(message)
+        {
+          body: message.body.to_s,
+          message_id: message.message_id,
+          timestamp: message.timestamp,
+          routing_key: message.routing_key
+        }
+      end
+    end
+  end
+end

data/lib/hutch/version.rb

@@ -1,4 +1,4 @@
 module Hutch
-  VERSION = '0.21.0'.freeze
+  VERSION = '0.25.0'.freeze
 end
 

data/lib/hutch/waiter.rb

@@ -0,0 +1,104 @@
+require 'hutch/logging'
+
+module Hutch
+  # Signal-handling class.
+  #
+  # Currently, the signal USR2 performs a thread dump,
+  # while QUIT, TERM and INT all perform a graceful shutdown.
+  class Waiter
+    include Logging
+
+    class ContinueProcessingSignals < RuntimeError
+    end
+
+    def self.supported_signals_of(list)
+      list.keep_if { |s| Signal.list.keys.include?(s) }.tap do |result|
+        result.delete('QUIT') if defined?(JRUBY_VERSION)
+      end
+    end
+
+    SHUTDOWN_SIGNALS = supported_signals_of(%w(QUIT TERM INT)).freeze
+    # We have chosen a JRuby-supported signal
+    USER_SIGNALS = supported_signals_of(%w(USR2)).freeze
+    REGISTERED_SIGNALS = (SHUTDOWN_SIGNALS + USER_SIGNALS).freeze
+
+    def self.wait_until_signaled
+      new.wait_until_signaled
+    end
+
+    def wait_until_signaled
+      self.sig_read, self.sig_write = IO.pipe
+
+      register_signal_handlers
+
+      begin
+        wait_for_signal
+
+        sig = sig_read.gets.strip
+        handle_signal(sig)
+      rescue ContinueProcessingSignals
+        retry
+      end
+    end
+
+    def handle_signal(sig)
+      raise ContinueProcessingSignals unless REGISTERED_SIGNALS.include?(sig)
+      if user_signal?(sig)
+        handle_user_signal(sig)
+      else
+        handle_shutdown_signal(sig)
+      end
+    end
+
+    # @raise ContinueProcessingSignals
+    def handle_user_signal(sig)
+      case sig
+      when 'USR2' then log_thread_backtraces
+      else raise "Assertion failed - unhandled signal: #{sig.inspect}"
+      end
+      raise ContinueProcessingSignals
+    end
+
+    def handle_shutdown_signal(sig)
+      logger.info "caught SIG#{sig}, stopping hutch..."
+    end
+
+    private
+
+    def log_thread_backtraces
+      logger.info 'Requested a VM-wide thread stack trace dump...'
+      Thread.list.each do |thread|
+        logger.info "Thread TID-#{thread.object_id.to_s(36)} #{thread['label']}"
+        logger.info backtrace_for(thread)
+      end
+    end
+
+    def backtrace_for(thread)
+      if thread.backtrace
+        thread.backtrace.join("\n")
+      else
+        '<no backtrace available>'
+      end
+    end
+
+    attr_accessor :sig_read, :sig_write
+
+    def wait_for_signal
+      IO.select([sig_read])
+    end
+
+    def register_signal_handlers
+      REGISTERED_SIGNALS.each do |sig|
+        # This needs to be reentrant, so we queue up signals to be handled
+        # in the run loop, rather than acting on signals here
+        trap(sig) do
+          sig_write.puts(sig)
+        end
+      end
+    end
+
+    def user_signal?(sig)
+      USER_SIGNALS.include?(sig)
+    end
+  end
+end