pg_eventstore 1.3.4 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66aeaf1c1365b962133efe784a507722fe0be9c80cb1911edd76512cb7a1af17
-  data.tar.gz: 34ebc698b212e0631f005f754bbcf808f95796c149f969a1466ede8c7842e362
+  metadata.gz: ec41b398e1f38d66e73967447ea4f12896ed2cf57eb0dbad8b71acf4257f9cd4
+  data.tar.gz: ce571ef411adeeb18b7bae463cac339a053d96f1b36e3de0b1023b8551b03ac5
 SHA512:
-  metadata.gz: ad3c0661aa7c995c357588cbbaa4c9958868068ec452284250f41e0c2e3ae98eabdae837e7c00e63e59f22df7c5920aef2ad1497340d99dcc5bdc8e3e98ffb1f
-  data.tar.gz: 395e5697dad7945e3c5bc2b51956195097aca503e9e20445b0d3b857fcdb17e4074ec392dc8fdf8a840e132e7f353093985e715a521ef7c73db5b902e0bcbffb
+  metadata.gz: 9273a4efb9855d219b1a92b5d9081e3d0d62f9de7f21c48e634949d218ed6a8278d81367f794ee8b70efa64541d7a4442ccf09e7b4cc3bcbd39398f5c7980ec2
+  data.tar.gz: ffb85f8c9063aa6e11b8f900e128b4b873e89db117b39e703de6603fc73c014811b63950ff0a0340b0316da11ed2562418f56f1faf42a04491fb0105d913fced

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [1.5.0]
+- Add ability to toggle link events in the admin UI
+- Mark linked events in the admin UI with "link" icon
+
+## [1.4.0]
+- Add an ability to configure subscription graceful shutdown timeout globally and per subscription. Default value is 15 seconds. Previously it was hardcoded to 5 seconds. Examples:
+
+```ruby
+# Set it globally, for all subscriptions
+PgEventstore.configure do |config|
+  config.subscription_graceful_shutdown_timeout = 5
+end
+
+# Set it per subscription
+subscriptions_manager.subscribe(
+  'MySubscriptionWithHeavyLiftingTask',
+  handler: proc { |event| puts event },
+  graceful_shutdown_timeout: 20
+)
+```
+
 ## [1.3.4]
 - Fix `NoMethodError` error in `Client#read_paginated` when stream does not exist or when there are no events matching the given filter
 

data/docs/configuration.md

@@ -2,21 +2,22 @@
 
 Configuration options:
 
