pg_eventstore 1.13.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94443dc3aa36701d5e126573a5babdd4585932d803b766b06b94c861f6b4ef5a
-  data.tar.gz: 86fcca21a3a2d3da35f3c760542b23cc97ae93ce97bae7b9baf011a957a9ffea
+  metadata.gz: a4799e200314277c53e9991483c429267213a9243a93c0ea85e7a23fa8c9b1ad
+  data.tar.gz: 38c68fd540c903d19ac316aca849007f3b4c27ab94dc09cfb2e71a9b9acdd734
 SHA512:
-  metadata.gz: 4fb5ed37edce4c557082ba60cfa18f7209f795fa29b98dff9f848bb83b0b1cec889f4a7ca7f77bef5c0d9c6b4065d53765dcfcdf50dffe2628c3e3ffb57d26ad
-  data.tar.gz: 0bc33722f13c57c11888ac205873ac93a3610ef5218e8dccf7c3e64d671852757e9d755ffe17ea8176b238dbe1722df47db522b5252ddceed52e14534c164c45
+  metadata.gz: 347354eb5327bf7a38df0682710f9b5a676488910ed3d0e7e967c9bcccd1d4e4b784c87e178dc6f4b5fcea2c8f681bfa0209618cf58f76dd5b36db1577d656f0
+  data.tar.gz: a567b9bfee1112e16d4f8b96b130e0f01c12b1f5349429c1ac873f4f3b4daa36628239b041eeecdc0f69a9807210d36bb30352dcb05b4100ef14eda37f1c6133

data/.rubocop.yml

@@ -2,7 +2,7 @@ plugins:
   - rubocop-rspec
 
 AllCops:
-  TargetRubyVersion: '3.0'
+  TargetRubyVersion: '3.2'
   NewCops: enable
   Exclude:
     - 'benchmark/*'

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [2.0.0]
+
+- **Breaking change**: `pg_eventstore` now requires [pg_cron](https://github.com/citusdata/pg_cron) extension
+- **Breaking change**: `pg_eventstore` now requires PostgreSQL v16+
+- Greatly decreased the number of connections, used by `pg_eventstore` subscriptions
+- **Breaking change**: drop support of Ruby v3.0 and v3.1. The gem now requires Ruby v3.2+
+- **Breaking change**: `PgEventstore::Extensions::OptionsExtension::Options` class is no longer a child of `Set` class - it has independent implementation now
+- Add support of Ruby v4.0
+- `Client#multiple` method now accepts `read_only` keyword argument. When it is set to true - transaction is run in read-only mode
+- **Breaking change**: rework links implementation. This change boosts performance, but affects the database structure, so your previous database dumps become incompatible with this change. `PgEventstore::Event#link_id` was replaced by `PgEventstore::Event#link_global_position`
+
+Changes above require you to run migrations - `bundle exec rake pg_eventstore:migrate`. One of the migrations also migrates existing data using several concurrent workers(threads). You can adjust the number of workers using `CONCURRENCY` environment variable. Default number of concurrent workers is `10`. **Migrations require a downtime - no reads/writes should be performed during the time of the migrations, so plan your maintenance downtime accordingly.**
+
 ## [1.13.4]
 
 - Fix subscriptions potentially skipping events when multiple events are appended in concurrent transactions

data/Dockerfile

@@ -0,0 +1,3 @@
+FROM postgres:18
+
+RUN apt-get update && apt-get -y install postgresql-18-cron

data/README.md

@@ -4,27 +4,30 @@ Implements database and API to store and read events in event sourced systems.
 
 ## Requirements
 
-- `pg_eventstore` requires a PostgreSQL database with jsonb data type support (which means you need to have v9.2+). However it is recommended to use a non [EOL](https://www.postgresql.org/support/versioning/) PostgreSQL version, because the development of this gem is targeted at current PostgreSQL versions. 
-- It is recommended you to have the default value set for `default_transaction_isolation` PostgreSQL config setting(`"read committed"`) as the implementation relies on it. All other transaction isolation levels(`"repeatable read"` and `"serializable"`) may cause unexpected serialization errors.
+- `pg_eventstore` requires a PostgreSQL v16+ with [pg_cron](https://github.com/citusdata/pg_cron) extension installed.
+- `pg_evenstore` requires a separate detabase. However, it is recommended that you spin it up on a separate PostgreSQL instance in a production environment.
+- `pg_eventstore` requires `default_transaction_isolation` server config option to be set to `'read committed'` (default behavior). Having this value set to move strict isolation level may result in unexpected behavior.
 - It is recommended to use a connection pooler (for example [PgBouncer](https://www.pgbouncer.org/)) in `transaction` pool mode to lower the load on a database.
 - `pg_eventstore` requires ruby v3+. The development of this gem is targeted at [current](https://endoflife.date/ruby) ruby versions.
 
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add pg_eventstore
+```bash
+bundle add pg_eventstore
+```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install pg_eventstore
+```bash
+gem install pg_eventstore
+```
 
 ## Usage
 
 Before start using the gem - you have to create the database. Please include this line into your `Rakefile`:
 
 ```ruby
-load "pg_eventstore/tasks/setup.rake"
+load 'pg_eventstore/tasks/setup.rake'
 ```
 
 This will include necessary rake tasks. You can now run 
@@ -54,6 +57,16 @@ Documentation chapters:
 
 The gem is shipped with its own CLI. Use `pg-eventstore --help` to find out its capabilities.
 
+## Maintenance
+
+You may want to backup your eventstore database. It is important to mention that you don't want to dump/restore records of `events_horizon` table. `events_horizon` table is used to supply subscriptions functionality and contains temporary data which is scoped to the PostgreSQL cluster they were created in. **Thus, it is even may be harmful if you restore records from this table into a new PostgreSQL cluster. Simply exclude that table's data when performing backups.** Example:
+
+```bash
+pg_dump --exclude-table-data=events_horizon eventstore -U postgres > eventstore.sql
+```
+
+Also, it is important you create and migrate new database via provided rake commands - they include an important setup of `pg_cron` jobs as well. **Even if you would like to restore your db backup on clean PostgreSQL instance - please initialize pg_eventstore via built-in tools first.**
+
 ## RSpec
 
 ### Clean up test db

data/db/migrations/10_setup_pg_cron.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+PgEventstore.connection(:_postgres_db_connection).with do |conn|
+  conn.exec(<<~SQL)
+    CREATE EXTENSION IF NOT EXISTS pg_cron
+  SQL
+  conn.exec_params(<<~SQL, ["prune_#{PgEventstore::MigrationHelpers.db_name}_events_horizon", PgEventstore::MigrationHelpers.db_name])
+    SELECT cron.schedule_in_database(
+      $1,
+      '*/10 * * * *',
+      $$DELETE FROM events_horizon WHERE xact_id <= (SELECT xact_id FROM events_horizon ORDER BY xact_id DESC OFFSET 100 LIMIT 1)$$,
+      $2
+     )
+  SQL
+  # Store information about finished cron jobs for 1 day
+  conn.exec(<<~SQL)
+    SELECT cron.schedule(
+      'delete-job-run-details',
+      '0 12 * * *',
+      $$DELETE FROM cron.job_run_details WHERE end_time < now() - interval '1 day'$$
+    );
+  SQL
+end

data/db/migrations/11_add_events_link_global_position.sql

@@ -0,0 +1 @@
+ALTER TABLE public.events ADD COLUMN link_global_position bigint;

data/db/migrations/12_migrate_legacy_links.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+CONCURRENCY = ENV['CONCURRENCY']&.to_i || 10
+
+PgEventstore.configure(name: :_eventstore_db_connection) do |config|
+  config.connection_pool_size = CONCURRENCY
+end
+
+partitions = PgEventstore.connection(:_eventstore_db_connection).with do |conn|
+  conn.exec('select id, table_name from partitions')
+end
+partitions = partitions.to_h { |attrs| [attrs['id'], attrs['table_name']] }
+
+total_links = PgEventstore.connection(:_eventstore_db_connection).with do |conn|
+  conn.exec_params(
+    'select count(*) all_count from events where events.type = $1 and link_global_position is null',
+    [PgEventstore::Event::LINK_TYPE]
+  )
+end.first['all_count']
+
+puts "Migrating legacy links. Links to process: #{total_links}. Concurrency is #{CONCURRENCY} concurrent writers."
+processed = 0
+processed_was = 0
+time = Time.now
+lock = Thread::Mutex.new
+threads = CONCURRENCY.times.map do |t|
+  Thread.new do
+    loop do
+      link_events = PgEventstore.connection(:_eventstore_db_connection).with do |conn|
+        conn.exec_params(<<~SQL, [PgEventstore::Event::LINK_TYPE, CONCURRENCY, t])
+          select * from events
+            where events.type = $1 and events.link_global_position is null and global_position % $2 = $3
+            limit 1_000
+        SQL
+      end.to_a
+      break if link_events.empty?
+
+      lock.synchronize { processed += link_events.size }
+      link_events = link_events.to_h { [_1['global_position'], _1] }
+      builders = link_events.values.map do |event|
+        builder = PgEventstore::SQLBuilder.new
+        builder.select("global_position, #{event['global_position']} as link_event_global_position")
+        builder.from(partitions[event['link_partition_id']]).where('id = ?', event['link_id'])
+      end
+      final_builder = PgEventstore::SQLBuilder.union_builders(builders)
+
+      positions_map = PgEventstore.connection(:_eventstore_db_connection).with do |conn|
+        conn.exec_params(*final_builder.to_exec_params)
+      end.to_a
+
+      update_queries = positions_map.map do |attrs|
+        <<~SQL
+          UPDATE events SET link_global_position = #{attrs['global_position']}
+            WHERE global_position = #{attrs['link_event_global_position']};
+        SQL
+      end
+
+      PgEventstore.connection(:_eventstore_db_connection).with do |conn|
+        conn.exec(update_queries.join("\n"))
+      end
+
+      # Only log from the first thread to prevent messages spam
+      next unless t == 0
+
+      lock.synchronize do
+        time_was = time
+        time = Time.now
+
+        performance_info = <<~TEXT.strip
+          Processed: #{processed}. Left: #{total_links - processed}. \
+          Performance: #{((processed - processed_was) / (time - time_was)).round(2)} events/second.
+        TEXT
+        processed_was = processed
+        print "#{performance_info}               \r"
+      end
+    end
+  end
+end
+threads.each(&:join)
+
+PgEventstore.connection(:_eventstore_db_connection).with do |conn|
+  conn.exec('VACUUM (ANALYZE) events;')
+end

data/db/migrations/13_remove_events_link_id.sql

@@ -0,0 +1,6 @@
+-- We need to drop view which uses link_id and re-create it after we remove link_id column
+DROP VIEW "$streams";
+
+ALTER TABLE public.events DROP COLUMN link_id;
+
+CREATE VIEW "$streams" AS SELECT * FROM events WHERE stream_revision = 0;

data/db/migrations/14_remove_ids_events_id_index.sql

@@ -0,0 +1 @@
+DROP INDEX idx_events_id;

data/db/migrations/9_create_events_horizon.sql

@@ -0,0 +1,21 @@
+CREATE UNLOGGED TABLE events_horizon
+(
+    global_position bigint not null,
+    xact_id         xid8 not null default pg_current_xact_id()
+);
+CREATE INDEX idx_xact_id_and_created_at_and_global_position ON events_horizon USING btree(xact_id, global_position);
+COMMENT ON TABLE events_horizon IS 'Internal use only. Data is limited to the PostgreSQL cluster in which it was created. DO NOT INCLUDE ITS DATA INTO YOUR DUMP.';
+
+CREATE OR REPLACE FUNCTION log_events_horizon()
+    RETURNS TRIGGER AS $$
+BEGIN
+    INSERT INTO events_horizon(global_position)
+    VALUES (NEW.global_position);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER log_events_horizon
+    AFTER INSERT ON events
+    FOR EACH ROW
+EXECUTE FUNCTION log_events_horizon();

data/docs/appending_events.md

@@ -13,7 +13,7 @@ end
 event = SomethingHappened.new(data: { user_id: SecureRandom.uuid, title: "Something happened" })
 stream = PgEventstore::Stream.new(context: 'MyAwesomeContext', stream_name: 'SomeStream', stream_id: 'f37b82f2-4152-424d-ab6b-0cc6f0a53aae')
 PgEventstore.client.append_to_stream(stream, event)
-# => #<SomethingHappened:0x0 @context="MyAwesomeContext", @created_at=2023-11-30 14:47:31.296229 UTC, @data={"title"=>"Something happened", "user_id"=>"be52a81c-ad5b-4cfd-a039-0b7276974e6b"}, @global_position=7, @id="0b01137b-bdd8-4f0d-8ccf-f8c959e3a324", @link_id=nil, @metadata={}, @stream_id="f37b82f2-4152-424d-ab6b-0cc6f0a53aae", @stream_name="SomeStream", @stream_revision=0, @type="SomethingHappened">
+# => #<SomethingHappened:0x0 @context="MyAwesomeContext", @created_at=2023-11-30 14:47:31.296229 UTC, @data={"title"=>"Something happened", "user_id"=>"be52a81c-ad5b-4cfd-a039-0b7276974e6b"}, @global_position=7, @id="0b01137b-bdd8-4f0d-8ccf-f8c959e3a324", @link_global_position=nil, @metadata={}, @stream_id="f37b82f2-4152-424d-ab6b-0cc6f0a53aae", @stream_name="SomeStream", @stream_revision=0, @type="SomethingHappened">
 ```
 
 ## Appending multiple events

data/docs/events_and_streams.md

@@ -16,7 +16,7 @@
 - `stream_revision` - Integer(optional, read only). A revision of an event inside its stream.
 - `data` - Hash(optional). Event's payload data. For example, if you have a `DescriptionChanged` event class, then you may want to have a description value in the event payload data. Example: `DescriptionChanged.new(data: { 'description' => 'Description of something', 'post_id' => SecureRandom.uuid })`
 - `metadata` - Hash(optional). Event metadata. Event meta information which is not part of an events data payload. Example: `{ published_by: publishing_user.id }`
-- `link_id` - String(UUIDv4, optional, read only). If an event is a link event (link events are pointers to other events), this attribute contains an `id` of the original event. Manually assigning this attribute has no effect. It is internally set when appending an event to the given stream or when reading events from the database.
+- `link_global_position` - Integer(optional, read only). If an event is a link event (link events are pointers to other events), this attribute contains a `global_position` of the original event. Manually assigning this attribute has no effect. It is internally set when linking an event to the given stream or when reading events from the database.
 - `link_partition_id` - Integer(optional, read only). If an event is a link event - this attribute contains a partition `id` of original event. Manually assigning this attribute has no effect. It is internally set when appending an event to the given stream or when reading events from the database.
 - `link` - PgEventstore::Event(optional, read only). When reading from a stream using `resolve_link_tos: true`, if an event is resolved from a link - this attribute contains a `PgEventstore::Event` object which corresponds to that link. Manually assigning this attribute has no effect. It is internally set when reading events from the database.
 - `created_at` - Time(optional, read only). Database's timestamp when an event was appended to a stream. You may want to put your own timestamp into a `metadata` attribute - it may be useful when migrating between different databases. Manually assigning this attribute has no effect. It is internally set when appending an event to the given stream or when reading events from the database.

data/docs/multiple_commands.md

@@ -1,6 +1,6 @@
 # Multiple commands
 
-`pg_eventstore` implements the `#multiple` method to allow you to make several different commands atomic. Example:
+`pg_eventstore` implements the `#multiple` method to allow you to make several different commands atomic. Internally it executes the given block within PostgreSQL transaction. Example:
 
 ```ruby
 PgEventstore.client.multiple do
@@ -11,6 +11,21 @@ PgEventstore.client.multiple do
 end
 ```
 
+Optionally, you can provide `read_only: true` argument to run the transaction in read-only mode. This, however, will raise `PG::ReadOnlySqlTransaction` exception if any mutating query is executed within the block. Example:
+
+```ruby
+# Good
+PgEventstore.client.multiple(read_only: true) do
+  PgEventstore.client.read(stream1)
+  PgEventstore.client.read(stream2)
+end
+# Bad. Will raise error
+PgEventstore.client.multiple(read_only: true) do
+  PgEventstore.client.append_to_stream(stream, event)
+end
+```
+
+
 All commands inside a `multiple` block either all succeed or all fail. This allows you to easily implement complex business rules. However, it comes with a price of performance. The more you put in a single block, the higher the chance it will have conflicts with other commands run in parallel, increasing overall time to complete. **Because of this performance implications, do not put more events than needed in a `multple` block.** You may still want to use it though as it could simplify your implementation.
 
 **Please take into account that due to concurrency of parallel commands, a block of code may be re-run several times before succeeding.** So, if you put any piece of code besides `pg_evenstore`'s commands - make sure it is ready for re-runs. A good and a bad examples:

data/lib/pg_eventstore/callbacks.rb

@@ -86,14 +86,16 @@ module PgEventstore
 
     # @param action [Object] an action to run
     # @return [Object] the result of passed block
-    def run_callbacks(action, *args, **kwargs, &blk)
+    # rubocop:disable Style/ArgumentsForwarding
+    def run_callbacks(action, *, **, &)
       return (yield if block_given?) unless @callbacks[action]
 
-      run_before_callbacks(action, *args, **kwargs)
-      result = run_around_callbacks(action, *args, **kwargs, &blk)
-      run_after_callbacks(action, *args, **kwargs)
+      run_before_callbacks(action, *, **)
+      result = run_around_callbacks(action, *, **, &)
+      run_after_callbacks(action, *, **)
       result
     end
+    # rubocop:enable Style/ArgumentsForwarding
 
     # @param action [Object]
     # @param filter [Symbol]
@@ -121,7 +123,7 @@ module PgEventstore
     end
 
     # @return [Object] the result of the passed block
-    def run_around_callbacks(action, *args, **kwargs, &_blk)
+    def run_around_callbacks(action, *args, **kwargs, &)
       result = nil
       stack = [proc { result = yield if block_given? }]
       @callbacks[action][:around]&.reverse_each&.with_index do |callback, index|

data/lib/pg_eventstore/cli/try_to_delete_subscriptions_set.rb

@@ -26,14 +26,14 @@ module PgEventstore
         )
         cmd_name = SubscriptionFeederCommands.command_class('Ping').new.name
         subscriptions_set_commands_queries.find_or_create_by(
-          subscriptions_set_id: subscriptions_set_id, command_name: cmd_name, data: {}
+          subscriptions_set_id:, command_name: cmd_name, data: {}
         )
         # Potentially CommandsHandler can be dead exactly at the same moment we expect it to process "Ping" command.
         # Wait for potential recover plus run interval and plus another second to allow potential processing of
         # "Ping" command. "Ping" command comes in prio, so it is guaranteed it will be processed as a first command.
         sleep RunnerRecoveryStrategies::RestoreConnection::TIME_BETWEEN_RETRIES + CommandsHandler::PULL_INTERVAL + 1
         existing_cmd = subscriptions_set_commands_queries.find_by(
-          subscriptions_set_id: subscriptions_set_id, command_name: cmd_name
+          subscriptions_set_id:, command_name: cmd_name
         )
         if existing_cmd
           # "Ping" command wasn't consumed. Related process must be dead.

data/lib/pg_eventstore/client.rb

@@ -33,7 +33,7 @@ module PgEventstore
             events: event_queries(middlewares(middlewares)),
             transactions: transaction_queries
           )
-        ).call(stream, *events_or_event, options: options)
+        ).call(stream, *events_or_event, options:)
       events_or_event.is_a?(Array) ? result : result.first
     end
 
@@ -47,9 +47,11 @@ module PgEventstore
     #     PgEventstore.client.append_to_stream(...)
     #   end
     #
+    # @param read_only [Boolean] whether transaction is read-only. Running mutation queries within read-only transaction
+    #   will result in exception
     # @return the result of the given block
-    def multiple(&blk)
-      Commands::Multiple.new(Queries.new(transactions: transaction_queries)).call(&blk)
+    def multiple(read_only: false, &)
+      Commands::Multiple.new(Queries.new(transactions: transaction_queries)).call(read_only:, &)
     end
 
     # Read events from the specific stream or from "all" stream.
@@ -138,7 +140,7 @@ module PgEventstore
       cmd_class = stream.all_stream? ? Commands::AllStreamReadGrouped : Commands::RegularStreamReadGrouped
       cmd_class.
         new(Queries.new(partitions: partition_queries, events: event_queries(middlewares(middlewares)))).
-        call(stream, options: options)
+        call(stream, options:)
     end
 
     # Links event from one stream into another stream. You can later access it by providing :resolve_link_tos option
@@ -160,7 +162,7 @@ module PgEventstore
             events: event_queries(middlewares(middlewares)),
             transactions: transaction_queries
           )
-        ).call(stream, *events_or_event, options: options)
+        ).call(stream, *events_or_event, options:)
       events_or_event.is_a?(Array) ? result : result.first
     end
 

