aws_sqs_moniter 0.0.1 → 0.0.3

data/lib/aws_sqs_moniter/configuration/queue_configuration.rb

@@ -0,0 +1,49 @@
+module AwsSqsMoniter
+  class Configuration
+    class QueueConfiguration
+      include Validatable
+
+      def initialize name
+        @name = name
+        @delay_seconds = 0
+        @message_retention_period = 1_209_600
+        @visibility_timeout = 30
+      end
+
+      attr_accessor :delay_seconds,
+                    :message_retention_period,
+                    :visibility_timeout
+
+      attr_reader :name
+
+      def redrive_policy
+        @redrive_policy ||= RedrivePolicyConfiguration.new self
+      end
+
+      def validate
+        unless (0..900).include? delay_seconds
+          errors << "#{name}.delay_seconds must be in the range 0..900"
+        end
+
+        unless (60..1_209_600).include? message_retention_period
+          errors << "#{name}.message_retention_period must be in the range 60..1209600"
+        end
+
+        unless (0..43_200).include? visibility_timeout
+          errors << "#{name}.visibility_timeout must be in the range 0..43200"
+        end
+
+        redrive_policy.valid?
+        errors.push *(redrive_policy.errors)
+      end
+
+      def copy_onto queue
+        queue.delay_seconds = delay_seconds
+        queue.message_retention_period = message_retention_period
+        queue.visibility_timeout = visibility_timeout
+
+        redrive_policy.copy_onto queue.redrive_policy if queue.respond_to? :redrive_policy
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/configuration/redrive_policy_configuration.rb

@@ -0,0 +1,33 @@
+module AwsSqsMoniter
+  class Configuration
+    class RedrivePolicyConfiguration
+      include Validatable
+
+      def initialize owner
+        @owner = owner
+        @enabled = true
+        @max_receive_count = 10
+      end
+
+      attr_accessor :enabled,
+                    :max_receive_count,
+                    :dead_letter_queue
+
+      def validate
+        unless (1..1000).include? max_receive_count
+          errors << "#{@owner.name}.redrive_policy.max_receive_count must be in the range 1..1000"
+        end
+
+        if enabled && dead_letter_queue.blank?
+          errors << "#{@owner.name}.redrive_policy.dead_letter_queue is required"
+        end
+      end
+
+      def copy_onto redrive_policy
+        redrive_policy.enabled = enabled
+        redrive_policy.max_receive_count = max_receive_count
+        redrive_policy.dead_letter_queue = dead_letter_queue
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/configuration/validatable.rb

@@ -0,0 +1,15 @@
+module AwsSqsMoniter
+  class Configuration
+    module Validatable
+      def errors
+        @errors ||= []
+      end
+
+      def valid?
+        @errors = []
+        validate
+        @errors.empty?
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/dead_letters/retrier.rb

@@ -0,0 +1,23 @@
+module AwsSqsMoniter
+  module DeadLetters
+    class Retrier
+      def initialize logger = nil
+        @publisher = AwsSqsMoniter::MessagePublisher.new
+        @logger = logger || Shoryuken::Logging.logger
+      end
+
+      def retry scope
+        return if scope.count == 0
+
+        count = 0
+        scope.each do |message|
+          count += 1
+          @publisher.publish message.message
+          message.delete
+        end
+
+        @logger.info "Retried #{count} dead letter(s)."
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/dead_letters/worker.rb

