pg_eventstore 1.13.4 → 2.0.0

data/lib/pg_eventstore/extensions/options_extension.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module PgEventstore
   module Extensions
     # A very simple extension that implements a DSL for adding attr_accessors with default values,
@@ -72,16 +70,47 @@ module PgEventstore
         end
       end
 
-      class Options < Set
-        def add(option)
-          @hash[option] = option
-          self
+      class Options
+        include Enumerable
+
+        attr_reader :options
+        protected :options
+
+        # @param options [Array<PgEventstore::Extensions::OptionsExtension::Option>]
+        def initialize(options = [])
+          @options = options.to_h { [_1, true] }
         end
 
-        # @param option [Symbol]
+        # @param option_name [Symbol]
         # @return [PgEventstore::Extensions::OptionsExtension::Option, nil]
-        def [](option)
-          @hash[Option.new(option)]
+        def [](option_name)
+          option = Option.new(option_name)
+          options.find { |key, _| key == option }&.dig(0)
+        end
+
+        # @param other [PgEventstore::Extensions::OptionsExtension::Options]
+        # @return [PgEventstore::Extensions::OptionsExtension::Options]
+        def +(other)
+          self.class.new(options.keys + other.options.keys)
+        end
+
+        # @param option [PgEventstore::Extensions::OptionsExtension::Option]
+        # @return [Boolean]
+        def include?(option)
+          options.key?(option)
+        end
+
+        # @return [Boolean]
+        def dup
+          self.class.new(options.keys)
+        end
+
+        def each(...)
+          options.keys.each(...)
+        end
+
+        def ==(other)
+          options.keys == other.options.keys
         end
       end
 
@@ -92,7 +121,7 @@ module PgEventstore
         #   context of your object to determine the default value of the option
         # @return [Symbol]
         def option(opt_name, metadata: nil, &blk)
-          self.options = (options + Options.new([Option.new(opt_name, metadata: metadata)])).freeze
+          self.options = (options + Options.new([Option.new(opt_name, metadata:)])).freeze
           warn_already_defined(opt_name)
           warn_already_defined(:"#{opt_name}=")
           define_method "#{opt_name}=" do |value|
@@ -112,7 +141,7 @@ module PgEventstore
 
         def inherited(klass)
           super
-          klass.options = Options.new(options).freeze
+          klass.options = options.dup.freeze
         end
 
         private

data/lib/pg_eventstore/maintenance.rb

@@ -25,7 +25,7 @@ module PgEventstore
     def delete_event(event, force: false)
       Commands::DeleteEvent.new(
         Queries.new(transactions: transaction_queries, maintenance: maintenance_queries)
-      ).call(event, force: force)
+      ).call(event, force:)
     end
 
     private

data/lib/pg_eventstore/queries/event_queries.rb

@@ -41,18 +41,18 @@ module PgEventstore
     # Takes an array of potentially persisted events and loads their ids from db. Those ids can be later used to check
     # whether events are actually existing events.
     # @param events [Array<PgEventstore::Event>]
-    # @return [Array<String>]
-    def ids_from_db(events)
-      sql_builder = SQLBuilder.new.from(Event::PRIMARY_TABLE_NAME).select('id')
+    # @return [Array<Integer>]
+    def global_positions_from_db(events)
+      sql_builder = SQLBuilder.new.from(Event::PRIMARY_TABLE_NAME).select('global_position')
       partition_attrs = events.map { |event| [event.stream&.context, event.stream&.stream_name, event.type] }.uniq
       partition_attrs.each do |context, stream_name, event_type|
         sql_builder.where_or('context = ? and stream_name = ? and type = ?', context, stream_name, event_type)
       end
-      sql_builder.where('id = ANY(?::uuid[])', events.map(&:id))
+      sql_builder.where('global_position = ANY(?::bigint[])', events.map(&:global_position))
       raw_events = PgEventstore.connection.with do |conn|
         conn.exec_params(*sql_builder.to_exec_params)
       end.to_a
