ruby_event_store-outbox 0.0.30 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b41d9195dccdaa450d5e52678e65e238a0e6e36ea9147cb8ec6c397605690baf
-  data.tar.gz: faab545ddeddc537089d2e0227c70cc493a9b4196ae39777dfb2f28da45aa9f6
+  metadata.gz: 67529756ee35bbaf8447ed5ed8afbc6b6e80e2eaae62a1c396492fe4f6fcb7e0
+  data.tar.gz: 617091c19ad0d7bd1a688178740b43aa41165ed7cd9a5a371da33ff7734d3873
 SHA512:
-  metadata.gz: a46cd984375895708527aa817da14e198b829d330f3063cccd838925ba6a5c3a12a2cb72bc06cc4725fc65d83bcb36bd7e0469f5a3d4cbc742b12f974a3c0bee
-  data.tar.gz: 67ccdf300534a01a646711cf924ba744904d7c7fdca3850b3a7cc97b76b6d5881d153844cea9b6e87ce116fb31788e2c63a9caa529dd2141a076567177cb086e
+  metadata.gz: 2ec5edfc468a99b05f38a9fc6f2db83bb30f2fd86a1c995f98476dee542a99b8f811a83e46e6915b20873eb1c291e5dc7f95a996542c3017a026fbad93eeb383
+  data.tar.gz: 63ee434baae965c530ac947820d0b1f5d2cf682268da3b7c377dde42eedd8eea91b3d56dbd6a96a0e10ec288d4ce6bedbb3cbac9bc874ea03642572f977f7b2a

data/lib/ruby_event_store/outbox/cleanup_strategies/none.rb

@@ -4,7 +4,8 @@ module RubyEventStore
   module Outbox
     module CleanupStrategies
       class None
-        def initialize; end
+        def initialize
+        end
 
         def call(_fetch_specification)
           :ok

data/lib/ruby_event_store/outbox/cleanup_strategies.rb

@@ -14,7 +14,7 @@ module RubyEventStore
           CleanOldEnqueued.new(
             repository,
             ActiveSupport::Duration.parse(configuration.cleanup),
-            configuration.cleanup_limit
+            configuration.cleanup_limit,
           )
         end
       end

data/lib/ruby_event_store/outbox/cli.rb

@@ -20,7 +20,8 @@ module RubyEventStore
         metrics_url: nil,
         cleanup_strategy: :none,
         cleanup_limit: :all,
-        sleep_on_empty: 0.5
+        sleep_on_empty: 0.5,
+        locking: true,
       }
       Options = Struct.new(*DEFAULTS.keys)
 
@@ -31,10 +32,9 @@ module RubyEventStore
             .new do |option_parser|
               option_parser.banner = "Usage: res_outbox [options]"
 
-              option_parser.on(
-                "--database-url=DATABASE_URL",
-                "Database where outbox table is stored"
-              ) { |database_url| options.database_url = database_url }
+              option_parser.on("--database-url=DATABASE_URL", "Database where outbox table is stored") do |database_url|
+                options.database_url = database_url
+              end
 
               option_parser.on("--redis-url=REDIS_URL", "URL to redis database") do |redis_url|
                 options.redis_url = redis_url
@@ -43,25 +43,25 @@ module RubyEventStore
               option_parser.on(
                 "--log-level=LOG_LEVEL",
                 %i[fatal error warn info debug],
-                "Logging level, one of: fatal, error, warn, info, debug. Default: warn"
+                "Logging level, one of: fatal, error, warn, info, debug. Default: warn",
               ) { |log_level| options.log_level = log_level.to_sym }
 
               option_parser.on(
                 "--message-format=FORMAT",
                 ["sidekiq5"],
-                "Message format, supported: sidekiq5. Default: sidekiq5"
+                "Message format, supported: sidekiq5. Default: sidekiq5",
               ) { |message_format| options.message_format = message_format }
 
               option_parser.on(
                 "--split-keys=SPLIT_KEYS",
                 Array,
-                "Split keys which should be handled, all if not specified"
+                "Split keys which should be handled, all if not specified",
               ) { |split_keys| options.split_keys = split_keys if !split_keys.empty? }
 
               option_parser.on(
                 "--batch-size=BATCH_SIZE",
                 Integer,
-                "Amount of records fetched in one fetch. Bigger value means more duplicated messages when network problems occur. Default: 100"
+                "Amount of records fetched in one fetch. Bigger value means more duplicated messages when network problems occur. Default: 100",
               ) { |batch_size| options.batch_size = batch_size }
 
               option_parser.on("--metrics-url=METRICS_URL", "URI to metrics collector, optional") do |metrics_url|
