pg_eventstore 0.10.1 → 1.0.0.rc1

data/lib/pg_eventstore/queries/subscription_queries.rb

@@ -22,11 +22,7 @@ module PgEventstore
     # @param attrs [Hash]
     # @return [Hash, nil]
     def find_by(attrs)
-      builder = SQLBuilder.new.select('*').from('subscriptions')
-      attrs.each do |attr, val|
-        builder.where("#{attr} = ?", val)
-      end
-
+      builder = find_by_attrs_builder(attrs).limit(1)
       pg_result = connection.with do |conn|
         conn.exec_params(*builder.to_exec_params)
       end
@@ -35,6 +31,25 @@ module PgEventstore
       deserialize(pg_result.to_a.first)
     end
 
+    # @param attrs [Hash]
+    # @return [Array<Hash>]
+    def find_all(attrs)
+      builder = find_by_attrs_builder(attrs)
+      pg_result = connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end
+      return [] if pg_result.ntuples.zero?
+
+      pg_result.map(&method(:deserialize))
+    end
+
+    # @return [Array<String>]
+    def set_collection
+      connection.with do |conn|
+        conn.exec('SELECT set FROM subscriptions GROUP BY set ORDER BY set ASC')
+      end.map { |attrs| attrs['set'] }
+    end
+
     # @param id [Integer]
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
@@ -58,40 +73,61 @@ module PgEventstore
 
     # @param id [Integer]
     # @param attrs [Hash]
-    def update(id, attrs)
+    # @param locked_by [Integer]
+    # @return [Hash]
+    # @raise [PgEventstore::RecordNotFound]
+    # @raise [PgEventstore::WrongLockIdError]
+    def update(id, attrs:, locked_by:)
       attrs = { updated_at: Time.now.utc }.merge(attrs)
       attrs_sql = attrs.keys.map.with_index(1) do |attr, index|
         "#{attr} = $#{index}"
       end.join(', ')
       sql =
         "UPDATE subscriptions SET #{attrs_sql} WHERE id = $#{attrs.keys.size + 1} RETURNING *"
-      pg_result = connection.with do |conn|
-        conn.exec_params(sql, [*attrs.values, id])
+      updated_attrs = transaction_queries.transaction do
+        pg_result = connection.with do |conn|
+          conn.exec_params(sql, [*attrs.values, id])
+        end
+        raise(RecordNotFound.new("subscriptions", id)) if pg_result.ntuples.zero?
+
+        updated_attrs = pg_result.to_a.first
+        unless updated_attrs['locked_by'] == locked_by
+          # Subscription is force-locked by someone else. We have to roll back such transaction
+          raise(WrongLockIdError.new(updated_attrs['set'], updated_attrs['name'], updated_attrs['locked_by']))
+        end
+        updated_attrs
       end
-      raise(RecordNotFound.new("subscriptions", id)) if pg_result.ntuples.zero?
 
-      deserialize(pg_result.to_a.first)
+      deserialize(updated_attrs)
     end
 
-    # @param query_options [Array<Array<Integer, Hash>>] array of runner ids and query options
-    # @return [Array<Hash>] array of raw events
+    # @param query_options [Hash{Integer => Hash}] runner_id/query options association
+    # @return [Hash{Integer => Hash}] runner_id/events association
     def subscriptions_events(query_options)
-      return [] if query_options.empty?
+      return {} if query_options.empty?
 
       final_builder = union_builders(query_options.map { |id, opts| query_builder(id, opts) })
-      connection.with do |conn|
+      raw_events = connection.with do |conn|
         conn.exec_params(*final_builder.to_exec_params)
       end.to_a
+      raw_events.group_by { _1['runner_id'] }.to_h do |runner_id, runner_raw_events|
+        next [runner_id, runner_raw_events] unless query_options[runner_id][:resolve_link_tos]
+
+        [runner_id, links_resolver.resolve(runner_raw_events)]
+      end
     end
 
     # @param id [Integer] subscription's id
-    # @param lock_id [String] UUIDv4 id of the subscriptions set which reserves the subscription
+    # @param lock_id [Integer] id of the subscriptions set which reserves the subscription
     # @param force [Boolean] whether to lock the subscription despite on #locked_by value
-    # @return [String] UUIDv4 lock id
+    # @return [Integer] lock id
     # @raise [SubscriptionAlreadyLockedError] in case the Subscription is already locked
