multi_dbs_load_balancer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 599c6e5a768320312bf00d07478354a250bd3f167b0dfc08071708864d6e0513
+  data.tar.gz: d0462ea28e57473be4aa5af57e9ca80359f2c3c0715ebffe02f60a400cd9f017
+SHA512:
+  metadata.gz: 824e76ac8571b4499720c6aecc38b9987fb8550fd12e40610a8388bf907f85c572394a5bea86baec8433ce13c346cd4ff0b8fccad43af3d50c959106c4fb87c9
+  data.tar.gz: a86aef07d4fca8c20083193657cb4fa4e3f7727e69eb8cbfb0c5e7d47741873374aab566e3293994107cc398e3a13387ac3dc440242acccec0fdcf3dd2603bb8

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 theforestvn88
+
+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,106 @@
+# MultiDbsLoadBalancer
+
+Allow to setup load balancers sit on top of [rails multi-databases](https://guides.rubyonrails.org/active_record_multiple_databases.html).
+
+## Installation
+
+```ruby
+gem "multi_dbs_load_balancer"
+
+$ bundle install
+$ rails g multi_dbs_load_balancer:install
+```
+
+## Usage
+
+Declaring load balancers
+```ruby
+# config/initializers/multi_dbs_load_balancer.rb
+    load_balancer.db_down_time = 120
+    load_balancer.redis_down_time = 120
+    load_balancer.init :rr_load_balancer,
+        [
+            {role: :reading1}, 
+            {role: :reading2},
+            {role: :reading3},
+        ],
+        algorithm: :round_robin,
+        redis: Redis.new(...)
+```
+
+Now you could use them on controllers/services ...
+```ruby
+# products_controller.rb
+def index
+    @products = ActiveRecord::Base.connected_through(:rr_load_balancer) { Product.all }
+    # alias methods: connected_by, connected_through_load_balancer
+end
+```
+
+You could also create and use a Middleware to wrap load balancer base on the request, for example:
+```ruby
+class LoadBalancerMiddleware
+    def initialize(app)
+        @app = app
+    end
+
+    def call(env)
+        request = ActionDispatch::Request.new(env)
+        if is_something?(request)
+            ActiveRecord::Base.connected_through(:rr_load_balancer) do
+                @app.call(env)    
+            end
+        else
+            @app.call(env)
+        end
+    end
+
+    private def is_something?(request)
+        # for example: check if reading request
+        request.get? || request.head?
+    end
+end
+
+Rails.application.config.app_middleware.use LoadBalancerMiddleware
+```
+
+## Notes
+
+- Support algorithms: `round_robin`, `weight_round_robin`, `least_connection`, `least_response_time`, `hash`, `randomized`
+
+- Distribute
+
+    If you launch multiple servers then you wish your load balancers will share states between servers,
+    there're 3 algorithms that will do that if you provide a redis server: 
+
+    + `round_robin` will share the current database
+
+    +  `least_connection` and `least_response_time` will share the sorted list of databases
+
+    Other algorithms are independent on each server, so you don't need to provide a redis server for them.
+
+- Fail-over
+
+    All load balancers here are passive, they don't track database connections or redis connections.
+    
+    Whenever it could not connect to a database, it mark that database have down for `db_down_time` seconds and ignore it on the next round, 
+    and try to connect to the next available database.
+
+    After `db_down_time` seconds, the load balancer will try to connect this database again.
+
+    Whenever the redis-server has down (or you dont setup redis), distribute load balancers will process offline on each server until redis come back.
+
+
+
+## Development
+
+run test
+```ruby
+rake setup_db
+rake spec
+```
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rails_dbs_load_balancer.

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task :setup_db do
+    p "setup db ..."
+    `sqlite3 spec/dummy/db/primary.sqlite3 'CREATE TABLE IF NOT EXISTS developers (name VARCHAR (255))'`
+    `sqlite3 spec/dummy/db/primary_replica1.sqlite3 'CREATE TABLE IF NOT EXISTS developers (name VARCHAR (255))'`
+    `sqlite3 spec/dummy/db/primary_replica2.sqlite3 'CREATE TABLE IF NOT EXISTS developers (name VARCHAR (255))'`
+    `sqlite3 spec/dummy/db/primary_replica3.sqlite3 'CREATE TABLE IF NOT EXISTS developers (name VARCHAR (255))'`
+    `sqlite3 spec/dummy/db/primary_replica4.sqlite3 'CREATE TABLE IF NOT EXISTS developers (name VARCHAR (255))'`
+    `sqlite3 spec/dummy/db/primary_replica5.sqlite3 'CREATE TABLE IF NOT EXISTS developers (name VARCHAR (255))'`
+    `sqlite3 spec/dummy/db/primary_replica6.sqlite3 'CREATE TABLE IF NOT EXISTS developers (name VARCHAR (255))'`
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:setup_db, :spec]