@@ -70,20 +70,24 @@ module RubyEventStore
 
               option_parser.on(
                 "--cleanup=STRATEGY",
-                "A strategy for cleaning old records. One of: none or iso8601 duration format how old enqueued records should be removed. Default: none"
+                "A strategy for cleaning old records. One of: none or iso8601 duration format how old enqueued records should be removed. Default: none",
               ) { |cleanup_strategy| options.cleanup_strategy = cleanup_strategy }
 
               option_parser.on(
                 "--cleanup-limit=LIMIT",
-                "Amount of records removed in single cleanup run. One of: all or number of records that should be removed. Default: all"
+                "Amount of records removed in single cleanup run. One of: all or number of records that should be removed. Default: all",
               ) { |cleanup_limit| options.cleanup_limit = cleanup_limit }
 
               option_parser.on(
                 "--sleep-on-empty=SLEEP_TIME",
                 Float,
-                "How long to sleep before next check when there was nothing to do. Default: 0.5"
+                "How long to sleep before next check when there was nothing to do. Default: 0.5",
               ) { |sleep_on_empty| options.sleep_on_empty = sleep_on_empty }
 
+              option_parser.on("-l", "--[no-]lock", "Lock split key in consumer") do |locking|
+                options.locking = locking
+              end
+
               option_parser.on_tail("--version", "Show version") do
                 puts VERSION
                 exit
@@ -96,26 +100,26 @@ module RubyEventStore
 
       def run(argv)
         options = Parser.parse(argv)
-        build_runner(options)
-          .run
+        build_runner(options).run
       end
 
       def build_runner(options)
         consumer_uuid = SecureRandom.uuid
         logger = Logger.new(STDOUT, level: options.log_level, progname: "RES-Outbox #{consumer_uuid}")
-        consumer_configuration = Configuration.new(
-          split_keys: options.split_keys,
-          message_format: options.message_format,
-          batch_size: options.batch_size,
-          database_url: options.database_url,
-          redis_url: options.redis_url,
-          cleanup: options.cleanup_strategy,
-          cleanup_limit: options.cleanup_limit,
-          sleep_on_empty: options.sleep_on_empty,
-        )
+        consumer_configuration =
+          Configuration.new(
+            split_keys: options.split_keys,
+            message_format: options.message_format,
+            batch_size: options.batch_size,
+            database_url: options.database_url,
+            redis_url: options.redis_url,
+            cleanup: options.cleanup_strategy,
+            cleanup_limit: options.cleanup_limit,
+            sleep_on_empty: options.sleep_on_empty,
+            locking: options.locking,
+          )
         metrics = Metrics.from_url(options.metrics_url)
-        outbox_consumer =
-          Outbox::Consumer.new(consumer_uuid, consumer_configuration, logger: logger, metrics: metrics)
+        outbox_consumer = Outbox::Consumer.new(consumer_uuid, consumer_configuration, logger: logger, metrics: metrics)
         Runner.new(outbox_consumer, consumer_configuration, logger: logger)
       end
     end

data/lib/ruby_event_store/outbox/configuration.rb

@@ -11,7 +11,8 @@ module RubyEventStore
         redis_url:,
         cleanup:,
         cleanup_limit:,
-        sleep_on_empty:
+        sleep_on_empty:,
+        locking:
       )
         @split_keys = split_keys
         @message_format = message_format
@@ -21,6 +22,7 @@ module RubyEventStore
         @cleanup = cleanup
         @cleanup_limit = cleanup_limit
         @sleep_on_empty = sleep_on_empty
+        @locking = locking
         freeze
       end
 
@@ -33,18 +35,20 @@ module RubyEventStore
           redis_url: overriden_options.fetch(:redis_url, redis_url),
           cleanup: overriden_options.fetch(:cleanup, cleanup),
           cleanup_limit: overriden_options.fetch(:cleanup_limit, cleanup_limit),
-          sleep_on_empty: overriden_options.fetch(:sleep_on_empty, sleep_on_empty)
+          sleep_on_empty: overriden_options.fetch(:sleep_on_empty, sleep_on_empty),
+          locking: overriden_options.fetch(:locking, locking),
         )
       end
 
       attr_reader :split_keys,
-        :message_format,
-        :batch_size,
-        :database_url,
-        :redis_url,
-        :cleanup,
-        :cleanup_limit,
-        :sleep_on_empty
+                  :message_format,
+                  :batch_size,
+                  :database_url,
+                  :redis_url,
+                  :cleanup,
+                  :cleanup_limit,
+                  :sleep_on_empty,
+                  :locking
     end
   end
 end

