activerecord_autoreplica 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ed3fdce7e191b78e8bc24c13cc926cb9b625052
-  data.tar.gz: 02bdd2ae70931f1a7376a9264bf6a5ac6442275e
+  metadata.gz: 0dec3a7a02bfdd20f0428bdb405016f3b16d7c12
+  data.tar.gz: c84f381a3f3c1d01f2066aec82597333a7a8d2c8
 SHA512:
-  metadata.gz: fa680e51be925cbe09927aa323e44be88fd26cf82b799474761bbae59a135a2123e1f459e9e350f9949eb58462338e7dc433558aaa9156463d8881fe141f82cf
-  data.tar.gz: 7db0c18d68ed48fdbf428d56bff0f49a1ec5137ef8f5c10e695eef9d41ec3e860a52ffff11256eb2525f98c7b004ecf1b4e465d8fa711e1d1dde932252250f5f
+  metadata.gz: 9d0de5551b0801a3dd9149111e2610715f27a12619f56fdbb29e3108591c06678e326bb2e7e14836ccc89e6f9ab4fc7eef212d52074bba39b4a37f332e8c852b
+  data.tar.gz: e4efd1d3811ffd76b38acb6707b7dbe57babbcad919da69d49e67746236fc15c58219c5ca2bf0b41745c9501f5326a4c925613f55c636a337f4619f3e8a2c72d

data/README.md

@@ -17,7 +17,9 @@ The only dependency is ActiveRecord itself.
 
 ### Usage
 
-The API consists of _one_ method. Pass it a complete ActiveRecord connection specificaton hash, and
+There are two options.
+
+The first is to pass a complete ActiveRecord connection specificaton hash, and
 everything within the block is going to use the read slave connections when performing standard
 ActiveRecord `SELECT` queries (not the hand-written ones).
 
@@ -27,11 +29,21 @@ ActiveRecord `SELECT` queries (not the hand-written ones).
     end
 
 Connection strings (URLs) are also supported, just like in ActiveRecord itself:
-  
+
     AutoReplica.using_read_replica_at('sqlite3:/replica_db_145.sqlite3') do
       ...
     end
-  
+
+Note that this will create and disconnect a ConnectionPool each time the block is called.
+
+The other option is to create the ConnectionPool yourself, and pass it to `using_read_replica_pool`:
+
+    AutoReplica.using_read_replica_pool(my_connection_pool) do
+      ...
+    end
+
+This will release connections to the pool at the end of the block, but not close them.
+
 To use in Rails controller context (for all actions of this controller):
 
     class SlowDataReportsController < ApplicationController
@@ -56,7 +68,7 @@ act accordingly.
 
 The `using_read_replica_at` block will allocate a `ConnectionPool` like the standard `ActiveRecord` connection
 manager does, and the pool is going to be closed and torn down at the end of the block. Since it only uses the basic