-      raw_events.map { |attrs| attrs['id'] }
+      raw_events.map { |attrs| attrs['global_position'] }
     end
 
     # @param stream [PgEventstore::Stream]
@@ -84,7 +84,7 @@ module PgEventstore
     # @return [Array<PgEventstore::Event>]
     def insert(stream, events)
       sql_rows_for_insert, values = prepared_statements(stream, events)
-      columns = %w[id data metadata stream_revision link_id link_partition_id type context stream_name stream_id]
+      columns = %w[id data metadata stream_revision link_global_position link_partition_id type context stream_name stream_id]
 
       sql = <<~SQL
         INSERT INTO events (#{columns.join(', ')})
@@ -129,7 +129,7 @@ module PgEventstore
       sql_rows_for_insert = events.map do |event|
         event = serializer.serialize(event)
         attributes = event.options_hash.slice(
-          :id, :data, :metadata, :stream_revision, :link_id, :link_partition_id, :type
+          :id, :data, :metadata, :stream_revision, :link_global_position, :link_partition_id, :type
         )
 
         attributes = attributes.merge(stream.to_hash)

data/lib/pg_eventstore/queries/links_resolver.rb

@@ -20,9 +20,9 @@ module PgEventstore
       link_events = raw_events.select { _1['link_partition_id'] }.group_by { _1['link_partition_id'] }
       return raw_events if link_events.empty?
 
-      original_events = load_original_events(link_events).to_h { |attrs| [attrs['id'], attrs] }
+      original_events = load_original_events(link_events).to_h { |attrs| [attrs['global_position'], attrs] }
       raw_events.map do |attrs|
-        original_event = original_events[attrs['link_id']]
+        original_event = original_events[attrs['link_global_position']]
         next attrs unless original_event
 
         original_event.merge('link' => attrs).merge(attrs.except(*original_event.keys))
@@ -37,7 +37,10 @@ module PgEventstore
       partitions = partition_queries.find_by_ids(link_events.keys)
       sql_builders = partitions.map do |partition|
         sql_builder = SQLBuilder.new.select('*').from(partition['table_name'])
-        sql_builder.where('id  = ANY(?::uuid[])', link_events[partition['id']].map { _1['link_id'] })
+        sql_builder.where(
+          'global_position = ANY(?::bigint[])',
+          link_events[partition['id']].map { _1['link_global_position'] }
+        )
       end
       sql_builder = sql_builders[1..].each_with_object(sql_builders.first) do |builder, top_builder|
         top_builder.union(builder)

data/lib/pg_eventstore/queries/partition_queries.rb

@@ -76,7 +76,7 @@ module PgEventstore
     # @return [Hash] partition attributes
     def create_event_type_partition(stream, event_type, stream_name_partition_name)
       attributes = {
-        context: stream.context, stream_name: stream.stream_name, event_type: event_type,
+        context: stream.context, stream_name: stream.stream_name, event_type:,
         table_name: event_type_partition_name(stream, event_type)
       }
 

data/lib/pg_eventstore/queries/transaction_queries.rb

@@ -23,24 +23,30 @@ module PgEventstore
     end
 
     # @param level [Symbol] transaction isolation level
+    # @param read_only [Boolean] whether transaction is read-only
     # @return [void]
-    def transaction(level = :serializable, &blk)
+    def transaction(level = :serializable, read_only: false, &blk)
       connection.with do |conn|
         # We are inside a transaction already - no need to start another one
         next yield if [PG::PQTRANS_ACTIVE, PG::PQTRANS_INTRANS].include?(conn.transaction_status)
 
-        pg_transaction(ISOLATION_LEVELS[level], conn, &blk)
+        pg_transaction(ISOLATION_LEVELS[level], read_only, conn, &blk)
       end
     end
 
     private
 
     # @param level [String] PostgreSQL transaction isolation level
+    # @param read_only [Boolean]
     # @param pg_connection [PG::Connection]
     # @return [void]
-    def pg_transaction(level, pg_connection, &_blk)
+    def pg_transaction(level, read_only, pg_connection, &)
       pg_connection.transaction do
-        pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level}")
+        if read_only
+          pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level} READ ONLY")
+        else
+          pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level}")
+        end
         yield
       end
     rescue PG::TRSerializationFailure, PG::TRDeadlockDetected

