pg_eventstore 1.12.0 → 1.13.1

data/lib/pg_eventstore/subscriptions/extensions/command_class_lookup_extension.rb

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module Extensions
+    # @!visibility private
     module CommandClassLookupExtension
       # @param cmd_name [String, Symbol]
       # @return [Class]

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies/restore_connection.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module RunnerRecoveryStrategies
+    # @!visibility private
+    class RestoreConnection
+      # @return [Integer] seconds
+      TIME_BETWEEN_RETRIES = 5
+      # @return [Array<StandardError>]
+      EXCEPTIONS_TO_HANDLE = [PG::ConnectionBad, PG::UnableToSend, ConnectionPool::TimeoutError].freeze
+
+      include RunnerRecoveryStrategy
+
+      # @param config_name [Symbol]
+      def initialize(config_name)
+        @config_name = config_name
+      end
+
+      def recovers?(error)
+        EXCEPTIONS_TO_HANDLE.any? {error.is_a?(_1) }
+      end
+
+      def recover(_error)
+        loop do
+          sleep TIME_BETWEEN_RETRIES
+
+          connection.with do |conn|
+            conn.exec('select version()')
+            # No error was raised during the request. We are good to recover!
+            return true
+          end
+        rescue *EXCEPTIONS_TO_HANDLE
+        end
+      end
+
+      private
+
+      # @return [PgEventstore::Connection]
+      def connection
+        PgEventstore.connection(@config_name)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies/restore_subscription_feeder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module RunnerRecoveryStrategies
+    # @!visibility private
+    class RestoreSubscriptionFeeder
+      include RunnerRecoveryStrategy
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      def initialize(subscriptions_set_lifecycle:)
+        @subscriptions_set_lifecycle = subscriptions_set_lifecycle
+      end
+
+      def recovers?(_error)
+        true
+      end
+
+      def recover(_error)
+        subscriptions_set = @subscriptions_set_lifecycle.persisted_subscriptions_set
+        return false if subscriptions_set.restart_count >= subscriptions_set.max_restarts_number
+
+        sleep subscriptions_set.time_between_restarts
+        true
+      end
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies/restore_subscription_runner.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module RunnerRecoveryStrategies
+    # @!visibility private
+    class RestoreSubscriptionRunner
+      include RunnerRecoveryStrategy
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param restart_terminator [#call, nil]
+      # @param failed_subscription_notifier [#call, nil]
+      def initialize(subscription:, restart_terminator:, failed_subscription_notifier:)
+        @subscription = subscription
+        @restart_terminator = restart_terminator
+        @failed_subscription_notifier = failed_subscription_notifier
+      end
+
+      def recovers?(error)
+        error.is_a?(WrappedException)
+      end
+
+      def recover(error)
+        return false if @restart_terminator&.call(@subscription.dup)
+        if @subscription.restart_count >= @subscription.max_restarts_number
+          @failed_subscription_notifier&.call(@subscription.dup, Utils.unwrap_exception(error))
+          return false
+        end
+
+        sleep @subscription.time_between_restarts
+        true
+      end
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'runner_recovery_strategies/restore_connection'
+require_relative 'runner_recovery_strategies/restore_subscription_runner'
+require_relative 'runner_recovery_strategies/restore_subscription_feeder'

data/lib/pg_eventstore/subscriptions/runner_recovery_strategy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # Defines an interface of a recovery strategy of the BasicRunner.
+  # See {PgEventstore::BasicRunner} for an example of usage.
+  module RunnerRecoveryStrategy
+    # Determines whether this strategy can recover from the error. If multiple strategies can recover from the error,
+    # the first one from the :recovery_strategies array is selected.
+    # @param error [StandardError]
+    # @return [Boolean]
+    def recovers?(error)
+    end
+
+    # Actual implementation of recovery strategy. Usually you want to implement here a logic that restores from the
+    # error. The returned boolean value will be used to determine whether the runner should be restarted.
+    # @param error [StandardError]
+    # @return [Boolean]
+    def recover(error)
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/subscription_feeder.rb

@@ -3,6 +3,7 @@
 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
 
@@ -15,7 +16,11 @@ module PgEventstore
     # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
     def initialize(config_name:, subscriptions_set_lifecycle:, subscriptions_lifecycle:)
       @config_name = config_name
-      @basic_runner = BasicRunner.new(0.2, 0)
+      @basic_runner = BasicRunner.new(
+        run_interval: 0.2,
+        async_shutdown_time: 0,
+        recovery_strategies: recovery_strategies(config_name, subscriptions_set_lifecycle)
+      )
       @subscriptions_set_lifecycle = subscriptions_set_lifecycle
       @subscriptions_lifecycle = subscriptions_lifecycle
       @commands_handler = CommandsHandler.new(@config_name, self, @subscriptions_lifecycle.runners)
@@ -71,10 +76,6 @@ module PgEventstore
         :after_runner_died, :before,
         SubscriptionFeederHandlers.setup_handler(:persist_error_info, @subscriptions_set_lifecycle)
       )
