ar-octopus 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0aec6b930a9c19e7477c1f9c756f87b356890e13
-  data.tar.gz: 74858f7cefccd1a2b9da09c8166c1e74ad0340a3
+  metadata.gz: b11a47088e651be24f08e79859ff992113aafa0d
+  data.tar.gz: 9a33b695f7736f5ea3fecf905442eb26743a1c1d
 SHA512:
-  metadata.gz: 7a89d3655be8e4e603e7fe9cd36da0c6a3b48c97fcfe77f365772cb4b0d8e4e450423e8ff2d65716e62919857676a730de709d28e0be481117296d07f569f08e
-  data.tar.gz: 84c86b4b832d476a0e4b5dcfceaab6c23d47511d3ecceb9c06e43894a64eb779afb0b0272c72491837b3912904ea2ae1a699a499b2c6fe05781bb21e8702a9e2
+  metadata.gz: 773b9c6d05403653ab26fc992daddfd9ac62d17e965ab0e980f8f052c450c8bde69951471993b03d56bac32c1015bcc42e7395876b91cc2df30a9a3892199778
+  data.tar.gz: f185670274cafadefa2c14390a32cd2e8dbeae2ca59059b0c07cd4f2f93d215c5eefa0ff29783281cc6ff761bc918f3f984dc6ef19b6eb84554dc9056b5370a1

data/.gitignore

@@ -2,6 +2,7 @@
 *.sqlite3
 .bundle
 .rvmrc
