chore: Use connection_pool for redis (#5790)

fixes: #3199

config/initializers/01_redis.rb

@@ -2,15 +2,15 @@ Rails.application.reloader.to_prepare do
   # Alfred
   # Add here as you use it for more features
   # Used for Round Robin, Conversation Emails & Online Presence
-  $alfred = ConnectionPool::Wrapper.new(size: 5, timeout: 3) do
+  $alfred = ConnectionPool.new(size: 5, timeout: 3) do
     redis = Rails.env.test? ? MockRedis.new : Redis.new(Redis::Config.app)
     Redis::Namespace.new('alfred', redis: redis, warning: true)
   end
 
   # Velma : Determined protector
   # used in rack attack
-  $velma = ConnectionPool::Wrapper.new(size: 5, timeout: 3) do
+  $velma = ConnectionPool.new(size: 5, timeout: 3) do
-    redis = Rails.env.test? ? MockRedis.new : Redis.new(Redis::Config.app)
+    config = Rails.env.test? ? MockRedis.new : Redis.new(Redis::Config.app)
-    Redis::Namespace.new('velma', redis: redis, warning: true)
+    Redis::Namespace.new('velma', redis: config, warning: true)
   end
 end

config/initializers/rack_attack.rb

@@ -11,7 +11,7 @@ class Rack::Attack
   # Rack::Attack.cache.store = ActiveSupport::Cache::MemoryStore.new
 
   # https://github.com/rack/rack-attack/issues/102
-  Rack::Attack.cache.store = Rack::Attack::StoreProxy::RedisProxy.new($velma)
+  Rack::Attack.cache.store = ActiveSupport::Cache::RedisCacheStore.new(redis: $velma)
 
   class Request < ::Rack::Request
     # You many need to specify a method to fetch the correct remote IP address

lib/global_config.rb

@@ -20,9 +20,9 @@ class GlobalConfig
     end
 
     def clear_cache
-      cached_keys = $alfred.keys("#{VERSION}:#{KEY_PREFIX}:*")
+      cached_keys = $alfred.with { |conn| conn.keys("#{VERSION}:#{KEY_PREFIX}:*") }
       (cached_keys || []).each do |cached_key|
-        $alfred.expire(cached_key, 0)
+        $alfred.with { |conn| conn.expire(cached_key, 0) }
       end
     end
 
@@ -30,12 +30,12 @@ class GlobalConfig
 
     def load_from_cache(config_key)
       cache_key = "#{VERSION}:#{KEY_PREFIX}:#{config_key}"
-      cached_value = $alfred.get(cache_key)
+      cached_value = $alfred.with { |conn| conn.get(cache_key) }
 
       if cached_value.blank?
         value_from_db = db_fallback(config_key)
         cached_value = { value: value_from_db }.to_json
-        $alfred.set(cache_key, cached_value, { ex: DEFAULT_EXPIRY })
+        $alfred.with { |conn| conn.set(cache_key, cached_value, { ex: DEFAULT_EXPIRY }) }
       end
 
       JSON.parse(cached_value)['value']

lib/redis/alfred.rb

@@ -8,92 +8,92 @@ module Redis::Alfred
 
     # set a value in redis
     def set(key, value)
-      $alfred.set(key, value)
+      $alfred.with { |conn| conn.set(key, value) }
     end
 
     # set a key with expiry period
     def setex(key, value, expiry = 1.day)
-      $alfred.setex(key, expiry, value)
+      $alfred.with { |conn| conn.setex(key, expiry, value) }
     end
 
     def get(key)
-      $alfred.get(key)
+      $alfred.with { |conn| conn.get(key) }
     end
 
     def delete(key)
-      $alfred.del(key)
+      $alfred.with { |conn| conn.del(key) }
     end
 
     # increment a key by 1. throws error if key value is incompatible
     # sets key to 0 before operation if key doesn't exist
     def incr(key)
-      $alfred.incr(key)
+      $alfred.with { |conn| conn.incr(key) }
     end
 
     # list operations
 
     def llen(key)
-      $alfred.llen(key)
+      $alfred.with { |conn| conn.llen(key) }
     end
 
     def lrange(key, start_index = 0, end_index = -1)
-      $alfred.lrange(key, start_index, end_index)
+      $alfred.with { |conn| conn.lrange(key, start_index, end_index) }
     end
 
     def rpop(key)
-      $alfred.rpop(key)
+      $alfred.with { |conn| conn.rpop(key) }
     end
 
     def lpush(key, values)
-      $alfred.lpush(key, values)
+      $alfred.with { |conn| conn.lpush(key, values) }
     end
 
     def rpoplpush(source, destination)
-      $alfred.rpoplpush(source, destination)
+      $alfred.with { |conn| conn.rpoplpush(source, destination) }
     end
 
     def lrem(key, value, count = 0)
-      $alfred.lrem(key, count, value)
+      $alfred.with { |conn| conn.lrem(key, count, value) }
     end
 
     # hash operations
 
     # add a key value to redis hash
     def hset(key, field, value)
-      $alfred.hset(key, field, value)
+      $alfred.with { |conn| conn.hset(key, field, value) }
     end
 
     # get value from redis hash
     def hget(key, field)
-      $alfred.hget(key, field)
+      $alfred.with { |conn| conn.hget(key, field) }
     end
 
     # get values of multiple keys from redis hash
     def hmget(key, fields)
-      $alfred.hmget(key, *fields)
+      $alfred.with { |conn| conn.hmget(key, *fields) }
     end
 
     # sorted set operations
 
     # add score and value for a key
     def zadd(key, score, value)
-      $alfred.zadd(key, score, value)
+      $alfred.with { |conn| conn.zadd(key, score, value) }
     end
 
     # get score of a value for key
     def zscore(key, value)
-      $alfred.zscore(key, value)
+      $alfred.with { |conn| conn.zscore(key, value) }
     end
 
     # get values by score
     def zrangebyscore(key, range_start, range_end)
-      $alfred.zrangebyscore(key, range_start, range_end)
+      $alfred.with { |conn| conn.zrangebyscore(key, range_start, range_end) }
     end
 
     # remove values by score
     # exclusive score is specified by prefixing (
     def zremrangebyscore(key, range_start, range_end)
-      $alfred.zremrangebyscore(key, range_start, range_end)
+      $alfred.with { |conn| conn.zremrangebyscore(key, range_start, range_end) }
     end
   end
 end

spec/controllers/api/v1/accounts/csat_survey_responses_controller_spec.rb

@@ -111,6 +111,9 @@ RSpec.describe 'CSAT Survey Responses API', type: :request do
       end
 
       it 'filters csat metrics based on a date range' do
+        # clearing any existing csat responses
+        CsatSurveyResponse.destroy_all
+
         create(:csat_survey_response, account: account, created_at: 10.days.ago)
         create(:csat_survey_response, account: account, created_at: 3.days.ago)