data/lib/pg_eventstore/query_builders/events_filtering.rb

@@ -90,7 +90,7 @@ module PgEventstore
             stream_attrs in { context: String | NilClass => context }
             stream_attrs in { stream_name: String | NilClass => stream_name }
             stream_attrs in { stream_id: String | NilClass => stream_id }
-            { context: context, stream_name: stream_name, stream_id: stream_id }
+            { context:, stream_name:, stream_id: }
           end
           streams || []
         end
@@ -111,7 +111,7 @@ module PgEventstore
       # @param stream_id [String, nil]
       # @return [void]
       def add_stream_attrs(context: nil, stream_name: nil, stream_id: nil)
-        stream_attrs = { context: context, stream_name: stream_name, stream_id: stream_id }
+        stream_attrs = { context:, stream_name:, stream_id: }
         return unless correct_stream_filter?(stream_attrs)
 
         stream_attrs.compact!

data/lib/pg_eventstore/query_builders/partitions_filtering.rb

@@ -24,7 +24,7 @@ module PgEventstore
           streams = streams&.map do |stream_attrs|
             stream_attrs in { context: String | NilClass => context }
             stream_attrs in { stream_name: String | NilClass => stream_name }
-            { context: context, stream_name: stream_name }
+            { context:, stream_name: }
           end
           streams || []
         end
@@ -52,7 +52,7 @@ module PgEventstore
       # @param stream_name [String, nil]
       # @return [PgEventstore::SQLBuilder]
       def add_stream_attrs(context: nil, stream_name: nil)
-        stream_attrs = { context: context, stream_name: stream_name }
+        stream_attrs = { context:, stream_name: }
         return @sql_builder unless self.class.correct_stream_filter?(stream_attrs)
 
         stream_attrs.compact!

data/lib/pg_eventstore/stream.rb

@@ -67,7 +67,7 @@ module PgEventstore
     # @param keys [Array<Symbol>, nil]
     # @return [Hash<Symbol => String>]
     def deconstruct_keys(keys)
-      hash = { context: context, stream_name: stream_name, stream_id: stream_id }
+      hash = { context:, stream_name:, stream_id: }
       return hash unless keys
 
       hash.slice(*keys)

data/lib/pg_eventstore/subscriptions/basic_runner.rb

@@ -46,7 +46,7 @@ module PgEventstore
   #
   #     def initialize
   #       @basic_runner = PgEventstore::BasicRunner.new(
-  #         run_interval: 1, async_shutdown_time: 2, recovery_strategies: recovery_strategies
+  #         run_interval: 1, async_shutdown_time: 2, recovery_strategies:
   #       )
   #       @jobs_performed = 0
   #       @jobs_limit = 3
@@ -224,7 +224,7 @@ module PgEventstore
 
     # @param state [Symbol]
     # @return [Object, nil] a result of evaluating of passed block
-    def within_state(state, &_blk)
+    def within_state(state, &)
       synchronize do
         return unless @state.public_send("#{RunnerState::STATES.fetch(state)}?")
 
@@ -248,8 +248,8 @@ module PgEventstore
 
     private
 
-    def synchronize(&blk)
-      @mutex.synchronize(&blk)
+    def synchronize(&)
+      @mutex.synchronize(&)
     end
 
     # @return [void]

data/lib/pg_eventstore/subscriptions/callback_handlers/subscription_feeder_handlers.rb

@@ -10,7 +10,7 @@ module PgEventstore
       # @param state [String]
       # @return [void]
       def update_subscriptions_set_state(subscriptions_set_lifecycle, state)
-        subscriptions_set_lifecycle.persisted_subscriptions_set.update(state: state)
+        subscriptions_set_lifecycle.persisted_subscriptions_set.update(state:)
       end
 
       # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]

data/lib/pg_eventstore/subscriptions/callback_handlers/subscription_runner_handlers.rb

@@ -21,7 +21,7 @@ module PgEventstore
       def update_subscription_stats(subscription, stats, current_position)
         subscription.update(
           average_event_processing_time: stats.average_event_processing_time,
-          current_position: current_position,
+          current_position:,
           total_processed_events: subscription.total_processed_events + 1
         )
       end
@@ -50,16 +50,7 @@ module PgEventstore
       # @param state [String]
       # @return [void]
       def update_subscription_state(subscription, state)
-        subscription.update(state: state)
-      end
-
-      # @param subscription_position_evaluation [PgEventstore::SubscriptionPositionEvaluation]
-      # @param state [String]
-      # @return [void]
-      def stop_position_evaluation(subscription_position_evaluation, state)
-        return if state == 'running'
-
-        subscription_position_evaluation.stop_evaluation
+        subscription.update(state:)
       end
     end
   end

data/lib/pg_eventstore/subscriptions/events_processor.rb

@@ -21,7 +21,7 @@ module PgEventstore
       @basic_runner = BasicRunner.new(
         run_interval: 0,
         async_shutdown_time: graceful_shutdown_timeout,
-        recovery_strategies: recovery_strategies
+        recovery_strategies:
       )
       attach_runner_callbacks
     end

data/lib/pg_eventstore/subscriptions/queries/subscription_command_queries.rb

@@ -21,15 +21,15 @@ module PgEventstore
     def find_or_create_by(subscription_id:, subscriptions_set_id:, command_name:, data:)
       transaction_queries.transaction do
         existing = find_by(
-          subscription_id: subscription_id, subscriptions_set_id: subscriptions_set_id, command_name: command_name
+          subscription_id:, subscriptions_set_id:, command_name:
         )
         next existing if existing
 
         create(
-          subscription_id: subscription_id,
-          subscriptions_set_id: subscriptions_set_id,
-          command_name: command_name,
-          data: data
+          subscription_id:,
+          subscriptions_set_id:,
+          command_name:,
+          data:
         )
       end
     end

data/lib/pg_eventstore/subscriptions/queries/subscription_queries.rb

@@ -60,7 +60,7 @@ module PgEventstore
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
     def find!(id)
-      find_by(id: id) || raise(RecordNotFound.new('subscriptions', id))
+      find_by(id:) || raise(RecordNotFound.new('subscriptions', id))
     end
 
     # @param attrs [Hash]
@@ -105,7 +105,7 @@ module PgEventstore
         updated_attrs
       end
 
-      deserialize(updated_attrs)
+      deserialize(updated_attrs).slice(*attrs.keys)
     end
 
     # @param subscriptions_set_id [Integer] SubscriptionsSet#id

data/lib/pg_eventstore/subscriptions/queries/subscription_service_queries.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class SubscriptionServiceQueries
+    # @return [Integer]
+    DEFAULT_SAFE_POSITION = 0
+    private_constant :DEFAULT_SAFE_POSITION
+
+    # @!attribute connection
+    #   @return [PgEventstore::Connection]
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @return [Integer]
+    def safe_global_position
+      result = transaction_queries.transaction(read_only: true) do
+        connection.with do |conn|
+          conn.exec(<<~SQL)
+            SELECT MAX(global_position) as global_position
+              FROM events_horizon
+              WHERE xact_id < pg_snapshot_xmin(pg_current_snapshot())
+          SQL
+        end
+      end
+
+      global_position = result.to_a.first&.dig('global_position')
+      return global_position if global_position
+
+      if global_position.nil? && !events_horizon_present?
+        init_events_horizon
+        return safe_global_position
+      end
+      # events_horizon table is not empty, but there is no safe position yet. Thus, we wait for the safe position by
+      # returning default value which will prevent from fetching events with gaps
+      DEFAULT_SAFE_POSITION
+    end
+
+    # @return [Boolean]
+    def events_horizon_present?
+      result = connection.with do |conn|
+        conn.exec(<<~SQL)
+          SELECT true as presence FROM events_horizon LIMIT 1
+        SQL
+      end
+      result.to_a.first&.dig('presence') || false
+    end
+
+    # @return [void]
+    def init_events_horizon
+      transaction_queries.transaction do
+        return if events_horizon_present?
+
+        max_pos = connection.with do |conn|
+          conn.exec('SELECT MAX(global_position) FROM events')
+        end
+        max_pos = max_pos.to_a.first&.dig('global_position') || DEFAULT_SAFE_POSITION
+        connection.with do |conn|
+          conn.exec_params(<<~SQL, [max_pos])
+            INSERT INTO events_horizon (global_position, xact_id) VALUES ($1, DEFAULT)
+          SQL
+        end
+      end
+    end
+
+    private
+
+    # @return [PgEventstore::TransactionQueries]
+    def transaction_queries
+      TransactionQueries.new(connection)
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/queries/subscriptions_set_command_queries.rb