data/benchmark.rb

@@ -0,0 +1,93 @@
+require 'benchmark/ips'
+require_relative "./lib/multi_dbs_load_balancer"
+require_relative "./spec/dummy/models/developer"
+
+Benchmark.ips do |bm|
+    bm.report("ActiveRecord#connected_to") do
+        threads = []
+        [:reading1, :reading2, :reading3, :reading4, :reading5, :reading6].each do |db|
+            10.times do |i|
+                threads << Thread.new do
+                    ActiveRecord::Base.connected_to(role: db) do
+                        result = Developer.all
+                    end
+                end
+            end
+        end
+        threads.map(&:join)
+    end
+
+    bm.report("connect through round robin load balancer") do
+        threads = []
+        60.times do |i|
+            threads << Thread.new do
+                Developer.connected_through_load_balancer(:rr) do
+                    result = Developer.all
+                end
+            end
+        end
+        threads.map(&:join)
+    end
+
+    bm.report("connect through least connection load balancer") do
+        threads = []
+        60.times do |i|
+            threads << Thread.new do
+                Developer.connected_through_load_balancer(:lc) do
+                    result = Developer.all
+                end
+            end
+        end
+        threads.map(&:join)
+    end
+
+    bm.report("connect through least response time load balancer") do
+        threads = []
+        60.times do |i|
+            threads << Thread.new do
+                Developer.connected_through_load_balancer(:lrt) do
+                    result = Developer.all
+                end
+            end
+        end
+        threads.map(&:join)
+    end
+
+    bm.report("connect through weight round robin load balancer") do
+        threads = []
+        60.times do |i|
+            threads << Thread.new do
+                Developer.connected_through_load_balancer(:wrr) do
+                    result = Developer.all
+                end
+            end
+        end
+        threads.map(&:join)
+    end
+
+    bm.report("connect through hash load balancer") do
+        threads = []
+        60.times do |i|
+            threads << Thread.new do
+                Developer.connected_through_load_balancer(:hash, source: "197.168.1.1") do
+                    result = Developer.all
+                end
+            end
+        end
+        threads.map(&:join)
+    end
+
+    bm.report("connect through randomized load balancer") do
+        threads = []
+        60.times do |i|
+            threads << Thread.new do
+                Developer.connected_through_load_balancer(:randomized) do
+                    result = Developer.all
+                end
+            end
+        end
+        threads.map(&:join)
+    end
+
+    bm.compare!
+end

data/lib/multi_dbs_load_balancer/distribute_lock.rb

@@ -0,0 +1,53 @@
+class DistributeLock
+    include RedisLua
+    attr_reader :redis
+
+    def initialize(redis)
+        @redis = redis
+    end
+
+    def synchronize(name, lock_time = 3600)
+        return yield if @redis.nil?
+        
+        lock_name = "#{name}:lock"
+        time_lock = eval_lua_script(LOCK_SCRIPT, LOCK_SCRIPT_SHA1, [lock_name], [lock_time])
+        return if time_lock.nil?
+
+        begin
+            yield
+        ensure
+            eval_lua_script(UNLOCK_SCRIPT, UNLOCK_SCRIPT_SHA1, [name], [time_lock.to_s])
+        end
+    rescue
+        yield
+    end
+
+    private
+
+        LOCK_SCRIPT = <<~LUA
+            local now = redis.call("time")[1]
+            local expire_time = now + ARGV[1]
+            local current_expire_time = redis.call("get", KEYS[1])
+
+            if current_expire_time and tonumber(now) <= tonumber(current_expire_time) then
+                return nil
+            else
+                local result = redis.call("setex", KEYS[1], ARGV[1] + 1, tostring(expire_time))
+                return expire_time
+            end
+        LUA
+        LOCK_SCRIPT_SHA1 = Digest::SHA1.hexdigest LOCK_SCRIPT
+
+        UNLOCK_SCRIPT = <<~LUA
+            local current_expire_time = redis.call("get", KEYS[1])
+
+            if current_expire_time == ARGV[1] then
+                local result = redis.call("del", KEYS[1])
+                return result ~= nil
+            else
+                return false
+            end
+        LUA
+        UNLOCK_SCRIPT_SHA1 = Digest::SHA1.hexdigest UNLOCK_SCRIPT
+
+end