-    def lock!(id, lock_id, force = false)
+    def lock!(id, lock_id, force: false)
       transaction_queries.transaction do
         attrs = find!(id)
+        # We don't care who locked the Subscription - whether it is the same SubscriptionsSet or not - multiple locks
+        # must not happen even with the same SubscriptionsSet. We later assume this to reset Subscription's stats, for
+        # example.
         if attrs[:locked_by] && !force
           raise SubscriptionAlreadyLockedError.new(attrs[:set], attrs[:name], attrs[:locked_by])
         end
@@ -102,22 +138,11 @@ module PgEventstore
       lock_id
     end
 
-    # @param id [Integer] subscription's id
-    # @param lock_id [String] UUIDv4 id of the set which reserved the subscription after itself
+    # @param id [Integer]
     # @return [void]
-    # @raise [SubscriptionUnlockError] in case the Subscription is locked by some SubscriptionsSet, other than the one,
-    #   persisted in memory
-    def unlock!(id, lock_id)
-      transaction_queries.transaction do
-        attrs = find!(id)
-        # Normally this should never happen as locking/unlocking happens within the same process. This is done only for
-        # the matter of consistency.
-        unless attrs[:locked_by] == lock_id
-          raise SubscriptionUnlockError.new(attrs[:set], attrs[:name], lock_id, attrs[:locked_by])
-        end
-        connection.with do |conn|
-          conn.exec_params('UPDATE subscriptions SET locked_by = $1 WHERE id = $2', [nil, id])
-        end
+    def delete(id)
+      connection.with do |conn|
+        conn.exec_params('DELETE FROM subscriptions WHERE id = $1', [id])
       end
     end
 
@@ -144,9 +169,9 @@ module PgEventstore
       TransactionQueries.new(connection)
     end
 
-    # @return [PgEventstore::EventTypeQueries]
-    def event_type_queries
-      EventTypeQueries.new(connection)
+    # @return [PgEventstore::LinksResolver]
+    def links_resolver
+      LinksResolver.new(connection)
     end
 
     # @param hash [Hash]
@@ -154,5 +179,15 @@ module PgEventstore
     def deserialize(hash)
       hash.transform_keys(&:to_sym)
     end
+
+    # @param attrs [Hash]
+    # @return [PgEventstore::SQLBuilder]
+    def find_by_attrs_builder(attrs)
+      builder = SQLBuilder.new.select('*').from('subscriptions').order('id ASC')
+      attrs.each do |attr, val|
+        builder.where("#{attr} = ?", val)
+      end
+      builder
+    end
   end
 end

data/lib/pg_eventstore/queries/subscriptions_set_command_queries.rb

@@ -11,6 +11,13 @@ module PgEventstore
       @connection = connection
     end
 
+    # @return [Hash]
+    def find_or_create_by(...)
+      transaction_queries.transaction do
+        find_by(...) || create(...)
+      end
+    end
+
     # @param subscriptions_set_id [Integer]
     # @param command_name [String]
     # @return [Hash, nil]
@@ -31,7 +38,7 @@ module PgEventstore
     # @param subscriptions_set_id [Integer]
     # @param command_name [String]
     # @return [Hash]
-    def create_by(subscriptions_set_id:, command_name:)
+    def create(subscriptions_set_id:, command_name:)
       sql = <<~SQL
         INSERT INTO subscriptions_set_commands (name, subscriptions_set_id) 
           VALUES ($1, $2)
@@ -72,5 +79,10 @@ module PgEventstore
     def deserialize(hash)
       hash.transform_keys(&:to_sym)
     end
+
+    # @return [PgEventstore::TransactionQueries]
+    def transaction_queries
+      TransactionQueries.new(connection)
+    end
   end
 end

data/lib/pg_eventstore/queries/subscriptions_set_queries.rb

@@ -14,7 +14,7 @@ module PgEventstore
     # @param attrs [Hash]
     # @return [Array<Hash>]
     def find_all(attrs)
-      builder = SQLBuilder.new.select('*').from('subscriptions_set')
+      builder = SQLBuilder.new.select('*').from('subscriptions_set').order('name ASC, id ASC')
       attrs.each do |attr, val|
         builder.where("#{attr} = ?", val)
       end