-ActiveRecord facilities (including mutexes) it should be threadsafe (but _not_ thread-local since the connection 
+ActiveRecord facilities (including mutexes) it should be threadsafe (but _not_ thread-local since the connection
 handler in ActiveRecord isn't).
 
 ### Running the specs
@@ -78,7 +90,7 @@ Rails 3.x support is likely to be dropped in the next major version.
 The gem version is specified in the Rakefile.
 
 ### Contributing to activerecord_autoreplica
- 
+
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
 * Fork the project.

data/Rakefile

@@ -13,7 +13,7 @@ require 'rake'
 
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
-  gem.version = '1.2.0'
+  gem.version = '1.3.0'
   # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
   gem.name = "activerecord_autoreplica"
   gem.homepage = "http://github.com/WeTransfer/activerecord_autoreplica"

data/activerecord_autoreplica.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: activerecord_autoreplica 1.2.0 ruby lib
+# stub: activerecord_autoreplica 1.3.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "activerecord_autoreplica"
-  s.version = "1.2.0"
+  s.version = "1.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Julik Tarkhanov"]
-  s.date = "2016-10-23"
+  s.date = "2016-11-07"
   s.description = " Redirect all SELECT queries to a separate connection within a block "
   s.email = "me@julik.nl"
   s.extra_rdoc_files = [

data/lib/activerecord_autoreplica.rb

@@ -14,10 +14,10 @@
 # * SomeRecord.connection calls ActiveRecord::Base.connection_handler
 # * It then asks the connection handler for a connection for this specific ActiveRecord subclass, or barring that
 #   - for the connection for one of it's ancestors, ending with ActiveRecord::Base itself
-# * The ConnectionHandler, in turn, asks one of it's managed ConnectionPool objects to give it a connection for use.
+# * The ConnectionHandler, in turn, asks one of its managed ConnectionPool objects to give it a connection for use.
 # * The connection is returned and then the query is ran against it.
 #
-# This is why the only integration point for this is ++ActiveRecord::Base.connection_hanler=++
+# This is why the only integration point for this is ++ActiveRecord::Base.connection_handler=++
 # To make our trick work, here is what we do:
 #
 # First we wrap the original ConnectionHandler used by ActiveRecord in our own proxy. That proxy will ask the original
@@ -41,7 +41,7 @@ module AutoReplica
   # Runs a given block with all SELECT statements being executed against the read slave
   # database.
   #
-  #     AutoReplica.using_read_replica_at(:adapter => 'mysql2', :datbase => 'read_replica', ...) do
+  #     AutoReplica.using_read_replica_at(:adapter => 'mysql2', :database => 'read_replica', ...) do
   #       customer = Customer.find(3) # Will SELECT from the replica database at the connection spec passed to the block
   #       customer.register_complaint! # Will UPDATE to the master database connection
   #     end
@@ -49,63 +49,49 @@ module AutoReplica
   # @param replica_connection_spec_hash_or_url[String, Hash] an ActiveRecord connection specification or a DSN URL
   # @return [void]
   def self.using_read_replica_at(replica_connection_spec_hash_or_url)
+    in_replica_context(replica_connection_spec_hash_or_url, AdHocConnectionHandler){ yield }
+  end
+
+  # Runs a given block with all SELECT statements being executed using the read slave
+  # connection pool.
+  #
+  #     read_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new(:adapter => 'mysql2', :database => 'read_replica', ...)
+  #     AutoReplica.using_read_replica_pool(read_pool) do
+  #       customer = Customer.find(3) # Will SELECT from the replica database picked off the read pool
+  #       customer.register_complaint! # Will UPDATE to the master database connection
+  #     end
+  #
+  # @param replica_connection_pool[ActiveRecord::ConnectionAdapters::ConnectionPool] an ActiveRecord connection pool instance
+  # @return [void]
+  def self.using_read_replica_pool(replica_connection_pool)
+    in_replica_context(replica_connection_pool){ yield }
+  end
+
+  def self.in_replica_context(handler_params, handler_class=ConnectionHandler)
     return yield if @in_replica_context # This method should not be reentrant
-    
-    # Resolve if there is a URL given
-    # Duplicate the hash so that we can change it if we have to
-    # (say by deleting :adapter)
-    config_hash = if replica_connection_spec_hash_or_url.is_a?(Hash)
-      replica_connection_spec_hash_or_url.dup
-    else
-      resolve_connection_url(replica_connection_spec_hash_or_url).dup
-    end
-    
+
     @in_replica_context = true
-    # Wrap the connection handler in our proxy
+
     original_connection_handler = ActiveRecord::Base.connection_handler
-    custom_handler = ConnectionHandler.new(original_connection_handler, config_hash)
+    custom_handler = handler_class.new(original_connection_handler, handler_params)
     begin
       ActiveRecord::Base.connection_handler = custom_handler
       yield
     ensure
       ActiveRecord::Base.connection_handler = original_connection_handler
-      custom_handler.disconnect_read_pool!
+      custom_handler.finish
       @in_replica_context = false
     end
   end
-  
-  # Resolve an ActiveRecord connection URL, from a string to a Hash.
-  #
-  # @param url_string[String] the connection URL (like `sqlite3://...`)
-  # @return [Hash] a symbol-keyed ActiveRecord connection specification
-  def self.resolve_connection_url(url_string)
-    # TODO: privatize this method.
-    if defined?(ActiveRecord::Base::ConnectionSpecification::Resolver) # AR3
-      resolver = ActiveRecord::Base::ConnectionSpecification::Resolver.new(url_string, {})
-      resolver.send(:connection_url_to_hash, url_string) # Because making this public was so hard
-    else  # AR4
-      resolved = ActiveRecord::ConnectionAdapters::ConnectionSpecification::ConnectionUrlResolver.new(url_string).to_hash
-      resolved["database"].gsub!(/^\//, '') # which is not done by the resolver
-      resolved.symbolize_keys # which is also not done by the resolver
-    end
-  end
-  
+
   # The connection handler that wraps the ActiveRecord one. Everything gets forwarded to the wrapped
   # object, but a "spiked" connection adapter gets returned from retrieve_connection.
   class ConnectionHandler # a proxy for ActiveRecord::ConnectionAdapters::ConnectionHandler
-    def initialize(original_handler, connection_specification_hash)
+    def initialize(original_handler, read_pool)
       @original_handler = original_handler
-      # We need to maintain our own pool for read replica connections,
-      # aside from the one managed by Rails proper.
-      adapter_method = "%s_connection" % connection_specification_hash[:adapter]
-      connection_specification = begin
-        ConnectionSpecification.new('autoreplica', connection_specification_hash, adapter_method)
-      rescue ArgumentError # AR 4 and lower wants 2 arguments
-        ConnectionSpecification.new(connection_specification_hash, adapter_method)
-      end
-      @read_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new(connection_specification)
+      @read_pool = read_pool
     end
-    
+
     # Overridden method which gets called by ActiveRecord to get a connection related to a specific
     # ActiveRecord::Base subclass.
     def retrieve_connection(for_ar_class)
@@ -113,18 +99,22 @@ module AutoReplica
       connection_for_reads = @read_pool.connection
       Adapter.new(connection_for_writes, connection_for_reads)
     end
-    
+
+    def release_read_pool_connection
+      @read_pool.release_connection
+    end
+
     # Close all the connections maintained by the read pool
     def disconnect_read_pool!
       @read_pool.disconnect!
     end
-    
+
     # Disconnect both the original handler AND the read pool
     def clear_all_connections!
       disconnect_read_pool!
       @original_handler.clear_all_connections!
     end
-    
+
     # The duo for method proxying without delegate
     def respond_to_missing?(method_name)
       @original_handler.respond_to?(method_name)
@@ -132,6 +122,60 @@ module AutoReplica
     def method_missing(method_name, *args, &blk)
       @original_handler.public_send(method_name, *args, &blk)
     end
+
+    # When finishing, releases the borrowed connection back into the pool
+    def finish
+      release_read_pool_connection
+    end
+  end
+
+  # A connection handler that creates an ad-hoc read connection pool, and disconnects it when finishing
+  class AdHocConnectionHandler < ConnectionHandler
+    def initialize(original_handler, replica_connection_spec_hash_or_url)
+      connection_specification_hash = parse_params(replica_connection_spec_hash_or_url)
+      # We need to maintain our own pool for read replica connections,
+      # aside from the one managed by Rails proper.
+      adapter_method = "%s_connection" % connection_specification_hash[:adapter]
+      connection_specification = begin
+        ConnectionSpecification.new('autoreplica', connection_specification_hash, adapter_method)
+      rescue ArgumentError # AR 4 and lower wants 2 arguments
+        ConnectionSpecification.new(connection_specification_hash, adapter_method)
+      end
+      read_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new(connection_specification)
+      super(original_handler, read_pool)
+    end
+
+    def parse_params(replica_connection_spec_hash_or_url)
+      # Resolve if there is a URL given
+      # Duplicate the hash so that we can change it if we have to
+      # (say by deleting :adapter)
+      if replica_connection_spec_hash_or_url.is_a?(Hash)
+        replica_connection_spec_hash_or_url.dup
+      else
+        resolve_connection_url(replica_connection_spec_hash_or_url).dup
+      end
+    end
+
+    # Resolve an ActiveRecord connection URL, from a string to a Hash.
+    #
+    # @param url_string[String] the connection URL (like `sqlite3://...`)
+    # @return [Hash] a symbol-keyed ActiveRecord connection specification
+    def resolve_connection_url(url_string)
+      # TODO: privatize this method.
+      if defined?(ActiveRecord::Base::ConnectionSpecification::Resolver) # AR3
+        resolver = ActiveRecord::Base::ConnectionSpecification::Resolver.new(url_string, {})
+        resolver.send(:connection_url_to_hash, url_string) # Because making this public was so hard
+      else  # AR4
+        resolved = ActiveRecord::ConnectionAdapters::ConnectionSpecification::ConnectionUrlResolver.new(url_string).to_hash
+        resolved["database"].gsub!(/^\//, '') # which is not done by the resolver
+        resolved.symbolize_keys # which is also not done by the resolver
+      end
+    end
+
+    # Disconnect all read pool connections, making the pool ready to be disposed.
+    def finish
+      disconnect_read_pool!
+    end
   end
 
   # Acts as a wrapping proxy that replaces an ActiveRecord Adapter object. This is the
@@ -146,7 +190,7 @@ module AutoReplica
       @master_connection = master_connection_adapter
       @read_connection = replica_connection_adapter
     end
-  
+
     # Under the hood, ActiveRecord uses methods for the most common database statements
     # like "select_all", "select_one", "select_value" and so on. Those can be overridden by concrete
     # connection adapters, but in the basic abstract Adapter they get included from
@@ -160,7 +204,7 @@ module AutoReplica
         @read_connection.send(select_method_name, *method_arguments)
       end
     end
-    
+
     # The duo for method proxying without delegate
     def respond_to_missing?(method_name)
       @master_connection.respond_to?(method_name)
@@ -169,11 +213,11 @@ module AutoReplica
       @master_connection.public_send(method_name, *args, &blk)
     end
   end
-  
+
 #  if respond_to?(:private_constant)
-#    private_constant :ConnectionSpecification 
+#    private_constant :ConnectionSpecification
 #    private_constant :ConnectionHandler
 #    private_constant :Adapter
 #  end
-  
+
 end

data/spec/activerecord_autoreplica_spec.rb

@@ -2,16 +2,16 @@ require_relative 'helper'
 require 'securerandom'
 
 describe AutoReplica do
-  
+
   before :all do
     test_seed_name = SecureRandom.hex(4)
     ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ('master_db_%s.sqlite3' % test_seed_name))
-    
+
     # Setup the master and replica connections
     @master_connection_config = ActiveRecord::Base.connection_config.dup
     @replica_connection_config = @master_connection_config.merge(database: ('replica_db_%s.sqlite3' % test_seed_name))
     @replica_connection_config_url = 'sqlite3:/replica_db_%s.sqlite3' % test_seed_name
-    
+
     ActiveRecord::Migration.suppress_messages do
       # Create both the master and the replica, with a simple small schema
       [@master_connection_config, @replica_connection_config].each do | db_config |
@@ -25,25 +25,25 @@ describe AutoReplica do
       end
     end
   end
-  
+
   after :all do
     # Ensure database files get killed afterwards
     [@master_connection_config, @replica_connection_config].map do | connection_config |
       File.unlink(connection_config[:database]) rescue nil
     end
   end
-  
+
   before :each do
     [@replica_connection_config, @master_connection_config].each do | config |
       ActiveRecord::Base.establish_connection(config)
       ActiveRecord::Base.connection.execute 'DELETE FROM things' # sqlite has no TRUNCATE
     end
   end
-  
+
   class TestThing < ActiveRecord::Base
     self.table_name = 'things'
   end
-  
+
   context 'using_read_replica_at' do
     it 'has no reentrancy problems' do
       id = described_class.using_read_replica_at(@replica_connection_config) do
@@ -53,7 +53,7 @@ describe AutoReplica do
             expect {
               TestThing.find(thing.id)
             }.to raise_error(ActiveRecord::RecordNotFound)
-            
+
             thing.id # return to the outside of the block
           end
         end
@@ -61,7 +61,7 @@ describe AutoReplica do
       found_on_master = TestThing.find(id)
       expect(found_on_master.description).to eq('A nice Thing in the master database')
     end
-    
+
     it 'executes the SELECT query against the replica database and returns the result of the block' do
       id = described_class.using_read_replica_at(@replica_connection_config) do
         thing = TestThing.create! description: 'A nice Thing in the master database'
@@ -72,20 +72,20 @@ describe AutoReplica do
       end
       found_on_master = TestThing.find(id)
       expect(found_on_master.description).to eq('A nice Thing in the master database')
-      
+
       ActiveRecord::Base.establish_connection(@replica_connection_config)
       thing_on_slave = TestThing.new(found_on_master.attributes)
       thing_on_slave.id = found_on_master.id # gets ignored in attributes
       thing_on_slave.description = 'A nice Thing that is in the slave database'
       thing_on_slave.save!
-      
+
       ActiveRecord::Base.establish_connection(@master_connection_config)
       described_class.using_read_replica_at(@replica_connection_config) do
         thing_from_replica = TestThing.find(id)
         expect(thing_from_replica.description).to eq('A nice Thing that is in the slave database')
       end
     end
-    
+
     it 'executes the SELECT query against the replica database with replica connection specification given as a URL' do
       id = described_class.using_read_replica_at(@replica_connection_config_url) do
         thing = TestThing.create! description: 'A nice Thing in the master database'
@@ -98,77 +98,120 @@ describe AutoReplica do
       expect(found_on_master.description).to eq('A nice Thing in the master database')
     end
   end
-  
+
   describe AutoReplica::ConnectionHandler do
+    it 'proxies all methods' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      expect(original_handler).to receive(:do_that_thing) { :yes }
+      pool_double = double('ConnectionPool')
+      subject = AutoReplica::ConnectionHandler.new(original_handler, pool_double)
+      expect(subject.do_that_thing).to eq(:yes)
+    end
+
+    it 'enhances connection_for and returns an instance of the Adapter' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      adapter_double = double('ActiveRecord_Adapter')
+      connection_double = double('Connection')
+      pool_double = double('ConnectionPool')
+      expect(original_handler).to receive(:retrieve_connection).with(TestThing) { adapter_double }
+      expect(pool_double).to receive(:connection) { connection_double }
+
+      subject = AutoReplica::ConnectionHandler.new(original_handler, pool_double)
+      connection = subject.retrieve_connection(TestThing)
+      expect(connection).to be_kind_of(AutoReplica::Adapter)
+    end
+
+    it 'releases the the read pool connection when finishing' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      pool_double = double('ConnectionPool')
+      subject = AutoReplica::ConnectionHandler.new(original_handler, pool_double)
+
+      expect(pool_double).to receive(:release_connection)
+      subject.finish
+    end
+
+    it 'performs clear_all_connections! both on the contained handler and on the read pool' do
+      original_handler = double('ActiveRecord_ConnectionHandler')
+      pool_double = double('ConnectionPool')
+
+      expect(original_handler).to receive(:clear_all_connections!)
+      expect(pool_double).to receive(:disconnect!)
+
+      subject = AutoReplica::ConnectionHandler.new(original_handler, pool_double)
+      subject.clear_all_connections!
+    end
+  end
+
+  describe AutoReplica::AdHocConnectionHandler do
     it 'creates a read pool with the replica connection specification hash' do
       original_handler = double('ActiveRecord_ConnectionHandler')
       expect(ActiveRecord::ConnectionAdapters::ConnectionPool).to receive(:new).
         with(instance_of(AutoReplica::ConnectionSpecification))
-      
-      AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+
+      AutoReplica::AdHocConnectionHandler.new(original_handler, @replica_connection_config)
     end
-    
+
     it 'proxies all methods' do
       original_handler = double('ActiveRecord_ConnectionHandler')
       expect(original_handler).to receive(:do_that_thing) { :yes }
-      subject = AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+      subject = AutoReplica::AdHocConnectionHandler.new(original_handler, @replica_connection_config)
       expect(subject.do_that_thing).to eq(:yes)
     end
-    
+
     it 'enhances connection_for and returns an instance of the Adapter' do
       original_handler = double('ActiveRecord_ConnectionHandler')
       adapter_double = double('ActiveRecord_Adapter')
       expect(original_handler).to receive(:retrieve_connection).with(TestThing) { adapter_double }
-      
-      subject = AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+
+      subject = AutoReplica::AdHocConnectionHandler.new(original_handler, @replica_connection_config)
       connection = subject.retrieve_connection(TestThing)
       expect(connection).to be_kind_of(AutoReplica::Adapter)
     end
-    
-    it 'disconnects the read pool when asked to' do
+
+    it 'disconnects the read pool when finishing' do
       original_handler = double('ActiveRecord_ConnectionHandler')
       pool_double = double('ConnectionPool')
       expect(ActiveRecord::ConnectionAdapters::ConnectionPool).to receive(:new).
         with(instance_of(AutoReplica::ConnectionSpecification)) { pool_double }
-      subject = AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
-      
+      subject = AutoReplica::AdHocConnectionHandler.new(original_handler, @replica_connection_config)
+
       expect(pool_double).to receive(:disconnect!)
-      subject.disconnect_read_pool!
+      subject.finish
     end
-    
+
     it 'performs clear_all_connections! both on the contained handler and on the read pool' do
       original_handler = double('ActiveRecord_ConnectionHandler')
       pool_double = double('ConnectionPool')
       expect(ActiveRecord::ConnectionAdapters::ConnectionPool).to receive(:new).
         with(instance_of(AutoReplica::ConnectionSpecification)) { pool_double }
-      
+
       expect(original_handler).to receive(:clear_all_connections!)
       expect(pool_double).to receive(:disconnect!)
-      
-      subject = AutoReplica::ConnectionHandler.new(original_handler, @replica_connection_config)
+
+      subject = AutoReplica::AdHocConnectionHandler.new(original_handler, @replica_connection_config)
       subject.clear_all_connections!
     end
   end
-  
+
   describe AutoReplica::Adapter do
     it 'mirrors select_ prefixed database statement methods in ActiveRecord::ConnectionAdapters::DatabaseStatements' do
       master = double()
       expect(master).not_to receive(:respond_to?)
       subject = AutoReplica::Adapter.new(master, double())
-      
+
       select_methods = ActiveRecord::ConnectionAdapters::DatabaseStatements.instance_methods.grep(/^select_/)
       expect(select_methods.length).to be > 1
-      
+
       select_methods.each do | select_method_in_database_statements |
         expect(subject).to respond_to(select_method_in_database_statements)
       end
     end
-    
+
     it 'redirects calls to all select_ methods to the read connection and others to the master connection' do
       master_adapter = double('Connection to the master DB')
       replica_adapter = double('Connection to the replica DB')
       subject = AutoReplica::Adapter.new(master_adapter, replica_adapter)
-      
+
       expect(master_adapter).to receive(:some_arbitrary_method) { :from_master }
       expect(replica_adapter).to receive(:select_values).with(:a, :b, :c) { :from_replica }
       expect(subject.some_arbitrary_method).to eq(:from_master)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_autoreplica
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-23 00:00:00.000000000 Z
+date: 2016-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord