shivam 0.0.0-java

data/lib/hutch/error_handlers/airbrake.rb

@@ -0,0 +1,54 @@
+require 'hutch/logging'
+require 'airbrake'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    class Airbrake < Base
+
+      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
+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/bugsnag.rb

@@ -0,0 +1,30 @@
+require "hutch/logging"
+require "bugsnag"
+require "hutch/error_handlers/base"
+
+module Hutch
+  module ErrorHandlers
+    class Bugsnag < Base
+      def handle(properties, payload, consumer, ex)
+        message_id = properties.message_id
+        prefix = "message(#{message_id || "-"}):"
+        logger.error "#{prefix} Logging event to Bugsnag"
+        logger.error "#{prefix} #{ex.class} - #{ex.message}"
+
+        ::Bugsnag.notify(ex) do |report|
+          report.add_tab(:hutch, {
+            payload: payload,
+            consumer: consumer
+          })
+        end
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Bugsnag"
+        logger.error "#{ex.class} - #{ex.message}"
+
+        ::Bugsnag.notify(ex)
+      end
+    end
+  end
+end

data/lib/hutch/error_handlers/honeybadger.rb

@@ -0,0 +1,43 @@
+require 'hutch/logging'
+require 'honeybadger'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    # Error handler for the Honeybadger.io service
+    class Honeybadger < Base
+
+      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
+end

data/lib/hutch/error_handlers/logger.rb

@@ -0,0 +1,22 @@
+require 'hutch/logging'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    class Logger < ErrorHandlers::Base
+
+      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
+  end
+end

data/lib/hutch/error_handlers/rollbar.rb

@@ -0,0 +1,28 @@
+require 'hutch/logging'
+require 'rollbar'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    class Rollbar < Base
+      def handle(properties, payload, consumer, ex)
+        message_id = properties.message_id
+        prefix = "message(#{message_id || '-'}):"
+        logger.error "#{prefix} Logging event to Rollbar"
+        logger.error "#{prefix} #{ex.class} - #{ex.message}"
+
+        ::Rollbar.error(ex,
+          payload: payload,
+          consumer: consumer
+        )
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Rollbar"
+        logger.error "#{ex.class} - #{ex.message}"
+
+        ::Rollbar.error(ex)
+      end
+    end
+  end
+end

data/lib/hutch/error_handlers/sentry.rb

@@ -0,0 +1,26 @@
+require 'hutch/logging'
+require 'sentry-ruby'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    class Sentry < Base
+      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}"
+        ::Sentry.configure_scope do |scope|
+          scope.set_context("payload", JSON.parse(payload))
+        end
+        ::Sentry.capture_exception(ex)
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Sentry"
+        logger.error "#{ex.class} - #{ex.message}"
+        ::Sentry.capture_exception(ex)
+      end
+    end
+  end
+end

data/lib/hutch/error_handlers/sentry_raven.rb

@@ -0,0 +1,31 @@
+require 'hutch/logging'
+require 'raven'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    class SentryRaven < Base
+
+      def initialize
+        unless Raven.respond_to?(:capture_exception)
+          raise "The Hutch Sentry error handler requires Raven >= 0.4.0"
+        end
+      end
+
+      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/error_handlers.rb

@@ -0,0 +1,11 @@
+module Hutch
+  module ErrorHandlers
+    autoload :Logger,      'hutch/error_handlers/logger'
+    autoload :Sentry,      'hutch/error_handlers/sentry'
+    autoload :SentryRaven, 'hutch/error_handlers/sentry_raven'
+    autoload :Honeybadger, 'hutch/error_handlers/honeybadger'
+    autoload :Airbrake,    'hutch/error_handlers/airbrake'
+    autoload :Rollbar,     'hutch/error_handlers/rollbar'
+    autoload :Bugsnag,     'hutch/error_handlers/bugsnag'
+  end
+end

data/lib/hutch/exceptions.rb

@@ -0,0 +1,14 @@
+module Hutch
+  if defined?(JRUBY_VERSION)
+    require 'march_hare/exceptions'
+    class Exception < MarchHare::Exception; end
+  else
+    require "bunny/exceptions"
+    # Bunny::Exception inherits from StandardError
+    class Exception < Bunny::Exception; end
+  end
+  class ConnectionError < Exception; end
+  class AuthenticationError < Exception; end
+  class WorkerSetupError < Exception; end
+  class PublishError < Exception; end
+end

data/lib/hutch/logging.rb

@@ -0,0 +1,32 @@
+require 'logger'
+require 'time'
+
+module Hutch
+  module Logging
+    class HutchFormatter < Logger::Formatter
+      def call(severity, time, program_name, message)
+        "#{time.utc.iso8601} #{Process.pid} #{severity} -- #{message}\n"
+      end
+    end
+
+    def self.setup_logger
+      require 'hutch/config'
+      @logger = Logger.new($stdout).tap do |l|
+        l.level = Hutch::Config.log_level
+        l.formatter = HutchFormatter.new
+      end
+    end
+
+    def self.logger
+      @logger || setup_logger
+    end
+
+    def self.logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      Hutch::Logging.logger
+    end
+  end
+end

data/lib/hutch/message.rb

@@ -0,0 +1,31 @@
+require 'forwardable'
+
+module Hutch
+  class Message
+    extend Forwardable
+
+    attr_reader :delivery_info, :properties, :payload
+
+    def initialize(delivery_info, properties, payload, serializer)
+      @delivery_info = delivery_info
+      @properties    = properties
+      @payload       = payload
+      @body          = serializer.decode(payload)
+    end
+
+    def_delegator :@body, :[]
+    def_delegators :@properties, :message_id, :timestamp
+    def_delegators :@delivery_info, :routing_key, :exchange
+
+    attr_reader :body
+
+    def to_s
+      attrs = { :@body => body.to_s, message_id: message_id,
+                timestamp: timestamp, routing_key: routing_key }
+      "#<Message #{attrs.map { |k,v| "#{k}=#{v.inspect}" }.join(', ')}>"
+    end
+
+    alias_method :inspect, :to_s
+  end
+end
+

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.debug {
+        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/serializers/identity.rb

@@ -0,0 +1,19 @@
+module Hutch
+  module Serializers
+    class Identity
+
+      def self.encode(payload)
+        payload
+      end
+
+      def self.decode(payload)
+        payload
+      end
+
+      def self.binary? ; false ; end
+
+      def self.content_type ; nil ; end
+
+    end
+  end
+end

data/lib/hutch/serializers/json.rb

@@ -0,0 +1,22 @@
+require 'multi_json'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Hutch
+  module Serializers
+    class JSON
+
+      def self.encode(payload)
+        ::MultiJson.dump(payload)
+      end
+
+      def self.decode(payload)
+        ::MultiJson.load(payload).with_indifferent_access
+      end
+
+      def self.binary? ; false ; end
+
+      def self.content_type ; 'application/json' ; end
+
+    end
+  end
+end

data/lib/hutch/tracers/datadog.rb

@@ -0,0 +1,18 @@
+require 'ddtrace'
+require 'ddtrace/auto_instrument'
+
+module Hutch
+  module Tracers
+    class Datadog
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def handle(message)
+        ::Datadog::Tracing.trace(@klass.class.name, continue_from: nil, service: 'hutch', type: 'rabbitmq') do
+          @klass.process(message)
+        end
+      end
+    end
+  end
+end

data/lib/hutch/tracers/newrelic.rb

@@ -0,0 +1,19 @@
+require 'newrelic_rpm'
+
+module Hutch
+  module Tracers
+    class NewRelic
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def handle(message)
+        @klass.process(message)
+      end
+
+      add_transaction_tracer :handle, :category => 'OtherTransaction/HutchConsumer', :path => '#{@klass.class.name}'
+    end
+  end
+end

data/lib/hutch/tracers/null_tracer.rb

@@ -0,0 +1,15 @@
+module Hutch
+  module Tracers
+    class NullTracer
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def handle(message)
+        @klass.process(message)
+      end
+
+    end
+  end
+end

data/lib/hutch/tracers.rb

@@ -0,0 +1,7 @@
+module Hutch
+  module Tracers
+    autoload :NullTracer, 'hutch/tracers/null_tracer'
+    autoload :NewRelic,   'hutch/tracers/newrelic'
+    autoload :Datadog,    'hutch/tracers/datadog'
+  end
+end

data/lib/hutch/version.rb

@@ -0,0 +1,3 @@
+module Hutch
+  VERSION = '1.3.0.pre'.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