data/lib/multi_dbs_load_balancer/healthcheck.rb

@@ -0,0 +1,36 @@
+module Healthcheck
+    cattr_reader :db_down_times, :redis_down_times
+
+    def mark_redis_down
+        set_redis_down_time(Time.now.to_i + LoadBalancer.redis_down_time)
+    end
+
+    def redis_available?
+        @redis.present? && redis_down_time < Time.now.to_i
+    end
+
+    def mark_db_down(db_index)
+        db_down_times[db_index] = Time.now.to_i + LoadBalancer.db_down_time
+    end
+
+    def db_available?(db_index)
+        db_down_times[db_index] < Time.now.to_i
+    end
+
+    private def db_down_times
+        @@db_down_times ||= {}
+        @@db_down_times["#{@key}:dt"] ||= Hash.new(0)
+    end
+
+    private def redis_down_times
+        @@redis_down_times ||= Hash.new(0)
+    end
+
+    private def redis_down_time
+        redis_down_times["#{@key}:dt"]
+    end
+
+    private def set_redis_down_time(t)
+        redis_down_times["#{@key}:dt"] = t
+    end
+end

data/lib/multi_dbs_load_balancer/load_balancer/algo.rb

@@ -0,0 +1,64 @@
+module LoadBalancer
+    class Algo
+        include RedisLua
+        include Healthcheck
+        attr_reader :database_configs, :redis, :key
+
+        def initialize(database_configs, redis:, key:)
+            @database_configs = database_configs
+            @redis = redis
+            @key = key
+        end
+
+        def warm_up
+        end
+
+        def next_db(**options)
+            raise NotImplementedError, ""
+        end
+
+        def after_connected
+        end
+
+        def after_executed
+        end
+
+        def connected_to_next_db(**options, &blk)
+            candidate_db, db_index = next_db(**options)
+            raise LoadBalancer::AllDatabasesHaveDown if candidate_db.nil?
+
+            if options.has_key?(:bases)
+                ::ActiveRecord::Base.connected_to_many(*options[:bases], **candidate_db.slice(:shard, :role), prevent_writes: options[:prevent_writes]) do
+                    after_connected
+                    blk.call
+                end
+            else
+                ::ActiveRecord::Base.connected_to(**candidate_db.slice(:shard, :role), prevent_writes: options[:prevent_writes]) do
+                    after_connected
+                    blk.call
+                end
+            end
+        rescue ActiveRecord::ConnectionNotEstablished
+            mark_db_down(db_index)
+            @should_retry = true
+        ensure
+            after_executed
+            if @should_retry
+                @should_retry = false
+                connected_to_next_db(**options, &blk)
+            end
+        end
+
+        def fail_over(next_choices)
+            candidate = next_choices.find do |i| 
+                db_available?(i) 
+            end
+
+            if candidate
+                [@database_configs[candidate], candidate]
+            else
+                [nil, -1]
+            end
+        end
+    end
+end

data/lib/multi_dbs_load_balancer/load_balancer/errors.rb

@@ -0,0 +1,3 @@
+module LoadBalancer
+    class AllDatabasesHaveDown < StandardError; end
+end

data/lib/multi_dbs_load_balancer/load_balancer/hash.rb

