with_advisory_lock 7.0.2 → 7.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a82d92e5b44f2cf65a9af5ac2d00baacab6d47b3b47be9fc2db82bd5677e4c7
-  data.tar.gz: 4a9b77cd24fad228812b9eff2f65079e6be7b95130a8e8d628d71525045ef902
+  metadata.gz: b1b30155d5acce8e77bf5fa733d0b4f257d34d3ccf4a40a3f2112314a34b83d9
+  data.tar.gz: 6c844c642c330044dd1e05355678fb862a5549ce9173fb794ee1d269cbe0cde9
 SHA512:
-  metadata.gz: 77996aa445351903666828d916b8bd02ad4357496c2240ac847f937f7b3adff7af83993b10d6af8bcdb33825992dc6391cc211f97428c36b2bd102e65e5c26b2
-  data.tar.gz: 94ec70a26f7c336f9dba44a384bc16d9d680d7495e43cb0c9fc22fee2380317f5d5263f36d3998837ca21f3e05424c7fc0fdb37ed75daf441ce534f0b4d67339
+  metadata.gz: bb0d2c8836c60963bc5c6dab3aaf3d7831ee1a2c8e86346970b77bf0de64779e0a5cef6a8965d89c0674a5daf0e892584d64116d9825e0e1bb9983d3e5698910
+  data.tar.gz: cc763d1ff02720ece882a9c9d0973818ac72f8774538c8d91848b4f0f9eac943b125fbecc01e9ca9d24a033977740ac189988e8225b878ad2010ac70a02826d7

data/.github/workflows/ci.yml

@@ -36,16 +36,38 @@ jobs:
           MYSQL_PASSWORD: with_advisory_pass
           MYSQL_DATABASE: with_advisory_lock_test
           MYSQL_ROOT_HOST: '%'
+      mariadb:
+        image: mariadb:12
+        ports:
+          - 3306
+        env:
+          MARIADB_ROOT_PASSWORD: root
+          MARIADB_DATABASE: with_advisory_lock_trilogy_test
+          MARIADB_USER: with_advisory
+          MARIADB_PASSWORD: with_advisory_pass
+          MARIADB_ROOT_HOST: '%'
+        options: >-
+          --health-cmd "healthcheck.sh --su-mysql --connect --innodb_initialized"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
     strategy:
       fail-fast: false
       matrix:
         ruby:
           - '3.3'
           - '3.4'
+          - '4.0'
           - 'truffleruby'
         rails:
           - 7.2
           - "8.0"
+          - "8.1"
+          - "edge"
+        exclude:
+          # TruffleRuby doesn't support Rails edge yet
+          - ruby: 'truffleruby'
+            rails: "edge"
     env:
       ACTIVERECORD_VERSION: ${{ matrix.rails }}
       RAILS_ENV: test
@@ -60,10 +82,14 @@ jobs:
           bundler-cache: true
           rubygems: latest
 
+
       - name: Setup test databases
+        timeout-minutes: 5
         env:
           DATABASE_URL_PG: postgres://with_advisory:with_advisory_pass@localhost:${{ job.services.postgres.ports[5432] }}/with_advisory_lock_test
           DATABASE_URL_MYSQL: mysql2://with_advisory:with_advisory_pass@127.0.0.1:${{ job.services.mysql.ports[3306] }}/with_advisory_lock_test
+          # Trilogy doesn't support TruffleRuby
+          DATABASE_URL_TRILOGY: ${{ matrix.ruby != 'truffleruby' && format('trilogy://with_advisory:with_advisory_pass@127.0.0.1:{0}/with_advisory_lock_trilogy_test', job.services.mariadb.ports[3306]) || '' }}
         run: |
           cd test/dummy
           bundle exec rake db:test:prepare
@@ -72,5 +98,7 @@ jobs:
         env:
           DATABASE_URL_PG: postgres://with_advisory:with_advisory_pass@localhost:${{ job.services.postgres.ports[5432] }}/with_advisory_lock_test
           DATABASE_URL_MYSQL: mysql2://with_advisory:with_advisory_pass@127.0.0.1:${{ job.services.mysql.ports[3306] }}/with_advisory_lock_test
+          # Trilogy doesn't support TruffleRuby
+          DATABASE_URL_TRILOGY: ${{ matrix.ruby != 'truffleruby' && format('trilogy://with_advisory:with_advisory_pass@127.0.0.1:{0}/with_advisory_lock_trilogy_test', job.services.mariadb.ports[3306]) || '' }}
           WITH_ADVISORY_LOCK_PREFIX: ${{ github.run_id }}
         run: bin/rails test

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"7.0.2"}
+{".":"7.5.0"}

data/.tool-versions

@@ -1 +1 @@
-ruby 3.4.6
+ruby 4.0.1

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## Changelog
 
