rails_failover 0.5.7 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6711544c6ae90ab17b509fc3cb97e7b5cc4fd5579daee706dfcc9abb03141a22
-  data.tar.gz: 4bea899af7859b72f88a5e9bd185f72fbca2b968b4a8ed0d73dbc6e41be5acce
+  metadata.gz: 152daf08d747b0015a4dddd514ab1478c7fe56e7cfde31900ddbcc7132a32aa8
+  data.tar.gz: 3d64f9b3bad32c9d941e6cd9439e91eab1f4ccc9f3277cd392821eb67d85d9fa
 SHA512:
-  metadata.gz: 9d58e8aeec4c77b22e8a44d80667b8af553b10323d826fa16da493ab71326e3f0fb4c8f8b4f00fa89f2e53a357642b6c84d138590561c2d389a03de83cac8510
-  data.tar.gz: a6de657f916e8ced227f21c06ab36f168ca8c17adfde474e80526d9a1ab145ab2b00500c93775b22bd6efa35e604fb0c8f9d9b91256caf567a80cb9599c9e270
+  metadata.gz: 296bef2bacd7b7ae81f6d707faaaec9ff8fe0cbcd252fd3151e35fe3465d16841687e8c8ad151c1b7ea39f914fe7b95da3f5ced9677e5b2678af87f04bb22d73
+  data.tar.gz: c6780fbf53a99acf790bd425d1856c8b3075ccb83433e577189ccdd674837d41f4b845294f0a822886e2141e37960c21ecde350a7100a0a59242ee714fd162e8

data/.github/workflows/ci.yml