@@ -0,0 +1,37 @@
+require_relative "./algo"
+
+module LoadBalancer
+    class Hash < Algo
+        def next_db(**options)
+            db_index = hash_to_index(**options)
+            return @database_configs[db_index], db_index if db_available?(db_index)
+            
+            # fail over
+            next_dbs = (db_index+1...db_index+@database_configs.size).map { |i| i % @database_configs.size }
+            fail_over(next_dbs)
+        end
+
+        private
+
+        def hash_to_index(**options)
+            rand(0...@database_configs.size) if options[:source].nil?
+
+            h = options[:hash_func]&.respond_to?(:call) ? options[:hash_func].call(options[:source]) : hashcode(options[:source])
+            h % @database_configs.size
+        end
+
+        def hashcode(source)
+            # NOTE:
+            # From Ruby 2.0 initialize MurmurHash using a random seed value which is reinitialized each time you restart Ruby.
+            # So `source.hash` will not be deterministic across servers.
+            # Therefore, this method uses java hashcode algorithm (Apache Harmony) instead.
+            h = 0
+            multipler = 1
+            (source.size-1).downto(0) do |i|
+                h = source[i].ord * multipler
+                multipler = (multipler << 5) - multipler
+            end
+            h
+        end
+    end
+end

data/lib/multi_dbs_load_balancer/load_balancer/least_connection.rb

@@ -0,0 +1,114 @@
+require_relative "../min_heap"
+
+module LoadBalancer
+    class LeastConnection < Algo
+        cattr_reader :mutexes, default: {}
+        cattr_reader :leasts, default: {}
+
+        def warm_up
+            pq_mutex.synchronize do
+                begin
+                    unless @redis.exists?(db_conns_pq_key)
+                        @database_configs.size.times do |i|
+                            @redis.zincrby(db_conns_pq_key, 1, i)
+                        end
+                    end
+                rescue => e
+                    # p e
+                ensure
+                    return if @@leasts.has_key?(db_conns_pq_key)
+
+                    @@leasts[db_conns_pq_key] = MinHeap.new
+                    @database_configs.size.times do |i|
+                        @@leasts[db_conns_pq_key].push([1, i])
+                    end
+                end
+            end
+        end
+
+        def next_db(**options)
+            @least_db_index = top_least
+            return @database_configs[@least_db_index], @least_db_index if db_available?(@least_db_index)
+            
+            # fail over
+            fail_over(next_dbs)
+        end
+
+        def after_connected
+            increase
+        end
+
+        def after_executed
+            decrease
+        end
+
+        private
+            
+            # CAS_TOP_SCRIPT = <<~LUA
+            #     local top = unpack(redis.call("zrange", KEYS[1], 0, 0))
+            #     redis.call("zincrby", KEYS[1], 1, top)
+            #     return top
+            # LUA
+            # CAS_TOP_SCRIPT_SHA1 = ::Digest::SHA1.hexdigest CAS_TOP_SCRIPT
+
+            def db_conns_pq_key
+                "#{@key}:lc:pq"
+            end
+
+            def pq_mutex
+                @@mutexes[db_conns_pq_key] ||= Mutex.new
+            end
+
+            def top_least
+                return local_least(:extract) unless redis_available?
+                # eval_lua_script(CAS_TOP_SCRIPT, CAS_TOP_SCRIPT_SHA1, [db_conns_pq_key], [])
+                @redis.zrange(db_conns_pq_key, 0, 0).first.to_i
+            rescue => error
+                mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                local_least(:extract)
+            end
+
+            def local_least(action = :extract)
+                pq_mutex.synchronize do
+                    case action
+                    when :extract
+                        count, x = @@leasts[db_conns_pq_key].peak
+                        x
+                    when :decrease
+                        @@leasts[db_conns_pq_key].decrease(@least_db_index, 1) if @least_db_index
+                    when :increase
+                        @@leasts[db_conns_pq_key].increase(@least_db_index, 1) if @least_db_index
+                    end
+                end
+            end
+
+            def decrease
+                return unless @least_db_index
+                return local_least(:decrease) unless redis_available?
+
+                @redis.zincrby(db_conns_pq_key, -1, @least_db_index)
+            rescue => error
+                mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                local_least(:decrease)
+            end
+
+            def increase
+                return unless @least_db_index
+                return local_least(:increase) unless redis_available?
+
+                @redis.zincrby(db_conns_pq_key, 1, @least_db_index)
+            rescue => error
+                mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                local_least(:increase)
+            end
+
+            def next_dbs
+                return @@leasts[db_conns_pq_key].order unless redis_available?
+                
+                @redis.zrange(db_conns_pq_key, 0, -1).map(&:to_i)
+            rescue => error
+                mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                @@leasts[db_conns_pq_key].order
+            end
+    end
+end

