Support multiple Redis instances based on queue type

22 files changed, 393 insertions, 174 deletions

diff --git a/lib/gitlab/auth/unique_ips_limiter.rb b/lib/gitlab/auth/unique_ips_limiter.rb
index bf2239ca150..baa1f802d8a 100644
--- a/lib/gitlab/auth/unique_ips_limiter.rb
+++ b/lib/gitlab/auth/unique_ips_limiter.rb
@@ -27,7 +27,7 @@ module Gitlab
           time = Time.now.utc.to_i
           key = "#{USER_UNIQUE_IPS_PREFIX}:#{user_id}"
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             unique_ips_count = nil
             redis.multi do |r|
               r.zadd(key, time, ip)
diff --git a/lib/gitlab/cache/ci/project_pipeline_status.rb b/lib/gitlab/cache/ci/project_pipeline_status.rb
index 9c2e09943b0..dba37892863 100644
--- a/lib/gitlab/cache/ci/project_pipeline_status.rb
+++ b/lib/gitlab/cache/ci/project_pipeline_status.rb
@@ -23,7 +23,7 @@ module Gitlab
         end
 
         def self.cached_results_for_projects(projects)
-          result = Gitlab::Redis.with do |redis|
+          result = Gitlab::Redis::Cache.with do |redis|
             redis.multi do
               projects.each do |project|
                 cache_key = cache_key_for_project(project)
@@ -100,19 +100,19 @@ module Gitlab
         end
 
         def load_from_cache
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::Cache.with do |redis|
             self.sha, self.status, self.ref = redis.hmget(cache_key, :sha, :status, :ref)
           end
         end
 
         def store_in_cache
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::Cache.with do |redis|
             redis.mapped_hmset(cache_key, { sha: sha, status: status, ref: ref })
           end
         end
 
         def delete_from_cache
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::Cache.with do |redis|
             redis.del(cache_key)
           end
         end
@@ -120,7 +120,7 @@ module Gitlab
         def has_cache?
           return self.loaded unless self.loaded.nil?
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::Cache.with do |redis|
             redis.exists(cache_key)
           end
         end
diff --git a/lib/gitlab/chat_name_token.rb b/lib/gitlab/chat_name_token.rb
index 1b081aa9b1d..e63e5437331 100644
--- a/lib/gitlab/chat_name_token.rb
+++ b/lib/gitlab/chat_name_token.rb
@@ -12,23 +12,23 @@ module Gitlab
     end
 
     def get
-      Gitlab::Redis.with do |redis|
-        data = redis.get(redis_key)
+      Gitlab::Redis::SharedState.with do |redis|
+        data = redis.get(redis_shared_state_key)
         JSON.parse(data, symbolize_names: true) if data
       end
     end
 
     def store!(params)
-      Gitlab::Redis.with do |redis|
+      Gitlab::Redis::SharedState.with do |redis|
         params = params.to_json
-        redis.set(redis_key, params, ex: EXPIRY_TIME)
+        redis.set(redis_shared_state_key, params, ex: EXPIRY_TIME)
         token
       end
     end
 
     def delete
-      Gitlab::Redis.with do |redis|
-        redis.del(redis_key)
+      Gitlab::Redis::SharedState.with do |redis|
+        redis.del(redis_shared_state_key)
       end
     end
 
@@ -38,7 +38,7 @@ module Gitlab
       Devise.friendly_token(TOKEN_LENGTH)
     end
 
-    def redis_key
+    def redis_shared_state_key
       "gitlab:chat_names:#{token}"
     end
   end
diff --git a/lib/gitlab/current_settings.rb b/lib/gitlab/current_settings.rb
index 7fa02f3d7b3..791a3c36476 100644
--- a/lib/gitlab/current_settings.rb
+++ b/lib/gitlab/current_settings.rb
@@ -25,7 +25,7 @@ module Gitlab
     def cached_application_settings
       begin
         ::ApplicationSetting.cached
-      rescue ::Redis::BaseError, ::Errno::ENOENT, ::Errno::EADDRNOTAVAIL
+      rescue ::Redis::BaseError, ::Errno::ENOENT
         # In case Redis isn't running or the Redis UNIX socket file is not available
       end
     end
