ruby_event_store-outbox 0.0.8 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9457e402dabad2f00ec38ce0a6aecb12dcfdd303614b0ed6c8e391214e2eece1
-  data.tar.gz: 8545183b1d4720f5674cfdd5cf385666f2cfcd38ed2cc9fdd4bf8aa79c750835
+  metadata.gz: 1b73edc767b3c0caa9ff76cd06a58468e18aa2556f25a7c170bd9f0da6bdce9a
+  data.tar.gz: b96f01c515c3975694b7ba54ab9b8057bb506534d22c313823488f0150b98ce3
 SHA512:
-  metadata.gz: dc5d885558ac2c2d3b446cc1499a9ceb8aaa541b29c1b85e8019cd832ca2572d883c4fa165abbcedc9470f36f29667becc0b7b937c49fc00b3a3aed2714699db
-  data.tar.gz: 4371dcb52922553adebe91a4fb36472c27bb0a4df0a76ec6782aaf4c48b57e424d55e7f8ba262b5f694d8d5c32e6062bbc504f8ca5e2edfb04767d0278cccc95
+  metadata.gz: d9c3e4f4d5733cb1afbea5ffa9ae91af3c1e4ef17f6d371a9dff483e95a4034f57c0bbe1166a87b5e44f562773f683d5442eaa60b0a704439d974c0718a74a49
+  data.tar.gz: 5a1e56fd33a9f296246ed9c429dc9abf35e7fed714c9a2b30cb6aaf926babf505a09c8a093a3aba77076aa6f6727f3568d4677035bec47289181811878534a0a

data/lib/generators/ruby_event_store/outbox/templates/create_event_store_outbox_template.rb

@@ -11,5 +11,13 @@ class CreateEventStoreOutbox < ActiveRecord::Migration<%= migration_version %>
     end
     add_index :event_store_outbox, [:format, :enqueued_at, :split_key], name: "index_event_store_outbox_for_pool"
     add_index :event_store_outbox, [:created_at, :enqueued_at], name: "index_event_store_outbox_for_clear"
+
+    create_table(:event_store_outbox_locks, force: false) do |t|
+      t.string :format, null: false
+      t.string :split_key, null: false
+      t.datetime :locked_at, null: true
+      t.string :locked_by, null: true, limit: 36
+    end
+    add_index :event_store_outbox_locks, [:format, :split_key], name: "index_event_store_outbox_locks_for_locking", unique: true
   end
 end

data/lib/ruby_event_store/outbox.rb

@@ -5,6 +5,7 @@ module RubyEventStore
   end
 end
 
+require_relative 'outbox/fetch_specification'
 require_relative 'outbox/record'
 require_relative 'outbox/sidekiq_scheduler'
 require_relative 'outbox/consumer'

data/lib/ruby_event_store/outbox/cli.rb

@@ -59,9 +59,8 @@ module RubyEventStore
       end
 
       def build_consumer(options)