@@ -25,13 +25,22 @@ module PgEventstore
       pg_result.to_a.map(&method(:deserialize))
     end
 
+    # @return [Array<String>]
+    def set_names
+      builder = SQLBuilder.new.select('name').from('subscriptions_set').group('name').order('name ASC')
+
+      connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end.map { |attrs| attrs['name'] }
+    end
+
     # The same as #find_all, but returns first result
     # @return [Hash, nil]
     def find_by(...)
       find_all(...).first
     end
 
-    # @param id [String] UUIDv4
+    # @param id [Integer]
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
     def find!(id)
@@ -52,7 +61,7 @@ module PgEventstore
       deserialize(pg_result.to_a.first)
     end
 
-    # @param id [String] UUIDv4
+    # @param id [Integer]
     # @param attrs [Hash]
     def update(id, attrs)
       attrs = { updated_at: Time.now.utc }.merge(attrs)
@@ -70,7 +79,7 @@ module PgEventstore
       deserialize(pg_result.to_a.first)
     end
 
-    # @return id [Integer]
+    # @param id [Integer]
     # @return [void]
     def delete(id)
       connection.with do |conn|
@@ -85,5 +94,10 @@ module PgEventstore
     def deserialize(hash)
       hash.transform_keys(&:to_sym)
     end
+
+    # @return [PgEventstore::TransactionQueries]
+    def transaction_queries
+      TransactionQueries.new(connection)
+    end
   end
 end

data/lib/pg_eventstore/queries.rb

@@ -9,6 +9,7 @@ require_relative 'queries/subscription_queries'
 require_relative 'queries/subscriptions_set_queries'
 require_relative 'queries/subscription_command_queries'
 require_relative 'queries/subscriptions_set_command_queries'
+require_relative 'queries/links_resolver'
 
 module PgEventstore
   # @!visibility private

data/lib/pg_eventstore/query_builders/events_filtering_query.rb

@@ -28,10 +28,9 @@ module PgEventstore
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
         def all_stream_filtering(options)
           event_filter = new
-          options in { filter: { event_types: Array => event_type_ids } }
-          event_filter.add_event_types(event_type_ids)
+          options in { filter: { event_types: Array => event_types } }
+          event_filter.add_event_types(event_types)
           event_filter.add_limit(options[:max_count])
-          event_filter.resolve_links(options[:resolve_link_tos])
           options in { filter: { streams: Array => streams } }
           streams&.each { |attrs| event_filter.add_stream_attrs(**attrs) }
           event_filter.add_global_position(options[:from_position], options[:direction])
@@ -44,10 +43,9 @@ module PgEventstore
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
         def specific_stream_filtering(stream, options)
           event_filter = new
-          options in { filter: { event_types: Array => event_type_ids } }
-          event_filter.add_event_types(event_type_ids)
+          options in { filter: { event_types: Array => event_types } }
+          event_filter.add_event_types(event_types)
           event_filter.add_limit(options[:max_count])
-          event_filter.resolve_links(options[:resolve_link_tos])
           event_filter.add_stream_attrs(**stream.to_hash)
           event_filter.add_revision(options[:from_revision], options[:direction])
           event_filter.add_stream_direction(options[:direction])
@@ -128,17 +126,6 @@ module PgEventstore
         @sql_builder.limit(limit)
       end
 
-      # @param should_resolve [Boolean]
-      # @return [void]
-      def resolve_links(should_resolve)
-        return unless should_resolve
-
-        @sql_builder.
-          unselect.
-          select("(COALESCE(original_events.*, events.*)).*").
-          join("LEFT JOIN events original_events ON original_events.id = events.link_id")
-      end
-
       # @return [PgEventstore::SQLBuilder]
       def to_sql_builder
         @sql_builder

data/lib/pg_eventstore/subscriptions/command_handlers/subscription_feeder_commands.rb

@@ -3,7 +3,7 @@
 module PgEventstore
   module CommandHandlers
     class SubscriptionFeederCommands
-      AVAILABLE_COMMANDS = %w[StopAll StartAll].freeze
+      AVAILABLE_COMMANDS = %i[StopAll StartAll Restore Stop].to_h { [_1, _1.to_s] }.freeze
 
       # @param config_name [Symbol]
       # @param subscription_feeder [PgEventstore::SubscriptionFeeder]