diff --git a/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base.rb b/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base.rb
index 33f8939bc61..1a697396ff1 100644
--- a/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base.rb
+++ b/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base.rb
@@ -145,7 +145,7 @@ module Gitlab
 
           def track_rename(type, old_path, new_path)
             key = redis_key_for_type(type)
-            Gitlab::Redis.with do |redis|
+            Gitlab::Redis::SharedState.with do |redis|
               redis.lpush(key, [old_path, new_path].to_json)
               redis.expire(key, 2.weeks.to_i)
             end
@@ -155,7 +155,7 @@ module Gitlab
           def reverts_for_type(type)
             key = redis_key_for_type(type)
 
-            Gitlab::Redis.with do |redis|
+            Gitlab::Redis::SharedState.with do |redis|
               failed_reverts = []
 
               while rename_info = redis.lpop(key)
diff --git a/lib/gitlab/etag_caching/store.rb b/lib/gitlab/etag_caching/store.rb
index 072fcfc65e6..21172ff8d93 100644
--- a/lib/gitlab/etag_caching/store.rb
+++ b/lib/gitlab/etag_caching/store.rb
@@ -2,17 +2,17 @@ module Gitlab
   module EtagCaching
     class Store
       EXPIRY_TIME = 20.minutes
-      REDIS_NAMESPACE = 'etag:'.freeze
+      SHARED_STATE_NAMESPACE = 'etag:'.freeze
 
       def get(key)
-        Gitlab::Redis.with { |redis| redis.get(redis_key(key)) }
+        Gitlab::Redis::SharedState.with { |redis| redis.get(redis_shared_state_key(key)) }
       end
 
       def touch(key, only_if_missing: false)
         etag = generate_etag
 
-        Gitlab::Redis.with do |redis|
-          redis.set(redis_key(key), etag, ex: EXPIRY_TIME, nx: only_if_missing)
+        Gitlab::Redis::SharedState.with do |redis|
+          redis.set(redis_shared_state_key(key), etag, ex: EXPIRY_TIME, nx: only_if_missing)
         end
 
         etag
@@ -24,10 +24,10 @@ module Gitlab
         SecureRandom.hex
       end
 
-      def redis_key(key)
+      def redis_shared_state_key(key)
         raise 'Invalid key' if !Rails.env.production? && !Gitlab::EtagCaching::Router.match(key)
 
-        "#{REDIS_NAMESPACE}#{key}"
+        "#{SHARED_STATE_NAMESPACE}#{key}"
       end
     end
   end
diff --git a/lib/gitlab/exclusive_lease.rb b/lib/gitlab/exclusive_lease.rb
index a0f46594eb1..3784f6c4947 100644
--- a/lib/gitlab/exclusive_lease.rb
+++ b/lib/gitlab/exclusive_lease.rb
@@ -26,17 +26,17 @@ module Gitlab
     EOS
 
     def self.cancel(key, uuid)
-      Gitlab::Redis.with do |redis|
-        redis.eval(LUA_CANCEL_SCRIPT, keys: [redis_key(key)], argv: [uuid])
+      Gitlab::Redis::SharedState.with do |redis|
+        redis.eval(LUA_CANCEL_SCRIPT, keys: [redis_shared_state_key(key)], argv: [uuid])
       end
     end
 
-    def self.redis_key(key)
+    def self.redis_shared_state_key(key)
       "gitlab:exclusive_lease:#{key}"
     end
 
     def initialize(key, timeout:)
-      @redis_key = self.class.redis_key(key)
+      @redis_shared_state_key = self.class.redis_shared_state_key(key)
       @timeout = timeout
       @uuid = SecureRandom.uuid
     end
@@ -45,24 +45,24 @@ module Gitlab
     # false if the lease is already taken.
     def try_obtain
       # Performing a single SET is atomic
-      Gitlab::Redis.with do |redis|
-        redis.set(@redis_key, @uuid, nx: true, ex: @timeout) && @uuid
+      Gitlab::Redis::SharedState.with do |redis|
+        redis.set(@redis_shared_state_key, @uuid, nx: true, ex: @timeout) && @uuid
       end
     end
 
     # Try to renew an existing lease. Return lease UUID on success,
     # false if the lease is taken by a different UUID or inexistent.
     def renew