+## [7.5.0](https://github.com/ClosureTree/with_advisory_lock/compare/with_advisory_lock/v7.0.2...with_advisory_lock/v7.5.0) (2026-01-21)
+
+
+### Features
+
+* add blocking advisory locks with deadlock detection for PostgreSQL ([#140](https://github.com/ClosureTree/with_advisory_lock/issues/140)) ([f7f9aff](https://github.com/ClosureTree/with_advisory_lock/commit/f7f9aff545381107a632a25511e8fc08654a28b6))
+* Add Trilogy adapter support with MariaDB 12.0+ ([#134](https://github.com/ClosureTree/with_advisory_lock/issues/134)) ([b7764cd](https://github.com/ClosureTree/with_advisory_lock/commit/b7764cd9432b25b37c6da9160f980da29a5cdaa6))
+* bump version for new features ([9a8c4be](https://github.com/ClosureTree/with_advisory_lock/commit/9a8c4be5cf51147e60df7e5733360e3dfd8d009e))
+
+
+### Bug Fixes
+
+* Use monotonic clock so postgres timeouts are unaffected by system clock changes ([#141](https://github.com/ClosureTree/with_advisory_lock/issues/141)) ([929e010](https://github.com/ClosureTree/with_advisory_lock/commit/929e0103e5ffc4c66f9088942441f764de1bc650))
+
 ## [7.0.2](https://github.com/ClosureTree/with_advisory_lock/compare/with_advisory_lock/v7.0.1...with_advisory_lock/v7.0.2) (2025-09-20)
 
 

data/Gemfile

@@ -11,12 +11,17 @@ gem 'benchmark'
 gem 'logger'
 gem 'ostruct'
 
-activerecord_version = ENV.fetch('ACTIVERECORD_VERSION', '7.2')
-
-gem 'activerecord', "~> #{activerecord_version}.0"
+activerecord_version = ENV.fetch('ACTIVERECORD_VERSION', '8.1')
+
+if activerecord_version == 'edge'
+  gem 'activerecord', github: 'rails/rails', branch: 'main'
+  gem 'railties', github: 'rails/rails', branch: 'main'
+else
+  gem 'activerecord', "~> #{activerecord_version}.0"
+  gem 'railties'
+end
 
 gem 'dotenv'
-gem 'railties'
 
 platforms :ruby do
   gem 'mysql2'

data/README.md

@@ -48,7 +48,7 @@ will be yielded to. If the lock is currently being held, the block will not be
 called.
 
 > **Note**
-> 
+>
 > If a non-nil value is provided for `timeout_seconds`, the block will
 *not* be invoked if the lock cannot be acquired within that time-frame. In this case, `with_advisory_lock` will return `false`, while `with_advisory_lock!` will raise a `WithAdvisoryLock::FailedToAcquireLock` error.
 
@@ -72,6 +72,32 @@ to `true`.
 Note: transaction-level locks will not be reflected by `.current_advisory_lock`
 when the block has returned.
 
+### Blocking locks (PostgreSQL only)
+
+By default, PostgreSQL advisory locks use a polling strategy with Ruby-level
+retries and sleeps. Setting `blocking: true` switches to database-level blocking
+locks that enable PostgreSQL's deadlock detection:
+
+```ruby
+User.with_advisory_lock("lock_name", blocking: true, transaction: true) do
+  # PostgreSQL will detect circular lock waits and raise an error
+  # instead of sleeping forever
+end
+```
+
+**Benefits:**
+- **Deadlock detection**: PostgreSQL detects circular waits and raises `PG::TRDeadlockDetected` after ~1 second (configurable via `deadlock_timeout`)
+- **No polling overhead**: The database handles the wait queue instead of Ruby sleep/retry loops
+- **Clean failure**: Returns `false` on deadlock instead of infinite retries
+
+**When to use:**
+- When acquiring multiple locks in your application (risk of deadlock)
+- When you need PostgreSQL to detect and break circular lock dependencies
+- When you want to avoid Ruby-level polling overhead
+
+**Note:** MySQL ignores this option since `GET_LOCK` already provides native
+timeout and deadlock detection via the MDL subsystem.
+
 ### Return values
 
 The return value of `with_advisory_lock_result` is a `WithAdvisoryLock::Result`
@@ -84,7 +110,7 @@ block, if the lock was able to be acquired and the block yielded, or `false`, if
 you provided a timeout_seconds value and the lock was not able to be acquired in
 time.
 
-`with_advisory_lock!` is similar to `with_advisory_lock`, but raises a `WithAdvisoryLock::FailedToAcquireLock` error if the lock was not able to be acquired in time. 
+`with_advisory_lock!` is similar to `with_advisory_lock`, but raises a `WithAdvisoryLock::FailedToAcquireLock` error if the lock was not able to be acquired in time.
 
 ### Testing for the current lock status
 
@@ -147,6 +173,16 @@ concurrent access to **any instance of a model**. Their coarseness means they
 aren't going to be commonly applicable, and they can be a source of
 [deadlocks](http://en.wikipedia.org/wiki/Deadlock).
 
+## Running Tests
+
+To setup the project and run the whole test suite:
+
+1. Have Docker running
+2. `echo -e "DB_USER=with_advisory\nDB_PASSWORD=with_advisory_pass\nDB_NAME=with_advisory_lock_test\nDATABASE_URL_PG=postgres://\$DB_USER:\$DB_PASSWORD@localhost:5433/\$DB_NAME\nDATABASE_URL_MYSQL=mysql2://\$DB_USER:\$DB_PASSWORD@127.0.0.1:3366/\$DB_NAME" > .env`
+3. `make`
+
+Alternatively to `make`, run `bin/rails test` to skip database and dependency setup.
+
 ## FAQ
 
 ### Transactions and Advisory Locks

data/bin/setup_test_db

@@ -3,6 +3,8 @@
 
 require 'bundler/setup'
 require 'active_record'
+require 'dotenv'
+Dotenv.load
 
 # Setup PostgreSQL database
 puts 'Setting up PostgreSQL test database...'
@@ -10,9 +12,9 @@ ActiveRecord::Base.establish_connection(
   adapter: 'postgresql',
   host: 'localhost',
   port: 5433,
-  database: 'with_advisory_lock_test',
-  username: 'with_advisory',
-  password: 'with_advisory_pass'
+  database: ENV['DB_NAME'],
+  username: ENV['DB_USER'],
+  password: ENV['DB_PASSWORD']
 )
 
 ActiveRecord::Schema.define(version: 1) do
@@ -36,9 +38,9 @@ ActiveRecord::Base.establish_connection(
   adapter: 'mysql2',
   host: '127.0.0.1',
   port: 3366,
-  database: 'with_advisory_lock_test',
-  username: 'with_advisory',
-  password: 'with_advisory_pass'
+  database: ENV['DB_NAME'],
+  username: ENV['DB_USER'],
+  password: ENV['DB_PASSWORD']
 )
 
 ActiveRecord::Schema.define(version: 1) do

data/docker-compose.yml

@@ -2,18 +2,28 @@ services:
   pg:
     image: postgres:17-alpine
     environment:
-      POSTGRES_USER: with_advisory
-      POSTGRES_PASSWORD: with_advisory_pass
+      POSTGRES_USER: test
+      POSTGRES_PASSWORD: test
       POSTGRES_DB: with_advisory_lock_test
     ports:
       - "5433:5432"
   mysql:
     image: mysql:8
     environment:
-      MYSQL_USER: with_advisory
-      MYSQL_PASSWORD: with_advisory_pass
+      MYSQL_USER: test
+      MYSQL_PASSWORD: test
       MYSQL_DATABASE: with_advisory_lock_test
       MYSQL_RANDOM_ROOT_PASSWORD: "yes"
       MYSQL_ROOT_HOST: '%'
     ports:
       - "3366:3306"
+  mariadb:
+    image: mariadb:12
+    environment:
+      MARIADB_USER: test
+      MARIADB_PASSWORD: test
+      MARIADB_DATABASE: with_advisory_lock_test_trilogy
+      MARIADB_RANDOM_ROOT_PASSWORD: "yes"
+      MARIADB_ROOT_HOST: '%'
+    ports:
+      - "3368:3306"

data/lib/with_advisory_lock/core_advisory.rb

@@ -15,7 +15,7 @@ module WithAdvisoryLock
 
     def with_advisory_lock_if_needed(lock_name, options = {}, &block)
       options = { timeout_seconds: options } unless options.respond_to?(:fetch)
-      options.assert_valid_keys :timeout_seconds, :shared, :transaction, :disable_query_cache
+      options.assert_valid_keys :timeout_seconds, :shared, :transaction, :disable_query_cache, :blocking
 
       # Validate transaction-level locks are used within a transaction
       if options.fetch(:transaction, false) && !transaction_open?
@@ -56,12 +56,14 @@ module WithAdvisoryLock
       timeout_seconds = options.fetch(:timeout_seconds, nil)
       shared = options.fetch(:shared, false)
       transaction = options.fetch(:transaction, false)
+      blocking = options.fetch(:blocking, false)
 
       lock_keys = lock_keys_for(lock_name)
 
       # MySQL supports database-level timeout in GET_LOCK, skip Ruby-level polling
-      if supports_database_timeout? || timeout_seconds&.zero?
-        yield_with_lock(lock_keys, lock_name, lock_str, lock_stack_item, shared, transaction, timeout_seconds, &)
+      # PostgreSQL blocking locks also skip polling and let the database handle waiting
+      if supports_database_timeout? || timeout_seconds&.zero? || blocking
+        yield_with_lock(lock_keys, lock_name, lock_str, lock_stack_item, shared, transaction, timeout_seconds, blocking, &)
       else
         yield_with_lock_and_timeout(lock_keys, lock_name, lock_str, lock_stack_item, shared, transaction,
                                     timeout_seconds, &)
@@ -70,9 +72,9 @@ module WithAdvisoryLock
 
     def yield_with_lock_and_timeout(lock_keys, lock_name, lock_str, lock_stack_item, shared, transaction,
                                     timeout_seconds, &)
-      give_up_at = timeout_seconds ? Time.now + timeout_seconds : nil
-      while give_up_at.nil? || Time.now < give_up_at
-        r = yield_with_lock(lock_keys, lock_name, lock_str, lock_stack_item, shared, transaction, 0, &)
+      give_up_at = timeout_seconds ? Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout_seconds : nil
+      while give_up_at.nil? || Process.clock_gettime(Process::CLOCK_MONOTONIC) < give_up_at
+        r = yield_with_lock(lock_keys, lock_name, lock_str, lock_stack_item, shared, transaction, 0, false, &)
         return r if r.lock_was_acquired?
 
         # Randomizing sleep time may help reduce contention.
@@ -81,9 +83,9 @@ module WithAdvisoryLock
       Result.new(lock_was_acquired: false)
     end
 
-    def yield_with_lock(lock_keys, lock_name, _lock_str, lock_stack_item, shared, transaction, timeout_seconds = nil)
+    def yield_with_lock(lock_keys, lock_name, _lock_str, lock_stack_item, shared, transaction, timeout_seconds = nil, blocking = false)
       if try_advisory_lock(lock_keys, lock_name: lock_name, shared: shared, transaction: transaction,
-                                      timeout_seconds: timeout_seconds)
+                                      timeout_seconds: timeout_seconds, blocking: blocking)
         begin
           advisory_lock_stack.push(lock_stack_item)
           result = block_given? ? yield : nil

data/lib/with_advisory_lock/mysql_advisory.rb

@@ -8,16 +8,23 @@ module WithAdvisoryLock
 
     LOCK_PREFIX_ENV = 'WITH_ADVISORY_LOCK_PREFIX'
 
-    def try_advisory_lock(lock_keys, lock_name:, shared:, transaction:, timeout_seconds: nil)
+    def try_advisory_lock(lock_keys, lock_name:, shared:, transaction:, timeout_seconds: nil, blocking: false)
       raise ArgumentError, 'shared locks are not supported on MySQL' if shared
       raise ArgumentError, 'transaction level locks are not supported on MySQL' if transaction
 
-      # MySQL GET_LOCK supports native timeout:
-      # - timeout_seconds = nil: wait indefinitely (-1)
+      # Note: blocking parameter is accepted for API compatibility but ignored for MySQL
+      # MySQL's GET_LOCK already provides native timeout support, making the blocking
+      # parameter redundant. MySQL doesn't have separate try/blocking functions like PostgreSQL.
+
+      # MySQL/MariaDB GET_LOCK supports native timeout:
+      # - timeout_seconds = nil: wait indefinitely
       # - timeout_seconds = 0: try once, no wait (0)
       # - timeout_seconds > 0: wait up to timeout_seconds
+      #
+      # Note: MySQL accepts -1 for infinite wait, but MariaDB does not.
+      # Using a large value (1 year) for cross-compatibility.
       mysql_timeout = case timeout_seconds
-                      when nil then -1
+                      when nil then 31_536_000 # 1 year in seconds
                       when 0 then 0
                       else timeout_seconds.to_i
                       end

data/lib/with_advisory_lock/postgresql_advisory.rb

@@ -10,11 +10,33 @@ module WithAdvisoryLock
     LOCK_RESULT_VALUES = ['t', true].freeze
     ERROR_MESSAGE_REGEX = / ERROR: +current transaction is aborted,/
 
-    def try_advisory_lock(lock_keys, lock_name:, shared:, transaction:, timeout_seconds: nil)
+    def try_advisory_lock(lock_keys, lock_name:, shared:, transaction:, timeout_seconds: nil, blocking: false)
       # timeout_seconds is accepted for compatibility but ignored - PostgreSQL doesn't support
       # native timeouts with pg_try_advisory_lock, requiring Ruby-level polling instead
-      function = advisory_try_lock_function(transaction, shared)
-      execute_advisory(function, lock_keys, lock_name)
+      function = if blocking
+                   advisory_lock_function(transaction, shared)
+                 else
+                   advisory_try_lock_function(transaction, shared)
+                 end
+      execute_advisory(function, lock_keys, lock_name, blocking: blocking)
+    rescue ActiveRecord::Deadlocked
+      # Rails 8.2+ raises ActiveRecord::Deadlocked directly for PostgreSQL deadlocks
+      # When using blocking locks, treat deadlocks as lock acquisition failure
+      return false if blocking
+
+      raise
+    rescue ActiveRecord::StatementInvalid => e
+      # PostgreSQL deadlock detection raises PG::TRDeadlockDetected (SQLSTATE 40P01)
+      # When using blocking locks, treat deadlocks as lock acquisition failure.
+      # Rails 8.2+ may also retry after deadlock and get "current transaction is aborted"
+      # when the transaction was rolled back by PostgreSQL's deadlock detection.
+      if blocking && (e.cause.is_a?(PG::TRDeadlockDetected) ||
+                      e.message.include?('deadlock detected') ||
+                      e.message =~ ERROR_MESSAGE_REGEX)
+        false
+      else
+        raise
+      end
     end
 
     def release_advisory_lock(*args)
@@ -88,6 +110,15 @@ module WithAdvisoryLock
       ].compact.join
     end
 
+    def advisory_lock_function(transaction_scope, shared)
+      [
+        'pg_advisory',
+        transaction_scope ? '_xact' : nil,
+        '_lock',
+        shared ? '_shared' : nil
+      ].compact.join
+    end
+
     def advisory_unlock_function(shared)
       [
         'pg_advisory_unlock',
@@ -95,9 +126,26 @@ module WithAdvisoryLock
       ].compact.join
     end
 
-    def execute_advisory(function, lock_keys, lock_name)
-      result = query_value(prepare_sql(function, lock_keys, lock_name))
-      LOCK_RESULT_VALUES.include?(result)
+    def execute_advisory(function, lock_keys, lock_name, blocking: false)
+      sql = prepare_sql(function, lock_keys, lock_name)
+      if blocking
+        # Blocking locks return void - if the query executes successfully, the lock was acquired.
+        # Rails 8.2+ uses lazy transaction materialization. We must use materialize_transactions: true
+        # to ensure the transaction is started on the database before acquiring the lock,
+        # otherwise the lock won't actually block other connections.
+        if respond_to?(:internal_exec_query, true)
+          # Rails < 8.2
+          query_value(sql)
+        else
+          # Rails 8.2+ - use query_all with materialize_transactions: true
+          send(:query_all, sql, 'AdvisoryLock', materialize_transactions: true)
+        end
+        true
+      else
+        # Non-blocking try locks return boolean
+        result = query_value(sql)
+        LOCK_RESULT_VALUES.include?(result)
+      end
     end
 
     def prepare_sql(function, lock_keys, lock_name)

data/lib/with_advisory_lock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WithAdvisoryLock
-  VERSION = Gem::Version.new('7.0.2')
+  VERSION = Gem::Version.new('7.5.0')
 end

data/test/dummy/app/models/trilogy_label.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TrilogyLabel < TrilogyRecord
+  self.table_name = 'trilogy_labels'
+end

data/test/dummy/app/models/trilogy_record.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class TrilogyRecord < ActiveRecord::Base
+  self.abstract_class = true
+  establish_connection :trilogy
+end

data/test/dummy/app/models/trilogy_tag.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class TrilogyTag < TrilogyRecord
+  self.table_name = 'trilogy_tags'
+
+  after_save do
+    TrilogyTagAudit.create(tag_name: name)
+    TrilogyLabel.create(name: name)
+  end
+end

data/test/dummy/app/models/trilogy_tag_audit.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TrilogyTagAudit < TrilogyRecord
+  self.table_name = 'trilogy_tag_audits'
+end

data/test/dummy/config/application.rb

@@ -14,6 +14,17 @@ module TestSystemApp
   class Application < Rails::Application
     config.load_defaults [Rails::VERSION::MAJOR, Rails::VERSION::MINOR].join('.')
     config.eager_load = true
+
+    # Ignore trilogy models when DATABASE_URL_TRILOGY is not set (e.g., TruffleRuby)
+    unless ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty?
+      config.autoload_lib(ignore: %w[])
+      initializer 'ignore_trilogy_models', before: :set_autoload_paths do |app|
+        trilogy_models = %w[trilogy_record trilogy_tag trilogy_tag_audit trilogy_label]
+        trilogy_models.each do |model|
+          Rails.autoloaders.main.ignore(Rails.root.join('app', 'models', "#{model}.rb"))
+        end
+      end
+    end
     config.serve_static_files = false
     config.public_file_server.enabled = false
     config.public_file_server.headers = { 'Cache-Control' => 'public, max-age=3600' }

data/test/dummy/config/database.yml

@@ -11,3 +11,11 @@ test:
     url: "<%= ENV['DATABASE_URL_MYSQL'] %>"
     properties:
       allowPublicKeyRetrieval: true
+<% if ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty? %>
+  trilogy:
+    <<: *default
+    url: "<%= ENV['DATABASE_URL_TRILOGY'] %>"
+    adapter: trilogy
+    properties:
+      allowPublicKeyRetrieval: true
+<% end %>

data/test/dummy/db/trilogy_schema.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table 'trilogy_tags', force: true do |t|
+    t.string 'name'
+  end
+
+  create_table 'trilogy_tag_audits', id: false, force: true do |t|
+    t.string 'tag_name'
+  end
+
+  create_table 'trilogy_labels', id: false, force: true do |t|
+    t.string 'name'
+  end
+end

data/test/dummy/lib/tasks/db.rake

@@ -4,37 +4,29 @@ namespace :db do
   namespace :test do
     desc 'Load schema for all databases'
     task prepare: :environment do
-      # Load schema for primary database
+      # Setup PostgreSQL database
       ActiveRecord::Base.establish_connection(:primary)
-      ActiveRecord::Schema.define(version: 1) do
-        create_table 'tags', force: true do |t|
-          t.string 'name'
-        end
+      load Rails.root.join('db', 'schema.rb')
+      puts 'PostgreSQL database schema loaded'
 
-        create_table 'tag_audits', id: false, force: true do |t|
-          t.string 'tag_name'
-        end
-
-        create_table 'labels', id: false, force: true do |t|
-          t.string 'name'
-        end
-      end
-
-      # Load schema for secondary database
+      # Setup MySQL database
       ActiveRecord::Base.establish_connection(:secondary)
-      ActiveRecord::Schema.define(version: 1) do
-        create_table 'mysql_tags', force: true do |t|
-          t.string 'name'
-        end
+      load Rails.root.join('db', 'secondary_schema.rb')
+      puts 'MySQL database schema loaded'
 
-        create_table 'mysql_tag_audits', id: false, force: true do |t|
-          t.string 'tag_name'
-        end
-
-        create_table 'mysql_labels', id: false, force: true do |t|
-          t.string 'name'
-        end
+      # Setup Trilogy database (MariaDB) - optional, not supported on TruffleRuby
+      if ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty?
+        ActiveRecord::Base.establish_connection(:trilogy)
+        load Rails.root.join('db', 'trilogy_schema.rb')
+        puts 'Trilogy database schema loaded'
+      else
+        puts 'Skipping Trilogy database (DATABASE_URL_TRILOGY not set)'
       end
+
+      puts 'All test databases prepared successfully'
+    rescue StandardError => e
+      puts "Error preparing test databases: #{e.message}"
+      raise e
     end
   end
 end

data/test/sanity_check_test.rb

@@ -43,7 +43,7 @@ class SanityCheckTest < GemTestCase
     assert_equal 'Mysql2', MysqlLabel.connection.adapter_name
   end
 
-  test 'can write to both databases in same test' do
+  test 'can write to PostgreSQL and MySQL databases in same test' do
     # Create records in both databases
     pg_tag = Tag.create!(name: 'test-pg')
     mysql_tag = MysqlTag.create!(name: 'test-mysql')
@@ -61,3 +61,50 @@ class SanityCheckTest < GemTestCase
     mysql_tag.destroy
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogySanityCheckTest < GemTestCase
+    test 'Trilogy database is isolated from PostgreSQL and MySQL' do
+      # Create tags in all databases
+      pg_tag = Tag.create!(name: 'pg-isolation-test')
+      mysql_tag = MysqlTag.create!(name: 'mysql-isolation-test')
+      trilogy_tag = TrilogyTag.create!(name: 'trilogy-isolation-test')
+
+      # Verify Trilogy tag exists only in Trilogy
+      assert TrilogyTag.exists?(name: 'trilogy-isolation-test')
+      assert_not Tag.exists?(name: 'trilogy-isolation-test')
+      assert_not MysqlTag.exists?(name: 'trilogy-isolation-test')
+
+      # Verify PostgreSQL tag doesn't exist in Trilogy
+      assert_not TrilogyTag.exists?(name: 'pg-isolation-test')
+
+      # Verify MySQL tag doesn't exist in Trilogy
+      assert_not TrilogyTag.exists?(name: 'mysql-isolation-test')
+
+      # Clean up
+      pg_tag.destroy
+      mysql_tag.destroy
+      trilogy_tag.destroy
+    end
+
+    test 'Trilogy models use Trilogy adapter' do
+      assert_equal 'Trilogy', TrilogyTag.connection.adapter_name
+      assert_equal 'Trilogy', TrilogyTagAudit.connection.adapter_name
+      assert_equal 'Trilogy', TrilogyLabel.connection.adapter_name
+    end
+
+    test 'can write to all three databases in same test' do
+      pg_tag = Tag.create!(name: 'test-pg')
+      mysql_tag = MysqlTag.create!(name: 'test-mysql')
+      trilogy_tag = TrilogyTag.create!(name: 'test-trilogy')
+
+      assert pg_tag.persisted?
+      assert mysql_tag.persisted?
+      assert trilogy_tag.persisted?
+
+      pg_tag.destroy
+      mysql_tag.destroy
+      trilogy_tag.destroy
+    end
+  end
+end

data/test/test_helper.rb

@@ -19,10 +19,19 @@ class GemTestCase < ActiveSupport::TestCase
   parallelize(workers: 1)
 
   def self.startup
-    # Validate environment variables when tests actually start running
+    # Validate required environment variables
     %w[DATABASE_URL_PG DATABASE_URL_MYSQL].each do |var|
       abort "Missing required environment variable: #{var}" if ENV[var].nil? || ENV[var].empty?
     end
+
+    # Trilogy is optional (not supported on TruffleRuby)
+    if ENV['DATABASE_URL_TRILOGY'].nil? || ENV['DATABASE_URL_TRILOGY'].empty?
+      puts 'DATABASE_URL_TRILOGY not set, skipping Trilogy tests'
+    end
+  end
+
+  def self.trilogy_available?
+    ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty?
   end
 
   # Override in test classes to clean only the tables you need

data/test/with_advisory_lock/blocking_test.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# Universal blocking tests - work on all adapters
+module BlockingTestCases
+  extend ActiveSupport::Concern
+
+  included do
+    setup do
+      @lock_name = 'test_blocking_lock'
+    end
+
+    test 'blocking lock acquires lock successfully' do
+      result = model_class.with_advisory_lock(@lock_name, blocking: true) do
+        'success'
+      end
+      assert_equal('success', result)
+    end
+  end
+end
+
+class PostgreSQLBlockingTest < GemTestCase
+  include BlockingTestCases
+
+  def model_class
+    Tag
+  end
+
+  def setup
+    super
+    Tag.delete_all
+  end
+
+  test 'blocking lock waits for lock to be released' do
+    lock_acquired = false
+    thread1_finished = false
+
+    thread1 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          Tag.with_advisory_lock(@lock_name, blocking: true, transaction: true) do
+            lock_acquired = true
+            sleep(0.5)
+            thread1_finished = true
+          end
+        end
+      end
+    end
+
+    sleep(0.1) until lock_acquired
+
+    thread2_result = nil
+    thread2 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          thread2_result = Tag.with_advisory_lock(@lock_name, blocking: true, transaction: true) do
+            'thread2_success'
+          end
+        end
+      end
+    end
+
+    thread1.join
+    thread2.join
+
+    assert(thread1_finished, 'Thread 1 should have finished')
+    assert_equal('thread2_success', thread2_result, 'Thread 2 should have acquired lock after thread 1 released it')
+  end
+
+  test 'blocking lock can be used with shared locks' do
+    thread1_result = nil
+    thread2_result = nil
+
+    thread1 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          thread1_result = Tag.with_advisory_lock(@lock_name, blocking: true, shared: true, transaction: true) do
+            'shared1'
+          end
+        end
+      end
+    end
+
+    thread2 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          thread2_result = Tag.with_advisory_lock(@lock_name, blocking: true, shared: true, transaction: true) do
+            'shared2'
+          end
+        end
+      end
+    end
+
+    thread1.join
+    thread2.join
+
+    assert_equal('shared1', thread1_result)
+    assert_equal('shared2', thread2_result)
+  end
+end
+
+class MySQLBlockingTest < GemTestCase
+  include BlockingTestCases
+
+  def model_class
+    MysqlTag
+  end
+
+  def setup
+    super
+    MysqlTag.delete_all
+  end
+end
+
+if GemTestCase.trilogy_available?
+  class TrilogyBlockingTest < GemTestCase
+    include BlockingTestCases
+
+    def model_class
+      TrilogyTag
+    end
+
+    def setup
+      super
+      TrilogyTag.delete_all
+    end
+  end
+end
+
+# Deadlock test requires non-transactional mode to work properly
+class PostgreSQLDeadlockTest < GemTestCase
+  self.use_transactional_tests = false
+
+  def setup
+    super
+    @lock_name = 'test_blocking_lock'
+    Tag.delete_all
+  end
+
+  test 'blocking lock detects deadlocks and returns false' do
+    deadlock_detected = false
+    thread1_started = Concurrent::AtomicBoolean.new(false)
+    thread2_started = Concurrent::AtomicBoolean.new(false)
+
+    thread1 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          Tag.with_advisory_lock('lock_a', blocking: true, transaction: true) do
+            thread1_started.make_true
+            sleep(0.1) until thread2_started.true?
+
+            result = Tag.with_advisory_lock('lock_b', blocking: true, transaction: true) do
+              'should_not_reach'
+            end
+            deadlock_detected = true if result == false
+          end
+        end
+      rescue ActiveRecord::StatementInvalid => e
+        deadlock_detected = true if e.message.downcase.include?('deadlock')
+      end
+    end
+
+    thread2 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          Tag.with_advisory_lock('lock_b', blocking: true, transaction: true) do
+            thread2_started.make_true
+            sleep(0.1) until thread1_started.true?
+
+            result = Tag.with_advisory_lock('lock_a', blocking: true, transaction: true) do
+              'should_not_reach'
+            end
+            deadlock_detected = true if result == false
+          end
+        end
+      rescue ActiveRecord::StatementInvalid => e
+        deadlock_detected = true if e.message.downcase.include?('deadlock')
+      end
+    end
+
+    joined1 = thread1.join(10)
+    joined2 = thread2.join(10)
+
+    unless joined1 && joined2
+      thread1.kill if thread1.alive?
+      thread2.kill if thread2.alive?
+      flunk 'Deadlock detection timed out - threads did not complete within 10 seconds'
+    end
+
+    assert(deadlock_detected, 'Deadlock should have been detected by PostgreSQL')
+  end
+end

data/test/with_advisory_lock/concern_test.rb

@@ -40,6 +40,16 @@ class MySQLConcernTest < GemTestCase
   end
 end
 
+if GemTestCase.trilogy_available?
+  class TrilogyConcernTest < GemTestCase
+    include ConcernTestCases
+
+    def model_class
+      TrilogyTag
+    end
+  end
+end
+
 # This test is adapter-agnostic, so we only need to test it once
 class ActiveRecordQueryCacheTest < GemTestCase
   self.use_transactional_tests = false

data/test/with_advisory_lock/lock_test.rb

@@ -200,13 +200,14 @@ class MySQLLockTest < GemTestCase
 
     begin
       # Attempt to acquire with a short timeout - should fail quickly
-      start_time = Time.now
-      result = model_class.with_advisory_lock(lock_name, timeout_seconds: 1) { 'success' }
-      elapsed = Time.now - start_time
+      elapsed = Benchmark.realtime do
+        result = model_class.with_advisory_lock(lock_name, timeout_seconds: 1) { 'success' }
+
+        # Should return false and complete within reasonable time (< 3 seconds)
+        # If it were using Ruby polling, it would take longer
+        assert_not result
+      end
 
-      # Should return false and complete within reasonable time (< 3 seconds)
-      # If it were using Ruby polling, it would take longer
-      assert_not result
       assert elapsed < 3.0, "Expected quick timeout, but took #{elapsed} seconds"
     ensure
       other_conn.query_value("SELECT RELEASE_LOCK(#{other_conn.quote(lock_keys.first)})")
@@ -214,3 +215,49 @@ class MySQLLockTest < GemTestCase
     end
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogyLockTest < GemTestCase
+    include LockTestCases
+
+    def model_class
+      TrilogyTag
+    end
+
+    def setup
+      super
+      TrilogyTag.delete_all
+    end
+
+    test 'uses database timeout for Trilogy' do
+      assert model_class.connection.supports_database_timeout?
+    end
+
+    test 'trilogy uses native timeout instead of polling' do
+      # This test verifies that Trilogy bypasses Ruby-level polling
+      # when timeout is specified, relying on GET_LOCK's native timeout
+      lock_name = 'trilogy_timeout_test'
+
+      # Hold a lock in another connection - need to use the same prefixed name as the gem
+      other_conn = model_class.connection_pool.checkout
+      lock_keys = other_conn.lock_keys_for(lock_name)
+      other_conn.query_value("SELECT GET_LOCK(#{other_conn.quote(lock_keys.first)}, 0)")
+
+      begin
+        # Attempt to acquire with a short timeout - should fail quickly
+        elapsed = Benchmark.realtime do
+          result = model_class.with_advisory_lock(lock_name, timeout_seconds: 1) { 'success' }
+
+          # Should return false and complete within reasonable time (< 3 seconds)
+          # If it were using Ruby polling, it would take longer
+          assert_not result
+        end
+
+        assert elapsed < 3.0, "Expected quick timeout, but took #{elapsed} seconds"
+      ensure
+        other_conn.query_value("SELECT RELEASE_LOCK(#{other_conn.quote(lock_keys.first)})")
+        model_class.connection_pool.checkin(other_conn)
+      end
+    end
+  end
+end

data/test/with_advisory_lock/multi_adapter_test.rb

@@ -6,12 +6,42 @@ class MultiAdapterIsolationTest < GemTestCase
   test 'postgresql and mysql adapters do not overlap' do
     lock_name = 'multi-adapter-lock'
 
+    # PostgreSQL lock doesn't block MySQL
     Tag.with_advisory_lock(lock_name) do
       assert MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
     end
 
+    # MySQL lock doesn't block PostgreSQL
     MysqlTag.with_advisory_lock(lock_name) do
       assert Tag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
     end
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogyMultiAdapterIsolationTest < GemTestCase
+    test 'trilogy adapter does not overlap with postgresql or mysql' do
+      lock_name = 'multi-adapter-lock'
+
+      # PostgreSQL lock doesn't block Trilogy
+      Tag.with_advisory_lock(lock_name) do
+        assert TrilogyTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+      end
+
+      # Trilogy lock doesn't block PostgreSQL
+      TrilogyTag.with_advisory_lock(lock_name) do
+        assert Tag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+      end
+
+      # MySQL lock doesn't block Trilogy
+      MysqlTag.with_advisory_lock(lock_name) do
+        assert TrilogyTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+      end
+
+      # Trilogy lock doesn't block MySQL
+      TrilogyTag.with_advisory_lock(lock_name) do
+        assert MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+      end
+    end
+  end
+end

data/test/with_advisory_lock/parallelism_test.rb

@@ -99,3 +99,13 @@ class MySQLParallelismTest < GemTestCase
     MysqlTag
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogyParallelismTest < GemTestCase
+    include ParallelismTestCases
+
+    def model_class
+      TrilogyTag
+    end
+  end
+end

data/test/with_advisory_lock/shared_test.rb

@@ -97,9 +97,6 @@ class PostgreSQLSharedLocksTest < GemTestCase
     two.cleanup!
   end
 
-  test 'allows shared lock to be upgraded to an exclusive lock' do
-    skip 'PostgreSQL lock visibility issue - locks acquired via advisory lock methods not showing in pg_locks'
-  end
 end
 
 class MySQLSharedLocksTest < GemTestCase
@@ -127,3 +124,31 @@ class MySQLSharedLocksTest < GemTestCase
     assert_match(/shared locks are not supported/, exception.message)
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogySharedLocksTest < GemTestCase
+    self.use_transactional_tests = false
+
+    test 'does not allow two exclusive locks' do
+      one = SharedTestWorker.new(TrilogyTag, false)
+      assert_predicate(one, :locked?)
+
+      two = SharedTestWorker.new(TrilogyTag, false)
+      refute(two.locked?)
+
+      one.cleanup!
+      two.cleanup!
+    end
+
+    test 'raises an error when attempting to use a shared lock' do
+      one = SharedTestWorker.new(TrilogyTag, true)
+      assert_equal(false, one.locked?)
+
+      exception = assert_raises(ArgumentError) do
+        one.cleanup!
+      end
+
+      assert_match(/shared locks are not supported/, exception.message)
+    end
+  end
+end

data/test/with_advisory_lock/thread_test.rb

@@ -81,3 +81,13 @@ class MySQLThreadTest < GemTestCase
     MysqlTag
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogyThreadTest < GemTestCase
+    include ThreadTestCases
+
+    def model_class
+      TrilogyTag
+    end
+  end
+end

data/test/with_advisory_lock/transaction_test.rb

@@ -12,10 +12,6 @@ class PostgreSQLTransactionScopingTest < GemTestCase
     end
   end
 
-  test 'session locks release after the block executes' do
-    skip 'PostgreSQL lock visibility issue - locks acquired via advisory lock methods not showing in pg_locks'
-  end
-
   test 'session locks release when transaction fails inside block' do
     Tag.transaction do
       assert_equal(0, @pg_lock_count.call)
@@ -31,10 +27,6 @@ class PostgreSQLTransactionScopingTest < GemTestCase
     end
   end
 
-  test 'transaction level locks hold until the transaction completes' do
-    skip 'PostgreSQL lock visibility issue - locks acquired via advisory lock methods not showing in pg_locks'
-  end
-
   test 'raises an error when attempting to use transaction level locks outside a transaction' do
     exception = assert_raises(ArgumentError) do
       Tag.with_advisory_lock 'test', transaction: true do
@@ -81,3 +73,41 @@ class MySQLTransactionScopingTest < GemTestCase
     assert_match(/#{Regexp.escape('require an active transaction')}/, exception.message)
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogyTransactionScopingTest < GemTestCase
+    self.use_transactional_tests = false
+
+    test 'raises an error when attempting to use transaction level locks' do
+      TrilogyTag.transaction do
+        exception = assert_raises(ArgumentError) do
+          TrilogyTag.with_advisory_lock 'test', transaction: true do
+            raise 'Trilogy transaction realm is forbidden!'
+          end
+        end
+
+        assert_match(/#{Regexp.escape('not supported')}/, exception.message)
+      end
+    end
+
+    test 'session locks work within transactions' do
+      lock_acquired = false
+      TrilogyTag.transaction do
+        TrilogyTag.with_advisory_lock 'test' do
+          lock_acquired = true
+        end
+      end
+      assert lock_acquired
+    end
+
+    test 'raises an error when attempting to use transaction level locks outside a transaction' do
+      exception = assert_raises(ArgumentError) do
+        TrilogyTag.with_advisory_lock 'test', transaction: true do
+          raise 'Trilogy gates are closed!'
+        end
+      end
+
+      assert_match(/#{Regexp.escape('require an active transaction')}/, exception.message)
+    end
+  end
+end

data/with_advisory_lock.gemspec

@@ -23,32 +23,10 @@ Gem::Specification.new do |spec|
   spec.metadata['source_code_uri'] = 'https://github.com/ClosureTree/with_advisory_lock'
   spec.metadata['changelog_uri'] = 'https://github.com/ClosureTree/with_advisory_lock/blob/master/CHANGELOG.md'
 
-  spec.post_install_message = <<~MESSAGE
-    ⚠️  IMPORTANT: Total rewrite in Rust/COBOL! ⚠️
-
-    Now that I got your attention...
-
-    This version contains a complete internal rewrite. While the public API#{' '}
-    remains the same, please test thoroughly before upgrading production systems.
-
-    New features:
-    - Mixed adapters are now fully supported! You can use PostgreSQL and MySQL
-      in the same application with different models.
-
-    Breaking changes:
-    - SQLite support has been removed
-    - MySQL 5.7 is no longer supported (use MySQL 8+)
-    - Rails 7.1 is no longer supported (use Rails 7.2+)
-    - Private APIs have been removed (Base, DatabaseAdapterSupport, etc.)
-
-    If your code relies on private APIs or unsupported databases, lock to an#{' '}
-    older version or update your code accordingly.
-  MESSAGE
-
   spec.add_dependency 'activerecord', '>= 7.2'
   spec.add_dependency 'zeitwerk', '>= 2.7'
 
-  spec.add_development_dependency 'maxitest'
+  spec.add_development_dependency 'maxitest', '6.2.0'
   spec.add_development_dependency 'minitest-reporters'
   spec.add_development_dependency 'mocha'
   spec.add_development_dependency 'yard'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: with_advisory_lock
 version: !ruby/object:Gem::Version
-  version: 7.0.2
+  version: 7.5.0
 platform: ruby
 authors:
 - Matthew McEachen
@@ -42,16 +42,16 @@ dependencies:
   name: maxitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.2.0
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
@@ -143,6 +143,10 @@ files:
 - test/dummy/app/models/mysql_tag_audit.rb
 - test/dummy/app/models/tag.rb
 - test/dummy/app/models/tag_audit.rb
+- test/dummy/app/models/trilogy_label.rb
+- test/dummy/app/models/trilogy_record.rb
+- test/dummy/app/models/trilogy_tag.rb
+- test/dummy/app/models/trilogy_tag_audit.rb
 - test/dummy/config.ru
 - test/dummy/config/application.rb
 - test/dummy/config/boot.rb
@@ -151,9 +155,11 @@ files:
 - test/dummy/config/routes.rb
 - test/dummy/db/schema.rb
 - test/dummy/db/secondary_schema.rb
+- test/dummy/db/trilogy_schema.rb
 - test/dummy/lib/tasks/db.rake
 - test/sanity_check_test.rb
 - test/test_helper.rb
+- test/with_advisory_lock/blocking_test.rb
 - test/with_advisory_lock/concern_test.rb
 - test/with_advisory_lock/lock_test.rb
 - test/with_advisory_lock/multi_adapter_test.rb
@@ -173,16 +179,6 @@ metadata:
   homepage_uri: https://github.com/ClosureTree/with_advisory_lock
   source_code_uri: https://github.com/ClosureTree/with_advisory_lock
   changelog_uri: https://github.com/ClosureTree/with_advisory_lock/blob/master/CHANGELOG.md
-post_install_message: "⚠️  IMPORTANT: Total rewrite in Rust/COBOL! ⚠️\n\nNow that
-  I got your attention...\n\nThis version contains a complete internal rewrite. While
-  the public API \nremains the same, please test thoroughly before upgrading production
-  systems.\n\nNew features:\n- Mixed adapters are now fully supported! You can use
-  PostgreSQL and MySQL\n  in the same application with different models.\n\nBreaking
-  changes:\n- SQLite support has been removed\n- MySQL 5.7 is no longer supported
-  (use MySQL 8+)\n- Rails 7.1 is no longer supported (use Rails 7.2+)\n- Private APIs
-  have been removed (Base, DatabaseAdapterSupport, etc.)\n\nIf your code relies on
-  private APIs or unsupported databases, lock to an \nolder version or update your
-  code accordingly.\n"
 rdoc_options: []
 require_paths:
 - lib
@@ -197,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Advisory locking for ActiveRecord
 test_files: []