data/lib/multi_dbs_load_balancer/load_balancer/least_response_time.rb

@@ -0,0 +1,101 @@
+require_relative "../min_heap"
+
+module LoadBalancer
+    class LeastResponseTime < Algo
+        cattr_reader :mutexes, default: {}
+        cattr_reader :response_times, default: {}
+
+        def warm_up
+            pq_mutex.synchronize do
+                begin
+                    unless @redis.exists?(db_conns_pq_key)
+                        @database_configs.size.times do |i|
+                            @redis.zincrby(db_conns_pq_key, 0, i)
+                        end
+                    end
+                rescue => error
+                    mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                ensure
+                    return if @@response_times.has_key?(db_conns_pq_key)
+
+                    @@response_times[db_conns_pq_key] = MinHeap.new
+                    @database_configs.size.times do |i|
+                        @@response_times[db_conns_pq_key].push([0, i])
+                    end
+                end
+            end
+        end
+
+        def next_db(**options)
+            @least_db_index = top_least.to_i
+            return @database_configs[@least_db_index], @least_db_index if db_available?(@least_db_index)
+            
+            # fail over
+            fail_over(next_dbs)
+        end
+
+        def after_connected
+            @start_time = Time.now
+        end
+
+        def after_executed
+            update_response_time(Time.now - @start_time) if @start_time
+        end
+
+        private
+            
+            CAS_TOP_SCRIPT = <<~LUA
+                local top = unpack(redis.call("zrange", KEYS[1], 0, 0))
+                redis.call("zincrby", KEYS[1], 0.1, top)
+                return top
+            LUA
+            CAS_TOP_SCRIPT_SHA1 = ::Digest::SHA1.hexdigest CAS_TOP_SCRIPT
+
+            def db_conns_pq_key
+                "#{@key}:lrt:pq"
+            end
+
+            def pq_mutex
+                @@mutexes[db_conns_pq_key] ||= Mutex.new
+            end
+
+            def top_least
+                return local_least unless redis_available?
+
+                eval_lua_script(CAS_TOP_SCRIPT, CAS_TOP_SCRIPT_SHA1, [db_conns_pq_key], [])
+            rescue => error
+                mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                local_least
+            end
+
+            def local_least(action = :extract, **options)
+                pq_mutex.synchronize do
+                    case action
+                    when :extract
+                        t, x = @@response_times[db_conns_pq_key].peak
+                        x
+                    when :update_response_time
+                        @@response_times[db_conns_pq_key].replace(@least_db_index, options[:time]) if @least_db_index
+                    end
+                end
+            end
+
+            def update_response_time(t)
+                return local_least(:update_response_time, time: t) unless redis_available?
+                
+                @redis.zadd(db_conns_pq_key, t, @least_db_index)
+            rescue => error
+                mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                local_least(:update_response_time, time: t)
+            end
+
+            def next_dbs
+                return @@response_times[db_conns_pq_key].order unless redis_available?
+
+                @redis.zrange(db_conns_pq_key, 0, -1).map(&:to_i)
+            rescue => error
+                mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                @@response_times[db_conns_pq_key].order
+            end
+    end
+end

data/lib/multi_dbs_load_balancer/load_balancer/randomized.rb

@@ -0,0 +1,19 @@
+require_relative "./algo"
+
+module LoadBalancer
+    class Randomized < Algo
+        def next_db(**options)
+            r = random_index
+            return @database_configs[r], r if db_available?(r)
+
+            next_dbs = (r+1...r+@database_configs.size).map { |i| i % @database_configs.size }
+            fail_over(next_dbs)
+        end
+
+        private
+
+            def random_index
+                rand(0...@database_configs.size)
+            end
+    end
+end

data/lib/multi_dbs_load_balancer/load_balancer/round_robin.rb