-| name                               | value   | default value                                                | description                                                                                                                                                                                                                                                                                                            |
-|------------------------------------|---------|--------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| pg_uri                             | String  | `'postgresql://postgres:postgres@localhost:5432/eventstore'` | PostgreSQL connection string. See PostgreSQL [docs](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING-URIS) for more information.                                                                                                                                                            |
-| max_count                          | Integer | `1000`                                                       | Number of events to return in one response when reading from a stream.                                                                                                                                                                                                                                                 |
-| middlewares                        | Array   | `{}`                                                         | A hash where a key is a name of your middleware and value is an object that respond to `#serialize` and `#deserialize` methods. See [**Writing middleware**](writing_middleware.md) chapter.                                                                                                                           |
-| event_class_resolver               | `#call` | `PgEventstore::EventClassResolver.new`                       | A `#call`-able object that accepts a string and returns an event's class. See **Resolving events classes** chapter bellow for more info.                                                                                                                                                                               |
-| connection_pool_size               | Integer | `5`                                                          | Max number of connections per ruby process. It must equal the number of threads of your application. When using subscriptions it is recommended to set it to the number of subscriptions divided by two or greater. See [**Picking max connections number**](#picking-max-connections-number) chapter of this section. |
-| connection_pool_timeout            | Integer | `5`                                                          | Time in seconds to wait for a connection in the pool to be released. If no connections are available during this time - `ConnectionPool::TimeoutError` will be raised. See `connection_pool` gem [docs](https://github.com/mperham/connection_pool#usage) for more info.                                               |
-| subscription_pull_interval         | Float   | `1.0`                                                        | How often to pull new subscription events in seconds. The minimum meaningful value is `0.2`. Values less than `0.2` will act as it is `0.2`.                                                                                                                                                                           |
-| subscription_max_retries           | Integer | `5`                                                          | Max number of retries of failed subscription.                                                                                                                                                                                                                                                                          |
-| subscription_retries_interval      | Integer | `1`                                                          | Interval in seconds between retries of failed subscriptions.                                                                                                                                                                                                                                                           |
-| subscriptions_set_max_retries      | Integer | `10`                                                         | Max number of retries for failed subscription sets.                                                                                                                                                                                                                                                                    |
-| subscriptions_set_retries_interval | Integer | `1`                                                          | Interval in seconds between retries of failed subscription sets.                                                                                                                                                                                                                                                       |
-| subscription_restart_terminator    | `#call` | `nil`                                                        | A callable object that accepts `PgEventstore::Subscription` object to determine whether restarts should be stopped(true - stops restarts, false - continues restarts).                                                                                                                                                 |
-| failed_subscription_notifier       | `#call` | `nil`                                                        | A callable object which is invoked with `PgEventstore::Subscription` instance and error instance after the related subscription died due to error and no longer can be automatically restarted due to max retries number reached. You can use this hook to send a notification about failed subscription.              |
+| name                                   | value          | default value                                                | description                                                                                                                                                                                                                                                                                                            |
+|----------------------------------------|----------------|--------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| pg_uri                                 | String         | `'postgresql://postgres:postgres@localhost:5432/eventstore'` | PostgreSQL connection string. See PostgreSQL [docs](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING-URIS) for more information.                                                                                                                                                            |
+| max_count                              | Integer        | `1000`                                                       | Number of events to return in one response when reading from a stream.                                                                                                                                                                                                                                                 |
+| middlewares                            | Array          | `{}`                                                         | A hash where a key is a name of your middleware and value is an object that respond to `#serialize` and `#deserialize` methods. See [**Writing middleware**](writing_middleware.md) chapter.                                                                                                                           |
+| event_class_resolver                   | `#call`        | `PgEventstore::EventClassResolver.new`                       | A `#call`-able object that accepts a string and returns an event's class. See **Resolving events classes** chapter bellow for more info.                                                                                                                                                                               |
+| connection_pool_size                   | Integer        | `5`                                                          | Max number of connections per ruby process. It must equal the number of threads of your application. When using subscriptions it is recommended to set it to the number of subscriptions divided by two or greater. See [**Picking max connections number**](#picking-max-connections-number) chapter of this section. |
+| connection_pool_timeout                | Integer        | `5`                                                          | Time in seconds to wait for a connection in the pool to be released. If no connections are available during this time - `ConnectionPool::TimeoutError` will be raised. See `connection_pool` gem [docs](https://github.com/mperham/connection_pool#usage) for more info.                                               |
+| subscription_pull_interval             | Float          | `1.0`                                                        | How often to pull new subscription events in seconds. The minimum meaningful value is `0.2`. Values less than `0.2` will act as it is `0.2`.                                                                                                                                                                           |
+| subscription_max_retries               | Integer        | `5`                                                          | Max number of retries of failed subscription.                                                                                                                                                                                                                                                                          |
+| subscription_retries_interval          | Integer        | `1`                                                          | Interval in seconds between retries of failed subscriptions.                                                                                                                                                                                                                                                           |
+| subscriptions_set_max_retries          | Integer        | `10`                                                         | Max number of retries for failed subscription sets.                                                                                                                                                                                                                                                                    |
+| subscriptions_set_retries_interval     | Integer        | `1`                                                          | Interval in seconds between retries of failed subscription sets.                                                                                                                                                                                                                                                       |
+| subscription_restart_terminator        | `#call`        | `nil`                                                        | A callable object that accepts `PgEventstore::Subscription` object to determine whether restarts should be stopped(true - stops restarts, false - continues restarts).                                                                                                                                                 |
+| failed_subscription_notifier           | `#call`        | `nil`                                                        | A callable object which is invoked with `PgEventstore::Subscription` instance and error instance after the related subscription died due to error and no longer can be automatically restarted due to max retries number reached. You can use this hook to send a notification about failed subscription.              |
+| subscription_graceful_shutdown_timeout | Integer, Float | `15`                                                         | The number of seconds to wait until force-shutdown the subscription during the stop process. If your subscription handler does not finish current event processing during this time(for example because of heavy-lifting task) - it will be force-shutdown.                                                            |
 
 ## Multiple configurations
 

data/docs/subscriptions.md

@@ -151,7 +151,7 @@ You will then see the output of your subscription handlers. To gracefully stop t
 
 ## Overriding Subscription config values
 
-You can override `subscription_pull_interval`, `subscription_max_retries`, `subscription_retries_interval`, `subscription_restart_terminator` and `failed_subscription_notifier` config values (see [**Configuration**](configuration.md) chapter for details) for the specific subscription by providing the corresponding arguments. Example:
+You can override `subscription_pull_interval`, `subscription_max_retries`, `subscription_retries_interval`, `subscription_restart_terminator`, `failed_subscription_notifier` and `subscription_graceful_shutdown_timeout` config values (see [**Configuration**](configuration.md) chapter for details) for the specific subscription by providing the corresponding arguments. Example:
 
 ```ruby
 subscriptions_manager.subscribe(
@@ -166,7 +166,9 @@ subscriptions_manager.subscribe(
   # overrides config.subscription_restart_terminator
   restart_terminator: proc { |subscription| subscription.last_error['class'] == 'NoMethodError' },
   # overrides config.failed_subscription_notifier
-  failed_subscription_notifier: proc { |_subscription, err| p err }
+  failed_subscription_notifier: proc { |_subscription, err| p err },
+  # overrides config.subscription_graceful_shutdown_timeout
+  graceful_shutdown_timeout: 20
 )
 ```
 

data/lib/pg_eventstore/config.rb

@@ -52,6 +52,9 @@ module PgEventstore
     #   @return [#call, nil] provide callable object that accepts Subscription instance and error. It is useful when you
     #     want to be get notified when your Subscription fails and no longer can be restarted
     option(:failed_subscription_notifier)
+    # @!attribute subscription_graceful_shutdown_timeout
+    #   @return [Integer] the number of seconds to wait until force-shutdown the subscription during the stop process
+    option(:subscription_graceful_shutdown_timeout) { 15 }
 
     # @param name [Symbol] config's name. Its value matches the appropriate key in PgEventstore.config hash
     def initialize(name:, **options)

data/lib/pg_eventstore/extensions/callback_handlers_extension.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Extensions
+    module CallbackHandlersExtension
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # @param name [Symbol] a name of the handler
+        # @return [Proc]
+        def setup_handler(name, *args)
+          proc do |*rest|
+            public_send(name, *args, *rest)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/basic_runner.rb

@@ -83,8 +83,8 @@ module PgEventstore
 
     # @param run_interval [Integer, Float] seconds. Determines how often to run async task. Async task is determined by
     #   :after_runner_stopped callback
-    # @param async_shutdown_time [Integer, Float] seconds. Determines how long to wait for the async shutdown to wait
-    #   for the runner to finish.
+    # @param async_shutdown_time [Integer, Float] seconds. Determines how long to wait before force-shutdown the runner.
+    #   It is only meaningful for the #stop_async
     def initialize(run_interval, async_shutdown_time)
       @run_interval = run_interval
       @async_shutdown_time = async_shutdown_time

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class CommandsHandlerHandlers
+    include Extensions::CallbackHandlersExtension
+
+    class << self
+      # @param config_name [Symbol]
+      # @param subscription_feeder [PgEventstore::SubscriptionFeeder]
+      # @return [void]
+      def process_feeder_commands(config_name, subscription_feeder)
+        CommandHandlers::SubscriptionFeederCommands.new(config_name, subscription_feeder).process
+      end
+
+      # @param config_name [Symbol]
+      # @param runners [Array<PgEventstore::SubscriptionRunner>]
+      # @param subscription_feeder [PgEventstore::SubscriptionFeeder]
+      # @return [void]
+      def process_runners_commands(config_name, runners, subscription_feeder)
+        CommandHandlers::SubscriptionRunnersCommands.new(config_name, runners, subscription_feeder.id).process
+      end
+
+      # @param basic_runner [PgEventstore::BasicRunner]
+      # @param restart_delay [Integer]
+      # @param error [StandardError]
+      # @return [void]
+      def restore_runner(basic_runner, restart_delay, error)
+        PgEventstore.logger&.error "PgEventstore::CommandsHandler: Error occurred: #{error.message}"
+        PgEventstore.logger&.error "PgEventstore::CommandsHandler: Backtrace: #{error.backtrace&.join("\n")}"
+        PgEventstore.logger&.error "PgEventstore::CommandsHandler: Trying to auto-repair in #{restart_delay} seconds..."
+        Thread.new do
+          sleep restart_delay
+          basic_runner.restore
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class EventsProcessorHandlers
+    include Extensions::CallbackHandlersExtension
+
+    class << self
+      # @param callbacks [PgEventstore::Callbacks]
+      # @param handler [#call]
+      # @param raw_events [Array<Hash>]
+      # @return [void]
+      def process_event(callbacks, handler, raw_events)
+        raw_event = raw_events.shift
+        return sleep 0.5 if raw_event.nil?
+
+        callbacks.run_callbacks(:process, Utils.original_global_position(raw_event)) do
+          handler.call(raw_event)
+        end
+      rescue
+        raw_events.unshift(raw_event)
+        raise
+      end
+
+      # @param callbacks [PgEventstore::Callbacks]
+      # @param error [StandardError]
+      # @return [void]
+      def after_runner_died(callbacks, error)
+        callbacks.run_callbacks(:error, error)
+      end
+
+      # @param callbacks [PgEventstore::Callbacks]
+      # @return [void]
+      def before_runner_restored(callbacks)
+        callbacks.run_callbacks(:restart)
+      end
+
+      # @param callbacks [PgEventstore::Callbacks]
+      # @param state [String]
+      # @return [void]
+      def change_state(callbacks, state)
+        callbacks.run_callbacks(:change_state, state)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class SubscriptionFeederHandlers
+    include Extensions::CallbackHandlersExtension
+
+    class << self
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @param state [String]
+      # @return [void]
+      def update_subscriptions_set_state(subscriptions_set_lifecycle, state)
+        subscriptions_set_lifecycle.persisted_subscriptions_set.update(state: state)
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @return [void]
+      def lock_subscriptions(subscriptions_lifecycle)
+        subscriptions_lifecycle.lock_all
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @return [void]
+      def start_runners(subscriptions_lifecycle)
+        subscriptions_lifecycle.runners.each(&:start)
+      end
+
+      # @param cmds_handler [PgEventstore::CommandsHandler]
+      # @return [void]
+      def start_cmds_handler(cmds_handler)
+        cmds_handler.start
+      end
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @param error [StandardError]
+      # @return [void]
+      def persist_error_info(subscriptions_set_lifecycle, error)
+        subscriptions_set_lifecycle.persisted_subscriptions_set.update(
+          last_error: Utils.error_info(error), last_error_occurred_at: Time.now.utc
+        )
+      end
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @param basic_runner [PgEventstore::BasicRunner]
+      # @param _error [StandardError]
+      # @return [void]
+      def restart_runner(subscriptions_set_lifecycle, basic_runner, _error)
+        subscriptions_set = subscriptions_set_lifecycle.persisted_subscriptions_set
+        return if subscriptions_set.restart_count >= subscriptions_set.max_restarts_number
+
+        Thread.new do
+          sleep subscriptions_set.time_between_restarts
+          basic_runner.restore
+        end
+      end
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @return [void]
+      def ping_subscriptions_set(subscriptions_set_lifecycle)
+        subscriptions_set_lifecycle.ping_subscriptions_set
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @param config_name [Symbol]
+      # @return [void]
+      def feed_runners(subscriptions_lifecycle, config_name)
+        SubscriptionRunnersFeeder.new(config_name).feed(subscriptions_lifecycle.runners)
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @return [void]
+      def ping_subscriptions(subscriptions_lifecycle)
+        subscriptions_lifecycle.ping_subscriptions
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @return [void]
+      def stop_runners(subscriptions_lifecycle)
+        subscriptions_lifecycle.runners.each(&:stop_async).each(&:wait_for_finish)
+      end
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @return [void]
+      def reset_subscriptions_set(subscriptions_set_lifecycle)
+        subscriptions_set_lifecycle.reset_subscriptions_set
+      end
+
+      # @param cmds_handler [PgEventstore::CommandsHandler]
+      # @return [void]
+      def stop_commands_handler(cmds_handler)
+        cmds_handler.stop
+      end
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @return [void]
+      def update_subscriptions_set_restarts(subscriptions_set_lifecycle)
+        subscriptions_set = subscriptions_set_lifecycle.persisted_subscriptions_set
+        subscriptions_set.update(
+          last_restarted_at: Time.now.utc, restart_count: subscriptions_set.restart_count + 1
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class SubscriptionRunnerHandlers
+    include Extensions::CallbackHandlersExtension
+
+    class << self
+      # @param stats [PgEventstore::SubscriptionHandlerPerformance]
+      # @param action [Proc]
+      # @param _current_position [Integer]
+      # @return [void]
+      def track_exec_time(stats, action, _current_position)
+        stats.track_exec_time { action.call }
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param stats [PgEventstore::SubscriptionHandlerPerformance]
+      # @param current_position [Integer]
+      # @return [void]
+      def update_subscription_stats(subscription, stats, current_position)
+        subscription.update(
+          average_event_processing_time: stats.average_event_processing_time,
+          current_position: current_position,
+          total_processed_events: subscription.total_processed_events + 1
+        )
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param error [StandardError]
+      # @return [void]
+      def update_subscription_error(subscription, error)
+        subscription.update(last_error: Utils.error_info(error), last_error_occurred_at: Time.now.utc)
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param restart_terminator [#call, nil]
+      # @param failed_subscription_notifier [#call, nil]
+      # @param events_processor [PgEventstore::EventsProcessor]
+      # @param error [StandardError]
+      # @return [void]
+      def restart_events_processor(subscription, restart_terminator, failed_subscription_notifier, events_processor,
+                                   error)
+        return if restart_terminator&.call(subscription.dup)
+        if subscription.restart_count >= subscription.max_restarts_number
+          return failed_subscription_notifier&.call(subscription.dup, error)
+        end
+
+        Thread.new do
+          sleep subscription.time_between_restarts
+          events_processor.restore
+        end
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param global_position [Integer]
+      # @return [void]
+      def update_subscription_chunk_stats(subscription, global_position)
+        subscription.update(last_chunk_fed_at: Time.now.utc, last_chunk_greatest_position: global_position)
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @return [void]
+      def update_subscription_restarts(subscription)
+        subscription.update(last_restarted_at: Time.now.utc, restart_count: subscription.restart_count + 1)
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param state [String]
+      # @return [void]
+      def update_subscription_state(subscription, state)
+        subscription.update(state: state)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/commands_handler.rb

@@ -31,35 +31,19 @@ module PgEventstore
     private
 
     def attach_runner_callbacks
-      @basic_runner.define_callback(:process_async, :before, method(:process_async))
-      @basic_runner.define_callback(:after_runner_died, :before, method(:after_runner_died))
-    end
-
-    def process_async
-      subscription_feeder_commands.process
-      subscription_runners_commands.process
-    end
-
-    # @param error [StandardError]
-    # @return [void]
-    def after_runner_died(error)
-      PgEventstore.logger&.error "#{self.class.name}: Error occurred: #{error.message}"
-      PgEventstore.logger&.error "#{self.class.name}: Backtrace: #{error.backtrace&.join("\n")}"
-      PgEventstore.logger&.error "#{self.class.name}: Trying to auto-repair in #{RESTART_DELAY} seconds..."
-      Thread.new do
-        sleep RESTART_DELAY
-        @basic_runner.restore
-      end
-    end
-
-    # @return [PgEventstore::CommandHandlers::SubscriptionFeederCommands]
-    def subscription_feeder_commands
-      CommandHandlers::SubscriptionFeederCommands.new(@config_name, @subscription_feeder)
-    end
-
-    # @return [PgEventstore::CommandHandlers::SubscriptionRunnersCommands]
-    def subscription_runners_commands
-      CommandHandlers::SubscriptionRunnersCommands.new(@config_name, @runners, @subscription_feeder.id)
+      @basic_runner.define_callback(
+        :process_async, :before,
+      CommandsHandlerHandlers.setup_handler(:process_feeder_commands, @config_name, @subscription_feeder)
+      )
+      @basic_runner.define_callback(
+        :process_async, :before,
+        CommandsHandlerHandlers.setup_handler(:process_runners_commands, @config_name, @runners, @subscription_feeder)
+      )
+
+      @basic_runner.define_callback(
+        :after_runner_died, :before,
+        CommandsHandlerHandlers.setup_handler(:restore_runner, @basic_runner, RESTART_DELAY)
+      )
     end
   end
 end

data/lib/pg_eventstore/subscriptions/events_processor.rb

@@ -11,10 +11,12 @@ module PgEventstore
                    :within_state
 
     # @param handler [#call]
-    def initialize(handler)
+    # @param graceful_shutdown_timeout [Integer, Float] seconds. Determines how long to wait before force-shutdown
+    #   the runner when stopping it using #stop_async
+    def initialize(handler, graceful_shutdown_timeout:)
       @handler = handler
       @raw_events = []
-      @basic_runner = BasicRunner.new(0, 5)
+      @basic_runner = BasicRunner.new(0, graceful_shutdown_timeout)
       attach_runner_callbacks
     end
 
@@ -24,7 +26,7 @@ module PgEventstore
       raise EmptyChunkFedError.new("Empty chunk was fed!") if raw_events.empty?
 
       within_state(:running) do
-        callbacks.run_callbacks(:feed, global_position(raw_events.last))
+        callbacks.run_callbacks(:feed, Utils.original_global_position(raw_events.last))
         @raw_events.push(*raw_events)
       end
     end
@@ -42,47 +44,23 @@ module PgEventstore
 
     private
 
-    # @param raw_event [Hash]
-    # @return [void]
-    def process_event(raw_event)
-      callbacks.run_callbacks(:process, global_position(raw_event)) do
-        @handler.call(raw_event)
-      end
-    end
-
     def attach_runner_callbacks
-      @basic_runner.define_callback(:process_async, :before, method(:process_async))
-      @basic_runner.define_callback(:after_runner_died, :before, method(:after_runner_died))
-      @basic_runner.define_callback(:before_runner_restored, :before, method(:before_runner_restored))
-      @basic_runner.define_callback(:change_state, :before, method(:change_state))
-    end
-
-    def process_async
-      raw_event = @raw_events.shift
-      return sleep 0.5 if raw_event.nil?
-
-      process_event(raw_event)
-    rescue
-      @raw_events.unshift(raw_event)
-      raise
-    end
-
-    def after_runner_died(...)
-      callbacks.run_callbacks(:error, ...)
-    end
-
-    def before_runner_restored
-      callbacks.run_callbacks(:restart)
-    end
-
-    def change_state(...)
-      callbacks.run_callbacks(:change_state, ...)
-    end
-
-    # @param raw_event [Hash]
-    # @return [Integer]
-    def global_position(raw_event)
-      raw_event['link'] ? raw_event['link']['global_position'] : raw_event['global_position']
+      @basic_runner.define_callback(
+        :process_async, :before,
+        EventsProcessorHandlers.setup_handler(:process_event, @callbacks, @handler, @raw_events)
+      )
+
+      @basic_runner.define_callback(
+        :after_runner_died, :before, EventsProcessorHandlers.setup_handler(:after_runner_died, callbacks)
+      )
+
+      @basic_runner.define_callback(
+        :before_runner_restored, :before, EventsProcessorHandlers.setup_handler(:before_runner_restored, callbacks)
+      )
+
+      @basic_runner.define_callback(
+        :change_state, :before, EventsProcessorHandlers.setup_handler(:change_state, callbacks)
+      )
     end
   end
 end