data/lib/ruby_event_store/outbox/consumer.rb

@@ -23,12 +23,13 @@ module RubyEventStore
         @metrics = metrics
         @tempo = Tempo.new(configuration.batch_size)
         @consumer_uuid = consumer_uuid
+        @locking = configuration.locking
 
         raise "Unknown format" if configuration.message_format != SIDEKIQ5_FORMAT
         redis_config = RedisClient.config(url: configuration.redis_url)
         @processor = SidekiqProcessor.new(redis_config.new_client)
 
-        @repository = Repository.new(configuration.database_url)
+        @repository = Repository.new(configuration.database_url, logger, metrics)
         @cleanup_strategy = CleanupStrategies.build(configuration, repository)
       end
 
@@ -43,56 +44,17 @@ module RubyEventStore
       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)
-          break if batch.empty?
-
-          batch_result = BatchResult.empty
-          batch.each do |record|
-            handle_failure(batch_result) do
-              now = @clock.now.utc
-              processor.process(record, now)
-
-              repository.mark_as_enqueued(record, now)
-              something_processed |= true
-              batch_result.count_success!
-            end
+        repository
+          .with_next_batch(fetch_specification, tempo.batch_size, consumer_uuid, locking, @clock) do |record|
+            now = @clock.now.utc
+            processor.process(record, now)
+            repository.mark_as_enqueued(record, now)
           end
-
-          metrics.write_point_queue(
-            enqueued: batch_result.success_count,
-            failed: batch_result.failed_count,
-            format: fetch_specification.message_format,
-            split_key: fetch_specification.split_key,
-            remaining: get_remaining_count(fetch_specification)
-          )
-
-          logger.info "Sent #{batch_result.success_count} messages from outbox table"
-
-          refresh_successful = refresh_lock_for_process(obtained_lock)
-          break unless refresh_successful
-        end
-
-        unless something_processed
-          metrics.write_point_queue(
-            format: fetch_specification.message_format,
-            split_key: fetch_specification.split_key,
-            remaining: get_remaining_count(fetch_specification)
-          )
-        end
-
-        release_lock_for_process(fetch_specification)
-
-        cleanup(fetch_specification)
-
-        processor.after_batch
-
-        something_processed
+          .tap do
+            cleanup(fetch_specification)
+            processor.after_batch
+          end
+          .success_count > 0
       end
 
       private
@@ -103,86 +65,10 @@ module RubyEventStore
                   :processor,
                   :consumer_uuid,
                   :repository,
+                  :locking,
                   :cleanup_strategy,
                   :tempo
 
-      def handle_failure(batch_result)
-        retried = false
-        yield
-      rescue RetriableRedisError => error
-        if retried
-          batch_result.count_failed!
-          log_error(error)
-        else
-          retried = true
-          retry
-        end
-      rescue => error
-        batch_result.count_failed!
-        log_error(error)
-      end
-
-      def log_error(e)
-        e.full_message.split($/).each { |line| logger.error(line) }
-      end
-
-      def obtain_lock_for_process(fetch_specification)
-        result = repository.obtain_lock_for_process(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")
-          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")
-          false
-        when :taken
-          logger.debug "Obtaining lock for split_key '#{fetch_specification.split_key}' unsuccessful (taken)"
-          metrics.write_operation_result("obtain", "taken")
-          false
-        else
-          result
-        end
-      end
-
-      def release_lock_for_process(fetch_specification)
-        result = repository.release_lock_for_process(fetch_specification, consumer_uuid)
-        case result
-        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")
-        end
-      end
-
-      def refresh_lock_for_process(lock)
-        result = lock.refresh(clock: @clock)
-        case result
-        when :ok
-          return true
-        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
-          raise "Unexpected result #{result}"
-        end
-      end
-
       def cleanup(fetch_specification)
         result = cleanup_strategy.call(fetch_specification)
         case result
@@ -194,14 +80,6 @@ module RubyEventStore
           metrics.write_operation_result("cleanup", "lock_timeout")
         end
       end
-
-      def retrieve_batch(fetch_specification)
-        repository.retrieve_batch(fetch_specification, tempo.batch_size)
-      end
-
-      def get_remaining_count(fetch_specification)
-        repository.get_remaining_count(fetch_specification)
-      end
     end
   end
 end

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

@@ -7,7 +7,6 @@ module RubyEventStore
     module Metrics
       class Influx
         def initialize(url)
-          uri = URI.parse(url)
           options = { url: url, async: true, time_precision: "ns" }
           @influxdb_client = InfluxDB::Client.new(**options)
         end
@@ -15,7 +14,7 @@ module RubyEventStore
         def write_operation_result(operation, result)
           write_point(
             "ruby_event_store.outbox.lock",
-            { values: { value: 1 }, tags: { operation: operation, result: result } }
+            { values: { value: 1 }, tags: { operation: operation, result: result } },
           )
         end
 
@@ -26,13 +25,13 @@ module RubyEventStore
               values: {
                 enqueued: enqueued,
                 failed: failed,
-                remaining: remaining
+                remaining: remaining,
               },
               tags: {
                 format: format,
-                split_key: split_key
-              }
-            }
+                split_key: split_key,
+              },
+            },
           )
         end
 

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