@@ -0,0 +1,52 @@
+require_relative "./algo"
+
+module LoadBalancer
+    class RoundRobin < Algo
+        cattr_accessor :currents
+        
+        def warm_up
+            @@currents ||= ::Hash.new(0)
+        end
+
+        def next_db(**options)
+            @current = cas_current
+            return @database_configs[@current], @current if db_available?(@current)
+            
+            next_dbs = (@current+1...@current+@database_configs.size).map { |i| i % @database_configs.size }
+            fail_over(next_dbs)
+        end
+
+        private
+
+            CAS_NEXT_SCRIPT = <<~LUA
+                local curr = redis.call("get", KEYS[1])
+                if curr then
+                    local next = (tonumber(curr) + 1) % ARGV[1]
+                    redis.call("set", KEYS[1], next)
+                    return next
+                else
+                    redis.call("set", KEYS[1], 0)
+                    return 0
+                end
+            LUA
+            CAS_NEXT_SCRIPT_SHA1 = ::Digest::SHA1.hexdigest CAS_NEXT_SCRIPT
+
+            def current_cached_key
+                "#{@key}:rr:current"
+            end
+
+            def cas_current
+                return local_current unless redis_available?
+                eval_lua_script(CAS_NEXT_SCRIPT, CAS_NEXT_SCRIPT_SHA1, [current_cached_key], [@database_configs.size])
+            rescue => error
+                # in case of redis failed
+                mark_redis_down if error.is_a?(Redis::CannotConnectError)
+                # random local server current
+                @@currents[current_cached_key] = rand(0...@database_configs.size)
+            end
+
+            def local_current
+                @@currents[current_cached_key] = (@@currents[current_cached_key] + 1) % @database_configs.size
+            end
+    end
+end

data/lib/multi_dbs_load_balancer/load_balancer/weight_round_robin.rb

@@ -0,0 +1,51 @@
+require_relative "./algo"
+
+module LoadBalancer
+    class WeightRoundRobin < Algo
+        cattr_reader :mutexes, default: {}
+        cattr_reader :cum_weights, default: {}
+        cattr_reader :weight_sums, default: ::Hash.new(0)
+
+        def warm_up
+            (@@mutexes[weights_key] ||= Mutex.new).synchronize do
+                return if @@cum_weights.has_key?(weights_key) or @database_configs.empty?
+
+                @@cum_weights[weights_key] = [@database_configs[0][:weight]]
+                (1...@database_configs.size).each do |i|
+                    @@weight_sums[weight_sum_key] += @database_configs[i][:weight]
+                    @@cum_weights[weights_key][i] = @@cum_weights[weights_key][i-1] + @database_configs[i][:weight]
+                end
+            end
+        end
+
+        def next_db(**options)
+            db_index = pick_db_by_random_weight
+            return @database_configs[db_index], db_index if db_available?(db_index)
+            
+            # fail over
+            next_dbs = (db_index+1...db_index+@database_configs.size).map { |i| i % @database_configs.size }
+            fail_over(next_dbs)
+        end
+
+        private
+
+        def weights_key
+            "#{@key}:weights"
+        end
+
+        def weight_sum_key
+            "#{@key}:weight_sum"
+        end
+
+        def random_weight
+            rand(@@weight_sums[weight_sum_key]-1)
+        end
+
+        def pick_db_by_random_weight
+            rw = random_weight
+            @@cum_weights[weights_key].find_index do |weight|
+                weight > rw
+            end
+        end
+    end
+end

data/lib/multi_dbs_load_balancer/load_balancer.rb

