idempo 1.0.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43b22b0723a04b9388d0c5d2142220c4eac8dbe97055ae9feac075522d022c14
-  data.tar.gz: 8f33ce3508f887f4e364abe12e57c20caec7b6214312d0258637d6dc928bf95a
+  metadata.gz: 79351972a8246031e7301fcadb2d3721fa99300edffc00a3cb1a2e5fa828c68b
+  data.tar.gz: 27bb14ea7cfe6a10de6367cd725a549a0e26ccec289ca6bdc192752df39c60db
 SHA512:
-  metadata.gz: e655619f00ad736e90114a4e7882f88c9d96113660af6c0b57990bf145a4a938713e50ab77c50e4cd0d07e85cb246d7be201a9308e8c921300bc15b3c5536d7e
-  data.tar.gz: 9dd5a0a0cd091da4bf78e254cae840362fd5c5ca99b4cdac38c5f1d5c5811d870e234fe5ab64f53eec6c9c9463a80b2e3fa8c7d5914d4a013a3040cce73874ac
+  metadata.gz: e7cab37f569d2688a83b0d2c25c8f73b720c3fbc294ab6f2cd70686167f8c8dfb1864c738a33ffa28fec152f346e409cc0088be2d9a907974ac8c5370a9469fb
+  data.tar.gz: f2ad3d16e636499ce989c9093ad0c7144fb9d22fe89d63939045fbe9df593595ce349d4e9ae25cb70898020bc1e66ea0307889cd7b1eb3060e758675219e5add

data/.github/workflows/ci.yml

@@ -7,22 +7,10 @@ on:
 env:
   BUNDLE_PATH: vendor/bundle
 
-services:
-  mysql:
-    image: mysql:5.7
-    env:
-        MYSQL_ALLOW_EMPTY_PASSWORD: yes
-    ports:
-        - 3306
-    options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
-  redis:
-    image: redis
-    options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
-
 jobs:
   lint:
     name: Code Style
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
     strategy:
       matrix:
@@ -30,73 +18,63 @@ jobs:
           - '2.7'
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-      - name: Gemfile Cache
-        uses: actions/cache@v2
-        with:
-          path: Gemfile.lock
-          key: ${{ runner.os }}-gemlock-${{ matrix.ruby }}-${{ hashFiles('Gemfile', 'idempo.gemspec') }}
-          restore-keys: |
-            ${{ runner.os }}-gemlock-${{ matrix.ruby }}-
-      - name: Bundle Cache
-        id: cache-gems
-        uses: actions/cache@v2
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-gems-${{ matrix.ruby }}-${{ hashFiles('Gemfile', 'Gemfile.lock', 'idempo.gemspec') }}
-          restore-keys: |
-            ${{ runner.os }}-gems-${{ matrix.ruby }}-
-            ${{ runner.os }}-gems-
-      - name: Bundle Install
-        if: steps.cache-gems.outputs.cache-hit != 'true'
-        run: bundle install --jobs 4 --retry 3
+          bundler-cache: true
       - name: Rubocop Cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: ~/.cache/rubocop_cache
           key: ${{ runner.os }}-rubocop-${{ hashFiles('.rubocop.yml') }}
           restore-keys: |
             ${{ runner.os }}-rubocop-
-      - name: Rubocop
-        run: bundle exec rubocop
+      - name: Standard (Lint)
+        run: bundle exec rake standard
   test:
     name: Specs
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
     strategy:
       matrix:
         ruby:
-          - '2.6'
-          - '3.0'
+          - '2.7'
+          - '3.2'
+    services:
+      mysql:
+        image: mysql:5.7
+        env:
+          MYSQL_ALLOW_EMPTY_PASSWORD: yes
+        ports:
+          - 3306:3306
+        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+        ports:
+          - 5432:5432
+      redis:
+        image: redis
+        options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+        ports:
+          - 6379:6379
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-      - name: Gemfile Cache
-        uses: actions/cache@v2
-        with:
-          path: Gemfile.lock
-          key: ${{ runner.os }}-gemlock-${{ matrix.ruby }}-${{ hashFiles('Gemfile', 'idempo.gemspec') }}
-          restore-keys: |
-            ${{ runner.os }}-gemlock-${{ matrix.ruby }}-
-      - name: Bundle Cache
-        id: cache-gems
-        uses: actions/cache@v2
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-gems-${{ matrix.ruby }}-${{ hashFiles('Gemfile', 'Gemfile.lock', 'idempo.gemspec') }}
-          restore-keys: |
-            ${{ runner.os }}-gems-${{ matrix.ruby }}-
-            ${{ runner.os }}-gems-
-      - name: Bundle Install
-        if: steps.cache-gems.outputs.cache-hit != 'true'
-        run: bundle install --jobs 4 --retry 3
+          bundler-cache: true
       - name: RSpec
         run: bundle exec rspec