@@ -4,9 +4,11 @@ module RubyEventStore
   module Outbox
     module Metrics
       class Null
-        def write_operation_result(operation, result); end
+        def write_operation_result(operation, result)
+        end
 
-        def write_point_queue(**kwargs); end
+        def write_point_queue(**kwargs)
+        end
       end
     end
   end

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

@@ -21,7 +21,7 @@ module RubyEventStore
             failed: failed,
             remaining: remaining,
             format: format,
-            split_key: split_key
+            split_key: split_key,
           }
         end
 

data/lib/ruby_event_store/outbox/repository.rb

@@ -113,27 +113,21 @@ module RubyEventStore
         end
       end
 
-      def initialize(database_url)
+      def initialize(database_url, logger, metrics)
+        @logger = logger
+        @metrics = metrics
         ::ActiveRecord::Base.establish_connection(database_url) unless ::ActiveRecord::Base.connected?
         if ::ActiveRecord::Base.connection.adapter_name == "Mysql2"
           ::ActiveRecord::Base.connection.execute("SET SESSION innodb_lock_wait_timeout = 1;")
         end
       end
 
-      def retrieve_batch(fetch_specification, batch_size)
-        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
-
-      def obtain_lock_for_process(fetch_specification, process_uuid, clock:)
-        Lock.obtain(fetch_specification, process_uuid, clock: clock)
-      end
-
-      def release_lock_for_process(fetch_specification, process_uuid)
-        Lock.release(fetch_specification, process_uuid)
+      def with_next_batch(fetch_specification, batch_size, consumer_uuid, locking, clock, &block)
+        if locking
+          with_next_locking_batch(fetch_specification, batch_size, consumer_uuid, clock, &block)
+        else
+          with_next_non_locking_batch(fetch_specification, batch_size, &block)
+        end
       end
 
       def mark_as_enqueued(record, now)
@@ -150,6 +144,123 @@ module RubyEventStore
       rescue ::ActiveRecord::LockWaitTimeout
         :lock_timeout
       end