@@ -0,0 +1,53 @@
+require "active_support"
+require 'digest'
+require_relative "./redis_lua"
+require_relative "./healthcheck"
+require_relative "./distribute_lock"
+require_relative "./load_balancer/errors"
+require_relative "./load_balancer/round_robin"
+require_relative "./load_balancer/least_connection"
+require_relative "./load_balancer/weight_round_robin"
+require_relative "./load_balancer/hash"
+require_relative "./load_balancer/randomized"
+require_relative "./load_balancer/least_response_time"
+
+module LoadBalancer
+    extend ::ActiveSupport::Concern
+
+    mattr_accessor :db_down_time, default: 120
+    mattr_accessor :redis_down_time, default: 120
+    mattr_reader :lb, default: {}
+
+    def init(name, db_configs, algorithm: :round_robin, redis: nil)
+        lb_algo_clazz = "LoadBalancer::#{algorithm.to_s.classify}".constantize
+        LoadBalancer.lb[name] = {
+            clazz: lb_algo_clazz,
+            db_configs: db_configs,
+            redis: redis,
+            key: name
+        }
+
+        DistributeLock.new(redis).synchronize(name) do
+            lb = lb_algo_clazz.new(db_configs, redis: redis, key: name)
+            lb.warm_up
+        end
+    end
+    module_function :init
+
+    module ClassMethods
+        def load_balancing(name, db_configs, algorithm: :round_robin, redis: nil)
+            LoadBalancer.init(name, db_configs, algorithm: algorithm, redis: redis)
+        end
+
+        def connected_through_load_balancer(name, **options, &blk)
+            raise ArgumentError, "not found #{name} load balancer" unless LoadBalancer.lb.has_key?(name)
+            
+            configs = LoadBalancer.lb[name]
+            lb = configs[:clazz].new(configs[:db_configs], redis: configs[:redis], key: configs[:key])
+            lb.connected_to_next_db(**options, &blk)
+        end
+        alias_method :connected_through, :connected_through_load_balancer
+        alias_method :connected_by, :connected_through_load_balancer
+    end
+end
+  

data/lib/multi_dbs_load_balancer/min_heap.rb

@@ -0,0 +1,90 @@
+class MinHeap
+    def initialize(comparator = lambda { |x, y| x <=> y })
+        @comparator = comparator
+        @items = []
+    end
+
+    def push(x)
+        @items.push(x)
+        swim_up(@items.size-1)
+    end
+
+    def pop
+        @items[0], @items[@items.size-1] = @items[@items.size-1], @items[0]
+        @items.pop.tap { sink_down(0) }
+    end
+
+    def peak
+        @items[0]
+    end
+
+    def update(item_index)
+        return if item_index < 0 || item_index >= @items.size
+
+        swim_up(item_index)
+        sink_down(item_index)
+    end
+
+    def decrease(index, delta)
+        item_index = find_item_index(index)
+        @items[item_index][0] -= delta
+        update(item_index)
+    end
+
+    def increase(index, delta)
+        item_index = find_item_index(index)
+        @items[item_index][0] += delta
+        update(item_index)
+    end
+
+    def replace(index, val)
+        item_index = find_item_index(index)
+        @items[item_index][0] = val
+        update(item_index)
+    end
+
+    # def find_item(index)
+    #     @items.find { |item| item.last == index }
+    # end
+
+    def find_item_index(index)
+        @items.find_index { |item| item.last == index }
+    end
+
+    def empty?
+        @items.empty?
+    end
+
+    def order
+        @items.sort.map(&:last)
+    end
+
+    private
+
+        def parent(i)
+            ((i-1)/2).floor
+        end
+
+        def left(i)
+            2*i + 1
+        end
+
+        def swim_up(i)
+            pi = parent(i)
+            if pi >= 0 && @comparator.call(@items[i], @items[pi]) <= 0
+                @items[pi], @items[i] = @items[i], @items[pi]
+                swim_up(pi)
+            end
+        end
+
+        def sink_down(i)
+            return if (li = left(i)) >= @items.size
+
+            ri = li + 1
+            swap_i = (li == @items.size-1 || @comparator.call(@items[li], @items[ri]) <= 0) ? li : ri
+            if (@comparator.call(@items[swap_i], @items[i]) <= 0)
+                @items[swap_i], @items[i] = @items[i], @items[swap_i]
+                sink_down(swap_i)
+            end
+        end
+end

data/lib/multi_dbs_load_balancer/redis_lua.rb

@@ -0,0 +1,12 @@
+module RedisLua
+    def eval_lua_script(script, sha1, *args, redis: @redis,**kwargs)
+        redis.evalsha sha1, *args, **kwargs
+    rescue ::Redis::CommandError => e
+        if e.to_s =~ /^NOSCRIPT/
+            redis.eval script, *args, **kwargs
+        else
+            raise
+        end
+    end
+    module_function :eval_lua_script
+end

data/lib/multi_dbs_load_balancer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MultiDbsLoadBalancer
+  VERSION = "0.0.1"
+end

data/lib/multi_dbs_load_balancer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "multi_dbs_load_balancer/version"
+require_relative "multi_dbs_load_balancer/load_balancer"
+
+module MultiDbsLoadBalancer
+  class Error < StandardError; end
+
+  def setup
+    yield(LoadBalancer)
+  end
+  module_function :setup
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.send(:include, LoadBalancer)
+end