-      Gitlab::Redis.with do |redis|
-        result = redis.eval(LUA_RENEW_SCRIPT, keys: [@redis_key], argv: [@uuid, @timeout])
+      Gitlab::Redis::SharedState.with do |redis|
+        result = redis.eval(LUA_RENEW_SCRIPT, keys: [@redis_shared_state_key], argv: [@uuid, @timeout])
         result == @uuid
       end
     end
 
     # Returns true if the key for this lease is set.
     def exists?
-      Gitlab::Redis.with do |redis|
-        redis.exists(@redis_key)
+      Gitlab::Redis::SharedState.with do |redis|
+        redis.exists(@redis_shared_state_key)
       end
     end
   end
diff --git a/lib/gitlab/health_checks/redis/cache_check.rb b/lib/gitlab/health_checks/redis/cache_check.rb
new file mode 100644
index 00000000000..a28658d42d4
--- /dev/null
+++ b/lib/gitlab/health_checks/redis/cache_check.rb
@@ -0,0 +1,31 @@
+module Gitlab
+  module HealthChecks
+    module Redis
+      class CacheCheck
+        extend SimpleAbstractCheck
+
+        class << self
+          def check_up
+            check
+          end
+
+          private
+
+          def metric_prefix
+            'redis_cache_ping'
+          end
+
+          def is_successful?(result)
+            result == 'PONG'
+          end
+
+          def check
+            catch_timeout 10.seconds do
+              Gitlab::Redis::Cache.with(&:ping)
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/health_checks/redis/queues_check.rb b/lib/gitlab/health_checks/redis/queues_check.rb
new file mode 100644
index 00000000000..f97d50d3947
--- /dev/null
+++ b/lib/gitlab/health_checks/redis/queues_check.rb
@@ -0,0 +1,31 @@
+module Gitlab
+  module HealthChecks
+    module Redis
+      class QueuesCheck
+        extend SimpleAbstractCheck
+
+        class << self
+          def check_up
+            check
+          end
+
+          private
+
+          def metric_prefix
+            'redis_queues_ping'
+          end
+
+          def is_successful?(result)
+            result == 'PONG'
+          end
+
+          def check
+            catch_timeout 10.seconds do
+              Gitlab::Redis::Queues.with(&:ping)
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/health_checks/redis/redis_check.rb b/lib/gitlab/health_checks/redis/redis_check.rb
new file mode 100644
index 00000000000..fe4e3c4a3ab
--- /dev/null
+++ b/lib/gitlab/health_checks/redis/redis_check.rb
@@ -0,0 +1,27 @@
+module Gitlab
+  module HealthChecks
+    module Redis
+      class RedisCheck
+        extend SimpleAbstractCheck
+
+        class << self
+          private
+
+          def metric_prefix
+            'redis_ping'
+          end
+
+          def is_successful?(result)
+            result == 'PONG'
+          end
+
+          def check
+            ::Gitlab::HealthChecks::Redis::CacheCheck.check_up &&
+              ::Gitlab::HealthChecks::Redis::QueuesCheck.check_up &&
+              ::Gitlab::HealthChecks::Redis::SharedStateCheck.check_up
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/health_checks/redis/shared_state_check.rb b/lib/gitlab/health_checks/redis/shared_state_check.rb
new file mode 100644
index 00000000000..e3244392902
--- /dev/null
+++ b/lib/gitlab/health_checks/redis/shared_state_check.rb
@@ -0,0 +1,31 @@
+module Gitlab
+  module HealthChecks
+    module Redis
+      class SharedStateCheck
+        extend SimpleAbstractCheck
+
+        class << self
+          def check_up
+            check
+          end
+
+          private
+
+          def metric_prefix
+            'redis_shared_state_ping'
+          end
+
+          def is_successful?(result)
+            result == 'PONG'
+          end
+
+          def check
+            catch_timeout 10.seconds do
+              Gitlab::Redis::SharedState.with(&:ping)
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/health_checks/redis_check.rb b/lib/gitlab/health_checks/redis_check.rb
deleted file mode 100644
index 57bbe5b3ad0..00000000000
--- a/lib/gitlab/health_checks/redis_check.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-module Gitlab
-  module HealthChecks
-    class RedisCheck
-      extend SimpleAbstractCheck
-
-      class << self
-        private
-
-        def metric_prefix
-          'redis_ping'
-        end
-
-        def is_successful?(result)
-          result == 'PONG'
-        end
-
-        def check
-          catch_timeout 10.seconds do
-            Gitlab::Redis.with(&:ping)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/lib/gitlab/lfs_token.rb b/lib/gitlab/lfs_token.rb
index 5f67e97fa2a..8e57ba831c5 100644
--- a/lib/gitlab/lfs_token.rb
+++ b/lib/gitlab/lfs_token.rb
@@ -18,10 +18,10 @@ module Gitlab
     end
 
     def token
