idempo 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bfbbd03a37973e1309f1c9d3a0aa1032cbfdfaae73f78f275a7fd9800e5e9ed
-  data.tar.gz: 54e1bb92e23d7003e7d4205e0964e94ab7288d342f2032fd4f7f2a280a2341f1
+  metadata.gz: 79351972a8246031e7301fcadb2d3721fa99300edffc00a3cb1a2e5fa828c68b
+  data.tar.gz: 27bb14ea7cfe6a10de6367cd725a549a0e26ccec289ca6bdc192752df39c60db
 SHA512:
-  metadata.gz: 9be3229d0844358a342b5fcc65a885e96f0ae7ae73ebcfe91b74046ed7ddc3e90d836d2fbe047f22434f9bd15beda36d5f0d0eb5bf4f8f597996fa7006a00101
-  data.tar.gz: a9933869e79cd56229907bafe38b8c135357eb1e3b9ff8954e51f74f4a171b33dee8e5322a9178782c95e4686d96104d9ff4fbc4d801b5ff12066591cd68cd7b
+  metadata.gz: e7cab37f569d2688a83b0d2c25c8f73b720c3fbc294ab6f2cd70686167f8c8dfb1864c738a33ffa28fec152f346e409cc0088be2d9a907974ac8c5370a9469fb
+  data.tar.gz: f2ad3d16e636499ce989c9093ad0c7144fb9d22fe89d63939045fbe9df593595ce349d4e9ae25cb70898020bc1e66ea0307889cd7b1eb3060e758675219e5add

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [1.2.1] - 2024-02-22
+
+- Use autoloading for internal modules. A user using Redis does not have to load the ActiveRecord storage backend, for example
+- Ensure that the original Rack response body receives a `close` when reading out for caching
+
+## [1.2.0] - 2024-02-22
+
+- Use memory locking in addition to DB locking in `ActiveRecordBackend`
+
 ## [1.1.0] - 2024-02-22
 
 - Use modern ActiveRecord migration options for better Rails 7.x compatibility

data/lib/idempo/active_record_backend.rb

@@ -60,6 +60,7 @@ class Idempo::ActiveRecordBackend
 
   def initialize
     require "active_record"
+    @memory_lock = Idempo::MemoryLock.new
   end
 
   # Allows the model to be defined lazily without having to require active_record when this module gets loaded
@@ -70,15 +71,25 @@ class Idempo::ActiveRecordBackend
   end
 
   def with_idempotency_key(request_key)
-    db_safe_key = Digest::SHA1.base64digest(request_key)
-    lock = lock_implementation_for_connection(model.connection)
-
-    raise Idempo::ConcurrentRequest unless lock.acquire(model.connection, request_key)
-
-    begin
-      yield(Store.new(db_safe_key, model))
-    ensure
-      lock.release(model.connection, request_key)
+    # We need to use an in-memory lock because database advisory locks are
+    # reentrant. Both Postgres and MySQL allow multiple acquisitions of the
+    # same advisory lock within the same connection - in most Rails/Rack apps
+    # this translates to "within the same thread". This means that if one
+    # elects to use a non-threading webserver (like Falcon), or tests Idempo
+    # within the same thread (like we do), they won't get advisory locking
+    # for concurrent requests. Therefore a staged lock is required. First we apply
+    # the memory lock (for same thread on this process/multiple threads on this
+    # process) and then once we have that - the DB lock.
+    @memory_lock.with(request_key) do
+      db_safe_key = Digest::SHA1.base64digest(request_key)
+      database_lock = lock_implementation_for_connection(model.connection)
+      raise Idempo::ConcurrentRequest unless database_lock.acquire(model.connection, request_key)
+
+      begin
+        yield(Store.new(db_safe_key, model))
+      ensure
+        database_lock.release(model.connection, request_key)
+      end
     end
   end
 

data/lib/idempo/concurrent_request_error_app.rb

@@ -1,5 +1,3 @@
-require "json"
-
 class Idempo::ConcurrentRequestErrorApp
   RETRY_AFTER_SECONDS = 2.to_s
 

data/lib/idempo/malformed_key_error_app.rb