+        env:
+          MYSQL_HOST: 127.0.0.1
+          MYSQL_PORT: 3306
+          PGHOST: localhost
+          PGUSER: postgres
+          PGPASSWORD: postgres

data/.rubocop.yml

@@ -1,2 +1,5 @@
 inherit_gem:
   wetransfer_style: ruby/default.yml
+
+AllCops:
+  TargetRubyVersion: 2.7

data/.standard.yml

@@ -0,0 +1 @@
+ruby_version: 2.7

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [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
+- Ensure Github actions CI can run and uses Postgres appropriately
+- Add examples for more sophisticated use cases
+- Implement `#prune!` on storage backends
+- Reformat all code using [standard](https://github.com/standardrb/standard) instead of wetransfer_style as it is both more relaxed and more modern
+
+## [1.0.0] - 2023-10-27
+
+- Release 1.0 as the API can be considered stable and the gem has been in production for years
+
 ## [0.2.0] - 2022-04-08
 
 - Allow setting the global default TTL for the cached responses

data/README.md

@@ -42,7 +42,7 @@ If you run only one Puma on one server (so multiple threads but one process) the
 * It uses a `Set` with a `Mutex` around it to store requests in progress
 * It uses a sorted array for expiration and cached responses.
 
-Needless to say, if your server terminates or restarts all the data goes dead with it. However 
+Needless to say, if your server terminates or restarts all the data disappears with it. This backend will also only work if you are running one Puma process (or other single-process server, and just one instance of it). 
 
 ## Using your database for idempotency keys (via ActiveRecord)
 
@@ -71,9 +71,11 @@ config.middleware.insert Idempo, backend: Idempo::ActiveRecordBackend.new
 In your regular tasks (cron or Rake) you will want to add a call to delete old Idempo responses (there is an index on `expire_at`):
 
 ```ruby
-Idempo::ActiveRecordBackend.new.model.where('expire_at_ < ?', Time.now).delete_all
+Idempo::ActiveRecordBackend.new.prune!
 ```
 
+If you need to use Idempo with PGBouncer you will need to write your own locking implementation based on fencing tokens or similar.
+
 ## Using Redis for idempotency keys
 
 Redis is a near-perfect data store for idempotency keys, but it can have race conditions with locks if your application runs for too long or crashes very often. If you have Redis, initialize Idempo using the `RedisBackend`:
@@ -88,7 +90,7 @@ If you have a configured Redis connection pool (and you should) - pass it to the
 config.middleware.insert Idempo, backend: Idempo::RedisBackend.new(config.redis_connection_pool)
 ```
 
-All data stored in Redis will have TTLs and will expire automatically.
+All data stored in Redis will have TTLs and will expire automatically. Redis scripts ensure that updates to the stored idempotent responses and locking happen atomically.
 
 
 ## Installation
@@ -107,6 +109,10 @@ Or install it yourself as:
 
     $ gem install idempo
 
+## More advanced use cases
+
+Check out the files in the `examples/` directory to see a few customisations you can do.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -2,6 +2,7 @@
 
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "standard/rake"
 
 RSpec::Core::RakeTask.new(:spec)
 

data/examples/custom_locking.rb

@@ -0,0 +1,22 @@
+# Sometimes you might need a different locking strategy than advisory locks,
+# but still use the database-backed storage for idempotent responses. This can arise
+# if you are using pgbouncer for instance, where advisory locks are not available
+# when using the "transaction mode". You can modify the backend to use a different
+# locking mechanism, but keep the rest.
+
+class ActiveRecordBackendWithDistributedLock < Idempo::ActiveRecordBackend
+  class LocksViaService
+    def acquire(_conn, based_on_str)
+      LockingService.acquire("idempo-lk-#{based_on_str}")
+    end
+
+    def release(_conn, based_on_str)
+      LockingService.release("idempo-lk-#{based_on_str}")
+      true
+    end
+  end
+
+  def lock_implementation_for_connection(_connection)
+    LocksViaService.new
+  end
+end

data/examples/jwt_iss_fingerprint.rb

@@ -0,0 +1,41 @@
+# Sometimes authentication is done using a Bearer token with a signature, or using another token format
+# which includes some form of expiration. This means that every time a request is made, the `Authorization`
+# HTTP header may have a different value, and thus the request fingerprint could change every time,
+# even though the idempotency key is the same.
+# For this case, a custom fingerprinting function can be used. For example, if the bearer token is
+# generated in JWT format by the client, it may include the `iss` (issuer) claim, identifying the
+# specific device. This identifier can then be used instead of the entire Authorization header.
+
+module FingerprinterWithIssuerClaim
+  def self.call(idempotency_key, rack_request)
+    d = Digest::SHA256.new
+    d << idempotency_key << "\n"
+    d << rack_request.url << "\n"
+    d << rack_request.request_method << "\n"
+    d << extract_jwt_iss_claim(rack_request) << "\n"
+    while (chunk = rack_request.env["rack.input"].read(1024 * 65))
+      d << chunk
+    end
+    Base64.strict_encode64(d.digest)
+  ensure
+    rack_request.env["rack.input"].rewind
+  end
+
+  def self.extract_jwt_iss_claim(rack_request)
+    header_value = rack_request.get_header("HTTP_AUTHORIZATION").to_s
+    return header_value unless header_value.start_with?("Bearer ")
+
+    jwt = header_value.delete_prefix("Bearer ")
+    # This is decoding without verification, but in this case it is reasonably safe
+    # as we are not actually authenticating the request - just using the `iss` claim.
+    # It can make the app slightly more sensitive to replay attacks but since the request
+    # is idempotent, an already executed (and authenticated) request that generated a
+    # cached response is reasonably safe to serve out.
+    unverified_claims, _unverified_header = JWT.decode(jwt, _key = nil, _verify = false)
+    unverified_claims.fetch("iss")
+  rescue
+    # If we fail to pick up the claim or anything else - assume the request is non-idempotent
+    # as treating it otherwise may create a replay attack
+    SecureRandom.bytes(32)
+  end
+end

data/idempo.gemspec

@@ -3,21 +3,21 @@
 require_relative "lib/idempo/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "idempo"
-  spec.version       = Idempo::VERSION
-  spec.authors       = ["Julik Tarkhanov", "Pablo Crivella"]
-  spec.email         = ["me@julik.nl", "pablocrivella@gmail.com"]
-
-  spec.summary       = "Idempotency keys for all."
-  spec.description   = "Provides idempotency keys for Rack applications."
-  spec.homepage      = "https://github.com/julik/idempo"
-  spec.license       = "MIT"
+  spec.name = "idempo"
+  spec.version = Idempo::VERSION
+  spec.authors = ["Julik Tarkhanov", "Pablo Crivella"]
+  spec.email = ["me@julik.nl", "pablocrivella@gmail.com"]
+
+  spec.summary = "Idempotency keys for all."
+  spec.description = "Provides idempotency keys for Rack applications."
+  spec.homepage = "https://github.com/julik/idempo"
+  spec.license = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
   else
     raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
   end
@@ -31,14 +31,14 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
   spec.add_dependency "rack"
   spec.add_dependency "msgpack"
-  spec.add_dependency "measurometer", '~> 1.3'
+  spec.add_dependency "measurometer", "~> 1.3"
 
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
@@ -47,7 +47,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "mysql2"
   spec.add_development_dependency "pg"
-  spec.add_development_dependency "wetransfer_style"
+  spec.add_development_dependency "standard"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/idempo/active_record_backend.rb

@@ -1,17 +1,17 @@
 # This backend currently only works with mysql2 since it uses advisory locks
 class Idempo::ActiveRecordBackend
   def self.create_table(via_migration)
-    via_migration.create_table 'idempo_responses', charset: 'utf8mb4', collation: 'utf8mb4_unicode_ci' do |t|
-      t.string :idempotent_request_key, index: true, unique: true, null: false
+    via_migration.create_table "idempo_responses", charset: "utf8mb4", collation: "utf8mb4_unicode_ci" do |t|
+      t.string :idempotent_request_key, index: {unique: true}, null: false
       t.datetime :expire_at, index: true, null: false # Needs an index for cleanup
-      t.binary :idempotent_response_payload, size: :medium
+      t.binary :idempotent_response_payload, limit: Idempo::SAVED_RESPONSE_BODY_SIZE_LIMIT
       t.timestamps
     end
   end
 
   class Store < Struct.new(:key, :model)
     def lookup
-      model.where(idempotent_request_key: key).where('expire_at > ?', Time.now).first&.idempotent_response_payload
+      model.where(idempotent_request_key: key).where("expire_at > ?", Time.now).first&.idempotent_response_payload
     end
 
     def store(data:, ttl:)
@@ -27,18 +27,18 @@ class Idempo::ActiveRecordBackend
 
   class PostgresLock
     def acquire(conn, based_on_str)
-      acquisition_result = conn.select_value('SELECT pg_try_advisory_lock(%d)' % derive_lock_key(based_on_str))
-      [true, 't'].include?(acquisition_result)
+      acquisition_result = conn.select_value("SELECT pg_try_advisory_lock(%d)" % derive_lock_key(based_on_str))
+      [true, "t"].include?(acquisition_result)
     end
 
     def release(conn, based_on_str)
-      conn.select_value('SELECT pg_advisory_unlock(%d)' % derive_lock_key(based_on_str))
+      conn.select_value("SELECT pg_advisory_unlock(%d)" % derive_lock_key(based_on_str))
     end
 
     def derive_lock_key(from_str)
       # The key must be a single bigint (signed long)
       hash_bytes = Digest::SHA1.digest(from_str)
-      hash_bytes[0...8].unpack('l_').first
+      hash_bytes[0...8].unpack1("l_")
     end
   end
 
@@ -59,35 +59,51 @@ class Idempo::ActiveRecordBackend
   end
 
   def initialize
-    require 'active_record'
+    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
   def model
     @model_class ||= Class.new(ActiveRecord::Base) do
-      self.table_name = 'idempo_responses'
+      self.table_name = "idempo_responses"
     end
   end
 
   def with_idempotency_key(request_key)
-    db_safe_key = Digest::SHA1.base64digest(request_key)
-    lock = lock_implementation_for_connection(model.connection)
+    # 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)
 
-    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)
+      begin
+        yield(Store.new(db_safe_key, model))
+      ensure
+        database_lock.release(model.connection, request_key)
+      end
     end
   end
 
+  # Deletes expired cached Idempo responses from the database, in batches
+  def prune!
+    model.where("expire_at < ?", Time.now).in_batches.delete_all
+  end
+
   private
 
   def lock_implementation_for_connection(connection)
-    if connection.adapter_name =~ /^mysql2/i
+    if /^mysql2/i.match?(connection.adapter_name)
       MysqlLock.new
-    elsif connection.adapter_name =~ /^postgres/i
+    elsif /^postgres/i.match?(connection.adapter_name)
       PostgresLock.new
     else
       raise "Unsupported database driver #{model.connection.adapter_name.downcase} - we don't know whether it supports advisory locks"

data/lib/idempo/concurrent_request_error_app.rb

@@ -1,5 +1,3 @@
-require 'json'
-
 class Idempo::ConcurrentRequestErrorApp
   RETRY_AFTER_SECONDS = 2.to_s
 
@@ -10,6 +8,6 @@ class Idempo::ConcurrentRequestErrorApp
         message: "Another request with this idempotency key is still in progress, please try again later"
       }
     }
-    [429, {'Retry-After' => RETRY_AFTER_SECONDS, 'Content-Type' => 'application/json'}, [JSON.pretty_generate(res)]]
+    [429, {"Retry-After" => RETRY_AFTER_SECONDS, "Content-Type" => "application/json"}, [JSON.pretty_generate(res)]]
   end
 end

data/lib/idempo/malformed_key_error_app.rb

@@ -1,5 +1,3 @@
-require 'json'
-
 class Idempo::MalformedKeyErrorApp
   def self.call(env)
     res = {
@@ -8,6 +6,6 @@ class Idempo::MalformedKeyErrorApp
         message: "The Idempotency-Key header provided was empty or malformed"
       }
     }
-    [400, {'Content-Type' => 'application/json'}, [JSON.pretty_generate(res)]]
+    [400, {"Content-Type" => "application/json"}, [JSON.pretty_generate(res)]]
   end
 end

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
+    require_relative "response_store"
+    @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,13 @@ 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
+
+  def prune!
+    @response_store.prune
+  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/redis_backend.rb

@@ -54,7 +54,7 @@ class Idempo::RedisBackend
         Idempo::RedisBackend.eval_or_evalsha(r, SET_WITH_TTL_IF_LOCK_STILL_HELD_SCRIPT, keys: keys, argv: argv)
       end
 
-      Measurometer.increment_counter('idempo.redis_lock_state_when_saving_response', 1, state: outcome_of_save)
+      Measurometer.increment_counter("idempo.redis_lock_state_when_saving_response", 1, state: outcome_of_save)
     end
   end
 
@@ -65,8 +65,8 @@ class Idempo::RedisBackend
   end
 
   def initialize(redis_or_connection_pool = Redis.new)
-    require 'redis'
-    require 'securerandom'
+    require "redis"
+    require "securerandom"
     @redis_pool = redis_or_connection_pool.respond_to?(:with) ? redis_or_connection_pool : NullPool.new(redis_or_connection_pool)
   end
 
@@ -84,10 +84,14 @@ class Idempo::RedisBackend
       outcome_of_del = @redis_pool.with do |r|
         Idempo::RedisBackend.eval_or_evalsha(r, DELETE_BY_KEY_AND_VALUE_SCRIPT, keys: [lock_key], argv: [token])
       end
-      Measurometer.increment_counter('idempo.redis_lock_state_when_releasing_lock', 1, state: outcome_of_del)
+      Measurometer.increment_counter("idempo.redis_lock_state_when_releasing_lock", 1, state: outcome_of_del)
     end
   end
 
+  def prune!
+    # Do nothing
+  end
+
   def self.eval_or_evalsha(redis, script_code, keys:, argv:)
     script_sha = Digest::SHA1.hexdigest(script_code)
     redis.evalsha(script_sha, keys: keys, argv: argv)

data/lib/idempo/request_fingerprint.rb

@@ -4,12 +4,12 @@ module Idempo::RequestFingerprint
     d << idempotency_key << "\n"
     d << rack_request.url << "\n"
     d << rack_request.request_method << "\n"
-    d << rack_request.get_header('HTTP_AUTHORIZATION').to_s << "\n"
-    while chunk = rack_request.env['rack.input'].read(1024 * 65)
+    d << rack_request.get_header("HTTP_AUTHORIZATION").to_s << "\n"
+    while (chunk = rack_request.env["rack.input"].read(1024 * 65))
       d << chunk
     end
     Base64.strict_encode64(d.digest)
   ensure
-    rack_request.env['rack.input'].rewind
+    rack_request.env["rack.input"].rewind
   end
 end

data/lib/idempo/response_store.rb

@@ -25,8 +25,6 @@ class Idempo::ResponseStore
     nil
   end
 
-  private
-
   def prune
     now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     items_to_delete = remove_lower_than(@expiries, now, &:expire_at)
@@ -35,6 +33,8 @@ class Idempo::ResponseStore
     end
   end
 
+  private
+
   def binary_insert(array, item, &property_getter)
     at_i = array.bsearch_index do |stored_item|
       yield(stored_item) <= yield(item)

data/lib/idempo/version.rb

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

data/lib/idempo.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
-require 'zlib'
-require 'msgpack'
-require 'base64'
-require 'digest'
-require 'json'
-require 'measurometer'
-
-require_relative "idempo/version"
-require_relative "idempo/request_fingerprint"
-require_relative "idempo/memory_backend"
-require_relative "idempo/redis_backend"
-require_relative "idempo/active_record_backend"
-require_relative "idempo/malformed_key_error_app"
-require_relative "idempo/concurrent_request_error_app"
+require "base64"
+require "digest"
+require "json"
+require "measurometer"
+require "msgpack"
+require "zlib"
+require "set"
+
+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
 
@@ -37,44 +40,44 @@ class Idempo
   def call(env)
     req = Rack::Request.new(env)
     return @app.call(env) if request_verb_idempotent?(req)
-    return @app.call(env) unless idempotency_key_header = extract_idempotency_key_from(env)
+    return @app.call(env) unless (idempotency_key_header = extract_idempotency_key_from(env))
 
     # The RFC requires that the Idempotency-Key header value is enclosed in quotes
     idempotency_key_header_value = unquote(idempotency_key_header)
-    raise MalformedIdempotencyKey if idempotency_key_header_value == ''
+    raise MalformedIdempotencyKey if idempotency_key_header_value == ""
 
     request_key = @fingerprint_calculator.call(idempotency_key_header_value, req)
 
     @backend.with_idempotency_key(request_key) do |store|
-      if stored_response = store.lookup
-        Measurometer.increment_counter('idempo.responses_served_from', 1, from: 'store')
+      if (stored_response = store.lookup)
+        Measurometer.increment_counter("idempo.responses_served_from", 1, from: "store")
         return from_persisted_response(stored_response)
       end
 
       status, headers, body = @app.call(env)
 
-      expires_in_seconds = (headers.delete('X-Idempo-Persist-For-Seconds') || @persist_for_seconds).to_i
+      expires_in_seconds = (headers.delete("X-Idempo-Persist-For-Seconds") || @persist_for_seconds).to_i
       if response_may_be_persisted?(status, headers, body)
         # Body is replaced with a cached version since a Rack response body is not rewindable
         marshaled_response, body = serialize_response(status, headers, body)
         store.store(data: marshaled_response, ttl: expires_in_seconds)
       end
 
-      Measurometer.increment_counter('idempo.responses_served_from', 1, from: 'freshly-generated')
+      Measurometer.increment_counter("idempo.responses_served_from", 1, from: "freshly-generated")
       [status, headers, body]
     end
   rescue MalformedIdempotencyKey
-    Measurometer.increment_counter('idempo.responses_served_from', 1, from: 'malformed-idempotency-key')
+    Measurometer.increment_counter("idempo.responses_served_from", 1, from: "malformed-idempotency-key")
     @malformed_key_error_app.call(env)
   rescue ConcurrentRequest
-    Measurometer.increment_counter('idempo.responses_served_from', 1, from: 'conflict-concurrent-request')
+    Measurometer.increment_counter("idempo.responses_served_from", 1, from: "conflict-concurrent-request")
     @concurrent_request_error_app.call(env)
   end
 
   private
 
   def from_persisted_response(marshaled_response)
-    if marshaled_response[-2..-1] != ':1'
+    if marshaled_response[-2..] != ":1"
       raise Error, "Unknown serialization of the marshaled response"
     else
       MessagePack.unpack(Zlib.inflate(marshaled_response[0..-3]))
@@ -84,34 +87,35 @@ class Idempo
   def serialize_response(status, headers, rack_response_body)
     # 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)
+    rack_response_body.each { |chunk| body_chunks << chunk.dup }
 
     # Only keep headers which are strings
     stringified_headers = headers.each_with_object({}) do |(header, value), filtered|
-      filtered[header] = value if !header.start_with?('rack.') && value.is_a?(String)
+      filtered[header] = value if !header.start_with?("rack.") && value.is_a?(String)
     end
 
     message_packed_str = MessagePack.pack([status, stringified_headers, body_chunks])
     deflated_message_packed_str = Zlib.deflate(message_packed_str) + ":1"
-    Measurometer.increment_counter('idempo.response_total_generated_bytes', deflated_message_packed_str.bytesize)
-    Measurometer.add_distribution_value('idempo.response_size_bytes', deflated_message_packed_str.bytesize)
+    Measurometer.increment_counter("idempo.response_total_generated_bytes", deflated_message_packed_str.bytesize)
+    Measurometer.add_distribution_value("idempo.response_size_bytes", deflated_message_packed_str.bytesize)
 
     # Add the version specifier at the end, because slicing a string in Ruby at the end
     # (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)
-    return false if headers.delete('X-Idempo-Policy') == 'no-store'
+    return false if headers.delete("X-Idempo-Policy") == "no-store"
     return false unless status_may_be_persisted?(status)
     return false unless body_size_within_limit?(headers, body)
     true
   end
 
   def body_size_within_limit?(response_headers, body)
-    return response_headers['Content-Length'].to_i <= SAVED_RESPONSE_BODY_SIZE_LIMIT if response_headers['Content-Length']
+    return response_headers["Content-Length"].to_i <= SAVED_RESPONSE_BODY_SIZE_LIMIT if response_headers["Content-Length"]
 
     return false unless body.is_a?(Array) # Arbitrary iterable of unknown size
 
@@ -132,7 +136,7 @@ class Idempo
   end
 
   def extract_idempotency_key_from(env)
-    env['HTTP_IDEMPOTENCY_KEY'] || env['HTTP_X_IDEMPOTENCY_KEY']
+    env["HTTP_IDEMPOTENCY_KEY"] || env["HTTP_X_IDEMPOTENCY_KEY"]
   end
 
   def request_verb_idempotent?(request)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idempo
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-27 00:00:00.000000000 Z
+date: 2024-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -152,7 +152,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: wetransfer_style
+  name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -176,6 +176,7 @@ files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- ".standard.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -183,12 +184,15 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/custom_locking.rb
+- examples/jwt_iss_fingerprint.rb
 - idempo.gemspec
 - lib/idempo.rb
 - lib/idempo/active_record_backend.rb
 - 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
@@ -216,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Idempotency keys for all.