@@ -0,0 +1,34 @@
+require 'aws_sqs_moniter/middleware/server/airbrake'
+require 'aws_sqs_moniter/middleware/server/active_record/connection_pool'
+require 'aws_sqs_moniter/middleware/server/active_record/transaction'
+
+module AwsSqsMoniter
+  module DeadLetters
+    class Worker
+      include Shoryuken::Worker
+
+      shoryuken_options(
+        auto_delete: true,
+        body_parser: :json,
+        subscriptions: {
+          financials_dlq: '*' })
+
+      server_middleware do |chain|
+        chain.remove Middleware::Server::Airbrake
+        chain.add Middleware::Server::ActiveRecord::ConnectionPool
+        chain.add Middleware::Server::ActiveRecord::Transaction, isolation: :repeatable_read
+      end
+
+      def perform sqs_message, payload
+        typed_message = TypedMessage.new sqs_message
+
+        return if DeadLetter.exists? message_id: typed_message.id
+
+        DeadLetter.create!(
+          sqs_id: sqs_message.message_id,
+          message_id: typed_message.id,
+          message: payload)
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/logging.rb

@@ -0,0 +1,66 @@
+require 'logger'
+
+module AwsSqsMoniter
+  module Logging
+    class Formatter < Logger::Formatter
+      def call severity, time, _program_name, message
+        data_hash = message.is_a?(Hash) ? message : { message: message }
+        error_hash = {}
+
+        %i(timestamp pid thread severity).each { |key| data_hash.delete key }
+
+        if (error_object = data_hash.delete(:error))
+          error_hash[:error] = error_object.to_s
+          error_hash[:backtrace] = format_backtrace(error_object.backtrace) if error_object.backtrace
+        end
+
+        timestamp = time.utc.iso8601
+        severity = severity.downcase
+        data = format_hash data_hash
+        error = format_hash error_hash
+        text = %(timestamp="#{timestamp}" pid="#{pid}" thread="#{thread}" severity="#{severity}" #{data} #{error}).strip
+
+        "#{text}\n"
+      end
+
+      private
+
+      def escape string
+        string.gsub(/"/, '"').gsub("\n", ' ')
+      end
+
+      def format_backtrace backtrace
+        backtrace.map { |line| %("#{line}") }.join(', ')
+      end
+
+      def format_hash hash
+        hash.map do |k, v|
+          v = escape v.to_s
+          %(#{k}="#{v}")
+        end.join ' '
+      end
+
+      def pid
+        Process.pid
+      end
+
+      def thread
+        Thread.current.object_id.to_s 36
+      end
+    end
+
+    class << self
+      attr_accessor :default_log_device
+      attr_writer :logger
+
+      def logger
+        @logger ||= begin
+          Logger.new(default_log_device || STDOUT).tap do |l|
+            l.level = Logger::INFO
+            l.formatter = Formatter.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/middleware/server/active_record/connection_pool.rb

@@ -0,0 +1,15 @@
+module AwsSqsMoniter
+  module Middleware
+    module Server
+      module ActiveRecord
+        class ConnectionPool
+          def call(*_args)
+            ::ActiveRecord::Base.connection_pool.with_connection do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/middleware/server/active_record/idempotence.rb

@@ -0,0 +1,24 @@
+module AwsSqsMoniter
+  module Middleware
+    module Server
+      module ActiveRecord
+        class Idempotence
+          def initialize logger: Shoryuken::Logging.logger
+            @logger = logger
+          end
+
+          def call _worker, queue, sqs_msg, _body
+            message = TypedMessage.new sqs_msg
+
+            if ProcessedMessage.exists? message_id: message.id, queue: queue
+              @logger.info middleware: 'idempotence', ignored_message_id: message.id
+            else
+              yield
+              ProcessedMessage.log message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/middleware/server/active_record/retrier.rb

@@ -0,0 +1,23 @@
+require 'retryable'
+
+module AwsSqsMoniter
+  module Middleware
+    module Server
+      module ActiveRecord
+        class Retrier
+          def initialize(options = {})
+            @options = { tries: 10, sleep: 0 }.merge options
+          end
+
+          def call(&block)
+            Retryable.retryable(@options.merge(on: [::ActiveRecord::RecordNotUnique])) do
+              Retryable.retryable(@options.merge(matching: /TRDeadlockDetected|TRSerializationFailure/)) do
+                yield block
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/middleware/server/active_record/transaction.rb

@@ -0,0 +1,36 @@
+require_relative 'retrier'
+
+module AwsSqsMoniter
+  module Middleware
+    module Server
+      module ActiveRecord
+        class Transaction
+          RETRIER_OPTIONS = %i(tries sleep on_retriable_error)
+          TRANSACTION_OPTIONS = %i(requires_new joinable isolation)
+
+          def initialize options = {}
+            @transaction_options = options.select { |k, _| TRANSACTION_OPTIONS.include? k }
+            @retrier_default_options = options.select { |k, _| RETRIER_OPTIONS.include? k }
+          end
+
+          def call worker, _queue, _sqs_msg, _body
+            Retrier.new(retrier_options(worker)).call do
+              ::ActiveRecord::Base.transaction(@transaction_options) do
+                yield
+              end
+            end
+          end
+
+          private
+
+          def retrier_options worker
+            options = @retrier_default_options.dup
+            on_error = options.delete :on_retriable_error
+            options[:exception_cb] = worker.method(on_error) unless on_error.to_s.empty?
+            options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/middleware/server/airbrake.rb

@@ -0,0 +1,24 @@
+module AwsSqsMoniter
+  module Middleware
+    module Server
+      class Airbrake
+        def call(_worker, _queue, sqs_msg, body)
+          yield
+        rescue => e
+          parameters = {}
+
+          begin
+            message = TypedMessage.new sqs_msg
+            parameters.store :message, message.headers
+          rescue
+            parameters.store :unknown_message_format, body
+          end
+
+          ::Airbrake.notify_or_ignore e, parameters: parameters
+
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/aws_sqs_moniter/monkey_patches/forbid_implicit_active_record_connection_checkout.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  class Base
+    class << self
+      def forbid_implicit_checkout!
+        Thread.current[:active_record_forbid_implicit_connections] = true
+      end
+
+      def implicit_checkout_forbidden?
+        !!Thread.current[:active_record_forbid_implicit_connections]
+      end
+
+      def connection_with_forbid_implicit(*args, &block)
+        if implicit_checkout_forbidden? && !connection_handler.retrieve_connection_pool(self).active_connection?
+          message = 'Implicit ActiveRecord checkout attempted when Thread :force_explicit_connections set!'
+
+          # I want to make SURE I see this error in test output, even though
+          # in some cases my code is swallowing the exception.
+          $stderr.puts(message) if Rails.env.test?
+
+          fail ImplicitConnectionForbiddenError, message
+        end
+
+        connection_without_forbid_implicit(*args, &block)
+      end
+
+      alias_method_chain :connection, :forbid_implicit
+    end
+  end
+
+  # We're refusing to give a connection when asked for. Same outcome
+  # as if the pool timed out on checkout, so let's subclass the exception
+  # used for that.
+  ImplicitConnectionForbiddenError = Class.new(::ActiveRecord::ConnectionTimeoutError)
+end

data/lib/aws_sqs_moniter/railtie.rb

@@ -0,0 +1,10 @@
+require 'rails'
+
+module AwsSqsMoniter
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path('../../tasks/aws_sqs_moniter.rake', __FILE__)
+    	load File.expand_path('../../tasks/aws_sqs_setup.rake', __FILE__)
+    end
+  end
+end

data/lib/aws_sqs_moniter/typed_message.rb

@@ -0,0 +1,37 @@
+module AwsSqsMoniter
+  class TypedMessage
+    def initialize(message)
+      @message = message
+    end
+
+    def id
+      headers['id']
+    end
+
+    def type
+      headers['type']
+    end
+
+    def version
+      headers['version']
+    end
+
+    def body
+      hash['body']
+    end
+
+    def to_h
+      hash
+    end
+
+    private
+
+    def hash
+      @hash ||= JSON.parse(@message.body)
+    end
+
+    def headers
+      hash['header']
+    end
+  end
+end