+.ruby-version
 Gemfile.lock
 gemfiles/*.lock
 pkg/*

data/.travis.yml

@@ -4,14 +4,22 @@ env:
 before_script:
   - "bundle exec rake db:prepare"
 rvm:
-  - 2.2.5
-  - 2.3.1
+  - 2.2.7
+  - 2.3.4
+  - 2.4.1
 gemfile:
   - gemfiles/rails4.gemfile
   - gemfiles/rails41.gemfile
   - gemfiles/rails42.gemfile
   - gemfiles/rails5.gemfile
+  - gemfiles/rails51.gemfile
 notifications:
   recipients:
     - gabriel.sobrinho@gmail.com
     - thiago.pradi@gmail.com
+matrix:
+  exclude:
+    - rvm: 2.4.1
+      gemfile: gemfiles/rails4.gemfile
+    - rvm: 2.4.1
+      gemfile: gemfiles/rails41.gemfile

data/Appraisals

@@ -13,4 +13,8 @@ end
 appraise "rails5" do
   gem "activerecord", "~> 5.0.0"
 end
+
+appraise "rails51" do
+  gem "activerecord", "~> 5.1.0"
+end
 # vim: ft=ruby

data/README.mkdn

@@ -5,7 +5,7 @@
 Octopus is a better way to do Database Sharding in ActiveRecord. Sharding allows multiple databases in the same rails application. While there are several projects that implement Sharding (e.g. DbCharmer, DataFabric, MultiDb), each project has its own limitations. The main goal of octopus project is to provide a better way of doing Database Sharding.
 
 ## Feature list:
-The api is designed to be simple as possible. Octopus focuses on the end user, giving the power of multiple databases but with reliable code and flexibility. Octopus is compatible with Rails 3.2 and Rails 4.
+The api is designed to be simple as possible. Octopus focuses on the end user, giving the power of multiple databases but with reliable code and flexibility. Octopus is compatible with Rails 4 and Rails 5.
 
 Octopus supports:
 

data/gemfiles/rails51.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.1.0"
+
+gemspec :path => "../"

data/lib/octopus.rb

@@ -102,8 +102,12 @@ module Octopus
     rails4? && ActiveRecord::VERSION::MINOR == 2
   end
 
-  def self.rails5?
-    ActiveRecord::VERSION::MAJOR == 5
+  def self.rails50?
+    ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 0
+  end
+
+  def self.rails51?
+    ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 1
   end
 
   attr_writer :logger
@@ -152,11 +156,11 @@ module Octopus
   end
 
   def self.fully_replicated(&_block)
-    old_fully_replicated = Thread.current[Octopus::Proxy::FULLY_REPLICATED_KEY]
-    Thread.current[Octopus::Proxy::FULLY_REPLICATED_KEY] = true
+    old_fully_replicated = Thread.current[Octopus::ProxyConfig::FULLY_REPLICATED_KEY]
+    Thread.current[Octopus::ProxyConfig::FULLY_REPLICATED_KEY] = true
     yield
   ensure
-    Thread.current[Octopus::Proxy::FULLY_REPLICATED_KEY] = old_fully_replicated
+    Thread.current[Octopus::ProxyConfig::FULLY_REPLICATED_KEY] = old_fully_replicated
   end
 end
 
@@ -170,7 +174,7 @@ require 'octopus/model'
 require 'octopus/migration'
 require 'octopus/association'
 require 'octopus/collection_association'
-require 'octopus/has_and_belongs_to_many_association' unless Octopus.rails41? || Octopus.rails5?
+require 'octopus/has_and_belongs_to_many_association' unless Octopus.rails41? || Octopus.rails50? || Octopus.rails51?
 require 'octopus/association_shard_tracking'
 require 'octopus/persistence'
 require 'octopus/log_subscriber'
@@ -180,6 +184,7 @@ require 'octopus/finder_methods'
 
 require 'octopus/railtie' if defined?(::Rails::Railtie)
 
+require 'octopus/proxy_config'
 require 'octopus/proxy'
 require 'octopus/collection_proxy'
 require 'octopus/relation_proxy'

data/lib/octopus/collection_association.rb

@@ -1,9 +1,15 @@
 module Octopus
   module CollectionAssociation
     def self.included(base)
-      base.sharded_methods :reader, :writer, :ids_reader, :ids_writer, :create, :create!,
-                           :build, :any?, :count, :empty?, :first, :include?, :last, :length,
-                           :load_target, :many?, :reload, :size, :select, :uniq
+      if Octopus.rails51?
+        base.sharded_methods :reader, :writer, :ids_reader, :ids_writer, :create, :create!,
+                             :build, :include?,
+                             :load_target, :reload, :size, :select
+      else
+        base.sharded_methods :reader, :writer, :ids_reader, :ids_writer, :create, :create!,
+                             :build, :any?, :count, :empty?, :first, :include?, :last, :length,
+                             :load_target, :many?, :reload, :size, :select, :uniq
+      end
     end
   end
 end

data/lib/octopus/finder_methods.rb

@@ -1,6 +1,6 @@
 # find_nth / find_nth! must be public here to allow Octopus to call
 # them on the scope proxy object
-if Octopus.rails42? || Octopus.rails5?
+if Octopus.rails42? || Octopus.rails50?
   module ActiveRecord::FinderMethods
     public :find_nth
     public :find_nth!

data/lib/octopus/load_balancing/round_robin.rb

@@ -6,6 +6,7 @@ module Octopus
   module LoadBalancing
     class RoundRobin
       def initialize(slaves_list)
+        raise Octopus::Exception.new("No slaves available") if slaves_list.empty?
         @slaves_list = slaves_list
         @slave_index = 0
       end

data/lib/octopus/log_subscriber.rb

@@ -3,8 +3,12 @@ module Octopus
   module LogSubscriber
     def self.included(base)
       base.send(:attr_accessor, :octopus_shard)
-      base.alias_method_chain :sql, :octopus_shard
-      base.alias_method_chain :debug, :octopus_shard
+
+      base.send :alias_method, :sql_without_octopus_shard, :sql
+      base.send :alias_method, :sql, :sql_with_octopus_shard
+
+      base.send :alias_method, :debug_without_octopus_shard, :debug
+      base.send :alias_method, :debug, :debug_with_octopus_shard
     end
 
     def sql_with_octopus_shard(event)

data/lib/octopus/migration.rb

@@ -19,7 +19,9 @@ module Octopus
     def self.included(base)
       base.extend(ClassMethods)
 
-      base.alias_method_chain :announce, :octopus
+      base.send :alias_method, :announce_without_octopus, :announce
+      base.send :alias_method, :announce, :announce_with_octopus
+
       base.class_attribute :current_shard, :current_group, :current_group_specified, :instance_reader => false, :instance_writer => false
     end
 
@@ -64,16 +66,28 @@ module Octopus
 
       base.class_eval do
         class << self
-          alias_method_chain :migrate, :octopus
-          alias_method_chain :up, :octopus
-          alias_method_chain :down, :octopus
-          alias_method_chain :run, :octopus
+          alias_method :migrate_without_octopus, :migrate
+          alias_method :migrate, :migrate_with_octopus
+
+          alias_method :up_without_octopus, :up
+          alias_method :up, :up_with_octopus
+
+          alias_method :down_without_octopus, :down
+          alias_method :down, :down_with_octopus
+
+          alias_method :run_without_octopus, :run
+          alias_method :run, :run_with_octopus
         end
       end
 
-      base.alias_method_chain :run, :octopus
-      base.alias_method_chain :migrate, :octopus
-      base.alias_method_chain :migrations, :octopus
+      base.send :alias_method, :run_without_octopus, :run
+      base.send :alias_method, :run, :run_with_octopus
+
+      base.send :alias_method, :migrate_without_octopus, :migrate
+      base.send :alias_method, :migrate, :migrate_with_octopus
+
+      base.send :alias_method, :migrations_without_octopus, :migrations
+      base.send :alias_method, :migrations, :migrations_with_octopus
     end
 
     def run_with_octopus(&block)
@@ -151,7 +165,9 @@ end
 module Octopus
   module UnknownMigrationVersionError
     def self.included(base)
-      base.alias_method_chain :initialize, :octopus
+      base.send :alias_method, :initialize_without_octopus, :initialize
+      base.send :alias_method, :initialize, :initialize_with_octopus
+
       base.send(:attr_accessor, :version)
     end
 

data/lib/octopus/model.rb

@@ -9,17 +9,6 @@ module Octopus
     end
 
     module SharedMethods
-      def clean_table_name
-        return unless connection_proxy.should_clean_table_name?
-
-        if self != ActiveRecord::Base && self.respond_to?(:reset_table_name) && !custom_octopus_table_name
-          reset_table_name
-        end
-
-        reset_column_information
-        instance_variable_set(:@quoted_table_name, nil)
-      end
-
       def using(shard)
         if block_given?
           raise Octopus::Exception, <<-EOF
@@ -30,7 +19,6 @@ If you are trying to scope everything to a specific shard, use Octopus.using ins
         end
 
         if Octopus.enabled?
-          clean_table_name
           Octopus::ScopeProxy.new(shard, self)
         else
           self
@@ -45,18 +33,13 @@ If you are trying to scope everything to a specific shard, use Octopus.using ins
         base.send(:alias_method, :equality_without_octopus, :==)
         base.send(:alias_method, :==, :equality_with_octopus)
         base.send(:alias_method, :eql?, :==)
-        base.send(:alias_method_chain, :perform_validations, :octopus)
+        base.send(:alias_method, :perform_validations_without_octopus, :perform_validations)
+        base.send(:alias_method, :perform_validations, :perform_validations_with_octopus)
       end
 
       def set_current_shard
         return unless Octopus.enabled?
-
-        if new_record? || self.class.connection_proxy.block
-          shard = self.class.connection_proxy.current_shard
-        else
-          shard = self.class.connection_proxy.last_current_shard || self.class.connection_proxy.current_shard
-        end
-
+        shard = self.class.connection_proxy.current_shard
         self.current_shard = shard if self.class.allowed_shard?(shard)
       end
 
@@ -111,11 +94,20 @@ If you are trying to scope everything to a specific shard, use Octopus.using ins
         class << self
           attr_accessor :custom_octopus_table_name
 
-          alias_method_chain :connection, :octopus
-          alias_method_chain :connection_pool, :octopus
-          alias_method_chain :clear_all_connections!, :octopus
-          alias_method_chain :clear_active_connections!, :octopus
-          alias_method_chain :connected?, :octopus
+          alias_method :connection_without_octopus, :connection
+          alias_method :connection, :connection_with_octopus
+
+          alias_method :connection_pool_without_octopus, :connection_pool
+          alias_method :connection_pool, :connection_pool_with_octopus
+
+          alias_method :clear_all_connections_without_octopus!, :clear_all_connections!
+          alias_method :clear_all_connections!, :clear_all_connections_with_octopus!
+
+          alias_method :clear_active_connections_without_octopus!, :clear_active_connections!
+          alias_method :clear_active_connections!, :clear_active_connections_with_octopus!
+
+          alias_method :connected_without_octopus?, :connected?
+          alias_method :connected?, :connected_with_octopus?
 
           def table_name=(value = nil)
             self.custom_octopus_table_name = true

data/lib/octopus/proxy.rb

@@ -4,216 +4,63 @@ require 'octopus/load_balancing/round_robin'
 
 module Octopus
   class Proxy
-    attr_accessor :config, :sharded
-
-    CURRENT_MODEL_KEY = 'octopus.current_model'.freeze
-    CURRENT_SHARD_KEY = 'octopus.current_shard'.freeze
-    CURRENT_GROUP_KEY = 'octopus.current_group'.freeze
-    CURRENT_SLAVE_GROUP_KEY = 'octopus.current_slave_group'.freeze
-    CURRENT_LOAD_BALANCE_OPTIONS_KEY = 'octopus.current_load_balance_options'.freeze
-    BLOCK_KEY = 'octopus.block'.freeze
-    LAST_CURRENT_SHARD_KEY = 'octopus.last_current_shard'.freeze
-    FULLY_REPLICATED_KEY = 'octopus.fully_replicated'.freeze
+    attr_accessor :proxy_config
+
+    delegate :current_model, :current_model=,
+             :current_shard, :current_shard=,
+             :current_group, :current_group=,
+             :current_slave_group, :current_slave_group=,
+             :current_load_balance_options, :current_load_balance_options=,
+             :block, :block=, :fully_replicated?, :has_group?,
+             :shard_names, :shards_for_group, :shards, :sharded, :slaves_list,
+             :shards_slave_groups, :slave_groups, :replicated, :slaves_load_balancer,
+             :config, :initialize_shards, :shard_name, to: :proxy_config, prefix: false
 
     def initialize(config = Octopus.config)
-      initialize_shards(config)
-      initialize_replication(config) if !config.nil? && config['replicated']
-    end
-
-    def initialize_shards(config)
-      @shards = HashWithIndifferentAccess.new
-      @shards_slave_groups = HashWithIndifferentAccess.new
-      @slave_groups = HashWithIndifferentAccess.new
-      @groups = {}
-      @adapters = Set.new
-      @config = ActiveRecord::Base.connection_pool_without_octopus.spec.config
-
-      unless config.nil?
-        @entire_sharded = config['entire_sharded']
-        @shards_config = config[Octopus.rails_env]
-      end
-
-      @shards_config ||= []
-
-      @shards_config.each do |key, value|
-        if value.is_a?(String)
-          value = resolve_string_connection(value).merge(:octopus_shard => key)
-          initialize_adapter(value['adapter'])
-          @shards[key.to_sym] = connection_pool_for(value, "#{value['adapter']}_connection")
-        elsif value.is_a?(Hash) && value.key?('adapter')
-          value.merge!(:octopus_shard => key)
-          initialize_adapter(value['adapter'])
-          @shards[key.to_sym] = connection_pool_for(value, "#{value['adapter']}_connection")
-
-          slave_group_configs = value.select do |_k, v|
-            structurally_slave_group? v
-          end
-
-          if slave_group_configs.present?
-            slave_groups = HashWithIndifferentAccess.new
-            slave_group_configs.each do |slave_group_name, slave_configs|
-              slaves = HashWithIndifferentAccess.new
-              slave_configs.each do |slave_name, slave_config|
-                @shards[slave_name.to_sym] = connection_pool_for(slave_config, "#{value['adapter']}_connection")
-                slaves[slave_name.to_sym] = slave_name.to_sym
-              end
-              slave_groups[slave_group_name.to_sym] = Octopus::SlaveGroup.new(slaves)
-            end
-            @shards_slave_groups[key.to_sym] = slave_groups
-            @sharded = true
-          end
-        elsif value.is_a?(Hash)
-          @groups[key.to_s] = []
-
-          value.each do |k, v|
-            fail 'You have duplicated shard names!' if @shards.key?(k.to_sym)
-
-            initialize_adapter(v['adapter'])
-            config_with_octopus_shard = v.merge(:octopus_shard => k)
-
-            @shards[k.to_sym] = connection_pool_for(config_with_octopus_shard, "#{v['adapter']}_connection")
-            @groups[key.to_s] << k.to_sym
-          end
-
-          if structurally_slave_group? value
-            slaves = Hash[@groups[key.to_s].map { |v| [v, v] }]
-            @slave_groups[key.to_sym] = Octopus::SlaveGroup.new(slaves)
-          end
-        end
-      end
-
-      @shards[:master] ||= ActiveRecord::Base.connection_pool_without_octopus if Octopus.master_shard == :master
-    end
-
-    def initialize_replication(config)
-      @replicated = true
-      if config.key?('fully_replicated')
-        @fully_replicated = config['fully_replicated']
-      else
-        @fully_replicated = true
-      end
-
-      @slaves_list = @shards.keys.map(&:to_s).sort
-      @slaves_list.delete('master')
-      @slaves_load_balancer = Octopus.load_balancer.new(@slaves_list)
-    end
-
-    def current_model
-      Thread.current[CURRENT_MODEL_KEY]
-    end
-
-    def current_model=(model)
-      Thread.current[CURRENT_MODEL_KEY] = model.is_a?(ActiveRecord::Base) ? model.class : model
+      self.proxy_config = Octopus::ProxyConfig.new(config)
     end
 
-    def current_shard
-      Thread.current[CURRENT_SHARD_KEY] ||= Octopus.master_shard
-    end
-
-    def current_shard=(shard_symbol)
-      if shard_symbol.is_a?(Array)
-        self.current_slave_group = nil
-        shard_symbol.each { |symbol| fail "Nonexistent Shard Name: #{symbol}" if @shards[symbol].nil? }
-      elsif shard_symbol.is_a?(Hash)
-        hash = shard_symbol
-        shard_symbol = hash[:shard]
-        slave_group_symbol = hash[:slave_group]
-        load_balance_options = hash[:load_balance_options]
-
-        if shard_symbol.nil? && slave_group_symbol.nil?
-          fail 'Neither shard or slave group must be specified'
-        end
+    # Rails Connection Methods - Those methods are overriden to add custom behavior that helps
+    # Octopus introduce Sharding / Replication.
+    delegate :adapter_name, :add_transaction_record, :case_sensitive_modifier,
+      :type_cast, :to_sql, :quote, :quote_column_name, :quote_table_name,
+      :quote_table_name_for_assignment, :supports_migrations?, :table_alias_for,
+      :table_exists?, :in_clause_length, :supports_ddl_transactions?,
+      :sanitize_limit, :prefetch_primary_key?, :current_database, :initialize_schema_migrations_table,
+      :combine_bind_parameters, :empty_insert_statement_value, :assume_migrated_upto_version,
+      :schema_cache, :substitute_at, :internal_string_options_for_primary_key, :lookup_cast_type_from_column,
+      :supports_advisory_locks?, :get_advisory_lock, :initialize_internal_metadata_table,
+      :release_advisory_lock, :prepare_binds_for_database, :cacheable_query, :column_name_for_operation,
+      :prepared_statements, :transaction_state, :create_table, to: :select_connection
 
-        if shard_symbol.present?
-          fail "Nonexistent Shard Name: #{shard_symbol}" if @shards[shard_symbol].nil?
-        end
-
-        if slave_group_symbol.present?
-          if (@shards_slave_groups.try(:[], shard_symbol).present? && @shards_slave_groups[shard_symbol][slave_group_symbol].nil?) ||
-              (@shards_slave_groups.try(:[], shard_symbol).nil? && @slave_groups[slave_group_symbol].nil?)
-            fail "Nonexistent Slave Group Name: #{slave_group_symbol} in shards config: #{@shards_config.inspect}"
-          end
-        end
-        self.current_slave_group = slave_group_symbol
-        self.current_load_balance_options = load_balance_options
-      else
-        fail "Nonexistent Shard Name: #{shard_symbol}" if @shards[shard_symbol].nil?
-      end
-
-      Thread.current[CURRENT_SHARD_KEY] = shard_symbol
+    def execute(sql, name = nil)
+      conn = select_connection
+      clean_connection_proxy
+      conn.execute(sql, name)
     end
 
-    def current_group
-      Thread.current[CURRENT_GROUP_KEY]
-    end
-
-    def current_group=(group_symbol)
-      # TODO: Error message should include all groups if given more than one bad name.
-      [group_symbol].flatten.compact.each do |group|
-        fail "Nonexistent Group Name: #{group}" unless has_group?(group)
-      end
-
-      Thread.current[CURRENT_GROUP_KEY] = group_symbol
+    def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+      conn = select_connection
+      clean_connection_proxy
+      conn.insert(arel, name, pk, id_value, sequence_name, binds)
     end
 
-    def current_slave_group
-      Thread.current[CURRENT_SLAVE_GROUP_KEY]
+    def update(arel, name = nil, binds = [])
+      conn = select_connection
+      clean_connection_proxy
+      conn.update(arel, name, binds)
     end
 
-    def current_slave_group=(slave_group_symbol)
-      Thread.current[CURRENT_SLAVE_GROUP_KEY] = slave_group_symbol
-      Thread.current[CURRENT_LOAD_BALANCE_OPTIONS_KEY] = nil if slave_group_symbol.nil?
+    def delete(*args, &block)
+      legacy_method_missing_logic('delete', *args, &block)
     end
 
-    def current_load_balance_options
-      Thread.current[CURRENT_LOAD_BALANCE_OPTIONS_KEY]
+    def select_all(*args, &block)
+      legacy_method_missing_logic('select_all', *args, &block)
     end
 
-    def current_load_balance_options=(options)
-      Thread.current[CURRENT_LOAD_BALANCE_OPTIONS_KEY] = options
-    end
-
-    def block
-      Thread.current[BLOCK_KEY]
-    end
-
-    def block=(block)
-      Thread.current[BLOCK_KEY] = block
-    end
-
-    def last_current_shard
-      Thread.current[LAST_CURRENT_SHARD_KEY]
-    end
-
-    def last_current_shard=(last_current_shard)
-      Thread.current[LAST_CURRENT_SHARD_KEY] = last_current_shard
-    end
-
-    def fully_replicated?
-      @fully_replicated || Thread.current[FULLY_REPLICATED_KEY]
-    end
-
-    # Public: Whether or not a group exists with the given name converted to a
-    # string.
-    #
-    # Returns a boolean.
-    def has_group?(group)
-      @groups.key?(group.to_s)
-    end
-
-    # Public: Retrieves names of all loaded shards.
-    #
-    # Returns an array of shard names as symbols
-    def shard_names
-      @shards.keys
-    end
-
-    # Public: Retrieves the defined shards for a given group.
-    #
-    # Returns an array of shard names as symbols or nil if the group is not
-    # defined.
-    def shards_for_group(group)
-      @groups.fetch(group.to_s, nil)
+    def select_value(*args, &block)
+      legacy_method_missing_logic('select_value', *args, &block)
     end
 
     # Rails 3.1 sets automatic_reconnect to false when it removes
@@ -222,22 +69,14 @@ module Octopus
     # reconnect, but in Rails 3.1 the flag prevents this.
     def safe_connection(connection_pool)
       connection_pool.automatic_reconnect ||= true
-      if !connection_pool.connected? && @shards[Octopus.master_shard].connection.query_cache_enabled
+      if !connection_pool.connected? && shards[Octopus.master_shard].connection.query_cache_enabled
         connection_pool.connection.enable_query_cache!
       end
       connection_pool.connection
     end
 
     def select_connection
-      safe_connection(@shards[shard_name])
-    end
-
-    def shard_name
-      current_shard.is_a?(Array) ? current_shard.first : current_shard
-    end
-
-    def should_clean_table_name?
-      @adapters.size > 1
+      safe_connection(shards[shard_name])
     end
 
     def run_queries_on_shard(shard, &_block)
@@ -261,7 +100,7 @@ module Octopus
     end
 
     def send_queries_to_all_shards(&block)
-      send_queries_to_multiple_shards(shard_names.uniq { |shard_name| @shards[shard_name] }, &block)
+      send_queries_to_multiple_shards(shard_names.uniq { |shard_name| shards[shard_name] }, &block)
     end
 
     def clean_connection_proxy
@@ -288,20 +127,7 @@ module Octopus
     end
 
     def method_missing(method, *args, &block)
-      if should_clean_connection_proxy?(method)
-        conn = select_connection
-        self.last_current_shard = current_shard
-        clean_connection_proxy
-        conn.send(method, *args, &block)
-      elsif should_send_queries_to_shard_slave_group?(method)
-        send_queries_to_shard_slave_group(method, *args, &block)
-      elsif should_send_queries_to_slave_group?(method)
-        send_queries_to_slave_group(method, *args, &block)
-      elsif should_send_queries_to_replicated_databases?(method)
-        send_queries_to_selected_slave(method, *args, &block)
-      else
-        select_connection.send(method, *args, &block)
-      end
+      legacy_method_missing_logic(method, *args, &block)
     end
 
     def respond_to?(method, include_private = false)
@@ -309,7 +135,7 @@ module Octopus
     end
 
     def connection_pool
-      @shards[current_shard]
+      shards[current_shard]
     end
 
     def enable_query_cache!
@@ -334,30 +160,49 @@ module Octopus
     end
 
     def connected?
-      @shards.any? { |_k, v| v.connected? }
+      shards.any? { |_k, v| v.connected? }
     end
 
     def should_send_queries_to_shard_slave_group?(method)
-      should_use_slaves_for_method?(method) && @shards_slave_groups.try(:[], current_shard).try(:[], current_slave_group).present?
+      should_use_slaves_for_method?(method) && shards_slave_groups.try(:[], current_shard).try(:[], current_slave_group).present?
     end
 
     def send_queries_to_shard_slave_group(method, *args, &block)
-      send_queries_to_balancer(@shards_slave_groups[current_shard][current_slave_group], method, *args, &block)
+      send_queries_to_balancer(shards_slave_groups[current_shard][current_slave_group], method, *args, &block)
     end
 
     def should_send_queries_to_slave_group?(method)
-      should_use_slaves_for_method?(method) && @slave_groups.try(:[], current_slave_group).present?
+      should_use_slaves_for_method?(method) && slave_groups.try(:[], current_slave_group).present?
     end
 
     def send_queries_to_slave_group(method, *args, &block)
-      send_queries_to_balancer(@slave_groups[current_slave_group], method, *args, &block)
+      send_queries_to_balancer(slave_groups[current_slave_group], method, *args, &block)
     end
 
     protected
 
+    # @thiagopradi - This legacy method missing logic will be keep for a while for compatibility
+    # and will be removed when Octopus 1.0 will be released.
+    # We are planning to migrate to a much stable logic for the Proxy that doesn't require method missing.
+    def legacy_method_missing_logic(method, *args, &block)
+      if should_clean_connection_proxy?(method)
+        conn = select_connection
+        clean_connection_proxy
+        conn.send(method, *args, &block)
+      elsif should_send_queries_to_shard_slave_group?(method)
+        send_queries_to_shard_slave_group(method, *args, &block)
+      elsif should_send_queries_to_slave_group?(method)
+        send_queries_to_slave_group(method, *args, &block)
+      elsif should_send_queries_to_replicated_databases?(method)
+        send_queries_to_selected_slave(method, *args, &block)
+      else
+        select_connection.send(method, *args, &block)
+      end
+    end
+
     # Ensure that a single failing slave doesn't take down the entire application
     def with_each_healthy_shard
-      @shards.each do |shard_name, v|
+      shards.each do |shard_name, v|
         begin
           yield(v)
         rescue => e
@@ -369,17 +214,10 @@ module Octopus
         end
       end
 
-      conn_handler = ActiveRecord::Base.connection_handler
-      if conn_handler.respond_to?(:connection_pool_list)
-        # Rails 4+
-        ar_pools = conn_handler.connection_pool_list
-      else
-        # Rails 3.2
-        ar_pools = conn_handler.connection_pools.values
-      end
+      ar_pools = ActiveRecord::Base.connection_handler.connection_pool_list
 
       ar_pools.each do |pool|
-        next if pool == @shards[:master] # Already handled this
+        next if pool == shards[:master] # Already handled this
 
         begin
           yield(pool)
@@ -393,52 +231,22 @@ module Octopus
       end
     end
 
-    def connection_pool_for(adapter, config)
-      if Octopus.rails4?
-        arg = ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(adapter.dup, config)
-      else
-        name = adapter["octopus_shard"]
-        arg = ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(name, adapter.dup, config)
-      end
-
-      ActiveRecord::ConnectionAdapters::ConnectionPool.new(arg)
-    end
-
-    def initialize_adapter(adapter)
-      @adapters << adapter
-      begin
-        require "active_record/connection_adapters/#{adapter}_adapter"
-      rescue LoadError
-        raise "Please install the #{adapter} adapter: `gem install activerecord-#{adapter}-adapter` (#{$ERROR_INFO})"
-      end
-    end
-
-    def resolve_string_connection(spec)
-      if Octopus.rails41? || Octopus.rails5?
-        resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new({})
-        HashWithIndifferentAccess.new(resolver.spec(spec).config)
-      else
-        resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(spec, {})
-        HashWithIndifferentAccess.new(resolver.spec.config)
-      end
-    end
-
     def should_clean_connection_proxy?(method)
       method.to_s =~ /insert|select|execute/ && !current_model_replicated? && (!block || block != current_shard)
     end
 
     # Try to use slaves if and only if `replicated: true` is specified in `shards.yml` and no slaves groups are defined
     def should_send_queries_to_replicated_databases?(method)
-      @replicated && method.to_s =~ /select/ && !block && !slaves_grouped?
+      replicated && method.to_s =~ /select/ && !block && !slaves_grouped?
     end
 
     def current_model_replicated?
-      @replicated && (current_model.try(:replicated) || fully_replicated?)
+      replicated && (current_model.try(:replicated) || fully_replicated?)
     end
 
     def send_queries_to_selected_slave(method, *args, &block)
       if current_model.replicated || fully_replicated?
-        selected_slave = @slaves_load_balancer.next current_load_balance_options
+        selected_slave = slaves_load_balancer.next current_load_balance_options
       else
         selected_slave = Octopus.master_shard
       end
@@ -460,7 +268,7 @@ module Octopus
     end
 
     def slaves_grouped?
-      @slave_groups.present?
+      slave_groups.present?
     end
 
     # Temporarily switch `current_shard` to the next slave in a slave group and send queries to it
@@ -498,7 +306,6 @@ module Octopus
       older_slave_group = current_slave_group
       older_load_balance_options = current_load_balance_options
 
-
       begin
         unless current_model && !current_model.allowed_shard?(shard)
           self.current_shard = shard
@@ -522,13 +329,5 @@ module Octopus
         self.current_group = older_group
       end
     end
-
-    def structurally_slave?(config)
-      config.is_a?(Hash) && config.key?('adapter')
-    end
-
-    def structurally_slave_group?(config)
-      config.is_a?(Hash) && config.values.any? { |v| structurally_slave? v }
-    end
   end
 end