Adds more explicit logging

application_example.py

@@ -1,6 +1,7 @@
 from diy_framework import App, Router
 from diy_framework.http_utils import Response
 
+
 async def home(r):
     rsp = Response()
     rsp.set_header('Content-Type', 'text/html')

diy_framework/application.py

@@ -11,6 +11,14 @@
 from . import http_parser
 from .http_server import HTTPServer
 
+logger = logging.getLogger(__name__)
+basic_logger_config = {
+    'format': '%(asctime)s [%(levelname)s] %(message)s',
+    'level': logging.INFO,
+    'filename': None
+}
+logging.basicConfig(**basic_logger_config)
+
 class App(object):
     def __init__(self,
                  router,
@@ -27,18 +35,7 @@ def __init__(self,
         self._connection_handler = None
         self._loop = None
 
-        self.initialize_logging(level=log_level)
-
-
-    def initialize_logging(self, **log_config):
-        basic_logging_config = {
-            'format': '%(asctime)s [%(levelname)s] %(message)s',
-            'level': logging.DEBUG,
-            'filename': None
-        }
-
-        config = {**basic_logging_config, **log_config}
-        logging.basicConfig(**config)
+        logger.setLevel(log_level)
 
     def start_server(self):
         if not self._server:
@@ -52,29 +49,29 @@ def start_server(self):
                 reuse_port=True,
                 loop=self.loop)
 
-            logging.info("Starting server on {0}:{1}".format(
+            logger.info('Starting server on {0}:{1}'.format(
                 self.host, self.port))
             self.loop.run_until_complete(self._connection_handler)
 
             try:
                 self.loop.run_forever()
             except KeyboardInterrupt:
-                logging.info("Got signal, killing server")
+                logger.info('Got signal, killing server')
             except DiyFrameworkException as e:
-                logging.error("Critical framework failure:")
-                logging.error(e.__traceback__)
+                logger.error('Critical framework failure:')
+                logger.error(e.__traceback__)
             finally:
                 self.loop.close()
         else:
-            logging.info("Server already started - {0}".format(self))
+            logger.info('Server already started - {0}'.format(self))
 
     def __repr__(self):
         cls = self.__class__
         if self._connection_handler:
-            return "{0} - Listening on: {1}:{2}".format(
+            return '{0} - Listening on: {1}:{2}'.format(
                 cls, self.host, self.port)
         else:
-            return "{0} - Not started".format(cls)
+            return '{0} - Not started'.format(cls)
 
 
 class HandlerWrapper(object):
@@ -96,29 +93,33 @@ def add_routes(self, routes):
             self.add_route(route, fn)
 
     def add_route(self, path, handler):
-        compiled_route = self.__class__.build_regexp(path)
+        # logger.debug('Adding handler for: {0}'.format(path))
+        compiled_route = self.__class__.build_route_regexp(path)
         if compiled_route not in self.routes:
             self.routes[compiled_route] = handler
         else:
             raise DuplicateRoute
 
     def get_handler(self, path):
-        logging.debug('Getting handler for: {0}'.format(path))
+        logger.debug('Getting handler for: {0}'.format(path))
         for route, handler in self.routes.items():
             path_params = self.__class__.match_path(route, path)
             if path_params is not None:
+                logger.debug('Got handler for: {0}'.format(path))
                 wrapped_handler = HandlerWrapper(handler, path_params)
                 return wrapped_handler
 
         raise NotFoundException()
 
     @classmethod
-    def build_regexp(cls, regexp_str):
+    def build_route_regexp(cls, regexp_str):
         def named_groups(matchobj):
             return '(?P<{0}>[a-zA-Z0-9_-]+)'.format(matchobj.group(1))
 
         re_str = re.sub(r'{([a-zA-Z0-9_-]+)}', named_groups, regexp_str)
-        return re.compile('^' + re_str + '$')
+        re_str = ''.join(('^', re_str, '$',))
+        # logger.debug('Compiling "{0}" regexp'.format(re_str))
+        return re.compile(re_str)
 
     @classmethod
     def match_path(cls, route, path):

diy_framework/http_server.py

@@ -40,7 +40,7 @@ async def handle_request(self):
         while not self.request.finished:
             self._reset_c_timeout()
             try:
-                await self.data_received(await self._reader.read(1024))
+                await self.process_data(await self._reader.read(1024))
             except (NotFoundException,
                     BadRequestException) as e:
                 self.error_reply(e.code, body=Response.reason_phrases[e.code])
@@ -55,13 +55,14 @@ async def handle_request(self):
         self.close_connection()
 
 
-    async def data_received(self, data):
+    async def process_data(self, data):
         self._buffer.extend(data)
 
         self._buffer = self.http_parser.parse_into(
             self.request, self._buffer)
 
     def close_connection(self):
+        logging.debug('Closing connection')
         self._cancel_c_timeout()
         self._writer.close()
 
@@ -71,6 +72,7 @@ def error_reply(self, code, body=''):
         self._writer.drain()
 
     async def reply(self):
+        logging.debug('Replying to request')
         request = self.request
         handler = self.router.get_handler(request.path)
 

tests/unit/test_router.py

@@ -20,31 +20,31 @@ def test_unique_route(self):
     def test_transform_route_into_regexp(self):
         route = r'/path/{id}'
         expected_regexp_str = r'^/path/(?P<id>[a-zA-Z0-9_-]+)$'
-        regexp_obj = self.router.build_regexp(route)
+        regexp_obj = self.router.build_route_regexp(route)
         self.assertEqual(expected_regexp_str, regexp_obj.pattern)
 
     def test_route_regexp_no_vars(self):
-        route = Router.build_regexp(r'/path')
+        route = Router.build_route_regexp(r'/path')
         path = r'/path'
         path_params = Router.match_path(route, path)
         self.assertDictEqual(path_params, {})
 
     def test_route_regexp_one_var(self):
-        route = Router.build_regexp(r'/path/{var1}')
+        route = Router.build_route_regexp(r'/path/{var1}')
         path = r'/path/12'
         path_params = Router.match_path(route, path)
         self.assertDictEqual({'var1': '12'}, path_params)
 
     def test_route_regexp_multiple_vars(self):
-        route = Router.build_regexp(r'/path/{var1}/edit/{var2}')
+        route = Router.build_route_regexp(r'/path/{var1}/edit/{var2}')
         path = r'/path/12/edit/name'
         path_params = Router.match_path(route, path)
         self.assertDictEqual(
             {'var1': '12', 'var2': 'name'},
             path_params)
 
     def test_add_multiple_routes(self):
-        route = Router.build_regexp(r'/{var1}/{var2}/{var3}')
+        route = Router.build_route_regexp(r'/{var1}/{var2}/{var3}')
         path = r'/1/12/123'
         path_params = Router.match_path(route, path)
         self.assertDictEqual(