-        logger = Logger.new(STDOUT, level: options.log_level, progname: "RES-Outbox")
-        # ActiveRecord::Base.logger = logger if options.log_level == :debug
-        # ActiveSupport::LogSubscriber.colorize_logging = false
+        consumer_uuid = SecureRandom.uuid
+        logger = Logger.new(STDOUT, level: options.log_level, progname: "RES-Outbox #{consumer_uuid}")
         consumer_configuration = Consumer::Configuration.new(
           split_keys: options.split_keys,
           message_format: options.message_format,
@@ -71,6 +70,7 @@ module RubyEventStore
         )
         metrics = Metrics.from_url(options.metrics_url)
         outbox_consumer = RubyEventStore::Outbox::Consumer.new(
+          consumer_uuid,
           options,
           logger: logger,
           metrics: metrics,

data/lib/ruby_event_store/outbox/consumer.rb

@@ -3,11 +3,14 @@ require "redis"
 require "active_record"
 require "ruby_event_store/outbox/record"
 require "ruby_event_store/outbox/sidekiq5_format"
+require "ruby_event_store/outbox/sidekiq_processor"
+require "ruby_event_store/outbox/fetch_specification"
 
 module RubyEventStore
   module Outbox
     class Consumer
       SLEEP_TIME_WHEN_NOTHING_TO_DO = 0.1
+      MAXIMUM_BATCH_FETCHES_IN_ONE_LOCK = 10
 
       class Configuration
         def initialize(
@@ -38,25 +41,26 @@ module RubyEventStore
         attr_reader :split_keys, :message_format, :batch_size, :database_url, :redis_url
       end
 
-      def initialize(configuration, clock: Time, logger:, metrics:)
+      def initialize(consumer_uuid, configuration, clock: Time, logger:, metrics:)
         @split_keys = configuration.split_keys
         @clock = clock
-        @redis = Redis.new(url: configuration.redis_url)
         @logger = logger
         @metrics = metrics
         @batch_size = configuration.batch_size
+        @consumer_uuid = consumer_uuid
         ActiveRecord::Base.establish_connection(configuration.database_url) unless ActiveRecord::Base.connected?
-        ActiveRecord::Base.connection.execute("SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;")
+        if ActiveRecord::Base.connection.adapter_name == "Mysql2"
+          ActiveRecord::Base.connection.execute("SET SESSION innodb_lock_wait_timeout = 1;")
+        end
 
         raise "Unknown format" if configuration.message_format != SIDEKIQ5_FORMAT
-        @message_format = SIDEKIQ5_FORMAT
+        @processor = SidekiqProcessor.new(Redis.new(url: configuration.redis_url))
 
         @gracefully_shutting_down = false
         prepare_traps
       end
 
       def init
-        @redis.sadd("queues", split_keys)
         logger.info("Initiated RubyEventStore::Outbox v#{VERSION}")
         logger.info("Handling split keys: #{split_keys ? split_keys.join(", ") : "(all of them)"}")
       end
@@ -73,51 +77,129 @@ module RubyEventStore
       end
 
       def one_loop
-        Record.transaction do
-          records_scope = Record.lock.where(format: message_format, enqueued_at: nil)
-          records_scope = records_scope.where(split_key: split_keys) if !split_keys.nil?
-          records = records_scope.order("id ASC").limit(batch_size).to_a
-          if records.empty?
-            metrics.write_point_queue(status: "ok")
-            return false
+        remaining_split_keys = @split_keys.dup
+
+        was_something_changed = false
+        while (split_key = remaining_split_keys.shift)
+          was_something_changed |= handle_split(FetchSpecification.new(processor.message_format, split_key))
+        end
+        was_something_changed
+      end
+
+      def handle_split(fetch_specification)
+        obtained_lock = obtain_lock_for_process(fetch_specification)
+        return false unless obtained_lock
+
+        something_processed = false
+
+        MAXIMUM_BATCH_FETCHES_IN_ONE_LOCK.times do
+          batch = retrieve_batch(fetch_specification)
+          if batch.empty?
+            break
           end
 
-          now = @clock.now.utc
           failed_record_ids = []
-          records.each do |record|
+          updated_record_ids = []
+          batch.each do |record|
             begin
-              handle_one_record(now, record)
+              now = @clock.now.utc
+              processor.process(record, now)
+
+              record.update_column(:enqueued_at, now)
+              something_processed |= true
+              updated_record_ids << record.id
             rescue => e
               failed_record_ids << record.id
               e.full_message.split($/).each {|line| logger.error(line) }
             end
           end
 
-          updated_record_ids = records.map(&:id) - failed_record_ids
-          Record.where(id: updated_record_ids).update_all(enqueued_at: now)
-          metrics.write_point_queue(status: "ok", enqueued: updated_record_ids.size, failed: failed_record_ids.size)
+          metrics.write_point_queue(
+            enqueued: updated_record_ids.size,
+            failed: failed_record_ids.size,
+            format: fetch_specification.message_format,
+            split_key: fetch_specification.split_key,
+            remaining: get_remaining_count(fetch_specification)
+          )
+
+          logger.info "Sent #{updated_record_ids.size} messages from outbox table"
 
-          logger.info "Sent #{records.size} messages from outbox table"
-          true
+          obtained_lock = refresh_lock_for_process(obtained_lock)
+          break unless obtained_lock
         end
-      rescue ActiveRecord::Deadlocked
-        logger.warn "Outbox fetch deadlocked"
-        metrics.write_point_queue(status: "deadlocked")
-        false
-      rescue ActiveRecord::LockWaitTimeout
-        logger.warn "Outbox fetch lock timeout"
-        metrics.write_point_queue(status: "lock_timeout")
-        false
+
+        metrics.write_point_queue(
+          format: fetch_specification.message_format,
+          split_key: fetch_specification.split_key,
+          remaining: get_remaining_count(fetch_specification)
+        ) unless something_processed
+
+        release_lock_for_process(fetch_specification)
+
+        processor.after_batch
+
+        something_processed
       end
 
       private
-      attr_reader :split_keys, :logger, :message_format, :batch_size, :metrics
+      attr_reader :split_keys, :logger, :batch_size, :metrics, :processor, :consumer_uuid
+
+      def obtain_lock_for_process(fetch_specification)
+        result = Lock.obtain(fetch_specification, consumer_uuid, clock: @clock)
+        case result
+        when :deadlocked
+          logger.warn "Obtaining lock for split_key '#{fetch_specification.split_key}' failed (deadlock)"
+          metrics.write_operation_result("obtain", "deadlocked")
+          return false
+        when :lock_timeout
+          logger.warn "Obtaining lock for split_key '#{fetch_specification.split_key}' failed (lock timeout)"
+          metrics.write_operation_result("obtain", "lock_timeout")
+          return false
+        when :taken
+          logger.debug "Obtaining lock for split_key '#{fetch_specification.split_key}' unsuccessful (taken)"
+          metrics.write_operation_result("obtain", "taken")
+          return false
+        else
+          return result
+        end
+      end
+
+      def release_lock_for_process(fetch_specification)
+        result = Lock.release(fetch_specification, consumer_uuid)
+        case result
+        when :ok
+        when :deadlocked
+          logger.warn "Releasing lock for split_key '#{fetch_specification.split_key}' failed (deadlock)"
+          metrics.write_operation_result("release", "deadlocked")
+        when :lock_timeout
+          logger.warn "Releasing lock for split_key '#{fetch_specification.split_key}' failed (lock timeout)"
+          metrics.write_operation_result("release", "lock_timeout")
+        when :not_taken_by_this_process
+          logger.debug "Releasing lock for split_key '#{fetch_specification.split_key}' failed (not taken by this process)"
+          metrics.write_operation_result("release", "not_taken_by_this_process")
+        else
+          raise "Unexpected result #{result}"
+        end
+      end
 
-      def handle_one_record(now, record)
-        hash_payload = JSON.parse(record.payload)
-        @redis.lpush("queue:#{hash_payload.fetch("queue")}", JSON.generate(JSON.parse(record.payload).merge({
-          "enqueued_at" => now.to_f,
-        })))
+      def refresh_lock_for_process(lock)
+        result = lock.refresh(clock: @clock)
+        case result
+        when :deadlocked
+          logger.warn "Refreshing lock for split_key '#{lock.split_key}' failed (deadlock)"
+          metrics.write_operation_result("refresh", "deadlocked")
+          return false
+        when :lock_timeout
+          logger.warn "Refreshing lock for split_key '#{lock.split_key}' failed (lock timeout)"
+          metrics.write_operation_result("refresh", "lock_timeout")
+          return false
+        when :stolen
+          logger.debug "Refreshing lock for split_key '#{lock.split_key}' unsuccessful (stolen)"
+          metrics.write_operation_result("refresh", "stolen")
+          return false
+        else
+          return result
+        end
       end
 
       def prepare_traps
@@ -132,6 +214,14 @@ module RubyEventStore
       def initiate_graceful_shutdown
         @gracefully_shutting_down = true
       end
+
+      def retrieve_batch(fetch_specification)
+        Record.remaining_for(fetch_specification).order("id ASC").limit(batch_size).to_a
+      end
+
+      def get_remaining_count(fetch_specification)
+        Record.remaining_for(fetch_specification).count
+      end
     end
   end
 end

data/lib/ruby_event_store/outbox/consumer_process.rb

@@ -0,0 +1,6 @@
+module RubyEventStore
+  module Outbox
+    class ConsumerProcess
+    end
+  end
+end

data/lib/ruby_event_store/outbox/fetch_specification.rb

@@ -0,0 +1,13 @@
+module RubyEventStore
+  module Outbox
+    class FetchSpecification
+      def initialize(message_format, split_key)
+        @message_format = message_format
+        @split_key = split_key
+        freeze
+      end
+
+      attr_reader :message_format, :split_key
+    end
+  end
+end

data/lib/ruby_event_store/outbox/metrics.rb

@@ -1,13 +1,12 @@
-require "ruby_event_store/outbox/metrics/null"
-require "ruby_event_store/outbox/metrics/influx"
-
 module RubyEventStore
   module Outbox
     module Metrics
       def self.from_url(metrics_url)
         if metrics_url.nil?
+          require "ruby_event_store/outbox/metrics/null"
           Null.new
         else
+          require "ruby_event_store/outbox/metrics/influx"
           Influx.new(metrics_url)
         end
       end

data/lib/ruby_event_store/outbox/metrics/influx.rb

@@ -12,26 +12,40 @@ module RubyEventStore
             async: true,
             time_precision: 'ns',
           }
-          options[:username] = params["username"]&.first if params["username"].present?
-          options[:password] = params["password"]&.first if params["password"].present?
+          options[:username] = params.fetch("username").first if params.key?("username")
+          options[:password] = params.fetch("password").first if params.key?("password")
           @influxdb_client = InfluxDB::Client.new(**options)
         end
 
-        def write_point_queue(status:, enqueued: 0, failed: 0)
+        def write_operation_result(operation, result)
+          write_point("ruby_event_store.outbox.lock", {
+            values: {
+              value: 1,
+            },
+            tags: {
+              operation: operation,
+              result: result,
+            }
+          })
+        end
+
+        def write_point_queue(enqueued: 0, failed: 0, remaining: 0, format: nil, split_key: nil)
           write_point("ruby_event_store.outbox.queue", {
             values: {
               enqueued: enqueued,
               failed: failed,
+              remaining: remaining,
             },
             tags: {
-              status: status,
+              format: format,
+              split_key: split_key,
             }
           })
         end
 
         def write_point(series, data)
-          data[:timestamp] ||= Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond).to_i
-          @influxdb_client.write_point(series, data)
+          data[:timestamp] = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+          influxdb_client.write_point(series, data)
         end
 
         attr_reader :influxdb_client

