Switched to module-level logging.

- getChild() not supported in 2.6 .
- Removed massive amount of commented logging/logic.

Author: dsoprea

gdrivefs/cache/cache_agent.py

@@ -10,11 +10,12 @@
 from gdrivefs.cache.cache_registry import CacheRegistry, CacheFault
 from gdrivefs.report import Report
 
+_logger = logging.getLogger(__name__)
+
+
 class CacheAgent(object):
     """A particular namespace within the cache."""
 
-    __log = None
-
     registry        = None
     resource_name   = None
     max_age         = None
@@ -27,9 +28,7 @@ class CacheAgent(object):
 
     def __init__(self, resource_name, max_age, fault_handler=None, 
                  cleanup_pretrigger=None):
-        self.__log = logging.getLogger().getChild('CacheAgent')
-
-        self.__log.debug("CacheAgent(%s,%s,%s,%s)" % (resource_name, max_age, 
+        _logger.debug("CacheAgent(%s,%s,%s,%s)" % (resource_name, max_age, 
                                                    type(fault_handler), 
                                                    cleanup_pretrigger))
 
@@ -55,20 +54,10 @@ def __del__(self):
     def __post_status(self):
         """Send the current status to our reporting tool."""
 
-        try:
-            num_values = self.registry.count(self.resource_name)
-        except:
-            self.__log.exception("Could not get count of values for resource "
-                                 "with name [%s]." % (self.resource_name))
-            raise
+        num_values = self.registry.count(self.resource_name)
 
-        try:
-            self.report.set_values(self.report_source_name, 'count', 
-                                   num_values)
-        except:
-            self.__log.exception("Cache could not post status for resource "
-                                 "with name [%s]." % (self.resource_name))
-            raise
+        self.report.set_values(self.report_source_name, 'count', 
+                               num_values)
 
         status_post_interval_s = Conf.get('cache_status_post_frequency_s')
         status_timer = Timer(status_post_interval_s, self.__post_status)
@@ -80,15 +69,10 @@ def __cleanup_check(self):
         removed.
         """
 
-        self.__log.debug("Doing clean-up for cache resource with name [%s]." % 
+        _logger.debug("Doing clean-up for cache resource with name [%s]." % 
                       (self.resource_name))
 
-        try:
-            cache_dict = self.registry.list_raw(self.resource_name)
-        except:
-            self.__log.exception("Could not do clean-up check with resource-"
-                                 "name [%s]." % (self.resource_name))
-            raise
+        cache_dict = self.registry.list_raw(self.resource_name)
 
         total_keys = [ (key, value_tuple[1]) for key, value_tuple \
                             in cache_dict.iteritems() ]
@@ -98,41 +82,35 @@ def __cleanup_check(self):
                             if (datetime.now() - value_tuple[1]).seconds > \
                                     self.max_age ]
 
-        self.__log.info("Found (%d) entries to clean-up from entry-cache." % 
-                        (len(cleanup_keys)))
+        _logger.info("Found (%d) entries to clean-up from entry-cache." % 
+                     (len(cleanup_keys)))
 
         if cleanup_keys:
             for key in cleanup_keys:
-                self.__log.debug("Cache entry [%s] under resource-name [%s] "
-                                 "will be cleaned-up." % (key, 
-                                                          self.resource_name))
+                _logger.debug("Cache entry [%s] under resource-name [%s] "
+                              "will be cleaned-up." % 
+                              (key, self.resource_name))
 
                 if self.exists(key, no_fault_check=True) == False:
-                    self.__log.debug("Entry with ID [%s] has already been "
-                                     "cleaned-up." % (key))
+                    _logger.debug("Entry with ID [%s] has already been "
+                                  "cleaned-up." % (key))
                 else:
-                    try:
-                        self.remove(key)
-                    except:
-                        self.__log.exception("Cache entry [%s] under resource-"
-                                             "name [%s] could not be cleaned-"
-                                             "up." % (key, self.resource_name))
-                        raise
+                    self.remove(key)
 
-            self.__log.debug("Scheduled clean-up complete.")
+            _logger.debug("Scheduled clean-up complete.")
 
         cleanup_interval_s = Conf.get('cache_cleanup_check_frequency_s')
         cleanup_timer = Timer(cleanup_interval_s, self.__cleanup_check)
 
         Timers.get_instance().register_timer('cleanup', cleanup_timer)
 
     def set(self, key, value):
-        self.__log.debug("CacheAgent.set(%s,%s)" % (key, value))
+        _logger.debug("CacheAgent.set(%s,%s)" % (key, value))
 
         return self.registry.set(self.resource_name, key, value)
 
     def remove(self, key):
-        self.__log.debug("CacheAgent.remove(%s)" % (key))
+        _logger.debug("CacheAgent.remove(%s)" % (key))
 
         return self.registry.remove(self.resource_name, 
                                     key, 
@@ -143,34 +121,28 @@ def get(self, key, handle_fault = None):
         if handle_fault == None:
             handle_fault = True
 
-        self.__log.debug("CacheAgent.get(%s)" % (key))
+        _logger.debug("CacheAgent.get(%s)" % (key))
 
         try:
             result = self.registry.get(self.resource_name, 
                                        key, 
                                        max_age=self.max_age, 
                                        cleanup_pretrigger=self.cleanup_pretrigger)
         except CacheFault:
-            self.__log.debug("There was a cache-miss while requesting item "
-                             "with ID (key).")
+            _logger.debug("There was a cache-miss while requesting item with "
+                          "ID (key).")
 
             if self.fault_handler == None or not handle_fault:
                 raise
 
-            try:
-                result = self.fault_handler(self.resource_name, key)
-            except:
-                self.__log.exception("There was an exception in the fault-"
-                                     "handler, handling for key [%s].", key)
-                raise
-
-            if result == None:
+            result = self.fault_handler(self.resource_name, key)
+            if result is None:
                 raise
 
         return result
 
     def exists(self, key, no_fault_check=False):
-        self.__log.debug("CacheAgent.exists(%s)" % (key))
+        _logger.debug("CacheAgent.exists(%s)" % (key))
 
         return self.registry.exists(self.resource_name, key, 
                                     max_age=self.max_age,

gdrivefs/cache/cache_registry.py

@@ -3,6 +3,8 @@
 from threading import RLock
 from datetime import datetime
 
+_logger = logging.getLogger(__name__)
+
 
 class CacheFault(Exception):
     pass
@@ -12,10 +14,8 @@ class CacheRegistry(object):
     """The main cache container."""
 
     __rlock = RLock()
-    __log = None
 
     def __init__(self):
-        self.__log = logging.getLogger().getChild('CacheReg')
         self.__cache = { }
 
     @staticmethod
@@ -34,8 +34,8 @@ def get_instance(resource_name):
 
     def set(self, resource_name, key, value):
 
-        self.__log.debug("CacheRegistry.set(%s,%s,%s)" % (resource_name, key, 
-                                                          value))
+        _logger.debug("CacheRegistry.set(%s,%s,%s)" % 
+                      (resource_name, key, value))
 
         with CacheRegistry.__rlock:
             try:
@@ -49,8 +49,8 @@ def set(self, resource_name, key, value):
 
     def remove(self, resource_name, key, cleanup_pretrigger=None):
 
-        self.__log.debug("CacheRegistry.remove(%s,%s,%s)" % 
-                         (resource_name, key, type(cleanup_pretrigger)))
+        _logger.debug("CacheRegistry.remove(%s,%s,%s)" % 
+                      (resource_name, key, type(cleanup_pretrigger)))
 
         with CacheRegistry.__rlock:
             try:
@@ -69,8 +69,8 @@ def get(self, resource_name, key, max_age, cleanup_pretrigger=None):
                                 if cleanup_pretrigger == None 
                                 else '<given>')
 
-        self.__log.debug("CacheRegistry.get(%s,%s,%s,%s)" % 
-                         (resource_name, key, max_age, trigger_given_phrase))
+        _logger.debug("CacheRegistry.get(%s,%s,%s,%s)" % 
+                      (resource_name, key, max_age, trigger_given_phrase))
 
         with CacheRegistry.__rlock:
             try:
@@ -88,30 +88,24 @@ def get(self, resource_name, key, max_age, cleanup_pretrigger=None):
 
     def list_raw(self, resource_name):
 
-        self.__log.debug("CacheRegistry.list(%s)" % (resource_name))
+        _logger.debug("CacheRegistry.list(%s)" % (resource_name))
 
         with CacheRegistry.__rlock:
-            try:
-                return self.__cache[resource_name]
-            except:
-                self.__log.exception("Could not list raw-entries under cache "
-                                  "labelled with resource-name [%s]." %
-                                  (resource_name))
-                raise
+            return self.__cache[resource_name]
 
     def exists(self, resource_name, key, max_age, cleanup_pretrigger=None, 
                no_fault_check=False):
 
-        self.__log.debug("CacheRegistry.exists(%s,%s,%s,%s)" % (resource_name, 
-                      key, max_age, cleanup_pretrigger))
+        _logger.debug("CacheRegistry.exists(%s,%s,%s,%s)" % 
+                      (resource_name, key, max_age, cleanup_pretrigger))
 
         with CacheRegistry.__rlock:
             try:
                 (value, timestamp) = self.__cache[resource_name][key]
             except:
                 return False
 
-            if max_age != None and not no_fault_check and \
+            if max_age is not None and not no_fault_check and \
                     (datetime.now() - timestamp).seconds > max_age:
                 self.__cleanup_entry(resource_name, key, False, 
                                      cleanup_pretrigger=cleanup_pretrigger)
@@ -126,23 +120,13 @@ def count(self, resource_name):
     def __cleanup_entry(self, resource_name, key, force, 
                         cleanup_pretrigger=None):
 
-        self.__log.debug("Doing clean-up for resource_name [%s] and key "
-                         "[%s]." % (resource_name, key))
+        _logger.debug("Doing clean-up for resource_name [%s] and key "
+                      "[%s]." % (resource_name, key))
 
-        if cleanup_pretrigger != None:
-            self.__log.debug("Running pre-cleanup trigger for resource_name "
-                             "[%s] and key [%s]." % (resource_name, key))
-
-            try:
-                cleanup_pretrigger(resource_name, key, force)
-            except:
-                self.__log.exception("Cleanup-trigger failed.")
-                raise
+        if cleanup_pretrigger is not None:
+            _logger.debug("Running pre-cleanup trigger for resource_name "
+                          "[%s] and key [%s]." % (resource_name, key))
 
-        try:
-            del self.__cache[resource_name][key]
-        except:
-            self.__log.exception("Could not clean-up entry with resource_name "
-                              "[%s] and key [%s]." % (resource_name, key))
-            raise
+            cleanup_pretrigger(resource_name, key, force)
 
+        del self.__cache[resource_name][key]

gdrivefs/cache/cacheclient_base.py

@@ -2,13 +2,14 @@
 
 from gdrivefs.cache.cache_agent import CacheAgent
 
+_logger = logging.getLogger(__name__)
+
+
 class CacheClientBase(object):
     """Meant to be inherited by a class. Is used to configure a particular 
     namespace within the cache.
     """
 
-    __log = None
-
     @property
     def cache(self):
         try:
@@ -23,11 +24,10 @@ def cache(self):
         return self._cache
 
     def __init__(self):
-        self.__log = logging.getLogger().getChild('CacheClientBase')
         child_type = self.__class__.__bases__[0].__name__
         max_age = self.get_max_cache_age_seconds()
 
-        self.__log.debug("CacheClientBase(%s,%s)" % (child_type, max_age))
+        _logger.debug("CacheClientBase(%s,%s)" % (child_type, max_age))
 
         self.child_type = child_type
         self.max_age = max_age