data/lib/pg_eventstore/commands/all_stream_read_grouped.rb

@@ -47,10 +47,10 @@ module PgEventstore
       def build_filter_options_for_streams(partition, stream_ids, options)
         stream_ids.map do |stream_id|
           filter = {
-            streams: [{ context: partition.context, stream_name: partition.stream_name, stream_id: stream_id }],
+            streams: [{ context: partition.context, stream_name: partition.stream_name, stream_id: }],
             event_types: [partition.event_type],
           }
-          options.merge(filter: filter, max_count: 1)
+          options.merge(filter:, max_count: 1)
         end
       end
 
@@ -62,7 +62,7 @@ module PgEventstore
           streams: [{ context: partition.context, stream_name: partition.stream_name }],
           event_types: [partition.event_type],
         }
-        options.merge(filter: filter, max_count: 1)
+        options.merge(filter:, max_count: 1)
       end
     end
   end

data/lib/pg_eventstore/commands/append.rb

@@ -50,19 +50,19 @@ module PgEventstore
         in [Integer, Integer]
           unless revision == expected_revision
             raise WrongExpectedRevisionError.new(
-              revision: revision, expected_revision: expected_revision, stream: stream
+              revision:, expected_revision:, stream:
             )
           end
 
         in [Integer, Symbol]
           if revision == Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :stream_exists
             raise WrongExpectedRevisionError.new(
-              revision: revision, expected_revision: expected_revision, stream: stream
+              revision:, expected_revision:, stream:
             )
           end
           if revision > Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :no_stream
             raise WrongExpectedRevisionError.new(
-              revision: revision, expected_revision: expected_revision, stream: stream
+              revision:, expected_revision:, stream:
             )
           end
         end

data/lib/pg_eventstore/commands/event_modifiers/prepare_link_event.rb

@@ -19,9 +19,12 @@ module PgEventstore
         # @return [PgEventstore::Event]
         def call(event, revision)
           Event.new(
-            link_id: event.id, link_partition_id: partition_id(event), type: Event::LINK_TYPE, stream_revision: revision
+            link_global_position: event.global_position,
+            link_partition_id: partition_id(event),
+            type: Event::LINK_TYPE,
+            stream_revision: revision
           ).tap do |e|
-            %i[link_id link_partition_id type stream_revision].each { |attr| e.readonly!(attr) }
+            %i[link_global_position link_partition_id type stream_revision].each { |attr| e.readonly!(attr) }
           end
         end
 

data/lib/pg_eventstore/commands/event_modifiers/prepare_regular_event.rb

@@ -13,7 +13,7 @@ module PgEventstore
           event.class.new(
             id: event.id, data: event.data, metadata: event.metadata, type: event.type, stream_revision: revision
           ).tap do |e|
-            %i[link_id link_partition_id stream_revision].each { |attr| e.readonly!(attr) }
+            %i[link_global_position link_partition_id stream_revision].each { |attr| e.readonly!(attr) }
           end
         end
       end

data/lib/pg_eventstore/commands/link_to.rb

@@ -16,22 +16,22 @@ module PgEventstore
         check_events_presence(events)
         append_cmd = Append.new(queries)
         append_cmd.call(
-          stream, *events, options: options, event_modifier: EventModifiers::PrepareLinkEvent.new(queries.partitions)
+          stream, *events, options:, event_modifier: EventModifiers::PrepareLinkEvent.new(queries.partitions)
         )
       end
 
       private
 
-      # Checks if the given events are persisted events. This is needed to prevent potentially non-existing id valuess
-      # from appearing in #link_id column.
+      # Checks if the given events are persisted events. This is needed to prevent potentially non-existing
+      # global_position values from appearing in #link_global_position column.
       # @param events [Array<PgEventstore::Event>]
       # @return [void]
       def check_events_presence(events)
-        ids_from_db = queries.events.ids_from_db(events)
-        missing_ids = events.map(&:id) - ids_from_db
+        global_positions_from_db = queries.events.global_positions_from_db(events)
+        missing_ids = events.map(&:global_position) - global_positions_from_db
         return if missing_ids.empty?
 
-        missing_event = events.find { |event| event.id == missing_ids.first }
+        missing_event = events.find { |event| event.global_position == missing_ids.first }
         raise NotPersistedEventError, missing_event
       end
     end

data/lib/pg_eventstore/commands/multiple.rb

