Merge branch 'master' into refactor_server_access_log

sanic/server.py

@@ -24,7 +24,7 @@ try:
 except ImportError:
     async_loop = asyncio
 
-from sanic.log import log, netlog
+from sanic.log import logger, access_logger
 from sanic.response import HTTPResponse
 from sanic.request import Request
 from sanic.exceptions import (
@@ -67,8 +67,8 @@ class HttpProtocol(asyncio.Protocol):
         'request_handler', 'request_timeout', 'response_timeout',
         'keep_alive_timeout', 'request_max_size', 'request_class',
         'is_request_stream', 'router',
-        # enable or disable access log / error log purpose
-        'has_log',
+        # enable or disable access log purpose
+        'access_log',
         # connection management
         '_total_request_size', '_request_timeout_handler',
         '_response_timeout_handler', '_keep_alive_timeout_handler',
@@ -77,7 +77,7 @@ class HttpProtocol(asyncio.Protocol):
     def __init__(self, *, loop, request_handler, error_handler,
                  signal=Signal(), connections=set(), request_timeout=60,
                  response_timeout=60, keep_alive_timeout=15,
-                 request_max_size=None, request_class=None, has_log=True,
+                 request_max_size=None, request_class=None, access_log=True,
                  keep_alive=True, is_request_stream=False, router=None,
                  state=None, debug=False, **kwargs):
         self.loop = loop
@@ -88,7 +88,7 @@ class HttpProtocol(asyncio.Protocol):
         self.headers = None
         self.router = router
         self.signal = signal
-        self.has_log = has_log
+        self.access_log = access_log
         self.connections = connections
         self.request_handler = request_handler
         self.error_handler = error_handler
@@ -190,7 +190,7 @@ class HttpProtocol(asyncio.Protocol):
                                      self.keep_alive_timeout_callback)
             )
         else:
-            log.info('KeepAlive Timeout. Closing connection.')
+            logger.info('KeepAlive Timeout. Closing connection.')
             self.transport.close()
 
     # -------------------------------------------- #
@@ -337,13 +337,13 @@ class HttpProtocol(asyncio.Protocol):
                     self.keep_alive_timeout))
             self.log_response(response)
         except AttributeError:
-            log.error(
+            logger.error(
                 ('Invalid response object for url {}, '
                  'Expected Type: HTTPResponse, Actual Type: {}').format(
                     self.url, type(response)))
             self.write_error(ServerError('Invalid response type'))
         except RuntimeError:
-            log.error(
+            logger.error(
                 'Connection lost before response written @ {}'.format(
                     self.request.ip))
         except Exception as e:
@@ -376,13 +376,13 @@ class HttpProtocol(asyncio.Protocol):
                 self.request.version, keep_alive, self.keep_alive_timeout)
             self.log_response(response)
         except AttributeError:
-            log.error(
+            logger.error(
                 ('Invalid response object for url {}, '
                  'Expected Type: HTTPResponse, Actual Type: {}').format(
                     self.url, type(response)))
             self.write_error(ServerError('Invalid response type'))
         except RuntimeError:
-            log.error(
+            logger.error(
                 'Connection lost before response written @ {}'.format(
                     self.request.ip))
         except Exception as e:
@@ -411,7 +411,7 @@ class HttpProtocol(asyncio.Protocol):
             version = self.request.version if self.request else '1.1'
             self.transport.write(response.output(version))
         except RuntimeError:
-            log.error(
+            logger.error(
                 'Connection lost before error written @ {}'.format(
                     self.request.ip if self.request else 'Unknown'))
         except Exception as e:
@@ -427,16 +427,16 @@ class HttpProtocol(asyncio.Protocol):
 
     def bail_out(self, message, from_error=False):
         if from_error or self.transport.is_closing():
-            log.error(
+            logger.error(
                 ("Transport closed @ {} and exception "
                  "experienced during error handling").format(
                     self.transport.get_extra_info('peername')))
-            log.debug(
+            logger.debug(
                 'Exception:\n{}'.format(traceback.format_exc()))
         else:
             exception = ServerError(message)
             self.write_error(exception)
-            log.error(message)
+            logger.error(message)
 
     def cleanup(self):
         """This is called when KeepAlive feature is used,
@@ -500,7 +500,7 @@ def serve(host, port, request_handler, error_handler, before_start=None,
           ssl=None, sock=None, request_max_size=None, reuse_port=False,
           loop=None, protocol=HttpProtocol, backlog=100,
           register_sys_signals=True, run_async=False, connections=None,
-          signal=Signal(), request_class=None, has_log=True,
+          signal=Signal(), request_class=None, access_log=True,
           keep_alive=True, is_request_stream=False, router=None,
           websocket_max_size=None, websocket_max_queue=None, state=None,
           graceful_shutdown_timeout=15.0):
@@ -529,7 +529,7 @@ def serve(host, port, request_handler, error_handler, before_start=None,
     :param loop: asyncio compatible event loop
     :param protocol: subclass of asyncio protocol class
     :param request_class: Request class to use
-    :param has_log: disable/enable access log and error log
+    :param access_log: disable/enable access log
     :param is_request_stream: disable/enable Request.stream
     :param router: Router object
     :return: Nothing
@@ -554,7 +554,7 @@ def serve(host, port, request_handler, error_handler, before_start=None,
         keep_alive_timeout=keep_alive_timeout,
         request_max_size=request_max_size,
         request_class=request_class,
-        has_log=has_log,
+        access_log=access_log,
         keep_alive=keep_alive,
         is_request_stream=is_request_stream,
         router=router,
@@ -586,7 +586,7 @@ def serve(host, port, request_handler, error_handler, before_start=None,
     try:
         http_server = loop.run_until_complete(server_coroutine)
     except:
-        log.exception("Unable to start server")
+        logger.exception("Unable to start server")
         return
 
     trigger_events(after_start, loop)
@@ -597,14 +597,15 @@ def serve(host, port, request_handler, error_handler, before_start=None,
             try:
                 loop.add_signal_handler(_signal, loop.stop)
             except NotImplementedError:
-                log.warn('Sanic tried to use loop.add_signal_handler but it is'
-                         ' not implemented on this platform.')
+                logger.warn(
+                    'Sanic tried to use loop.add_signal_handler but it is'
+                    ' not implemented on this platform.')
     pid = os.getpid()
     try:
-        log.info('Starting worker [{}]'.format(pid))
+        logger.info('Starting worker [{}]'.format(pid))
         loop.run_forever()
     finally:
-        log.info("Stopping worker [{}]".format(pid))
+        logger.info("Stopping worker [{}]".format(pid))
 
         # Run the on_stop function if provided
         trigger_events(before_stop, loop)
@@ -666,7 +667,7 @@ def serve_multiple(server_settings, workers):
         server_settings['port'] = None
 
     def sig_handler(signal, frame):
-        log.info("Received signal {}. Shutting down.".format(
+        logger.info("Received signal {}. Shutting down.".format(
             Signals(signal).name))
         for process in processes:
             os.kill(process.pid, SIGINT)