Make redis an instance variable

This means connections will be restablished between requests

Author: theospears

experiments/counters.py

@@ -8,26 +8,27 @@
 REDIS_PASSWORD = getattr(settings, 'EXPERIMENTS_REDIS_PASSWORD', None)
 REDIS_EXPERIMENTS_DB = getattr(settings, 'EXPERIMENTS_REDIS_DB', 0)
 
-r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, db=REDIS_EXPERIMENTS_DB)
-
 COUNTER_CACHE_KEY = 'experiments:participants:%s'
 COUNTER_FREQ_CACHE_KEY = 'experiments:freq:%s'
 
 
 class Counters(object):
+    def __init__(self):
+        self.redis = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, db=REDIS_EXPERIMENTS_DB)
+
     def increment(self, key, participant_identifier, count=1):
         if count == 0:
             return
 
         try:
             cache_key = COUNTER_CACHE_KEY % key
             freq_cache_key = COUNTER_FREQ_CACHE_KEY % key
-            new_value = r.hincrby(cache_key, participant_identifier, count)
+            new_value = self.redis.hincrby(cache_key, participant_identifier, count)
 
             # Maintain histogram of per-user counts
             if new_value > count:
-                r.hincrby(freq_cache_key, new_value - count, -1)
-            r.hincrby(freq_cache_key, new_value, 1)
+                self.redis.hincrby(freq_cache_key, new_value - count, -1)
+            self.redis.hincrby(freq_cache_key, new_value, 1)
         except (ConnectionError, ResponseError):
             # Handle Redis failures gracefully
             pass
@@ -36,28 +37,28 @@ def clear(self, key, participant_identifier):
         try:
             # Remove the direct entry
             cache_key = COUNTER_CACHE_KEY % key
-            pipe = r.pipeline()
+            pipe = self.redis.pipeline()
             freq, _ = pipe.hget(cache_key, participant_identifier).hdel(cache_key, participant_identifier).execute()
 
             # Remove from the histogram
             freq_cache_key = COUNTER_FREQ_CACHE_KEY % key
-            r.hincrby(freq_cache_key, freq, -1)
+            self.redis.hincrby(freq_cache_key, freq, -1)
         except (ConnectionError, ResponseError):
             # Handle Redis failures gracefully
             pass
 
     def get(self, key):
         try:
             cache_key = COUNTER_CACHE_KEY % key
-            return r.hlen(cache_key)
+            return self.redis.hlen(cache_key)
         except (ConnectionError, ResponseError):
             # Handle Redis failures gracefully
             return 0
 
     def get_frequency(self, key, participant_identifier):
         try:
             cache_key = COUNTER_CACHE_KEY % key
-            freq = r.hget(cache_key, participant_identifier)
+            freq = self.redis.hget(cache_key, participant_identifier)
             return int(freq) if freq else 0
         except (ConnectionError, ResponseError):
             # Handle Redis failures gracefully
@@ -70,17 +71,17 @@ def get_frequencies(self, key):
             # briefly be a negative result for some frequency count. We discard these
             # as they shouldn't really affect the result, and they are about to become
             # zero anyway.
-            return dict((int(k), int(v)) for (k, v) in r.hgetall(freq_cache_key).items() if int(v) > 0)
+            return dict((int(k), int(v)) for (k, v) in self.redis.hgetall(freq_cache_key).items() if int(v) > 0)
         except (ConnectionError, ResponseError):
             # Handle Redis failures gracefully
             return tuple()
 
     def reset(self, key):
         try:
             cache_key = COUNTER_CACHE_KEY % key
-            r.delete(cache_key)
+            self.redis.delete(cache_key)
             freq_cache_key = COUNTER_FREQ_CACHE_KEY % key
-            r.delete(freq_cache_key)
+            self.redis.delete(freq_cache_key)
             return True
         except (ConnectionError, ResponseError):
             # Handle Redis failures gracefully
@@ -90,11 +91,11 @@ def reset_pattern(self, pattern_key):
         #similar to above, but can pass pattern as arg instead
         try:
             cache_key = COUNTER_CACHE_KEY % pattern_key
-            for key in r.keys(cache_key):
-                r.delete(key)
+            for key in self.redis.keys(cache_key):
+                self.redis.delete(key)
             freq_cache_key = COUNTER_FREQ_CACHE_KEY % pattern_key
-            for key in r.keys(freq_cache_key):
-                r.delete(key)
+            for key in self.redis.keys(freq_cache_key):
+                self.redis.delete(key)
             return True
         except (ConnectionError, ResponseError):
             # Handle Redis failures gracefully