-      @basic_runner.define_callback(
-        :after_runner_died, :before,
-        SubscriptionFeederHandlers.setup_handler(:restart_runner, @subscriptions_set_lifecycle, @basic_runner)
-      )
 
       @basic_runner.define_callback(
         :process_async, :before,
@@ -107,5 +108,17 @@ module PgEventstore
         SubscriptionFeederHandlers.setup_handler(:update_subscriptions_set_restarts, @subscriptions_set_lifecycle)
       )
     end
+
+    # @param config_name [Symbol]
+    # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+    # @return [Array<PgEventstore::RunnerRecoveryStrategy>]
+    def recovery_strategies(config_name, subscriptions_set_lifecycle)
+      [
+        RunnerRecoveryStrategies::RestoreConnection.new(config_name),
+        RunnerRecoveryStrategies::RestoreSubscriptionFeeder.new(
+          subscriptions_set_lifecycle: subscriptions_set_lifecycle
+        ),
+      ]
+    end
   end
 end

data/lib/pg_eventstore/subscriptions/subscription_runner.rb

@@ -28,15 +28,10 @@ module PgEventstore
     # @param stats [PgEventstore::SubscriptionHandlerPerformance]
     # @param events_processor [PgEventstore::EventsProcessor]
     # @param subscription [PgEventstore::Subscription]
-    # @param restart_terminator [#call, nil]
-    # @param failed_subscription_notifier [#call, nil]
-    def initialize(stats:, events_processor:, subscription:, restart_terminator: nil,
-                   failed_subscription_notifier: nil)
+    def initialize(stats:, events_processor:, subscription:)
       @stats = stats
       @events_processor = events_processor
       @subscription = subscription
-      @restart_terminator = restart_terminator
-      @failed_subscription_notifier = failed_subscription_notifier
 
       attach_callbacks
     end
@@ -87,13 +82,6 @@ module PgEventstore
         :error, :after,
         SubscriptionRunnerHandlers.setup_handler(:update_subscription_error, @subscription)
       )
-      @events_processor.define_callback(
-        :error, :after,
-        SubscriptionRunnerHandlers.setup_handler(
-          :restart_events_processor,
-          @subscription, @restart_terminator, @failed_subscription_notifier, @events_processor
-        )
-      )
 
       @events_processor.define_callback(
         :feed, :after,

data/lib/pg_eventstore/subscriptions/subscriptions_lifecycle.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class SubscriptionsLifecycle
     extend Forwardable
 

data/lib/pg_eventstore/subscriptions/subscriptions_manager.rb

@@ -3,6 +3,8 @@
 require 'forwardable'
 require_relative 'runner_state'
 require_relative 'basic_runner'
+require_relative 'runner_recovery_strategy'
+require_relative 'runner_recovery_strategies'
 require_relative 'subscription'
 require_relative 'events_processor'
 require_relative 'subscription_handler_performance'
@@ -102,11 +104,11 @@ module PgEventstore
       runner = SubscriptionRunner.new(
         stats: SubscriptionHandlerPerformance.new,
         events_processor: EventsProcessor.new(
-          create_raw_event_handler(middlewares, handler), graceful_shutdown_timeout: graceful_shutdown_timeout
+          create_raw_event_handler(middlewares, handler),
+          graceful_shutdown_timeout: graceful_shutdown_timeout,
+          recovery_strategies: recovery_strategies(subscription, restart_terminator, failed_subscription_notifier)
         ),
         subscription: subscription,
-        restart_terminator: restart_terminator,
-        failed_subscription_notifier: failed_subscription_notifier
       )
 
       @subscriptions_lifecycle.runners.push(runner)
@@ -170,5 +172,20 @@ module PgEventstore
 
       config.middlewares.slice(*middlewares).values
     end
+
+    # @param subscription [PgEventstore::Subscription]
+    # @param restart_terminator [#call, nil]
+    # @param failed_subscription_notifier [#call, nil]
+    # @return [Array<PgEventstore::RunnerRecoveryStrategy>]
+    def recovery_strategies(subscription, restart_terminator, failed_subscription_notifier)
+      [
+        RunnerRecoveryStrategies::RestoreConnection.new(config_name),
+        RunnerRecoveryStrategies::RestoreSubscriptionRunner.new(
+          subscription: subscription,
+          restart_terminator: restart_terminator,
+          failed_subscription_notifier: failed_subscription_notifier,
+        ),
+      ]
+    end
   end
 end

data/lib/pg_eventstore/subscriptions/subscriptions_set_lifecycle.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class SubscriptionsSetLifecycle
     # @return [Integer] number of seconds between heartbeat updates
     HEARTBEAT_INTERVAL = 10 # seconds

data/lib/pg_eventstore/version.rb

@@ -2,5 +2,5 @@
 
 module PgEventstore
   # @return [String]
-  VERSION = "1.12.0"
+  VERSION = "1.13.1"
 end

data/lib/pg_eventstore/web/application.rb

@@ -5,6 +5,7 @@ require 'base64'
 
 module PgEventstore
   module Web
+    # @!visibility private
     class Application < Sinatra::Base
       # @return [Symbol]
       DEFAULT_ADMIN_UI_CONFIG = :admin_web_ui

data/lib/pg_eventstore.rb

@@ -36,10 +36,11 @@ module PgEventstore
     # @return [Object] a result of the given block
     def configure(name: DEFAULT_CONFIG)
       mutex.synchronize do
-        @config[name] ||= Config.new(name: name)
+        @config[name] = @config[name] ? Config.new(name: name, **@config[name].options_hash) : Config.new(name: name)
         connection_config_was = @config[name].connection_options
 
         yield(@config[name]).tap do
+          @config[name].freeze
           next if connection_config_was == @config[name].connection_options
 
           # Reset the connection if user decided to reconfigure connection's options

data/sig/pg_eventstore/connection.rbs

@@ -12,6 +12,8 @@ module PgEventstore
     # _@param_ `pool_timeout` — Connection pool timeout in seconds
     def initialize: (uri: String, ?pool_size: Integer, ?pool_timeout: Integer) -> void
 
+    def shutdown: -> untyped
+
     def with: () { (PG::Connection connection) -> untyped } -> untyped
 
     def init_pool: () -> ConnectionPool[untyped]

data/sig/pg_eventstore/subscriptions/basic_runner.rbs

@@ -1,12 +1,25 @@
 module PgEventstore
   class BasicRunner
-    include PgEventstore::Extensions::CallbacksExtension
+    include Extensions::CallbacksExtension
     extend Forwardable
 
-    # _@param_ `run_interval` — seconds. Determines how often to run async task. Async task is determined by :after_runner_stopped callback
-    #
-    # _@param_ `async_shutdown_time` — seconds. Determines how long to wait for the async shutdown to wait for the runner to finish.
-    %a{rbs:test:skip} def initialize: ((Integer | Float) run_interval, (Integer | Float) async_shutdown_time) -> void
+    @async_shutdown_time: Integer | Float
+    @mutex: Thread::Mutex
+    @recovery_strategies: Array[RunnerRecoveryStrategy]
+    @run_interval: Integer | Float
+    @runner: Thread?
+
+    @state: RunnerState
+
+    %a{rbs:test:skip} def initialize: (
+        run_interval: (Integer | Float),
+        async_shutdown_time: (Integer | Float),
+        recovery_strategies: Array[RunnerRecoveryStrategy]
+      ) -> void
+
+    def async_recover: (StandardError error, RunnerRecoveryStrategy strategy, Integer current_runner_id)-> Thread
+
+    def restore: -> untyped
 
     def start: () -> self
 
@@ -14,14 +27,16 @@ module PgEventstore
 
     def stop_async: () -> self
 
-    def restore: () -> self
-
     def wait_for_finish: () -> self
 
     def state: () -> String
 
     # _@param_ `state`
-    def within_state: (Symbol state) { () -> untyped } -> untyped
+    def within_state: (Symbol state) { () -> untyped } -> untyped?
+
+    private
+
+    def suitable_strategy: (StandardError error)-> RunnerRecoveryStrategy?
 
     def synchronize: () { () -> untyped } -> untyped
 
@@ -29,9 +44,10 @@ module PgEventstore
 
     def delegate_change_state_cbx: () -> void
 
-    # _@param_ `state`
     def change_state: (String state) -> void
 
-    def define_callback: () -> void
+    def recoverable: { () -> untyped } -> untyped
+
+    def init_recovery_ripper: (Integer current_runner_id) -> untyped
   end
 end

data/sig/pg_eventstore/subscriptions/callback_handlers/commands_handler_handlers.rbs

@@ -1,10 +1,10 @@
 module PgEventstore
   class CommandsHandlerHandlers
-    def self.process_feeder_commands: (Symbol config_name, PgEventstore::SubscriptionFeeder subscription_feeder) -> void
+    def self.process_feeder_commands: (Symbol config_name, SubscriptionFeeder subscription_feeder) -> void
 
-    def self.process_runners_commands: (Symbol config_name, Array[PgEventstore::SubscriptionRunner] runners,
-        PgEventstore::SubscriptionFeeder subscription_feeder) -> void
-
-    def self.restore_runner: (PgEventstore::BasicRunner basic_runner, Integer restart_delay, StandardError error) -> void
+    def self.process_runners_commands: (
+        Symbol config_name, Array[SubscriptionRunner] runners,
+        SubscriptionFeeder subscription_feeder
+      ) -> void
   end
 end

data/sig/pg_eventstore/subscriptions/callback_handlers/subscription_feeder_handlers.rbs

@@ -1,6 +1,6 @@
 module PgEventstore
   class SubscriptionFeederHandlers
-    include PgEventstore::Extensions::CallbackHandlersExtension
+    include Extensions::CallbackHandlersExtension
 
     def self.update_subscriptions_set_state: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle, String state) -> void
 