@@ -19,8 +19,8 @@ module PgEventstore
     # @return [PgEventstore::SubscriptionFeederCommands::Base]
     def find_or_create_by(subscriptions_set_id:, command_name:, data:)
       transaction_queries.transaction do
-        find_by(subscriptions_set_id: subscriptions_set_id, command_name: command_name) ||
-          create(subscriptions_set_id: subscriptions_set_id, command_name: command_name, data: data)
+        find_by(subscriptions_set_id:, command_name:) ||
+          create(subscriptions_set_id:, command_name:, data:)
       end
     end
 

data/lib/pg_eventstore/subscriptions/queries/subscriptions_set_queries.rb

@@ -62,7 +62,7 @@ module PgEventstore
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
     def find!(id)
-      find_by(id: id) || raise(RecordNotFound.new('subscriptions_set', id))
+      find_by(id:) || raise(RecordNotFound.new('subscriptions_set', id))
     end
 
     # @param attrs [Hash]

data/lib/pg_eventstore/subscriptions/subscription.rb

@@ -113,7 +113,7 @@ module PgEventstore
     # @param attrs [Hash]
     # @return [Hash]
     def update(attrs)
-      assign_attributes(subscription_queries.update(id, attrs: attrs, locked_by: locked_by))
+      assign_attributes(subscription_queries.update(id, attrs:, locked_by:))
     end
 
     # @param attrs [Hash]
@@ -129,8 +129,8 @@ module PgEventstore
     # @param force [Boolean]
     # @return [PgEventstore::Subscription]
     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: force)
+      self.id = subscription_queries.find_or_create_by(set:, name:)[:id]
+      self.locked_by = subscription_queries.lock!(id, lock_id, force:)
       reset_runtime_attributes
       self
     end
@@ -173,18 +173,19 @@ module PgEventstore
     # @return [void]
     def reset_runtime_attributes
       update(
-        options: options,
+        options:,
         restart_count: 0,
         last_restarted_at: nil,
-        max_restarts_number: max_restarts_number,
+        max_restarts_number:,
         chunk_query_interval: [chunk_query_interval, MIN_EVENTS_PULL_INTERVAL].max,
         last_chunk_fed_at: DEFAULT_TIMESTAMP,
         last_chunk_greatest_position: nil,
         last_error: nil,
         last_error_occurred_at: nil,
-        time_between_restarts: time_between_restarts,
+        time_between_restarts:,
         state: RunnerState::STATES[:initial]
       )
+      reload
     end
 
     # @return [PgEventstore::SubscriptionQueries]

data/lib/pg_eventstore/subscriptions/subscription_feeder.rb

@@ -10,7 +10,7 @@ module PgEventstore
     # Determines how often to fetch events from the event store.
     # @see PgEventstore::Subscription::MIN_EVENTS_PULL_INTERVAL
     # @return [Float]
-    EVENTS_PULL_INTERVAL = 0.1 # seconds
+    EVENTS_PULL_INTERVAL = 0.2 # seconds
     private_constant :EVENTS_PULL_INTERVAL
 
     attr_reader :config_name