@@ -1,5 +1,3 @@
-require "json"
-
 class Idempo::MalformedKeyErrorApp
   def self.call(env)
     res = {

data/lib/idempo/memory_backend.rb

@@ -1,12 +1,9 @@
 class Idempo::MemoryBackend
   def initialize
-    require "set"
     require_relative "response_store"
-
-    @requests_in_flight_mutex = Mutex.new
-    @in_progress = Set.new
-    @store_mutex = Mutex.new
+    @lock = Idempo::MemoryLock.new
     @response_store = Idempo::ResponseStore.new
+    @store_mutex = Mutex.new
   end
 
   class Store < Struct.new(:store_mutex, :response_store, :key, keyword_init: true)
@@ -24,22 +21,9 @@ class Idempo::MemoryBackend
   end
 
   def with_idempotency_key(request_key)
-    did_insert = @requests_in_flight_mutex.synchronize do
-      if @in_progress.include?(request_key)
-        false
-      else
-        @in_progress << request_key
-        true
-      end
-    end
-
-    raise Idempo::ConcurrentRequest unless did_insert
-
-    store = Store.new(store_mutex: @store_mutex, response_store: @response_store, key: request_key)
-    begin
+    @lock.with(request_key) do
+      store = Store.new(store_mutex: @store_mutex, response_store: @response_store, key: request_key)
       yield(store)
-    ensure
-      @requests_in_flight_mutex.synchronize { @in_progress.delete(request_key) }
     end
   end
 

data/lib/idempo/memory_lock.rb

@@ -0,0 +1,21 @@
+# A memory lock prevents multiple requests with the same request
+# fingerprint from running concurrently
+class Idempo::MemoryLock
+  def initialize
+    @requests_in_flight_mutex = Mutex.new
+    @in_progress = Set.new
+  end
+
+  def with(request_key)
+    @requests_in_flight_mutex.synchronize do
+      if @in_progress.include?(request_key)
+        raise Idempo::ConcurrentRequest
+      else
+        @in_progress << request_key
+      end
+    end
+    yield
+  ensure
+    @requests_in_flight_mutex.synchronize { @in_progress.delete(request_key) }
+  end
+end

data/lib/idempo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Idempo
-  VERSION = "1.1.0"
+  VERSION = "1.2.1"
 end

data/lib/idempo.rb

@@ -6,16 +6,19 @@ require "json"
 require "measurometer"
 require "msgpack"
 require "zlib"
+require "set"
 
-require_relative "idempo/active_record_backend"
-require_relative "idempo/concurrent_request_error_app"
-require_relative "idempo/malformed_key_error_app"
-require_relative "idempo/memory_backend"
-require_relative "idempo/redis_backend"
-require_relative "idempo/request_fingerprint"
-require_relative "idempo/version"
+require "idempo/version"
 
 class Idempo
+  autoload :ConcurrentRequestErrorApp, "idempo/concurrent_request_error_app"
+  autoload :MalformedKeyErrorApp, "idempo/malformed_key_error_app"
+  autoload :MemoryBackend, "idempo/memory_backend"
+  autoload :RedisBackend, "idempo/redis_backend"
+  autoload :ActiveRecordBackend, "idempo/active_record_backend"
+  autoload :RequestFingerprint, "idempo/request_fingerprint"
+  autoload :MemoryLock, "idempo/memory_lock"
+
   DEFAULT_TTL_SECONDS = 30
   SAVED_RESPONSE_BODY_SIZE_LIMIT = 4 * 1024 * 1024
 
@@ -85,7 +88,6 @@ class Idempo
     # Buffer the Rack response body, we can only do that once (it is non-rewindable)
     body_chunks = []
     rack_response_body.each { |chunk| body_chunks << chunk.dup }
-    rack_response_body.close if rack_response_body.respond_to?(:close)
 
     # Only keep headers which are strings
     stringified_headers = headers.each_with_object({}) do |(header, value), filtered|
@@ -101,6 +103,8 @@ class Idempo
     # (when we unserialize our response again) does a realloc, while slicing at the start
     # does not
     [deflated_message_packed_str, body_chunks]
+  ensure
+    rack_response_body.close if rack_response_body.respond_to?(:close)
   end
 
   def response_may_be_persisted?(status, headers, body)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idempo
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-22 00:00:00.000000000 Z
+date: 2024-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -192,6 +192,7 @@ files:
 - lib/idempo/concurrent_request_error_app.rb
 - lib/idempo/malformed_key_error_app.rb
 - lib/idempo/memory_backend.rb
+- lib/idempo/memory_lock.rb
 - lib/idempo/redis_backend.rb
 - lib/idempo/request_fingerprint.rb
 - lib/idempo/response_store.rb