@@ -12,8 +12,6 @@ module PgEventstore
 
     def self.persist_error_info: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle, StandardError error) -> void
 
-    def self.restart_runner: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle, PgEventstore::BasicRunner basic_runner, StandardError _error) -> void
-
     def self.ping_subscriptions_set: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle) -> void
 
     def self.feed_runners: (PgEventstore::SubscriptionsLifecycle subscriptions_lifecycle, Symbol config_name) -> void

data/sig/pg_eventstore/subscriptions/callback_handlers/subscription_runner_handlers.rbs

@@ -6,10 +6,6 @@ module PgEventstore
 
     def self.update_subscription_error: (PgEventstore::Subscription subscription, PgEventstore::WrappedException error) -> void
 
-    def self.restart_events_processor: (PgEventstore::Subscription subscription, _RestartTerminator? restart_terminator,
-        _FailedSubscriptionNotifier? failed_subscription_notifier, PgEventstore::EventsProcessor events_processor,
-        PgEventstore::WrappedException error) -> void
-
     def self.update_subscription_chunk_stats: (PgEventstore::Subscription subscription, Integer global_position) -> void
 
     def self.update_subscription_restarts: (PgEventstore::Subscription subscription) -> void

data/sig/pg_eventstore/subscriptions/commands_handler.rbs