@@ -122,7 +122,7 @@ module PgEventstore
       [
         RunnerRecoveryStrategies::RestoreConnection.new(config_name),
         RunnerRecoveryStrategies::RestoreSubscriptionFeeder.new(
-          subscriptions_set_lifecycle: subscriptions_set_lifecycle
+          subscriptions_set_lifecycle:
         ),
       ]
     end

data/lib/pg_eventstore/subscriptions/subscription_handler_performance.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'benchmark'
-
 module PgEventstore
   # This class measures the performance of Subscription's handler and returns the average time required to process an
   # event.
@@ -23,7 +21,7 @@ module PgEventstore
     # @return [Object] the result of yielded block
     def track_exec_time
       result = nil
-      time = Benchmark.realtime { result = yield }
+      time = Utils.benchmark { result = yield }
       synchronize do
         @timings.shift if @timings.size == TIMINGS_TO_KEEP
         @timings.push(time)

data/lib/pg_eventstore/subscriptions/subscription_runner.rb

@@ -28,12 +28,10 @@ module PgEventstore
     # @param stats [PgEventstore::SubscriptionHandlerPerformance]
     # @param events_processor [PgEventstore::EventsProcessor]
     # @param subscription [PgEventstore::Subscription]
-    # @param position_evaluation [PgEventstore::SubscriptionPositionEvaluation]
-    def initialize(stats:, events_processor:, subscription:, position_evaluation:)
+    def initialize(stats:, events_processor:, subscription:)
       @stats = stats
       @events_processor = events_processor
       @subscription = subscription
-      @position_evaluation = position_evaluation
 
       attach_callbacks
     end
@@ -42,19 +40,13 @@ module PgEventstore
     def next_chunk_query_opts
       @subscription.options.merge(
         from_position: next_chunk_global_position,
-        max_count: estimate_events_number,
-        to_position: @position_evaluation.last_safe_position
+        max_count: estimate_events_number
       )
     end
 
     # @return [Boolean]
     def time_to_feed?
-      @subscription.last_chunk_fed_at + @subscription.chunk_query_interval <= Time.now.utc
-    end
-
-    # @return [Boolean]
-    def next_chunk_safe?
-      estimate_events_number == 0 ? false : @position_evaluation.evaluate(next_chunk_global_position).safe?
+      estimate_events_number > 0 && @subscription.last_chunk_fed_at + @subscription.chunk_query_interval <= Time.now.utc
     end
 
     private
@@ -108,11 +100,6 @@ module PgEventstore
         :change_state, :after,
         SubscriptionRunnerHandlers.setup_handler(:update_subscription_state, @subscription)
       )
-      # Prevent dangling position evaluation runner when subscription changes the state to something except 'running'
-      @events_processor.define_callback(
-        :change_state, :after,
-        SubscriptionRunnerHandlers.setup_handler(:stop_position_evaluation, @position_evaluation)
-      )
     end
   end
 end

data/lib/pg_eventstore/subscriptions/subscription_runners_feeder.rb

@@ -12,10 +12,13 @@ module PgEventstore
     # @param runners [Array<PgEventstore::SubscriptionRunner>]
     # @return [void]
     def feed(runners)
-      runners = runners.select(&:running?).select(&:time_to_feed?).select(&:next_chunk_safe?)
+      runners = runners.select(&:running?).select(&:time_to_feed?)
       return if runners.empty?
 
-      runners_query_options = runners.to_h { |runner| [runner.id, runner.next_chunk_query_opts] }
+      safe_pos = subscription_service_queries.safe_global_position
+      runners_query_options = runners.to_h do |runner|
+        [runner.id, runner.next_chunk_query_opts.merge(to_position: safe_pos)]
+      end
       grouped_events = subscription_queries.subscriptions_events(runners_query_options)
 
       runners.each do |runner|
@@ -34,5 +37,10 @@ module PgEventstore
     def subscription_queries
       SubscriptionQueries.new(connection)
     end
+
+    # @return [PgEventstore::SubscriptionServiceQueries]
+    def subscription_service_queries
+      SubscriptionServiceQueries.new(connection)
+    end
   end
 end