data/lib/ruby_event_store/outbox/metrics/null.rb

@@ -2,7 +2,10 @@ module RubyEventStore
   module Outbox
     module Metrics
       class Null
-        def write_point_queue(status:, enqueued: 0, failed: 0)
+        def write_operation_result(operation, result)
+        end
+
+        def write_point_queue(**kwargs)
         end
       end
     end

data/lib/ruby_event_store/outbox/record.rb

@@ -8,9 +8,97 @@ module RubyEventStore
       self.primary_key = :id
       self.table_name = 'event_store_outbox'
 
+      def self.remaining_for(fetch_specification)
+        where(format: fetch_specification.message_format, split_key: fetch_specification.split_key, enqueued_at: nil)
+      end
+
       def hash_payload
         JSON.parse(payload).deep_symbolize_keys
       end
+
+      def enqueued?
+        !enqueued_at.nil?
+      end
+    end
+
+    class Lock < ::ActiveRecord::Base
+      self.primary_key = :split_key
+      self.table_name = 'event_store_outbox_locks'
+
+      def self.obtain(fetch_specification, process_uuid, clock:)
+        l = nil
+        transaction do
+          l = get_lock_record(fetch_specification)
+
+          return :taken if l.recently_locked?
+
+          l.update!(
+            locked_by: process_uuid,
+            locked_at: clock.now,
+          )
+        end
+        l
+      rescue ActiveRecord::Deadlocked
+        :deadlocked
+      rescue ActiveRecord::LockWaitTimeout
+        :lock_timeout
+      end
+
+      def refresh(clock:)
+        transaction do
+          current_process_uuid = locked_by
+          lock!
+          if locked_by == current_process_uuid
+            update!(locked_at: clock.now)
+            return self
+          else
+            return :stolen
+          end
+        end
+      rescue ActiveRecord::Deadlocked
+        :deadlocked
+      rescue ActiveRecord::LockWaitTimeout
+        :lock_timeout
+      end
+
+      def self.release(fetch_specification, process_uuid)
+        transaction do
+          l = get_lock_record(fetch_specification)
+          return :not_taken_by_this_process if !l.locked_by?(process_uuid)
+
+          l.update!(locked_by: nil, locked_at: nil)
+        end
+        :ok
+      rescue ActiveRecord::Deadlocked
+        :deadlocked
+      rescue ActiveRecord::LockWaitTimeout
+        :lock_timeout
+      end
+
+      def locked_by?(process_uuid)
+        locked_by.eql?(process_uuid)
+      end
+
+      def recently_locked?
+        locked_by && locked_at > 10.minutes.ago
+      end
+
+      private
+      def self.lock_for_split_key(fetch_specification)
+        lock.find_by(format: fetch_specification.message_format, split_key: fetch_specification.split_key)
+      end
+
+      def self.get_lock_record(fetch_specification)
+        l = lock_for_split_key(fetch_specification)
+        if l.nil?
+          begin
+            l = create!(format: fetch_specification.message_format, split_key: fetch_specification.split_key)
+          rescue ActiveRecord::RecordNotUnique
+            l = lock_for_split_key(fetch_specification)
+          end
+        end
+        l
+      end
     end
   end
 end