+
+      private
+
+      def with_next_locking_batch(fetch_specification, batch_size, consumer_uuid, clock, &block)
+        BatchResult.empty.tap do |result|
+          obtained_lock = obtain_lock_for_process(fetch_specification, consumer_uuid, clock: clock)
+          case obtained_lock
+          when :deadlocked
+            logger.warn "Obtaining lock for split_key '#{fetch_specification.split_key}' failed (deadlock)"
+            metrics.write_operation_result("obtain", "deadlocked")
+            return BatchResult.empty
+          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 BatchResult.empty
+          when :taken
+            logger.debug "Obtaining lock for split_key '#{fetch_specification.split_key}' unsuccessful (taken)"
+            metrics.write_operation_result("obtain", "taken")
+            return BatchResult.empty
+          end
+
+          Consumer::MAXIMUM_BATCH_FETCHES_IN_ONE_LOCK.times do
+            batch = retrieve_batch(fetch_specification, batch_size).to_a
+            break if batch.empty?
+            batch.each { |record| handle_execution(result) { block.call(record) } }
+            case (refresh_result = obtained_lock.refresh(clock: clock))
+            when :ok
+            when :deadlocked
+              logger.warn "Refreshing lock for split_key '#{lock.split_key}' failed (deadlock)"
+              metrics.write_operation_result("refresh", "deadlocked")
+              break
+            when :lock_timeout
+              logger.warn "Refreshing lock for split_key '#{lock.split_key}' failed (lock timeout)"
+              metrics.write_operation_result("refresh", "lock_timeout")
+              break
+            when :stolen
+              logger.debug "Refreshing lock for split_key '#{lock.split_key}' unsuccessful (stolen)"
+              metrics.write_operation_result("refresh", "stolen")
+              break
+            else
+              raise "Unexpected result #{refresh_result}"
+            end
+          end
+
+          case release_lock_for_process(fetch_specification, consumer_uuid)
+          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")
+          end
+          instrument_batch_result(fetch_specification, result)
+        end
+      end
+
+      def with_next_non_locking_batch(fetch_specification, batch_size, &block)
+        BatchResult.empty.tap do |result|
+          Record.transaction do
+            batch = retrieve_batch(fetch_specification, batch_size).lock("FOR UPDATE SKIP LOCKED")
+            break if batch.empty?
+            batch.each { |record| handle_execution(result) { block.call(record) } }
+          end
+
+          instrument_batch_result(fetch_specification, result)
+        end
+      end
+
+      def instrument_batch_result(fetch_specification, result)
+        metrics.write_point_queue(
+          enqueued: result.success_count,
+          failed: result.failed_count,
+          format: fetch_specification.message_format,
+          split_key: fetch_specification.split_key,
+          remaining: Record.remaining_for(fetch_specification).count,
+        )
+
+        logger.info "Sent #{result.success_count} messages from outbox table"
+      end
+
+      def handle_execution(batch_result)
+        retried = false
+        yield
+        batch_result.count_success!
+      rescue RetriableRedisError => error
+        if retried
+          batch_result.count_failed!
+          log_error(error)
+        else
+          retried = true
+          retry
+        end
+      rescue => error
+        batch_result.count_failed!
+        log_error(error)
+      end
+
+      def log_error(e)
+        e.full_message.split($/).each { |line| logger.error(line) }
+      end
+
+      def retrieve_batch(fetch_specification, batch_size)
+        Record.remaining_for(fetch_specification).order("id ASC").limit(batch_size)
+      end
+
+      def obtain_lock_for_process(fetch_specification, process_uuid, clock:)
+        Lock.obtain(fetch_specification, process_uuid, clock: clock)
+      end
+
+      def release_lock_for_process(fetch_specification, process_uuid)
+        Lock.release(fetch_specification, process_uuid)
+      end
+
+      attr_reader :logger, :metrics
     end
   end
 end

data/lib/ruby_event_store/outbox/runner.rb

@@ -8,12 +8,14 @@ module RubyEventStore
         @logger = logger
         @sleep_on_empty = configuration.sleep_on_empty
         @split_keys = configuration.split_keys
+        @locking = configuration.locking
         @gracefully_shutting_down = false
         prepare_traps
       end
 
       def run
         logger.info("Initiated RubyEventStore::Outbox v#{VERSION}")
+        logger.info("Using #{@locking ? "locking" : "non-locking"} mode")
         logger.info("Handling split keys: #{split_keys ? split_keys.join(", ") : "(all of them)"}")
 
         while !@gracefully_shutting_down
@@ -28,6 +30,7 @@ module RubyEventStore
       end
 
       private
+
       attr_reader :consumer, :logger, :sleep_on_empty, :split_keys
 
       def prepare_traps

data/lib/ruby_event_store/outbox/sidekiq_processor.rb

@@ -20,7 +20,7 @@ module RubyEventStore
 
         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 }))
+        payload = JSON.generate(parsed_record.merge({ "enqueued_at" => record.created_at.to_f }))
 
         redis.call("LPUSH", "queue:#{queue}", payload)
 

data/lib/ruby_event_store/outbox/sidekiq_producer.rb

@@ -20,7 +20,7 @@ module RubyEventStore
           Repository::Record.create!(
             format: SIDEKIQ5_FORMAT,
             split_key: payload.fetch("queue"),
-            payload: payload.to_json
+            payload: payload.to_json,
           )
         end
       end

data/lib/ruby_event_store/outbox/version.rb

@@ -2,6 +2,6 @@
 
 module RubyEventStore
   module Outbox
-    VERSION = "0.0.30"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store-outbox
 version: !ruby/object:Gem::Version
-  version: 0.0.30
+  version: 0.2.0
 platform: ruby
 authors:
 - Arkency
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_event_store
@@ -38,7 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
-description:
 email: dev@arkency.com
 executables:
 - res_outbox
@@ -79,7 +77,6 @@ metadata:
   source_code_uri: https://github.com/RailsEventStore/rails_event_store
   bug_tracker_uri: https://github.com/RailsEventStore/rails_event_store/issues
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -94,8 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Active Record based outbox for Ruby Event Store
 test_files: []