@@ -16,7 +16,7 @@ module PgEventstore
       # @return [void]
       def process
         queries.find_commands(@subscription_feeder.id).each do |command|
-          unless AVAILABLE_COMMANDS.include?(command[:name])
+          unless AVAILABLE_COMMANDS.values.include?(command[:name])
             PgEventstore.logger&.warn(
               "#{self.class.name}: Don't know how to handle #{command[:name].inspect}. Details: #{command.inspect}."
             )
@@ -47,6 +47,14 @@ module PgEventstore
       def start_all
         @subscription_feeder.start_all
       end
+
+      def restore
+        @subscription_feeder.restore
+      end
+
+      def stop
+        @subscription_feeder.stop
+      end
     end
   end
 end

data/lib/pg_eventstore/subscriptions/command_handlers/subscription_runners_commands.rb

@@ -3,20 +3,22 @@
 module PgEventstore
   module CommandHandlers
     class SubscriptionRunnersCommands
-      AVAILABLE_COMMANDS = %w[StopRunner RestoreRunner StartRunner].freeze
+      AVAILABLE_COMMANDS = %i[Start Stop Restore].to_h { [_1, _1.to_s] }.freeze
 
       # @param config_name [Symbol]
       # @param runners [Array<PgEventstore::SubscriptionRunner>]
-      def initialize(config_name, runners)
+      # @param subscriptions_set_id [Integer]
+      def initialize(config_name, runners, subscriptions_set_id)
         @config_name = config_name
         @runners = runners
+        @subscriptions_set_id = subscriptions_set_id
       end
 
       # Look up commands for all given SubscriptionRunner-s and execute them
       # @return [void]
       def process
-        queries.find_commands(@runners.map(&:id)).each do |command|
-          unless AVAILABLE_COMMANDS.include?(command[:name])
+        queries.find_commands(@runners.map(&:id), subscriptions_set_id: @subscriptions_set_id).each do |command|
+          unless AVAILABLE_COMMANDS.values.include?(command[:name])
             PgEventstore.logger&.warn(
               "#{self.class.name}: Don't know how to handle #{command[:name].inspect}. Details: #{command.inspect}."
             )
@@ -48,19 +50,19 @@ module PgEventstore
 
       # @param subscription_id [Integer]
       # @return [void]
-      def start_runner(subscription_id)
+      def start(subscription_id)
         find_subscription_runner(subscription_id)&.start
       end
 
       # @param subscription_id [Integer]
       # @return [void]
-      def restore_runner(subscription_id)
+      def restore(subscription_id)
         find_subscription_runner(subscription_id)&.restore
       end
 
       # @param subscription_id [Integer]
       # @return [void]
-      def stop_runner(subscription_id)
+      def stop(subscription_id)
         find_subscription_runner(subscription_id)&.stop_async
       end
     end

data/lib/pg_eventstore/subscriptions/commands_handler.rb

@@ -11,6 +11,7 @@ module PgEventstore
     extend Forwardable
 
     RESTART_DELAY = 5 # seconds
+    PULL_INTERVAL = 1
 
     def_delegators :@basic_runner, :start, :stop, :state, :stop_async, :wait_for_finish
 
@@ -21,7 +22,7 @@ module PgEventstore
       @config_name = config_name
       @subscription_feeder = subscription_feeder
       @runners = runners
-      @basic_runner = BasicRunner.new(1, 0)
+      @basic_runner = BasicRunner.new(PULL_INTERVAL, 0)
       attach_runner_callbacks
     end
 
@@ -56,7 +57,7 @@ module PgEventstore
 
     # @return [PgEventstore::CommandHandlers::SubscriptionRunnersCommands]
     def subscription_runners_commands
-      CommandHandlers::SubscriptionRunnersCommands.new(@config_name, @runners)
+      CommandHandlers::SubscriptionRunnersCommands.new(@config_name, @runners, @subscription_feeder.id)
     end
   end
 end

data/lib/pg_eventstore/subscriptions/events_processor.rb

@@ -20,7 +20,7 @@ module PgEventstore
     # @param raw_events [Array<Hash>]
     # @return [void]
     def feed(raw_events)
-      callbacks.run_callbacks(:feed, raw_events.last&.dig('global_position'))
+      callbacks.run_callbacks(:feed, global_position(raw_events.last))
       @raw_events.push(*raw_events)
     end
 
