idempo 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c746ccbd1875f6a87ff6eabf4aa2566180fae441fa70eada8e7e703612ecd003
+  data.tar.gz: fd2365ee176c8f2c5667f78721f7886a9511a9d45a8699ce3d5b7b83ecaff17a
+SHA512:
+  metadata.gz: 1ede112b38e43dd06261438216a4afe4c5ef08348cb462a38ae2acf9a6b0f6cd530b74dbe469dd4889ef3364e1880803764bb80c65d94954715c19dd50eb67cd
+  data.tar.gz: 69c3d9946da4cc27dbf2b5eeace3d577d62de3c15ca0750b66cbfa0854af7ec991e0da6cfd6d3a1a365337f7f6a0f364da3d9793ab94d13fd7792b026c2b68b7

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# Gem lock not required for libraries
+Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,2 @@
+inherit_gem:
+  wetransfer_style: ruby/default.yml

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2021-10-14
+
+- Initial release

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Julik Tarkhanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# Idempo
+
+A relatively straightforward idempotency keys gem. If your client sends the `Idempotency-Key` or `X-Idempotency-Key` header to your Rack
+application, and the response can be cached, Idempo will provide both a concurrent request lock and a cache for idempotent responses. If
+the idempotent response is already saved for this idempotency key and request fingerprint, the cached response is going to be served
+instead of calling your application.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'idempo'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install idempo
+
+## Usage
+
+Idempo supports a number of backends, we recommend using Redis if you have multiple application servers / dynos and MemoryBackend if you are only using one single Puma worker. To initialize with Redis as backend pass the `backend:` parameter when adding the middleware:
+
+```ruby
+use Idempo, backend: Idempo::RedisBackend.new(Rails.application.config.redis_connection_pool)
+```
+
+and to initialize with a memory store as backend:
+
+```ruby
+use Idempo, backend: Idempo::MemoryBackend.new)
+```
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/julik/idempo.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "idempo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/idempo.gemspec

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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.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"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "https://github.com/julik/idempo/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  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.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_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "redis", "~> 4"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "mysql2"
+  spec.add_development_dependency "wetransfer_style"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/idempo/active_record_backend.rb

@@ -0,0 +1,54 @@
+# 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
+      t.datetime :expire_at, index: true, null: false
+      t.binary :idempotent_response_payload, size: :medium
+      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
+    end
+
+    def store(data:, ttl:)
+      # MySQL does not support datetime with subsecont precision, so ceil() it is
+      expire_at = Time.now.utc + ttl.ceil
+      model.transaction do
+        model.where(idempotent_request_key: key).delete_all
+        model.create(idempotent_request_key: key, idempotent_response_payload: data, expire_at: expire_at)
+      end
+      true
+    end
+  end
+
+  def initialize
+    require 'active_record'
+  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'
+    end
+  end
+
+  def with_idempotency_key(request_key)
+    db_safe_key = Base64.strict_encode64(request_key)
+
+    lock_name = "idempo_%s" % db_safe_key[0..48]
+    quoted_lock_name = model.connection.quote(lock_name) # Note there is a limit of 64 bytes on the lock name
+    did_acquire = model.connection.select_value("SELECT GET_LOCK(%s, %d)" % [quoted_lock_name, 0])
+
+    raise Idempo::ConcurrentRequest unless did_acquire == 1
+
+    begin
+      yield(Store.new(db_safe_key, model))
+    ensure
+      model.connection.select_value("SELECT RELEASE_LOCK(%s)" % quoted_lock_name)
+    end
+  end
+end

data/lib/idempo/memory_backend.rb

@@ -0,0 +1,45 @@
+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
+    @response_store = Idempo::ResponseStore.new
+  end
+
+  class Store < Struct.new(:store_mutex, :response_store, :key, keyword_init: true)
+    def lookup
+      store_mutex.synchronize do
+        response_store.lookup(key)
+      end
+    end
+
+    def store(data:, ttl:)
+      store_mutex.synchronize do
+        response_store.save(key, data, ttl)
+      end
+    end
+  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
+      yield(store)
+    ensure
+      @requests_in_flight_mutex.synchronize { @in_progress.delete(request_key) }
+    end
+  end
+end

data/lib/idempo/redis_backend.rb

