retrieve tracim logger

tracim/config.py

 from paste.deploy.converters import asbool
 from urllib.parse import urlparse
-import logging
+from tracim.logger import logger
 
 from pyramid.request import Request
 
-logger = logging.getLogger(__name__)
-
 
 class RequestWithCFG(Request):
 
             # we do not show URL because At the time of configuration setup,
             # it can't be evaluated
             # We do not show CONTENT in order not to pollute log files
-            logger.info('CONFIG: [ {} | {} ]'.format(key, value))
+            logger.info(self, 'CONFIG: [ {} | {} ]'.format(key, value))
         else:
-            logger.info('CONFIG: [ {} | <value not shown> ]'.format(key))
+            logger.info(self, 'CONFIG: [ {} | <value not shown> ]'.format(key))
 
         self.__dict__[key] = value
 
     def __init__(self, settings):
         """Parse configuration file."""
 
-        ### General
+        ###
+        # General
+        ###
 
         mandatory_msg = \
             'ERROR: {} configuration is mandatory. Set it before continuing.'
         if not self.WEBSITE_SERVER_NAME:
             self.WEBSITE_SERVER_NAME = urlparse(self.WEBSITE_BASE_URL).hostname
             logger.warning(
+                self,
                 'NOTE: Generated website.server_name parameter from '
                 'website.base_url parameter -> {0}'
                 .format(self.WEBSITE_SERVER_NAME)
         #             self.WEBSITE_SERVER_NAME,
         #             self.WSGIDAV_PORT,
         #         )
-        #     logger.warning(
+        #     logger.warning(self,
         #         'NOTE: Generated wsgidav.client.base_url parameter with '
         #         'followings parameters: website.server_name and '
         #         'wsgidav.conf port'.format(
         # )
         # if not self.RADICALE_SERVER_ALLOW_ORIGIN:
         #     self.RADICALE_SERVER_ALLOW_ORIGIN = self.WEBSITE_BASE_URL
-        #     logger.warning(
+        #     logger.warning(self,
         #         'NOTE: Generated radicale.server.allow_origin parameter with '
         #         'followings parameters: website.base_url ({0})'
         #         .format(self.WEBSITE_BASE_URL)
         #         = '/' + self.RADICALE_CLIENT_BASE_URL_PREFIX
         #
         # if not self.RADICALE_CLIENT_BASE_URL_HOST:
-        #     logger.warning(
+        #     logger.warning(self,
         #         'Generated radicale.client.base_url.host parameter with '
         #         'followings parameters: website.server_name -> {}'
         #         .format(self.WEBSITE_SERVER_NAME)
         #     self.RADICALE_CLIENT_BASE_URL_PREFIX,
         # )
 
-
     class CST(object):
         ASYNC = 'ASYNC'
         SYNC = 'SYNC'

tracim/logger.py

+import logging
+
+class Logger(object):
+    TPL = '[{cls}] {msg}'
+    def __init__(self, logger_name):
+        self._name = logger_name
+        self._logger = logging.getLogger(self._name)
+
+    def _txt(self, instance_or_class):
+        if instance_or_class.__class__.__name__ in ('function', 'type'):
+            return instance_or_class.__name__
+        else:
+            return instance_or_class.__class__.__name__
+
+    def debug(self, instance_or_class, message):
+        self._logger.debug(Logger.TPL.format(cls=self._txt(instance_or_class), msg=message))
+
+    def error(self, instance_or_class, message, exc_info=0):
+        self._logger.error(Logger.TPL.format(cls=self._txt(instance_or_class), msg=message, exc_info=exc_info))
+
+    def info(self, instance_or_class, message):
+        self._logger.info(Logger.TPL.format(cls=self._txt(instance_or_class), msg=message))
+
+    def warning(self, instance_or_class, message):
+        self._logger.warning(Logger.TPL.format(cls=self._txt(instance_or_class), msg=message))
+
+logger = Logger('tracim')

tracim/views/default.py

 
 @view_config(route_name='home', renderer='../templates/mytemplate.jinja2')
 def my_view(request):
+    request.config()
     try:
         query = request.dbsession.query(MyModel)
         one = query.filter(MyModel.name == 'one').first()