@@ -4,8 +4,8 @@ module PgEventstore
   module Commands
     # @!visibility private
     class Multiple < AbstractCommand
-      def call(&blk)
-        queries.transactions.transaction(&blk)
+      def call(read_only:, &)
+        queries.transactions.transaction(read_only:, &)
       end
     end
   end

data/lib/pg_eventstore/commands/regular_stream_read_grouped.rb

@@ -22,7 +22,7 @@ module PgEventstore
         )
         options_by_event_type = queries.partitions.partitions(stream_filters, event_types).map do |partition|
           filter = { event_types: [partition.event_type] }
-          options.merge(filter: filter, max_count: 1)
+          options.merge(filter:, max_count: 1)
         end
         queries.events.grouped_events(stream, options_by_event_type, **options.slice(:resolve_link_tos))
       end

data/lib/pg_eventstore/commands/regular_stream_read_paginated.rb

@@ -10,7 +10,7 @@ module PgEventstore
           next_revision = nil
           loop do
             options = options.merge(from_revision: next_revision) if next_revision
-            events = read_cmd.call(stream, options: options)
+            events = read_cmd.call(stream, options:)
             yielder << events if events.any?
             if end_reached?(events, options[:max_count] || QueryBuilders::EventsFiltering::DEFAULT_LIMIT)
               raise StopIteration