@@ -0,0 +1,104 @@
+class Idempo::RedisBackend
+  # The TTL value for the lock, which is used if the process
+  # holding the lock crashes or gets killed
+  LOCK_TTL_SECONDS = 5 * 60
+
+  # See https://redis.io/topics/distlock
+  DELETE_BY_KEY_AND_VALUE_SCRIPT = <<~EOL
+    redis.replicate_commands()
+    if redis.call("get",KEYS[1]) == ARGV[1] then
+      -- we are still holding the lock, release it
+      redis.call("del",KEYS[1])
+      return "ok"
+    else
+      -- someone else holds the lock or it has expired
+      return "lock_lost"
+    end
+  EOL
+
+  # See https://redis.io/topics/distlock as well as a rebuttal in
+  # https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html
+  SET_WITH_TTL_IF_LOCK_STILL_HELD_SCRIPT = <<~EOL
+    redis.replicate_commands()
+    if redis.call("get", KEYS[1]) == ARGV[1] then
+      -- we are still holding the lock, we can go ahead and set it
+      redis.call("set", KEYS[2], ARGV[2], "px", ARGV[3])
+      return "ok"
+    else
+      return "lock_lost"
+    end
+  EOL
+
+  class Store < Struct.new(:redis_pool, :key, :lock_redis_key, :lock_token, keyword_init: true)
+    def lookup
+      response_redis_key = "idempo:response:#{key}"
+      redis_pool.with do |r|
+        bin_str = r.get(response_redis_key)
+        bin_str&.force_encoding(Encoding::BINARY)
+      end
+    end
+
+    def store(data:, ttl:)
+      response_redis_key = "idempo:response:#{key}"
+      ttl_millis = (ttl * 1000.0).round
+
+      # We save our payload using a script, and we will _only_ save it if our lock is still held.
+      # If our lock expires during the request - for example our app.call takes too long -
+      # we might have lost it, and another request has already saved a payload on our behalf. At this point
+      # we have no guarantee that our response was generated exclusively, or that the response that was generated
+      # by our "competitor" is equal to ours, or that a "competing" request is not holding our lock and executing the
+      # same workload as we just did. The only sensible thing to do when we encounter this is to actually _skip_ the write.
+      keys = [lock_redis_key, response_redis_key]
+      argv = [lock_token, data.force_encoding(Encoding::BINARY), ttl_millis]
+      outcome_of_save = redis_pool.with do |r|
+        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_when_storing', 1, outcome: outcome_of_save)
+    end
+  end
+
+  class NullPool < Struct.new(:redis)
+    def with
+      yield redis
+    end
+  end
+
+  def initialize(redis_or_connection_pool)
+    require 'redis'
+    require 'securerandom'
+    @redis_pool = redis_or_connection_pool.respond_to?(:with) ? redis_or_connection_pool : NullPool.new(redis_or_connection_pool)
+  end
+
+  def with_idempotency_key(request_key)
+    lock_key = "idempo:lock:#{request_key}"
+    token = SecureRandom.bytes(32)
+    did_acquire = @redis_pool.with { |r| r.set(lock_key, token, nx: true, ex: LOCK_TTL_SECONDS) }
+
+    raise Idempo::ConcurrentRequest unless did_acquire
+
+    begin
+      store = Store.new(redis_pool: @redis_pool, lock_redis_key: lock_key, lock_token: token, key: request_key)
+      yield(store)
+    ensure
+      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_release_lock', 1, outcome: outcome_of_del)
+    end
+  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)
+  rescue Redis::CommandError => e
+    if e.message.include? "NOSCRIPT"
+      # The Redis server has never seen this script before. Needs to run only once in the entire lifetime
+      # of the Redis server, until the script changes - in which case it will be loaded under a different SHA
+      redis.script(:load, script_code)
+      retry
+    else
+      raise e
+    end
+  end
+end

data/lib/idempo/response_store.rb

@@ -0,0 +1,57 @@
+class Idempo::ResponseStore
+  ExpiryHandle = Struct.new(:key, :expire_at)
+  StoredResponse = Struct.new(:key, :expire_at, :payload)
+
+  def initialize
+    @values = {}
+    @expiries = []
+  end
+
+  def save(key, value, expire_in)
+    prune
+    exp = expire_in + Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    res = StoredResponse.new(key, exp, value)
+    expiry_handle = ExpiryHandle.new(key, exp)
+    binary_insert(@expiries, expiry_handle, &:expire_at)
+    @values[key] = res
+  end
+
+  def lookup(key)
+    prune
+    stored = @values[key]
+    return unless stored
+    return stored.payload if stored.expire_at > Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    @values.delete(key)
+    nil
+  end
+
+  private
+
+  def prune
+    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    items_to_delete = remove_lower_than(@expiries, now, &:expire_at)
+    items_to_delete.each do |expiry_handle|
+      @values.delete(expiry_handle.key) if @values[expiry_handle.key] && @values[expiry_handle.key].expire_at < now
+    end
+  end
+
+  def binary_insert(array, item, &property_getter)
+    at_i = array.bsearch_index do |stored_item|
+      yield(stored_item) <= yield(item)
+    end
+    at_i ? array.insert(at_i, item) : array.push(item)
+  end
+
+  def remove_lower_than(array, threshold_value, &property_getter)
+    at_i = array.bsearch_index do |stored_item|
+      yield(stored_item) <= threshold_value
+    end
+    if at_i
+      array[at_i..array.length].tap do |_deleted_items|
+        array.replace(array[0..at_i])
+      end
+    else
+      []
+    end
+  end
+end

data/lib/idempo/version.rb

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