@@ -0,0 +1,81 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+    tags:
+      - v*
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    env:
+      BUILD_TYPE: ${{ matrix.build_types }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - 2.6
+          - 2.7
+        build_types: ["LINT", "REDIS", "ACTIVERECORD"]
+        exclude:
+          - ruby: 2.6
+            build_types: "LINT"
+
+    steps:
+      - uses: actions/checkout@v1
+
+      - name: Setup ruby
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          architecture: 'x64'
+
+      - name: Setup bundler
+        run: gem install bundler
+
+      - name: Setup gems
+        run: bundle install
+
+      - name: Rubocop
+        run: bundle exec rubocop
+        if: env.BUILD_TYPE == 'LINT'
+
+      - name: Setup redis
+        run: sudo apt-get install redis-server
+        if: env.BUILD_TYPE == 'REDIS'
+
+      - name: Redis specs
+        run: bin/rspec redis
+        if: env.BUILD_TYPE == 'REDIS'
+
+      - name: Setup test app gems
+        run: cd spec/support/dummy_app && bundle install
+        if: env.BUILD_TYPE == 'ACTIVERECORD'
+
+      - name: Setup postgres
+        run: |
+          make setup_pg
+          make start_pg
+        if: env.BUILD_TYPE == 'ACTIVERECORD'
+
+      - name: ActiveRecord specs
+        run: bin/rspec active_record
+        if: env.BUILD_TYPE == 'ACTIVERECORD'
+
+  publish:
+    if: contains(github.ref, 'refs/tags/v')
+    needs: build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Release Gem
+        uses: CvX/publish-rubygems-action@master
+        env:
+          RUBYGEMS_API_KEY: ${{secrets.RUBYGEMS_API_KEY}}

data/CHANGELOG.md

@@ -6,6 +6,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.2] - 2020-11-19
+
+- FIX: Use concurrent-ruby maps to simplify concurrency logic. Resolves a number of possible concurrency issues
+
+## [0.6.1] - 2020-11-19
+
+- FIX: Recover correctly if both the primary and replica go offline
+
+  Previously, a replica failing would cause it to be added to the 'primaries_down' list. The fallback handler would then continuously try and fallback the replica to itself, looping forever, and meaning that fallback to primary would never happen.
+
+## [0.6.0] - 2020-11-09
+- FEATURE: Run failover/fallback callbacks once for each backend
+
+  Previously the failover callback would only fire when the first backend failed, and the fallback callback would only fire when the last backend recovered. Now both failover and fallback callbacks will be triggered for each backend. The key for each backend is also passed to the callbacks for consumption by consuming applications.
+
+- FEATURE: Add primaries_down_count function to failover handlers
+
+  This is intended for consumption by monitoring systems (e.g. the Discourse prometheus exporter) 
+
+## [0.5.9] - 2020-11-06
+- FIX: Ignore errors from the redis socket shutdown call
+
+  This can fail with various i/o errors, but in all cases we want the thread to continue closing the connection with the error, and all the other connections.
+
+## [0.5.8] - 2020-11-05
+
+- FIX: Handle concurrency issues during redis disconnection (#10)
+
+  This handles concurrency issues which can happen during redis failover/fallback:
+  - Previously, 'subscribed' redis clients were skipped during the disconnect process. This is resolved by directly accessing the original_client from the ::Redis instance
+  - Trying to acquire the mutex on a subscribed redis client is impossible, so the close operation would never complete. Now we send the shutdown() signal to the thread, then allow up to 1 second for the mutex to be released before we close the socket
+  - Failover is almost always triggered inside a redis client mutex. Failover then has its own mutex, within which we attempted to acquire mutexes for all redis clients. This logic causes a deadlock when multiple clients failover simultaneously. Now, all disconnection is performed by the Redis::Handler failover thread, outside of any other mutexes. To make this safe, the primary/replica state is stored in the connection driver, and disconnect_clients is updated to specifically target primary/replica connections.
+
 ## [0.5.7] - 2020-09-16
 
 - FIX: Avoid disconnecting Redis connections abruptly.

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    rails_failover (0.5.7)
+    rails_failover (0.6.2)
       activerecord (~> 6.0)
+      concurrent-ruby
       railties (~> 6.0)
 
 GEM
@@ -38,7 +39,7 @@ GEM
     concurrent-ruby (1.1.6)
     crass (1.0.6)
     diff-lcs (1.3)
-    erubi (1.9.0)
+    erubi (1.10.0)
     i18n (1.8.2)
       concurrent-ruby (~> 1.0)
     loofah (2.7.0)

data/lib/rails_failover/active_record.rb

@@ -47,16 +47,20 @@ module RailsFailover
       @on_failover_callback = block
     end
 
-    def self.on_failover_callback
-      @on_failover_callback
+    def self.on_failover_callback!(key)
+      @on_failover_callback&.call(key)
+    rescue => e
+      logger.warn("RailsFailover::ActiveRecord.on_failover failed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
     end
 
     def self.on_fallback(&block)
       @on_fallback_callback = block
     end
 
-    def self.on_fallback_callback
-      @on_fallback_callback
+    def self.on_fallback_callback!(key)
+      @on_fallback_callback&.call(key)
+    rescue => e
+      logger.warn("RailsFailover::ActiveRecord.on_fallback failed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
     end
   end
 end

data/lib/rails_failover/active_record/handler.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'singleton'
 require 'monitor'
+require 'concurrent'
 
 module RailsFailover
   module ActiveRecord
@@ -11,41 +12,38 @@ module RailsFailover
       VERIFY_FREQUENCY_BUFFER_PRECENT = 20
 
       def initialize
-        @primaries_down = {}
-        @ancestor_pid = Process.pid
+        @primaries_down = Concurrent::Map.new
 
         super() # Monitor#initialize
       end
 
       def verify_primary(handler_key)
+        primary_down(handler_key)
+
         mon_synchronize do
-          primary_down(handler_key)
           return if @thread&.alive?
-
           logger.warn "Failover for ActiveRecord has been initiated"
+          @thread = Thread.new { loop_until_all_up }
+        end
+      end
 
-          begin
-            RailsFailover::ActiveRecord.on_failover_callback&.call
-          rescue => e
-            logger.warn("RailsFailover::ActiveRecord.on_failover_callback failed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
-          end
+      def primary_down?(handler_key)
+        primaries_down[handler_key]
+      end
 
-          @thread = Thread.new do
-            loop do
-              initiate_fallback_to_primary
+      def primaries_down_count
+        primaries_down.size
+      end
 
-              if all_primaries_up
-                logger.warn "Fallback to primary for ActiveRecord has been completed."
+      private
 
-                begin
-                  RailsFailover::ActiveRecord.on_fallback_callback&.call
-                rescue => e
-                  logger.warn("RailsFailover::ActiveRecord.on_fallback_callback failed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
-                end
+      def loop_until_all_up
+        loop do
+          initiate_fallback_to_primary
 
-                break
-              end
-            end
+          if all_primaries_up
+            logger.warn "Fallback to primary for ActiveRecord has been completed."
+            break
           end
         end
       end
@@ -83,28 +81,18 @@ module RailsFailover
         end
       end
 
-      def primary_down?(handler_key)
-        primaries_down[handler_key]
-      end
-
-      private
-
       def all_primaries_up
-        mon_synchronize do
-          primaries_down.empty?
-        end
+        primaries_down.empty?
       end
 
       def primary_down(handler_key)
-        mon_synchronize do
-          primaries_down[handler_key] = true
-        end
+        already_down = primaries_down.put_if_absent(handler_key, true)
+        RailsFailover::ActiveRecord.on_failover_callback!(handler_key) if !already_down
       end
 
       def primary_up(handler_key)
-        mon_synchronize do
-          primaries_down.delete(handler_key)
-        end
+        already_up = !primaries_down.delete(handler_key)
+        RailsFailover::ActiveRecord.on_fallback_callback!(handler_key) if !already_up
       end
 
       def spec_name
@@ -112,24 +100,17 @@ module RailsFailover
       end
 
       def primaries_down
-        process_pid = Process.pid
-        return @primaries_down[process_pid] if @primaries_down[process_pid]
-
-        mon_synchronize do
-          if !@primaries_down[process_pid]
-            @primaries_down[process_pid] = @primaries_down[@ancestor_pid] || {}
-
-            if process_pid != @ancestor_pid
-              @primaries_down.delete(@ancestor_pid)
-
-              @primaries_down[process_pid].each_key do |handler_key|
-                verify_primary(handler_key)
-              end
-            end
-          end
+        ancestor_pids = nil
+        value = @primaries_down.compute_if_absent(Process.pid) do
+          ancestor_pids = @primaries_down.keys
+          @primaries_down.values.first || Concurrent::Map.new
+        end
 
-          @primaries_down[process_pid]
+        ancestor_pids&.each do |pid|
+          @primaries_down.delete(pid)&.each_key { |key| verify_primary(key) }
         end
+
+        value
       end
 
       def logger

data/lib/rails_failover/redis.rb

@@ -13,6 +13,9 @@ require_relative 'redis/connector'
 
 module RailsFailover
   class Redis
+    PRIMARY = :primary
+    REPLICA = :replica
+
     def self.logger=(logger)
       @logger = logger
     end
@@ -37,16 +40,20 @@ module RailsFailover
       @on_failover_callback = block
     end
 
-    def self.on_failover_callback
-      @on_failover_callback
+    def self.on_failover_callback!(key)
+      @on_failover_callback&.call(key)
+    rescue => e
+      logger.warn("RailsFailover::Redis.on_failover failed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
     end
 
     def self.on_fallback(&block)
       @on_fallback_callback = block
     end
 
-    def self.on_fallback_callback
-      @on_fallback_callback
+    def self.on_fallback_callback!(key)
+      @on_fallback_callback&.call(key)
+    rescue => e
+      logger.warn("RailsFailover::Redis.on_fallback failed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
     end
 
     # For testing

data/lib/rails_failover/redis/connector.rb

@@ -10,7 +10,11 @@ module RailsFailover
 
         options[:driver] = Class.new(options[:driver]) do
           def self.connect(options)
-            super(options)
+            is_failover_replica = (options[:host] == options[:replica_host]) &&
+                                  (options[:port] == options[:replica_port])
+            super(options).tap do |conn|
+              conn.rails_failover_role = is_failover_replica ? REPLICA : PRIMARY
+            end
           rescue ::Redis::TimeoutError,
                  SocketError,
                  Errno::EADDRNOTAVAIL,
@@ -22,9 +26,16 @@ module RailsFailover
                  Errno::ETIMEDOUT,
                  Errno::EINVAL => e
 
-            Handler.instance.verify_primary(options)
+            Handler.instance.verify_primary(options) if !is_failover_replica
             raise e
           end
+
+          attr_accessor :rails_failover_role
+
+          def shutdown_socket
+            @sock&.shutdown
+          rescue Errno::ENOTCONN
+          end
         end
 
         options[:original_driver] = orignal_driver
@@ -54,8 +65,8 @@ module RailsFailover
 
       def replica_options(options)
         opts = options.dup
-        opts[:host] = opts.delete(:replica_host)
-        opts[:port] = opts.delete(:replica_port)
+        opts[:host] = opts[:replica_host]
+        opts[:port] = opts[:replica_port]
         opts
       end
     end

data/lib/rails_failover/redis/handler.rb

@@ -2,6 +2,7 @@
 
 require 'monitor'
 require 'singleton'
+require 'concurrent'
 
 module RailsFailover
   class Redis
@@ -12,58 +13,65 @@ module RailsFailover
       PRIMARY_ROLE_STATUS = "role:master"
       PRIMARY_LOADED_STATUS = "loading:0"
       VERIFY_FREQUENCY_BUFFER_PRECENT = 20
+      SOFT_DISCONNECT_TIMEOUT_SECONDS = 1
+      SOFT_DISCONNECT_POLL_SECONDS = 0.05
 
       def initialize
-        @primaries_down = {}
-        @clients = {}
-        @ancestor_pid = Process.pid
+        @primaries_down = Concurrent::Map.new
+        @clients = Concurrent::Map.new
 
         super() # Monitor#initialize
       end
 
       def verify_primary(options)
-        mon_synchronize do
-          primary_down(options)
-          disconnect_clients(options)
+        primary_down(options)
 
+        mon_synchronize do
           return if @thread&.alive?
-
           logger&.warn "Failover for Redis has been initiated"
+          @thread = Thread.new { loop_until_all_up }
+        end
+      end
 
-          begin
-            RailsFailover::Redis.on_failover_callback&.call
-          rescue => e
-            logger&.warn("RailsFailover::Redis.on_failover_callback failed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
-          end
+      def register_client(client)
+        id = client.options[:id]
+        clients_for_id(id).put_if_absent(client, true)
+      end
+
+      def deregister_client(client)
+        id = client.options[:id]
+        clients_for_id(id).delete(client)
+      end
+
+      def primary_down?(options)
+        primaries_down[options[:id]]
+      end
 
-          @thread = Thread.new do
-            loop do
-              thread = Thread.new { initiate_fallback_to_primary }
-              thread.join
+      def primaries_down_count
+        primaries_down.size
+      end
 
-              if all_primaries_up
-                logger&.warn "Fallback to primary for Redis has been completed."
+      private
 
-                begin
-                  RailsFailover::Redis.on_fallback_callback&.call
-                rescue => e
-                  logger&.warn("RailsFailover::Redis.on_fallback_callback failed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
-                end
+      def loop_until_all_up
+        loop do
+          ensure_primary_clients_disconnected
+          try_fallback_to_primary
 
-                break
-              end
-            end
+          if all_primaries_up
+            logger&.warn "Fallback to primary for Redis has been completed."
+            break
           end
         end
       end
 
-      def initiate_fallback_to_primary
+      def try_fallback_to_primary
         frequency = RailsFailover::Redis.verify_primary_frequency_seconds
         sleep(frequency * ((rand(VERIFY_FREQUENCY_BUFFER_PRECENT) + 100) / 100.0))
 
         active_primaries_keys = {}
 
-        mon_synchronize { primaries_down.dup }.each do |key, options|
+        primaries_down.each do |key, options|
           info = nil
           options = options.dup
 
@@ -86,110 +94,104 @@ module RailsFailover
 
         active_primaries_keys.each do |key, options|
           primary_up(options)
-          disconnect_clients(options)
+          disconnect_clients(options, RailsFailover::Redis::REPLICA)
         end
       end
 
-      def register_client(client)
-        key = client.options[:id]
-
-        mon_synchronize do
-          clients[key] ||= []
-          clients[key] << client
-        end
+      def all_primaries_up
+        primaries_down.empty?
       end
 
-      def deregister_client(client)
-        key = client.options[:id]
+      def primary_up(options)
+        already_up = !primaries_down.delete(options[:id])
+        RailsFailover::Redis.on_fallback_callback!(options[:id]) if !already_up
+      end
 
-        mon_synchronize do
-          if clients[key]
-            clients[key].delete(client)
+      def primary_down(options)
+        already_down = primaries_down.put_if_absent(options[:id], options.dup)
+        RailsFailover::Redis.on_failover_callback!(options[:id]) if !already_down
+      end
 
-            if clients[key].empty?
-              clients.delete(key)
-            end
-          end
+      def primaries_down
+        ancestor_pids = nil
+        value = @primaries_down.compute_if_absent(Process.pid) do
+          ancestor_pids = @primaries_down.keys
+          @primaries_down.values.first || Concurrent::Map.new
         end
-      end
 
-      def primary_down?(options)
-        mon_synchronize do
-          primaries_down[options[:id]]
+        ancestor_pids&.each do |pid|
+          @primaries_down.delete(pid)&.each { |id, options| verify_primary(options) }
         end
-      end
 
-      private
+        value
+      end
 
-      def all_primaries_up
-        mon_synchronize { primaries_down.empty? }
+      def clients_for_id(id)
+        clients.compute_if_absent(id) { Concurrent::Map.new }
       end
 
-      def primary_up(options)
-        mon_synchronize do
-          primaries_down.delete(options[:id])
+      def clients
+        ancestor_pids = nil
+        clients_for_pid = @clients.compute_if_absent(Process.pid) do
+          ancestor_pids = @clients.keys
+          Concurrent::Map.new
         end
+        ancestor_pids&.each { |k| @clients.delete(k) }
+        clients_for_pid
       end
 
-      def primary_down(options)
-        mon_synchronize do
-          primaries_down[options[:id]] = options.dup
+      def ensure_primary_clients_disconnected
+        primaries_down.each do |key, options|
+          disconnect_clients(options, RailsFailover::Redis::PRIMARY)
         end
       end
 
-      def clients
-        process_pid = Process.pid
-        return @clients[process_pid] if @clients[process_pid]
+      def disconnect_clients(options, role)
+        id = options[:id]
 
-        mon_synchronize do
-          if !@clients[process_pid]
-            @clients[process_pid] = {}
+        matched_clients = clients_for_id(id)&.keys
+          &.filter { |c| c.connection.rails_failover_role == role }
+          &.to_set
 
-            if process_pid != @ancestor_pid
-              @clients.delete(@ancestor_pid)
-            end
-          end
+        return if matched_clients.nil? || matched_clients.empty?
 
-          @clients[process_pid]
+        # This is not ideal, but the mutex we need is contained
+        # in the ::Redis instance, not the Redis::Client
+        ObjectSpace.each_object(::Redis) do |redis|
+          # When subscribed, Redis#_client is not a Redis::Client
+          # Instance variable is the only reliable way
+          client = redis.instance_variable_get(:@original_client)
+          next if !matched_clients.include?(client)
+          soft_disconnect(redis, client, role)
         end
       end
 
-      def primaries_down
-        process_pid = Process.pid
-        return @primaries_down[process_pid] if @primaries_down[process_pid]
+      # Calling .disconnect can cause a running subscribe() to block forever
+      # Therefore try to acquire the lock
+      def soft_disconnect(redis, client, role)
+        has_lock = redis.mon_try_enter
 
-        mon_synchronize do
-          if !@primaries_down[process_pid]
-            @primaries_down[process_pid] = @primaries_down[@ancestor_pid] || {}
-
-            if process_pid != @ancestor_pid
-              @primaries_down.delete(@ancestor_pid)&.each do |id, options|
-                verify_primary(options)
-              end
-            end
+        if !has_lock
+          begin
+            client.connection.shutdown_socket
+          rescue => e
+            logger&.warn "Redis shutdown_socket for (#{role}) failed with #{e.class} '#{e.message}'"
           end
 
-          @primaries_down[process_pid]
-        end
-      end
-
-      def disconnect_clients(options)
-        key = options[:id]
-
-        mon_synchronize do
-          if to_disconnect = clients[key].dup
-            # Don't disconnect connections abruptly since it may lead to unexepcted
-            # errors. Is there a better way to do this without having to monkey patch
-            # the redis-rb gem heavily?
-            ObjectSpace.each_object(::Redis).each do |redis|
-              to_disconnect.each do |c|
-                if redis._client == c
-                  redis.synchronize { |_client| _client.disconnect }
-                end
-              end
-            end
+          waiting_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          loop do # Keep trying
+            break if has_lock = redis.mon_try_enter
+            break if !client.connection.connected? # Disconnected by other thread
+            break if client.connection.rails_failover_role != role # Reconnected by other thread
+            time_now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            break if time_now > waiting_since + SOFT_DISCONNECT_TIMEOUT_SECONDS
+            sleep SOFT_DISCONNECT_POLL_SECONDS
           end
         end
+
+        client.disconnect if client.connection&.rails_failover_role == role
+      ensure
+        redis.mon_exit if has_lock
       end
 
       def logger

data/lib/rails_failover/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsFailover
-  VERSION = "0.5.7"
+  VERSION = "0.6.2"
 end

data/makefile

@@ -18,4 +18,4 @@ stop_dummy_rails_server:
 	@kill -TERM $(shell cat spec/support/dummy_app/tmp/pids/unicorn.pid)
 
 teardown_dummy_rails_server:
-	@cd spec/support/dummy_app && DISABLE_DATABASE_ENVIRONMENT_CHECK=1 RAILS_ENV=production $(BUNDLER_BIN) exec rails db:drop
+	@cd spec/support/dummy_app && (! (bundle check > /dev/null 2>&1) || DISABLE_DATABASE_ENVIRONMENT_CHECK=1 RAILS_ENV=production $(BUNDLER_BIN) exec rails db:drop)

data/rails_failover.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   ["activerecord", "railties"].each do |gem_name|
     spec.add_dependency gem_name, "~> 6.0"
   end
+  spec.add_dependency "concurrent-ruby"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_failover
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.6.2
 platform: ruby
 authors:
 - Alan Tan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-16 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - tgx@discourse.org
@@ -45,10 +59,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -92,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Failover for ActiveRecord and Redis

data/.travis.yml

@@ -1,6 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.6.2
-before_install: gem install bundler -v 2.1.4