@@ -35,7 +35,7 @@ module PgEventstore
     # @param raw_event [Hash]
     # @return [void]
     def process_event(raw_event)
-      callbacks.run_callbacks(:process, raw_event['global_position']) do
+      callbacks.run_callbacks(:process, global_position(raw_event)) do
         @handler.call(raw_event)
       end
     end
@@ -68,5 +68,13 @@ module PgEventstore
     def change_state(...)
       callbacks.run_callbacks(:change_state, ...)
     end
+
+    # @param raw_event [Hash, nil]
+    # @return [Integer, nil]
+    def global_position(raw_event)
+      return unless raw_event
+
+      raw_event['link'] ? raw_event['link']['global_position'] : raw_event['global_position']
+    end
   end
 end

data/lib/pg_eventstore/subscriptions/subscription.rb

@@ -63,8 +63,8 @@ module PgEventstore
     #     processor
     attribute(:last_chunk_greatest_position)
     # @!attribute locked_by
-    #   @return [String, nil] UUIDv4. The id of subscription manager which obtained the lock of the Subscription. _nil_
-    #     value means that the Subscription isn't locked yet by any subscription manager.
+    #   @return [Integer, nil] The id of subscription manager which obtained the lock of the Subscription. _nil_ value
+    #     means that the Subscription isn't locked yet by any subscription manager.
     attribute(:locked_by)
     # @!attribute created_at
     #   @return [Time]
@@ -80,7 +80,7 @@ module PgEventstore
     # @param attrs [Hash]
     # @return [Hash]
     def update(attrs)
-      assign_attributes(subscription_queries.update(id, attrs))
+      assign_attributes(subscription_queries.update(id, attrs: attrs, locked_by: locked_by))
     end
 
     # @param attrs [Hash]
@@ -93,20 +93,13 @@ module PgEventstore
 
     # Locks the Subscription by the given lock id
     # @return [PgEventstore::Subscription]
-    def lock!(lock_id, force = false)
+    def lock!(lock_id, force: false)
       self.id = subscription_queries.find_or_create_by(set: set, name: name)[:id]
-      self.locked_by = subscription_queries.lock!(id, lock_id, force)
+      self.locked_by = subscription_queries.lock!(id, lock_id, force: force)
       reset_runtime_attributes
       self
     end
 
-    # Unlocks the Subscription.
-    # @return [void]
-    def unlock!
-      subscription_queries.unlock!(id, locked_by)
-      self.locked_by = nil
-    end
-
     # Dup the current object without assigned connection
     # @return [PgEventstore::Subscription]
     def dup
@@ -119,6 +112,27 @@ module PgEventstore
       self
     end
 
+    # @return [Integer]
+    def hash
+      id.hash
+    end
+
+    # @param another [Object]
+    # @return [Boolean]
+    def eql?(another)
+      return false unless another.is_a?(Subscription)
+
+      hash == another.hash
+    end
+
+    # @param another [PgEventstore::SubscriptionsSet]
+    # @return [Boolean]
+    def ==(another)
+      return false unless another.is_a?(Subscription)
+
+      id == another.id
+    end
+
     private
 
     def reset_runtime_attributes
@@ -130,6 +144,9 @@ module PgEventstore
         chunk_query_interval: chunk_query_interval,
         last_chunk_fed_at: Time.at(0).utc,
         last_chunk_greatest_position: nil,
+        last_error: nil,
+        last_error_occurred_at: nil,
+        time_between_restarts: time_between_restarts,
         state: RunnerState::STATES[:initial]
       )
     end

data/lib/pg_eventstore/subscriptions/subscription_feeder.rb

@@ -3,10 +3,11 @@
 module PgEventstore
   # This class is responsible for starting/stopping all SubscriptionRunners. The background runner of it is responsible
   # for events pulling and feeding those SubscriptionRunners.
-  # @!visibility private
   class SubscriptionFeeder
     extend Forwardable
 
+    HEARTBEAT_INTERVAL = 10 # seconds
+
     def_delegators :subscriptions_set, :id
     def_delegators :@basic_runner, :start, :stop, :restore, :state, :wait_for_finish, :stop_async
 
@@ -17,12 +18,13 @@ module PgEventstore
     def initialize(config_name:, set_name:, max_retries:, retries_interval:)
       @config_name = config_name
       @runners = []
-      @set_name = set_name
-      @max_retries = max_retries
-      @retries_interval = retries_interval
+      @subscriptions_set_attrs = {
+        name: set_name, max_restarts_number: max_retries, time_between_restarts: retries_interval
+      }
       @commands_handler = CommandsHandler.new(@config_name, self, @runners)
-      @basic_runner = BasicRunner.new(1, 0)
+      @basic_runner = BasicRunner.new(0.2, 0)
       @force_lock = false
+      @refreshed_at = Time.at(0)
       attach_runner_callbacks
     end
 
@@ -77,18 +79,12 @@ module PgEventstore
     # Locks all Subscriptions behind the current SubscriptionsSet
     # @return [void]
     def lock_all
-      @runners.each { |runner| runner.lock!(subscriptions_set.id, @force_lock) }
-    end
-
-    # @return [void]
-    def unlock_all
-      @runners.each(&:unlock!)
+      @runners.each { |runner| runner.lock!(subscriptions_set.id, force: @force_lock) }
     end
 
     # @return [PgEventstore::SubscriptionsSet]
     def subscriptions_set
-      @subscriptions_set ||= SubscriptionsSet.using_connection(@config_name).
-        create(name: @set_name, max_restarts_number: @max_retries, time_between_restarts: @retries_interval)
+      @subscriptions_set ||= SubscriptionsSet.using_connection(@config_name).create(**@subscriptions_set_attrs)
     end
 
     # @return [PgEventstore::SubscriptionRunnersFeeder]
@@ -102,6 +98,7 @@ module PgEventstore
       @basic_runner.define_callback(:before_runner_started, :before, method(:before_runner_started))
       @basic_runner.define_callback(:after_runner_died, :before, method(:after_runner_died))
       @basic_runner.define_callback(:after_runner_died, :after, method(:restart_runner))
+      @basic_runner.define_callback(:process_async, :before, method(:ping_subscriptions_set))
       @basic_runner.define_callback(:process_async, :before, method(:process_async))
       @basic_runner.define_callback(:after_runner_stopped, :before, method(:after_runner_stopped))
       @basic_runner.define_callback(:before_runner_restored, :after, method(:update_runner_restarts))
@@ -141,13 +138,20 @@ module PgEventstore
       feeder.feed(@runners)
     end
 
+    # @return [void]
+    def ping_subscriptions_set
+      return unless subscriptions_set.updated_at > Time.now.utc - HEARTBEAT_INTERVAL
+
+      subscriptions_set.update(updated_at: Time.now.utc)
+      @refreshed_at = Time.now.utc
+    end
+
     # @return [void]
     def after_runner_stopped
-      @commands_handler.stop
+      @runners.each(&:stop_async).each(&:wait_for_finish)
       @subscriptions_set&.delete
       @subscriptions_set = nil
-      @runners.each(&:stop_async).each(&:wait_for_finish)
-      unlock_all
+      @commands_handler.stop
     end
 
     # @return [void]

data/lib/pg_eventstore/subscriptions/subscription_runner.rb

@@ -16,7 +16,7 @@ module PgEventstore
     attr_reader :subscription
 
     def_delegators :@events_processor, :start, :stop, :stop_async, :feed, :wait_for_finish, :restore, :state, :running?
-    def_delegators :@subscription, :lock!, :unlock!, :id
+    def_delegators :@subscription, :lock!, :id
 
     # @param stats [PgEventstore::SubscriptionHandlerPerformance]
     # @param events_processor [PgEventstore::EventsProcessor]

data/lib/pg_eventstore/subscriptions/subscription_runners_feeder.rb

@@ -15,11 +15,10 @@ module PgEventstore
       runners = runners.select(&:running?).select(&:time_to_feed?)
       return if runners.empty?
 
-      runners_query_options = runners.map { |runner| [runner.id, runner.next_chunk_query_opts] }
-      raw_events = subscription_queries.subscriptions_events(runners_query_options)
-      grouped_events = raw_events.group_by { |attrs| attrs['runner_id'] }
+      runners_query_options = runners.to_h { |runner| [runner.id, runner.next_chunk_query_opts] }
+      grouped_events = subscription_queries.subscriptions_events(runners_query_options)
       runners.each do |runner|
-        runner.feed(grouped_events[runner.id]) if grouped_events[runner.id]
+        runner.feed(grouped_events[runner.id] || [])
       end
     end