data/lib/rails/generators/multi_dbs_load_balancer/install_generator.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "rails/generators"
+
+module MultiDbsLoadBalancer
+  class InstallGenerator < ::Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+    
+    def create_initializer
+      copy_file "initializer.rb", "config/initializers/multi_dbs_load_balancer.rb"
+    end
+  end
+end

data/lib/rails/generators/multi_dbs_load_balancer/templates/initializer.rb

@@ -0,0 +1,19 @@
+MultiDbsLoadBalancer.setup do |load_balancer|
+    ## The interval time that any have-down(disconnected, error, ...) db will be ignored,
+    ## after that, the load balancer will retry to pick this db if the algorithm point to this
+    # load_balancer.db_down_time = 120
+
+    ## The interval time that all algorithms will process in local server if the redis disconnected,
+    ## after that, they will retry to connect to redis again.
+    # load_balancer.redis_down_time = 120
+
+    # load_balancer.init :round_robin,
+    #     [
+    #         {role: :reading1}, 
+    #         {role: :reading2},
+    #         {role: :reading3},
+    #     ],
+    #     algorithm: :round_robin,
+    #     redis: Redis.new(host: 'localhost')
+    #
+end

data/multi_dbs_load_balancer.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/multi_dbs_load_balancer/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "multi_dbs_load_balancer"
+  spec.version = MultiDbsLoadBalancer::VERSION
+  spec.authors = ["theforestvn88"]
+  spec.email = ["theforestvn88@gmail.com"]
+
+  spec.summary = "rails multiple databases load balancer"
+  spec.description = "rails multiple databases load balancer"
+  spec.homepage = "https://github.com/theforestvn88/rails_dbs_load_balancer"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/theforestvn88/rails_dbs_load_balancer"
+  spec.metadata["changelog_uri"] = "https://github.com/theforestvn88/rails_dbs_load_balancer"
+
+  # 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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activerecord',  '>= 6.0'
+  spec.add_runtime_dependency 'activesupport', '>= 6.0'
+
+end

data/sig/multi_dbs_load_balancer.rbs

@@ -0,0 +1,4 @@
+module MultiDbsLoadBalancer
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: multi_dbs_load_balancer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- theforestvn88
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: rails multiple databases load balancer
+email:
+- theforestvn88@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark.rb
+- lib/multi_dbs_load_balancer.rb
+- lib/multi_dbs_load_balancer/distribute_lock.rb
+- lib/multi_dbs_load_balancer/healthcheck.rb
+- lib/multi_dbs_load_balancer/load_balancer.rb
+- lib/multi_dbs_load_balancer/load_balancer/algo.rb
+- lib/multi_dbs_load_balancer/load_balancer/errors.rb
+- lib/multi_dbs_load_balancer/load_balancer/hash.rb
+- lib/multi_dbs_load_balancer/load_balancer/least_connection.rb
+- lib/multi_dbs_load_balancer/load_balancer/least_response_time.rb
+- lib/multi_dbs_load_balancer/load_balancer/randomized.rb
+- lib/multi_dbs_load_balancer/load_balancer/round_robin.rb
+- lib/multi_dbs_load_balancer/load_balancer/weight_round_robin.rb
+- lib/multi_dbs_load_balancer/min_heap.rb
+- lib/multi_dbs_load_balancer/redis_lua.rb
+- lib/multi_dbs_load_balancer/version.rb
+- lib/rails/generators/multi_dbs_load_balancer/install_generator.rb
+- lib/rails/generators/multi_dbs_load_balancer/templates/initializer.rb
+- multi_dbs_load_balancer.gemspec
+- sig/multi_dbs_load_balancer.rbs
+homepage: https://github.com/theforestvn88/rails_dbs_load_balancer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/theforestvn88/rails_dbs_load_balancer
+  source_code_uri: https://github.com/theforestvn88/rails_dbs_load_balancer
+  changelog_uri: https://github.com/theforestvn88/rails_dbs_load_balancer
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.4
+signing_key: 
+specification_version: 4
+summary: rails multiple databases load balancer
+test_files: []