-      Gitlab::Redis.with do |redis|
-        token = redis.get(redis_key)
+      Gitlab::Redis::SharedState.with do |redis|
+        token = redis.get(redis_shared_state_key)
         token ||= Devise.friendly_token(TOKEN_LENGTH)
-        redis.set(redis_key, token, ex: EXPIRY_TIME)
+        redis.set(redis_shared_state_key, token, ex: EXPIRY_TIME)
 
         token
       end
@@ -41,7 +41,7 @@ module Gitlab
 
     private
 
-    def redis_key
+    def redis_shared_state_key
       "gitlab:lfs_token:#{actor.class.name.underscore}_#{actor.id}" if actor
     end
   end
diff --git a/lib/gitlab/mail_room.rb b/lib/gitlab/mail_room.rb
index 3503fac40e8..9f432673a6e 100644
--- a/lib/gitlab/mail_room.rb
+++ b/lib/gitlab/mail_room.rb
@@ -1,6 +1,6 @@
 require 'yaml'
 require 'json'
-require_relative 'redis' unless defined?(Gitlab::Redis)
+require_relative 'redis/queues' unless defined?(Gitlab::Redis::Queues)
 
 module Gitlab
   module MailRoom
@@ -34,11 +34,11 @@ module Gitlab
         config[:idle_timeout] = 60 if config[:idle_timeout].nil?
 
         if config[:enabled] && config[:address]
-          gitlab_redis = Gitlab::Redis.new(rails_env)
-          config[:redis_url] = gitlab_redis.url
+          gitlab_redis_queues = Gitlab::Redis::Queues.new(rails_env)
+          config[:redis_url] = gitlab_redis_queues.url
 
-          if gitlab_redis.sentinels?
-            config[:sentinels] = gitlab_redis.sentinels
+          if gitlab_redis_queues.sentinels?
+            config[:sentinels] = gitlab_redis_queues.sentinels
           end
         end
 