data/lib/ruby_event_store/outbox/sidekiq_processor.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "ruby_event_store/outbox/sidekiq5_format"
+
+module RubyEventStore
+  module Outbox
+    class SidekiqProcessor
+      InvalidPayload = Class.new(StandardError)
+
+      def initialize(redis)
+        @redis = redis
+        @recently_used_queues = Set.new
+      end
+
+      def process(record, now)
+        parsed_record = JSON.parse(record.payload)
+
+        queue = parsed_record["queue"]
+        raise InvalidPayload.new("Missing queue") if queue.nil? || queue.empty?
+        payload = JSON.generate(parsed_record.merge({
+          "enqueued_at" => now.to_f,
+        }))
+
+        redis.lpush("queue:#{queue}", payload)
+
+        @recently_used_queues << queue
+      end
+
+      def after_batch
+        if !@recently_used_queues.empty?
+          redis.sadd("queues", @recently_used_queues.to_a)
+          @recently_used_queues.clear
+        end
+      end
+
+      def message_format
+        SIDEKIQ5_FORMAT
+      end
+
+      private
+      attr_reader :redis
+    end
+  end
+end

data/lib/ruby_event_store/outbox/sidekiq_producer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+require "ruby_event_store/outbox/sidekiq5_format"
+
+module RubyEventStore
+  module Outbox
+    class SidekiqProducer
+      def call(klass, args)
+        sidekiq_client = Sidekiq::Client.new(Sidekiq.redis_pool)
+        item = {
+          'class' => klass,
+          'args' => args,
+        }
+        normalized_item = sidekiq_client.__send__(:normalize_item, item)
+        payload = sidekiq_client.__send__(:process_single, normalized_item.fetch('class'), normalized_item)
+        if payload
+          Record.create!(
+            format: SIDEKIQ5_FORMAT,
+            split_key: payload.fetch('queue'),
+            payload: payload.to_json
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/outbox/sidekiq_scheduler.rb

@@ -1,31 +1,24 @@
 # frozen_string_literal: true
 
-require 'sidekiq'
-require "ruby_event_store/outbox/sidekiq5_format"
+require "ruby_event_store/outbox/sidekiq_producer"
 
 module RubyEventStore
   module Outbox
     class SidekiqScheduler
+      def initialize
+        @sidekiq_producer = SidekiqProducer.new
+      end
+
       def call(klass, serialized_event)
-        sidekiq_client = Sidekiq::Client.new(Sidekiq.redis_pool)
-        item = {
-          'class' => klass,
-          'args' => [serialized_event.to_h],
-        }
-        normalized_item = sidekiq_client.__send__(:normalize_item, item)
-        payload = sidekiq_client.__send__(:process_single, normalized_item.fetch('class'), normalized_item)
-        if payload
-          Record.create!(
-            format: SIDEKIQ5_FORMAT,
-            split_key: payload.fetch('queue'),
-            payload: payload.to_json
-          )
-        end
+        sidekiq_producer.call(klass, [serialized_event.to_h])
       end
 
       def verify(subscriber)
         Class === subscriber && subscriber.respond_to?(:through_outbox?) && subscriber.through_outbox?
       end
+
+      private
+      attr_reader :sidekiq_producer
     end
   end
 end

data/lib/ruby_event_store/outbox/version.rb

@@ -2,6 +2,6 @@
 
 module RubyEventStore
   module Outbox
-    VERSION = "0.0.8"
+    VERSION = "0.0.13"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store-outbox
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.13
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-25 00:00:00.000000000 Z
+date: 2020-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_event_store
@@ -53,12 +53,16 @@ files:
 - lib/ruby_event_store/outbox.rb
 - lib/ruby_event_store/outbox/cli.rb
 - lib/ruby_event_store/outbox/consumer.rb
+- lib/ruby_event_store/outbox/consumer_process.rb
+- lib/ruby_event_store/outbox/fetch_specification.rb
 - lib/ruby_event_store/outbox/metrics.rb
 - lib/ruby_event_store/outbox/metrics/influx.rb
 - lib/ruby_event_store/outbox/metrics/null.rb
 - lib/ruby_event_store/outbox/record.rb
 - lib/ruby_event_store/outbox/sidekiq5_format.rb
 - lib/ruby_event_store/outbox/sidekiq_message_handler.rb
+- lib/ruby_event_store/outbox/sidekiq_processor.rb
+- lib/ruby_event_store/outbox/sidekiq_producer.rb
 - lib/ruby_event_store/outbox/sidekiq_scheduler.rb
 - lib/ruby_event_store/outbox/version.rb
 homepage: https://railseventstore.org