@@ -1,25 +1,22 @@
 module PgEventstore
   class CommandsHandler
     extend Forwardable
-    RESTART_DELAY: Integer
+
     PULL_INTERVAL: Integer
 
+    @basic_runner: BasicRunner
+    @config_name: Symbol
+
+    @runners: ::Array[SubscriptionRunner]
+    @subscription_feeder: SubscriptionFeeder
+
     # _@param_ `config_name`
     #
     # _@param_ `subscription_feeder`
     #
     # _@param_ `runners`
-    def initialize: (Symbol config_name, PgEventstore::SubscriptionFeeder subscription_feeder, ::Array[PgEventstore::SubscriptionRunner] runners) -> void
+    def initialize: (Symbol config_name, SubscriptionFeeder subscription_feeder, ::Array[SubscriptionRunner] runners) -> void
 
     def attach_runner_callbacks: () -> untyped
-
-    def process_async: () -> untyped
-
-    # _@param_ `error`
-    def after_runner_died: (StandardError error) -> void
-
-    def subscription_feeder_commands: () -> PgEventstore::CommandHandlers::SubscriptionFeederCommands
-
-    def subscription_runners_commands: () -> PgEventstore::CommandHandlers::SubscriptionRunnersCommands
   end
 end

data/sig/pg_eventstore/subscriptions/events_processor.rbs

@@ -3,32 +3,20 @@ module PgEventstore
     include PgEventstore::Extensions::CallbacksExtension
     extend Forwardable
 
-    # _@param_ `handler`
-    %a{rbs:test:skip} def initialize: (_RawEventHandler handler, graceful_shutdown_timeout: Float | Integer) -> void
+    %a{rbs:test:skip} def initialize: (
+        _RawEventHandler handler,
+        graceful_shutdown_timeout: Float | Integer,
+        ?recovery_strategies: Array[RunnerRecoveryStrategy]
+      ) -> void
 
-    # _@param_ `raw_events`
     def feed: (::Array[::Hash[untyped, untyped]] raw_events) -> void
 
     def events_left_in_chunk: () -> Integer
 
     def clear_chunk: () -> void
 
-    # _@param_ `raw_event`
     def process_event: (::Hash[untyped, untyped] raw_event) -> void
 
     def attach_runner_callbacks: () -> void
-
-    def process_async: () -> void
-
-    def after_runner_died: (StandardError error) -> void
-
-    def before_runner_restored: () -> void
-
-    def change_state: (*untyped args, **untyped kwargs) -> void
-
-    # _@param_ `raw_event`
-    def global_position: (::Hash[untyped, untyped] raw_event) -> Integer
-
-    def define_callback: () -> void
   end
 end

data/sig/pg_eventstore/subscriptions/runner_recovery_strategies/restore_connection.rbs

@@ -0,0 +1,18 @@
+module PgEventstore
+  module RunnerRecoveryStrategies
+    class RestoreConnection
+      include RunnerRecoveryStrategy
+
+      EXCEPTIONS_TO_HANDLE: Array[StandardError]
+      TIME_BETWEEN_RETRIES: Integer
+
+      @config_name: Symbol
+
+      def initialize: (Symbol config_name)-> untyped
+
+      private
+
+      def connection: -> Connection
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/runner_recovery_strategies/restore_subscription_feeder.rbs

@@ -0,0 +1,11 @@
+module PgEventstore
+  module RunnerRecoveryStrategies
+    class RestoreSubscriptionFeeder
+      include RunnerRecoveryStrategy
+
+      @subscriptions_set_lifecycle: SubscriptionsSetLifecycle
+
+      def initialize: (subscriptions_set_lifecycle: SubscriptionsSetLifecycle)-> untyped
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/runner_recovery_strategies/restore_subscription_runner.rbs