diff --git a/lib/gitlab/redis.rb b/lib/gitlab/redis.rb
deleted file mode 100644
index bc5370de32a..00000000000
--- a/lib/gitlab/redis.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-# This file should not have any direct dependency on Rails environment
-# please require all dependencies below:
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/module/delegation'
-
-module Gitlab
-  class Redis
-    CACHE_NAMESPACE = 'cache:gitlab'.freeze
-    SESSION_NAMESPACE = 'session:gitlab'.freeze
-    SIDEKIQ_NAMESPACE = 'resque:gitlab'.freeze
-    MAILROOM_NAMESPACE = 'mail_room:gitlab'.freeze
-    DEFAULT_REDIS_URL = 'redis://localhost:6379'.freeze
-
-    class << self
-      delegate :params, :url, to: :new
-
-      def with
-        @pool ||= ConnectionPool.new(size: pool_size) { ::Redis.new(params) }
-        @pool.with { |redis| yield redis }
-      end
-
-      def pool_size
-        if Sidekiq.server?
-          # the pool will be used in a multi-threaded context
-          Sidekiq.options[:concurrency] + 5
-        else
-          # probably this is a Unicorn process, so single threaded
-          5
-        end
-      end
-
-      def _raw_config
-        return @_raw_config if defined?(@_raw_config)
-
-        begin
-          @_raw_config = ERB.new(File.read(config_file)).result.freeze
-        rescue Errno::ENOENT
-          @_raw_config = false
-        end
-
-        @_raw_config
-      end
-
-      def config_file
-        ENV['GITLAB_REDIS_CONFIG_FILE'] || File.expand_path('../../config/resque.yml', __dir__)
-      end
-    end
-
-    def initialize(rails_env = nil)
-      @rails_env = rails_env || ::Rails.env
-    end
-
-    def params
-      redis_store_options
-    end
-
-    def url
-      raw_config_hash[:url]
-    end
-
-    def sentinels
-      raw_config_hash[:sentinels]
-    end
-
-    def sentinels?
-      sentinels && !sentinels.empty?
-    end
-
-    private
-
-    def redis_store_options
-      config = raw_config_hash
-      redis_url = config.delete(:url)
-      redis_uri = URI.parse(redis_url)
-
-      if redis_uri.scheme == 'unix'
-        # Redis::Store does not handle Unix sockets well, so let's do it for them
-        config[:path] = redis_uri.path
-        config
-      else
-        redis_hash = ::Redis::Store::Factory.extract_host_options_from_uri(redis_url)
-        # order is important here, sentinels must be after the connection keys.
-        # {url: ..., port: ..., sentinels: [...]}
-        redis_hash.merge(config)
-      end
-    end
-
-    def raw_config_hash
-      config_data = fetch_config
-
-      if config_data
-        config_data.is_a?(String) ? { url: config_data } : config_data.deep_symbolize_keys
-      else
-        { url: DEFAULT_REDIS_URL }
-      end
-    end
-
-    def fetch_config
-      self.class._raw_config ? YAML.load(self.class._raw_config)[@rails_env] : false
-    end
-  end
-end
diff --git a/lib/gitlab/redis/cache.rb b/lib/gitlab/redis/cache.rb
new file mode 100644
index 00000000000..b0da516ff83
--- /dev/null
+++ b/lib/gitlab/redis/cache.rb
@@ -0,0 +1,34 @@
+# please require all dependencies below:
+require_relative 'wrapper' unless defined?(::Gitlab::Redis::Wrapper)
+
+module Gitlab
+  module Redis
+    class Cache < ::Gitlab::Redis::Wrapper
+      CACHE_NAMESPACE = 'cache:gitlab'.freeze
+      DEFAULT_REDIS_CACHE_URL = 'redis://localhost:6380'.freeze
+      REDIS_CACHE_CONFIG_ENV_VAR_NAME = 'GITLAB_REDIS_CACHE_CONFIG_FILE'.freeze
+      if defined?(::Rails) && ::Rails.root.present?
+        DEFAULT_REDIS_CACHE_CONFIG_FILE_NAME = ::Rails.root.join('config', 'redis.cache.yml').freeze
+      end
+
+      class << self
+        def default_url
+          DEFAULT_REDIS_CACHE_URL
+        end
+
+        def config_file_name
+          # if ENV set for this class, use it even if it points to a file does not exist
+          file_name = ENV[REDIS_CACHE_CONFIG_ENV_VAR_NAME]
+          return file_name unless file_name.nil?
+
+          # otherwise, if config files exists for this class, use it
+          file_name = File.expand_path(DEFAULT_REDIS_CACHE_CONFIG_FILE_NAME, __dir__)
+          return file_name if File.file?(file_name)
+
+          # this will force use of DEFAULT_REDIS_QUEUES_URL when config file is absent
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/redis/queues.rb b/lib/gitlab/redis/queues.rb
new file mode 100644
index 00000000000..f9249d05565
--- /dev/null
+++ b/lib/gitlab/redis/queues.rb
@@ -0,0 +1,35 @@
+# please require all dependencies below:
+require_relative 'wrapper' unless defined?(::Gitlab::Redis::Wrapper)
+
+module Gitlab
+  module Redis
+    class Queues < ::Gitlab::Redis::Wrapper
+      SIDEKIQ_NAMESPACE = 'resque:gitlab'.freeze
+      MAILROOM_NAMESPACE = 'mail_room:gitlab'.freeze
+      DEFAULT_REDIS_QUEUES_URL = 'redis://localhost:6381'.freeze
+      REDIS_QUEUES_CONFIG_ENV_VAR_NAME = 'GITLAB_REDIS_QUEUES_CONFIG_FILE'.freeze
+      if defined?(::Rails) && ::Rails.root.present?
+        DEFAULT_REDIS_QUEUES_CONFIG_FILE_NAME = ::Rails.root.join('config', 'redis.queues.yml').freeze
+      end
+
+      class << self
+        def default_url
+          DEFAULT_REDIS_QUEUES_URL
+        end
+
+        def config_file_name
+          # if ENV set for this class, use it even if it points to a file does not exist
+          file_name = ENV[REDIS_QUEUES_CONFIG_ENV_VAR_NAME]
+          return file_name if file_name
+
+          # otherwise, if config files exists for this class, use it
+          file_name = File.expand_path(DEFAULT_REDIS_QUEUES_CONFIG_FILE_NAME, __dir__)
+          return file_name if File.file?(file_name)
+
+          # this will force use of DEFAULT_REDIS_QUEUES_URL when config file is absent
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/redis/shared_state.rb b/lib/gitlab/redis/shared_state.rb
new file mode 100644
index 00000000000..395dcf082da
--- /dev/null
+++ b/lib/gitlab/redis/shared_state.rb
@@ -0,0 +1,34 @@
+# please require all dependencies below:
+require_relative 'wrapper' unless defined?(::Gitlab::Redis::Wrapper)
+
+module Gitlab
+  module Redis
+    class SharedState < ::Gitlab::Redis::Wrapper
+      SESSION_NAMESPACE = 'session:gitlab'.freeze
+      DEFAULT_REDIS_SHARED_STATE_URL = 'redis://localhost:6382'.freeze
+      REDIS_SHARED_STATE_CONFIG_ENV_VAR_NAME = 'GITLAB_REDIS_SHARED_STATE_CONFIG_FILE'.freeze
+      if defined?(::Rails) && ::Rails.root.present?
+        DEFAULT_REDIS_SHARED_STATE_CONFIG_FILE_NAME = ::Rails.root.join('config', 'redis.shared_state.yml').freeze
+      end
+
+      class << self
+        def default_url
+          DEFAULT_REDIS_SHARED_STATE_URL
+        end
+
+        def config_file_name
+          # if ENV set for this class, use it even if it points to a file does not exist
+          file_name = ENV[REDIS_SHARED_STATE_CONFIG_ENV_VAR_NAME]
+          return file_name if file_name
+
+          # otherwise, if config files exists for this class, use it
+          file_name = File.expand_path(DEFAULT_REDIS_SHARED_STATE_CONFIG_FILE_NAME, __dir__)
+          return file_name if File.file?(file_name)
+
+          # this will force use of DEFAULT_REDIS_SHARED_STATE_URL when config file is absent
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/redis/wrapper.rb b/lib/gitlab/redis/wrapper.rb
new file mode 100644
index 00000000000..10c16a962ca
--- /dev/null
+++ b/lib/gitlab/redis/wrapper.rb
@@ -0,0 +1,123 @@
+# This file should only be used by sub-classes, not directly by any clients of the sub-classes
+# please require all dependencies below:
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/module/delegation'
+
+module Gitlab
+  module Redis
+    class Wrapper
+      DEFAULT_REDIS_URL = 'redis://localhost:6379'.freeze
+      REDIS_CONFIG_ENV_VAR_NAME = 'GITLAB_REDIS_CONFIG_FILE'.freeze
+      if defined?(::Rails) && ::Rails.root.present?
+        DEFAULT_REDIS_CONFIG_FILE_NAME = ::Rails.root.join('config', 'resque.yml').freeze
+      end
+
+      class << self
+        delegate :params, :url, to: :new
+
+        def with
+          @pool ||= ConnectionPool.new(size: pool_size) { ::Redis.new(params) }
+          @pool.with { |redis| yield redis }
+        end
+
+        def pool_size
+          # heuristic constant 5 should be a config setting somewhere -- related to CPU count?
+          size = 5
+          if Sidekiq.server?
+            # the pool will be used in a multi-threaded context
+            size += Sidekiq.options[:concurrency]
+          end
+          size
+        end
+
+        def _raw_config
+          return @_raw_config if defined?(@_raw_config)
+
+          begin
+            @_raw_config = ERB.new(File.read(config_file_name)).result.freeze
+          rescue Errno::ENOENT
+            @_raw_config = false
+          end
+
+          @_raw_config
+        end
+
+        def default_url
+          DEFAULT_REDIS_URL
+        end
+
+        def config_file_name
+          # if ENV set for wrapper class, use it even if it points to a file does not exist
+          file_name = ENV[REDIS_CONFIG_ENV_VAR_NAME]
+          return file_name unless file_name.nil?
+
+          # otherwise, if config files exists for wrapper class, use it
+          file_name = File.expand_path(DEFAULT_REDIS_CONFIG_FILE_NAME, __dir__)
+          return file_name if File.file?(file_name)
+
+          # nil will force use of DEFAULT_REDIS_URL when config file is absent
+          nil
+        end
+      end
+
+      def initialize(rails_env = nil)
+        @rails_env = rails_env || ::Rails.env
+      end
+
+      def params
+        redis_store_options
+      end
+
+      def url
+        raw_config_hash[:url]
+      end
+
+      def sentinels
+        raw_config_hash[:sentinels]
+      end
+
+      def sentinels?
+        sentinels && !sentinels.empty?
+      end
+
+      private
+
+      def redis_store_options
+        config = raw_config_hash
+        redis_url = config.delete(:url)
+        redis_uri = URI.parse(redis_url)
+
+        if redis_uri.scheme == 'unix'
+          # Redis::Store does not handle Unix sockets well, so let's do it for them
+          config[:path] = redis_uri.path
+          query = redis_uri.query
+          unless query.nil?
+            queries = CGI.parse(redis_uri.query)
+            db_numbers = queries["db"] if queries.key?("db")
+            config[:db] = db_numbers[0].to_i if db_numbers.any?
+          end
+          config
+        else
+          redis_hash = ::Redis::Store::Factory.extract_host_options_from_uri(redis_url)
+          # order is important here, sentinels must be after the connection keys.
+          # {url: ..., port: ..., sentinels: [...]}
+          redis_hash.merge(config)
+        end
+      end
+
+      def raw_config_hash
+        config_data = fetch_config
+
+        if config_data
+          config_data.is_a?(String) ? { url: config_data } : config_data.deep_symbolize_keys
+        else
+          { url: self.class.default_url }
+        end
+      end
+
+      def fetch_config
+        self.class._raw_config ? YAML.load(self.class._raw_config)[@rails_env] : false
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/user_activities.rb b/lib/gitlab/user_activities.rb
index eb36ab9fded..125488536e1 100644
--- a/lib/gitlab/user_activities.rb
+++ b/lib/gitlab/user_activities.rb
@@ -6,13 +6,13 @@ module Gitlab
     BATCH_SIZE = 500
 
     def self.record(key, time = Time.now)