data/lib/idempo.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'zlib'
+require 'msgpack'
+require 'base64'
+require 'digest'
+require 'json'
+require 'measurometer'
+
+require_relative "idempo/version"
+require_relative "idempo/memory_backend"
+require_relative "idempo/redis_backend"
+require_relative "idempo/active_record_backend"
+
+class Idempo
+  DEFAULT_TTL = 30
+  SAVED_RESPONSE_BODY_SIZE_LIMIT = 4 * 1024 * 1024
+
+  class Error < StandardError; end
+
+  class ConcurrentRequest < Error; end
+
+  class MalformedIdempotencyKey < Error; end
+
+  def initialize(app, backend: MemoryBackend.new)
+    @backend = backend
+    @app = app
+  end
+
+  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)
+
+    # The RFC requires that the Idempotency-Key header value is enclosed in quotes
+    idempotency_key_header = unquote(idempotency_key_header)
+    raise MalformedIdempotencyKey if idempotency_key_header == ''
+
+    fingerprint = compute_request_fingerprint(req)
+    request_key = "#{idempotency_key_header}_#{fingerprint}"
+
+    @backend.with_idempotency_key(request_key) do |store|
+      if stored_response = store.lookup
+        Measurometer.increment_counter('idempo.served', 1, via: 'cached')
+        return from_persisted_response(stored_response)
+      end
+
+      status, headers, body = @app.call(env)
+
+      if response_may_be_persisted?(status, headers, body)
+        expires_in_seconds = (headers.delete('X-Idempo-Persist-For-Seconds') || DEFAULT_TTL).to_i
+        # 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.served', 1, via: 'stored')
+      [status, headers, body]
+    end
+  rescue MalformedIdempotencyKey
+    res = {
+      ok: false,
+      error: {
+        message: "The Idempotency-Key header provided was empty"
+      }
+    }
+    [400, {'Content-Type' => 'application/json'}, [JSON.pretty_generate(res)]]
+  rescue ConcurrentRequest
+    Measurometer.increment_counter('idempo.served', 1, via: 'concurrent-request-error')
+    res = {
+      ok: false,
+      error: {
+        message: "Another request with this idempotency key is still in progress, please try again later"
+      }
+    }
+    [429, {'Retry-After' => '2', 'Content-Type' => 'application/json'}, [JSON.pretty_generate(res)]]
+  end
+
+  private
+
+  def from_persisted_response(marshaled_response)
+    if marshaled_response[-2..-1] != ':1'
+      raise Error, "Unknown serialization of the marshaled response"
+    else
+      MessagePack.unpack(Zlib.inflate(marshaled_response[0..-3]))
+    end
+  end
+
+  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)
+
+    # Only keep headers which are strings
+    stringified_headers = headers.each_with_object({}) do |(header, value), filtered|
+      filtered[header] = value if 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)
+
+    # 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]
+  end
+
+  def response_may_be_persisted?(status, headers, body)
+    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 false unless body.is_a?(Array) # Arbitrary iterable of unknown size
+
+    precomputed_body_size = body.inject(0) { |sum, chunk| sum + chunk.bytesize }
+    precomputed_body_size <= SAVED_RESPONSE_BODY_SIZE_LIMIT
+  end
+
+  def status_may_be_persisted?(status)
+    case status
+    when 200..400
+      true
+    when 429, 425
+      false
+    when 400..499
+      true
+    else
+      false
+    end
+  end
+
+  def compute_request_fingerprint(req)
+    d = Digest::SHA256.new
+    d << req.url << "\n"
+    d << req.request_method << "\n"
+    while chunk = req.env['rack.input'].read(1024 * 65)
+      d << chunk
+    end
+    Base64.strict_encode64(d.digest)
+  ensure
+    req.env['rack.input'].rewind
+  end
+
+  def extract_idempotency_key_from(env)
+    env['HTTP_IDEMPOTENCY_KEY'] || env['HTTP_X_IDEMPOTENCY_KEY']
+  end
+
+  def request_verb_idempotent?(request)
+    request.get? || request.head? || request.options?
+  end
+
+  def unquote(str)
+    # Do not use regular expressions so that we don't have to thing about a catastrophic lookahead
+    double_quote = '"'
+    if str.start_with?(double_quote) && str.end_with?(double_quote)
+      str[1..-2]
+    else
+      str
+    end
+  end
+end

metadata

@@ -0,0 +1,205 @@
+--- !ruby/object:Gem::Specification
+name: idempo
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Julik Tarkhanov
+- Pablo Crivella
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: measurometer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: wetransfer_style
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides idempotency keys for Rack applications.
+email:
+- me@julik.nl
+- pablocrivella@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- idempo.gemspec
+- lib/idempo.rb
+- lib/idempo/active_record_backend.rb
+- lib/idempo/memory_backend.rb
+- lib/idempo/redis_backend.rb
+- lib/idempo/response_store.rb
+- lib/idempo/version.rb
+homepage: https://github.com/julik/idempo
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/julik/idempo
+  source_code_uri: https://github.com/julik/idempo
+  changelog_uri: https://github.com/julik/idempo/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Idempotency keys for all.
+test_files: []