@@ -0,0 +1,17 @@
+module PgEventstore
+  module RunnerRecoveryStrategies
+    class RestoreSubscriptionRunner
+      include RunnerRecoveryStrategy
+
+      @failed_subscription_notifier: _FailedSubscriptionNotifier?
+      @restart_terminator: _RestartTerminator?
+      @subscription: Subscription
+
+      def initialize: (
+          subscription: Subscription,
+          restart_terminator: _RestartTerminator?,
+          failed_subscription_notifier: _FailedSubscriptionNotifier?
+        )-> untyped
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/runner_recovery_strategy.rbs

@@ -0,0 +1,7 @@
+module PgEventstore
+  module RunnerRecoveryStrategy
+    def recover: (StandardError error)-> bool
+
+    def recovers?: (StandardError error)-> bool
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feeder.rbs

@@ -17,19 +17,17 @@ module PgEventstore
 
     def id: () -> Integer?
 
-    # _@param_ `runner`
-    def add: (PgEventstore::SubscriptionRunner runner) -> PgEventstore::SubscriptionRunner
-
     def start_all: () -> void
 
     def stop_all: () -> void
 
-    def read_only_subscriptions: () -> ::Array[PgEventstore::Subscription]
-
-    def read_only_subscriptions_set: () -> PgEventstore::SubscriptionsSet?
-
     def attach_runner_callbacks: () -> void
 
-    def assert_proper_state!: () -> void
+    private
+
+    def recovery_strategies: (
+        Symbol config_name,
+        SubscriptionsSetLifecycle subscriptions_set_lifecycle
+      ) -> Array[RunnerRecoveryStrategy]
   end
 end

data/sig/pg_eventstore/subscriptions/subscription_runner.rbs

@@ -5,19 +5,13 @@ module PgEventstore
     MIN_EVENTS_PER_CHUNK: Integer
     INITIAL_EVENTS_PER_CHUNK: Integer
 
-    # _@param_ `stats`
-    #
-    # _@param_ `events_processor`
-    #
-    # _@param_ `subscription`
-    #
-    # _@param_ `restart_terminator`
-    #
-    # _@param_ `failed_subscription_notifier`
+    # Returns the value of attribute subscription.
+    attr_reader subscription: Subscription
+
     def initialize: (
-        stats: PgEventstore::SubscriptionHandlerPerformance,
-        events_processor: PgEventstore::EventsProcessor,
-        subscription: PgEventstore::Subscription,
+        stats: SubscriptionHandlerPerformance,
+        events_processor: EventsProcessor,
+        subscription: Subscription,
         ?restart_terminator: _RestartTerminator?,
         ?failed_subscription_notifier: _FailedSubscriptionNotifier?
       ) -> void
@@ -31,28 +25,5 @@ module PgEventstore
     def estimate_events_number: () -> Integer
 
     def attach_callbacks: () -> void
-
-    # _@param_ `action`
-    def track_exec_time: (Proc action, *untyped args) -> void
-
-    # _@param_ `current_position`
-    def update_subscription_stats: (Integer current_position) -> void
-
-    # _@param_ `state`
-    def update_subscription_state: (String state) -> void
-
-    def update_subscription_restarts: () -> void
-
-    # _@param_ `error`
-    def update_subscription_error: (StandardError error) -> void
-
-    # _@param_ `global_position`
-    def update_subscription_chunk_stats: (Integer global_position) -> void
-
-    # _@param_ `_error`
-    def restart_subscription: (StandardError error) -> void
-
-    # Returns the value of attribute subscription.
-    attr_accessor subscription: PgEventstore::Subscription
   end
 end

data/sig/pg_eventstore/subscriptions/subscriptions_manager.rbs

@@ -74,5 +74,13 @@ module PgEventstore
 
     # Returns the value of attribute config.
     attr_accessor config: PgEventstore::Config
+
+    private
+
+    def recovery_strategies: (
+        Subscription subscription,
+        _RestartTerminator? restart_terminator,
+        _FailedSubscriptionNotifier? failed_subscription_notifier
+      ) -> Array[RunnerRecoveryStrategy]
   end
 end