thanx-knockoff 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e4a9c23826fcfe014d7664d2b77b099356b4c8e1fefff23f2c50a90311c224c
+  data.tar.gz: 37d81e202e622fcd79d203339e4f0c4c705f52beb2d53ab73c9235fdf2833d33
+SHA512:
+  metadata.gz: b589d8997c9ce7f627c82ffa05f147448d8a19f95650c5b53f0b287ec17a7efa39b83e918de0cbcd57a3b312151e877d4f0797c847b4ec8691fb3461dc9344a5
+  data.tar.gz: a33d6341c20bb278a0357e0eabbc14f6639ba6a5bf5af3f1c387402ba207745cc4d091e8a5cab7d75968bc0949d284f250db199f267006468fb66221c516b028

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/spec/tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+notifications:
+  email: false
+rvm:
+  - 2.3.1
+  - 2.4.0
+  - 2.5.1
+  - ruby-head

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## Unreleased
+
+*None*
+
+## 1.1.0
+
+- Allow for not checking `inside_transaction?` on primary database (https://github.com/joinhandshake/knockoff/pull/13)
+- Allow setting `Knockoff.default_target` to set the default target other than `:primary` (https://github.com/joinhandshake/knockoff/pull/11)
+- Drop Ruby 2.2 support
+- Add Ruby 2.5 support

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in knockoff.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Scott Ringwelski
+
+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,204 @@
+# Knockoff
+
+[![Build Status](https://travis-ci.org/joinhandshake/knockoff.svg?branch=master)](https://travis-ci.org/joinhandshake/knockoff)
+[![Gem Version](https://badge.fury.io/rb/knockoff.svg)](https://badge.fury.io/rb/knockoff)
+
+A gem for easily using read replicas.
+
+:handshake: Battle tested at [Handshake](https://joinhandshake.com/engineering/)
+
+## Library Goals
+
+* Minimal ActiveRecord monkey-patching
+* Easy run-time configuration using ENV variables
+* Opt-in usage of replicas
+* No need to change code when adding/removing replicas
+* Be thread safe
+
+## Supported Versions
+
+Knockoff supports Rails 4 and 5
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'knockoff'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install knockoff
+
+## Usage
+
+### Initializer
+
+Add an initializer at config/knockoff.rb with the below contents
+
+```
+Knockoff.enabled = true # NOTE: Consider adding ENV based disabling
+```
+
+### Configuration
+
+Configuration is done using ENV properties. This makes it easy to add and remove replicas at runtime (or to fully disable if needed). First, set up ENV variables pointing to your replica databases. Consider using the [dotenv](https://github.com/bkeepers/dotenv) gem for manging ENV variables.
+
+```
+# .env
+
+REPLICA_1=postgres://username:password@localhost:5432/database_name
+```
+
+The second ENV variable to set is `KNOCKOFF_REPLICA_ENVS` which is a comma-separated list of ENVS holding database URLs to use as replicas. In this case, the ENV would be set as follows.
+
+```
+# .env
+
+KNOCKOFF_REPLICA_ENVS=REPLICA_1
+```
+
+Note that it can be multiple replicas, and `knockoff` will use both evenly:
+
+```
+KNOCKOFF_REPLICA_ENVS=REPLICA_1,REPLICA_2
+```
+
+Lastly, knockoff will read the `'knockoff_replicas'` database.yml config for specifying additional params:
+
+```
+# database.yml
+
+knockoff_replicas:
+  <<: *common
+  prepared_statements: false
+```
+
+### Basics
+
+To use one of the replica databases, use
+
+```
+Knockoff.on_replica { User.count }
+```
+
+To force primary, use
+
+```
+Knockoff.on_primary { User.create(name: 'Bob') }
+```
+
+### Using in Controllers
+
+A common use case is to use replicas for GET requests and otherwise use primary. A simplified use case might look something like this:
+
+```
+# application_controller.rb
+
+around_action :choose_database
+
+def choose_database(&block)
+  if should_use_primary_database?
+    Knockoff.on_primary(&block)
+  else
+    Knockoff.on_replica(&block)
+  end
+end
+
+def should_use_primary_database?
+  request.method_symbol != :get
+end
+
+```
+
+#### Replication Lag
+
+Replicas will often be slightly behind the primary database. To compensate, consider "sticking" a user who has recently made changes to the primary for a small duration of time to the primary database. This will avoid cases where a user creates a record on primary, is redirected to view that record, and receives a 404 error since the record is not yet in the replica. A simple implementation for this could look like:
+
+```
+# application_record.rb
+
+after_commit :track_commit_occurred_in_request
+
+# If any commit happens in a request, we record that and have the logged_in_user
+# read from primary for a short period of time.
+def track_commit_occurred_in_request
+  RequestLocals.store['commit_occurred_in_current_request'] = true
+end
+
+# application_controller.rb
+
+after_action :force_leader_if_commit
+
+def force_leader_if_commit
+  if RequestLocals.store['commit_occurred_in_current_request'].to_b
+    session[:use_leader_until] = Time.current + FORCE_PRIMARY_DURATION
+  end
+end
+
+```
+
+Then, in your `should_use_primary_database?` method, consult `session[:use_leader_until]` for the decision.
+
+### Run-time Configuration
+
+Knockoff can be configured during runtime. This is done through the `establish_new_connections!` method which takes in a hash of new configurations to apply to each replica before re-connecting.
+
+```
+Knockoff.establish_new_connections!({ 'pool' => db_pool })
+```
+
+For example, to specify a puma connection pool at bootup your code might look something like
+
+```
+# puma.rb
+
+db_pool = Integer(ENV['PUMA_WORKER_DB_POOL'] || threads_count)
+# Configure the database connection to have the new pool size and re-establish connection
+database_config = ActiveRecord::Base.configurations[Rails.env] || Rails.application.config.database_configuration[Rails.env]
+database_config['pool'] = db_pool
+ActiveRecord::Base.establish_connection(database_config)
+Knockoff.establish_new_connections!({ 'pool' => db_pool })
+
+```
+
+#### Forking
+
+For forking servers, you may disconnect all replicas before forking with `Knockoff.disconnect_all!`.
+
+```
+# puma.rb
+
+before_fork do
+  ActiveRecord::Base.connection_pool.disconnect!
+  Knockoff.disconnect_all!
+end
+```
+
+### Other Cases
+
+There are likely other cases specific to each application where it makes sense to force primary database and avoid replication lag. Good candidates are time-based pages (a live calendar, for example), forms, and payments.
+
+## Usage Notes
+
+* Do not use prepared statements with this gem
+
+## 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 tags, 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/joinhandshake/knockoff.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "knockoff"
+
+# 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

data/bin/setup

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

data/ci/install_modern_sqlite.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -e # halt script on error
+
+sudo apt-get autoremove sqlite3
+sudo apt-get install python-software-properties
+sudo apt-add-repository -y ppa:travis-ci/sqlite3
+sudo apt-get -y update
+sudo apt-cache show sqlite3
+sudo apt-get install sqlite3=3.7.15.1-1~travis1
+sudo sqlite3 -version
+sudo psql --version
+sudo mysql --version
+gem update bundler

data/knockoff.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'knockoff/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "thanx-knockoff"
+  spec.version       = Knockoff::VERSION
+  spec.authors       = ["Scott Ringwelski"]
+  spec.email         = ["me@sgringwe.com"]
+
+  spec.summary       = %q{A gem for easily using read replicas}
+  spec.homepage      = "https://github.com/sgringwe/knockoff"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activerecord', '>= 4.0.0'
+  spec.add_runtime_dependency 'activesupport', '>= 4.0.0'
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'sqlite3'
+end

data/lib/knockoff.rb

@@ -0,0 +1,65 @@
+require 'active_record'
+require 'knockoff/version'
+require 'knockoff/base'
+require 'knockoff/config'
+require 'knockoff/error'
+require 'knockoff/replica_connection_pool'
+require 'knockoff/active_record/base'
+require 'knockoff/active_record/relation'
+
+module Knockoff
+  class << self
+    attr_accessor :enabled
+    attr_reader :default_target
+
+    def on_replica(check_transaction: true, &block)
+      Base.new(:replica, check_transaction: check_transaction).run(&block)
+    end
+
+    def on_primary(&block)
+      Base.new(:primary).run(&block)
+    end
+
+    def default_target=(target)
+      @default_target = Base.new(target).target
+    end
+
+    def replica_pool
+      @replica_pool ||= ReplicaConnectionPool.new(config.replica_database_keys)
+    end
+
+    def clear_all_active_connections!
+      replica_pool.clear_all_active_connections!
+    end
+
+    # Iterates through the replica pool and calls disconnect on each one's connection.
+    def disconnect_all!
+      replica_pool.disconnect_all_replicas!
+    end
+
+    # Updates the config (both internal representation and the ActiveRecord::Base.configuration)
+    # with the new config, and then reconnects each replica connection in the replica
+    # pool.
+    def establish_new_connections!(new_config)
+      config.update_replica_configs(new_config)
+      replica_pool.reconnect_all_replicas!
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def base_transaction_depth
+      @base_transaction_depth ||= begin
+        testcase = ActiveSupport::TestCase
+        if defined?(testcase) &&
+            testcase.respond_to?(:use_transactional_fixtures) &&
+            testcase.try(:use_transactional_fixtures)
+          1
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/knockoff/active_record/base.rb

@@ -0,0 +1,29 @@
+module ActiveRecord
+  class Base
+    class << self
+      alias_method :original_connection, :connection
+
+      def connection
+        target = Thread.current[:knockoff] || Knockoff.default_target
+        case target
+        when :replica
+          # Attempts to use a random replica connection, but otherwise falls back to primary
+          Knockoff.replica_pool.random_replica_connection.original_connection
+        when :primary, NilClass
+          original_connection
+        else
+          raise Knockoff::Error, "Invalid target: #{Thread.current[:knockoff]}"
+        end
+      end
+
+      # Generate scope at top level e.g. User.on_replica
+      def on_replica
+        # Why where(nil)?
+        # http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
+        context = where(nil)
+        context.knockoff_target = :replica
+        context
+      end
+    end
+  end
+end

data/lib/knockoff/active_record/relation.rb

@@ -0,0 +1,28 @@
+module ActiveRecord
+  class Relation
+    attr_accessor :knockoff_target
+
+    # Supports queries like User.on_replica.to_a
+    alias_method :exec_queries_without_knockoff, :exec_queries
+
+    def exec_queries
+      if knockoff_target == :replica
+        Knockoff.on_replica { exec_queries_without_knockoff }
+      else
+        exec_queries_without_knockoff
+      end
+    end
+
+
+    # Supports queries like User.on_replica.count
+    alias_method :calculate_without_knockoff, :calculate
+
+    def calculate(*args)
+      if knockoff_target == :replica
+        Knockoff.on_replica { calculate_without_knockoff(*args) }
+      else
+        calculate_without_knockoff(*args)
+      end
+    end
+  end
+end

data/lib/knockoff/base.rb

@@ -0,0 +1,43 @@
+module Knockoff
+  class Base
+    attr_reader :target
+
+    def initialize(target, check_transaction: true)
+      @target = decide_with(target, check_transaction)
+    end
+
+    def run(&block)
+      run_on @target, &block
+    end
+
+  private
+
+    def decide_with(target, check_transaction)
+      calculated_target =
+        if Knockoff.enabled
+          target
+        else
+          :primary
+        end
+
+      # Don't allow setting the target to anything other than primary if we are already in a transaction
+      if calculated_target != :primary && check_transaction && inside_transaction?
+        raise Knockoff::Error.new('on_replica cannot be used inside transaction block!')
+      end
+      calculated_target
+    end
+
+    def inside_transaction?
+      open_transactions = run_on(:primary) { ActiveRecord::Base.connection.open_transactions }
+      open_transactions > Knockoff.base_transaction_depth
+    end
+
+    def run_on(target)
+      backup = Thread.current[:knockoff] # Save for recursive nested calls
+      Thread.current[:knockoff] = target
+      yield
+    ensure
+      Thread.current[:knockoff] = backup
+    end
+  end
+end

data/lib/knockoff/config.rb

@@ -0,0 +1,113 @@
+module Knockoff
+  class Config
+    # The current environment. Normally set to Rails.env, but
+    # will default to 'development' outside of Rails apps.
+    attr_reader :environment
+
+    # An array of configs to use for the replica pool.
+    attr_reader :replica_configs
+
+    # A hash of replica configs to their config hash.
+    attr_reader :replicas_configurations
+
+    def initialize
+      @environment = 'development'
+      @replicas_configurations = {}
+      set_replica_configs
+
+      if !properly_configured? && Knockoff.enabled
+        puts "[Knockoff] WARNING: Detected enabled Knockoff without proper replica pool configuration. Setting Knockoff.enabled to false."
+        Knockoff.enabled = false
+      end
+    end
+
+    def replica_database_keys
+      @replicas_configurations.keys
+    end
+
+    def replica_env_keys
+      if ENV['KNOCKOFF_REPLICA_ENVS'].nil?
+        []
+      else
+        ENV['KNOCKOFF_REPLICA_ENVS'].split(',').map(&:strip)
+      end
+    end
+
+    def update_replica_configs(new_configs)
+      ActiveRecord::Base.configurations['knockoff_replicas'].merge(new_configs) if ActiveRecord::Base.configurations['knockoff_replicas'].present?
+      @replicas_configurations.each do |key, _config|
+        update_replica_config(key, new_configs)
+      end
+    end
+
+    # If replica_configs actually containts some configuration information, then
+    # we know it was properly configured. Improper URI's will be ignored during the
+    # initialization step.
+    def properly_configured?
+      !@replica_configs.empty?
+    end
+
+    private
+
+    def update_replica_config(key, new_configs)
+      @replicas_configurations[key].merge!(new_configs)
+      ActiveRecord::Base.configurations[key].merge!(new_configs)
+    end
+
+    def set_replica_configs
+      @replica_configs ||= parse_knockoff_replica_envs_to_configs
+    end
+
+    def parse_knockoff_replica_envs_to_configs
+      # As a basic prevention of crashes, attempt to parse each DB uri
+      # and don't add the uri to the final list if it can't be parsed
+      replica_env_keys.map.with_index(0) do |env_key, index|
+        begin
+          uri = URI.parse(ENV[env_key])
+
+          # Configure parameters such as prepared_statements, pool, reaping_frequency for all replicas.
+          replica_config = ActiveRecord::Base.configurations['knockoff_replicas'] || {}
+
+          adapter =
+            if uri.scheme == "postgres"
+              'postgresql'
+            else
+              uri.scheme
+            end
+
+          # Base config from the ENV uri. Sqlite is a special case
+          # and all others follow 'normal' config
+          uri_config =
+            if uri.scheme == 'sqlite3'
+              {
+                'adapter' => adapter,
+                'database' => uri.to_s.split(':')[1]
+              }
+            else
+              {
+                'adapter' => adapter,
+                'database' => (uri.path || "").split("/")[1],
+                'username' => uri.user,
+                'password' => uri.password,
+                'host' => uri.host,
+                'port' => uri.port
+              }.merge(Rack::Utils.parse_query(uri.query))
+            end
+
+          # Store the hash in configuration and use it when we establish the connection later.
+          key = "knockoff_replica_#{index}"
+          full_config = replica_config.merge(uri_config)
+
+          ActiveRecord::Base.configurations[key] = full_config
+          @replicas_configurations[key] = full_config
+        rescue URI::InvalidURIError
+          Rails.logger.info "LOG NOTIFIER: Invalid URL specified in follower_env_keys. Not including URI, which may result in no followers used." # URI is purposely not printed to logs
+          # Return a 'nil' which will be removed from
+          # configs with `compact`, resulting in no configs and no followers,
+          # therefore disabled since this env will not be in environments list.
+          nil
+        end
+      end.compact
+    end
+  end
+end

data/lib/knockoff/error.rb

@@ -0,0 +1,4 @@
+module Knockoff
+  class Error < StandardError
+  end
+end

data/lib/knockoff/replica_connection_pool.rb

@@ -0,0 +1,58 @@
+module Knockoff
+  class ReplicaConnectionPool
+    attr_reader :pool
+
+    def initialize(config_keys)
+      @pool = Concurrent::Hash.new
+
+      config_keys.each do |config_key|
+        @pool[config_key] = connection_class(config_key)
+      end
+    end
+
+    def clear_all_active_connections!
+      @pool.each do |_name, klass|
+        klass.clear_active_connections!
+      end
+    end
+
+    def disconnect_all_replicas!
+      @pool.each do |_name, klass|
+        klass.connection.disconnect!
+      end
+    end
+
+    # Assumes that the config has been updated to something new, and
+    # simply reconnects with the config.
+    def reconnect_all_replicas!
+      @pool.each do |database_key, klass|
+        klass.establish_connection database_key.to_sym
+      end
+    end
+
+    def random_replica_connection
+      @pool[@pool.keys.sample]
+    end
+
+    # Based off of code from replica_pools gem
+    # generates a unique ActiveRecord::Base subclass for a single replica
+    def connection_class(config_key)
+      # Config key is of schema 'knockoff_replica_n'
+      class_name = "KnockoffReplica#{config_key.split('_').last}"
+
+      # TODO: Hardcoding the uri string feels meh. Either set the database config
+      # or reference ENV instead
+      Knockoff.module_eval %Q{
+        class #{class_name} < ActiveRecord::Base
+          self.abstract_class = true
+          establish_connection :#{config_key}
+          def self.connection_config
+            configurations[#{config_key.to_s.inspect}]
+          end
+        end
+      }, __FILE__, __LINE__
+
+      Knockoff.const_get(class_name)
+    end
+  end
+end

data/lib/knockoff/version.rb

@@ -0,0 +1,3 @@
+module Knockoff
+  VERSION = '1.1.1'.freeze
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: thanx-knockoff
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Scott Ringwelski
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: sqlite3
+  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: 
+email:
+- me@sgringwe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ci/install_modern_sqlite.sh
+- knockoff.gemspec
+- lib/knockoff.rb
+- lib/knockoff/active_record/base.rb
+- lib/knockoff/active_record/relation.rb
+- lib/knockoff/base.rb
+- lib/knockoff/config.rb
+- lib/knockoff/error.rb
+- lib/knockoff/replica_connection_pool.rb
+- lib/knockoff/version.rb
+homepage: https://github.com/sgringwe/knockoff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: A gem for easily using read replicas
+test_files: []