-      Gitlab::Redis.with do |redis|
+      Gitlab::Redis::SharedState.with do |redis|
         redis.hset(KEY, key, time.to_i)
       end
     end
 
     def delete(*keys)
-      Gitlab::Redis.with do |redis|
+      Gitlab::Redis::SharedState.with do |redis|
         redis.hdel(KEY, keys)
       end
     end
@@ -21,7 +21,7 @@ module Gitlab
       cursor = 0
       loop do
         cursor, pairs =
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             redis.hscan(KEY, cursor, count: BATCH_SIZE)
           end
 
diff --git a/lib/gitlab/workhorse.rb b/lib/gitlab/workhorse.rb
index 4aef23b6aee..ee4f2b773ea 100644
--- a/lib/gitlab/workhorse.rb
+++ b/lib/gitlab/workhorse.rb
@@ -176,7 +176,7 @@ module Gitlab
       end
 
       def set_key_and_notify(key, value, expire: nil, overwrite: true)
-        Gitlab::Redis.with do |redis|
+        Gitlab::Redis::Queues.with do |redis|
           result = redis.set(key, value, ex: expire, nx: !overwrite)
           if result
             redis.publish(NOTIFICATION_CHANNEL, "#{key}=#{value}")
diff --git a/lib/tasks/cache.rake b/lib/tasks/cache.rake
index 125a3d560d6..564aa141952 100644
--- a/lib/tasks/cache.rake
+++ b/lib/tasks/cache.rake
@@ -5,12 +5,12 @@ namespace :cache do
 
     desc "GitLab | Clear redis cache"
     task redis: :environment do
-      Gitlab::Redis.with do |redis|
+      Gitlab::Redis::Cache.with do |redis|
         cursor = REDIS_SCAN_START_STOP
         loop do
           cursor, keys = redis.scan(
             cursor,
-            match: "#{Gitlab::Redis::CACHE_NAMESPACE}*",
+            match: "#{Gitlab::Redis::Cache::CACHE_NAMESPACE}*",
             count: REDIS_CLEAR_BATCH_SIZE
           )