Fixes #224. I believe this is a Postgres only issue

Postgres, unlike mysql and sqlite, invalidates the current transaction on
a database contraint violation such as an attempt to insert
a duplicate key into a unique index.

SolidQueue uses a pretty standard design pattern of application level
conflict detection and resolution via error handling as part of it's
concurrency management in Semaphore::Proxy#attempt create (via create! and rescue).

For Postgres based implementations when:
* enqueing a job inside a transaction
* under load such that the race condition triggerng the simultanious conflicted insert

the transaction would become unrecoverable at the application level.

There are two simple paths to address this issue in Postgres:
* Nested transactions
* Insert using 'on conflict do nothing'

Nested transaction are the easiest to implement and are portable across all 3
of the Rails standard databases. Unfortunately, nested transactions have a
known and very signifant performance problem, especially for databases under
load and/or replicated databases with long running queries.

Each of the big three database inplements the ANSI standard Insert on conflict do nothing
in a very different way.

Because of this, this PR only replaces the current implementation of
application level conflict handling for Postgres.  It takes advantage
of the Rails standard ActiveRecord::Persistence::Insert method supporting on
conflict semantics.

Author: hms

Gemfile.lock

@@ -171,6 +171,7 @@ GEM
 
 PLATFORMS
   arm64-darwin-22
+  arm64-darwin-23
   x86_64-darwin-21
   x86_64-darwin-23
   x86_64-linux

app/models/solid_queue/semaphore.rb

@@ -41,16 +41,30 @@ def signal
       end
 
       private
+
         attr_accessor :job
 
-        def attempt_creation
+        def attempt_creation_with_insert_on_conflict
+          results = Semaphore.insert({ key: key, value: limit - 1, expires_at: expires_at }, unique_by: :key)
+
+          if results.length.zero?
+            limit == 1 ? false : attempt_decrement
+          else
+            true
+          end
+        end
+
+        def attempt_creation_with_create_and_exception_handling
           Semaphore.create!(key: key, value: limit - 1, expires_at: expires_at)
           true
         rescue ActiveRecord::RecordNotUnique
-          if limit == 1 then false
-          else
-            attempt_decrement
-          end
+          limit == 1 ? false : attempt_decrement
+        end
+
+        if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+          alias attempt_creation attempt_creation_with_insert_on_conflict
+        else
+          alias attempt_creation attempt_creation_with_create_and_exception_handling
         end
 
         def attempt_decrement

test/integration/concurrency_controls_test.rb

@@ -183,7 +183,46 @@ class ConcurrencyControlsTest < ActiveSupport::TestCase
     assert job.reload.ready?
   end
 
+  if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+    test "insert_with_unique_by_has_same_database_results_as_create!_with_exception_handling" do
+      key = "key", limit = 1, expires_at = 1.minute.from_now
+
+      assert SolidQueue::Semaphore.count == 0
+
+      SolidQueue::Semaphore.insert({ key: key, value: limit - 1, expires_at: expires_at }, unique_by: :key)
+      assert SolidQueue::Semaphore.count == 1
+
+      SolidQueue::Semaphore.insert({ key: key, value: limit - 1, expires_at: expires_at }, unique_by: :key)
+      assert SolidQueue::Semaphore.count == 1
+
+      SolidQueue::Semaphore.delete_all
+      assert SolidQueue::Semaphore.count == 0
+
+      SolidQueue::Semaphore.create!(key: key, value: limit - 1, expires_at: expires_at)
+      assert SolidQueue::Semaphore.count == 1
+
+      assert_raises ActiveRecord::RecordNotUnique do
+        SolidQueue::Semaphore.create!(key: key, value: limit - 1, expires_at: expires_at)
+      end
+    end
+  end
+
+  test "confirm correct version of attempt_creation by database adaptor" do
+    proxy = SolidQueue::Semaphore::Proxy.new(true)
+
+    aliased_method = proxy.method(:attempt_creation)
+
+    if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+      original_method = proxy.method(:attempt_creation_with_insert_on_conflict)
+    else
+      original_method = proxy.method(:attempt_creation_with_create_and_exception_handling)
+    end
+
+    assert_equal original_method.name, aliased_method.original_name, "The alias maps to the correct original method"
+  end
+
   private
+
     def assert_stored_sequence(result, *sequences)
       expected = sequences.map { |sequence| "seq: " + sequence.map { |name| "s#{name}c#{name}" }.join }
       skip_active_record_query_cache do