data/lib/pg_eventstore/commands/system_stream_read_paginated.rb

@@ -10,7 +10,7 @@ module PgEventstore
           next_position = nil
           loop do
             options = options.merge(from_position: next_position) if next_position
-            events = read_cmd.call(stream, options: options)
+            events = read_cmd.call(stream, options:)
             yielder << events if events.any?
             if end_reached?(events, options[:max_count] || QueryBuilders::EventsFiltering::DEFAULT_LIMIT)
               raise StopIteration

data/lib/pg_eventstore/connection.rb

@@ -8,36 +8,6 @@ require_relative 'pg_connection'
 
 module PgEventstore
   class Connection
-    # Starting from ruby v3.1 ConnectionPool closes connections after forking by default. For ruby v3 we need this patch
-    # to correctly reload the ConnectionPool. Otherwise the same connection will leak into another process which will
-    # result in disaster.
-    # @!visibility private
-    module Ruby30Patch
-      def initialize(**)
-        @current_pid = Process.pid
-        @mutext = Mutex.new
-        super
-      end
-
-      def with(&blk)
-        reload_after_fork
-        super
-      end
-
-      private
-
-      def reload_after_fork
-        return if @current_pid == Process.pid
-
-        @mutext.synchronize do
-          return if @current_pid == Process.pid
-
-          @pool.reload(&:close)
-          @current_pid = Process.pid
-        end
-      end
-    end
-
     # @!attribute uri
     #   @return [String]
     attr_reader :uri
@@ -63,7 +33,7 @@ module PgEventstore
     # A shorthand from ConnectionPool#with.
     # @yieldparam connection [PG::Connection] PostgreSQL connection instance
     # @return [Object] a value of a given block
-    def with(&_blk)
+    def with(&)
       should_retry = true
       @pool.with do |conn|
         yield conn
@@ -107,7 +77,3 @@ module PgEventstore
     end
   end
 end
-
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
-  PgEventstore::Connection.prepend(PgEventstore::Connection::Ruby30Patch)
-end

data/lib/pg_eventstore/errors.rb

@@ -203,7 +203,7 @@ module PgEventstore
 
     # @return [String]
     def user_friendly_message
-      "Event with #id #{event.id.inspect} must be present, but it could not be found."
+      "Event #{event.inspect} is not persisted a persisted event."
     end
   end
 

data/lib/pg_eventstore/event.rb

@@ -30,10 +30,10 @@ module PgEventstore
     # @!attribute metadata
     #   @return [Hash] event's metadata
     attribute(:metadata) { {} }
-    # @!attribute link_id
-    #   @return [String, nil] UUIDv4 of an event the current event points to. If it is not nil, then the current
-    #     event is a link
-    attribute(:link_id)
+    # @!attribute link_global_position
+    #   @return [Integer, nil] global_position of an event the current event points to. If it is not nil, then the
+    #     current event is a link
+    attribute(:link_global_position)
     # @!attribute link_partition_id
     #   @return [Integer, nil] a partition id of an event the link event points to. It is used to load original event
     #     when resolve_link_tos: true option is provided when reading events.
@@ -58,7 +58,7 @@ module PgEventstore
     # Detect whether an event is a link event
     # @return [Boolean]
     def link?
-      !link_id.nil?
+      !link_global_position.nil?
     end
 
     # Detect whether an event is a system event