implementing AbstractAsyncAccessLogger

aiohttp/abc.py

@@ -206,3 +206,18 @@ def log(self,
             response: StreamResponse,
             time: float) -> None:
         """Emit log to logger."""
+
+
+class AbstractAsyncAccessLogger(ABC):
+    """Abstract async writer to access log."""
+
+    def __init__(self, logger: logging.Logger, log_format: str) -> None:
+        self.logger = logger
+        self.log_format = log_format
+
+    @abstractmethod
+    async def log(self,
+                  request: BaseRequest,
+                  response: StreamResponse,
+                  request_start: float) -> None:
+        """Emit log to logger."""

aiohttp/web_protocol.py

@@ -18,7 +18,11 @@
 
 import yarl
 
-from .abc import AbstractAccessLogger, AbstractStreamWriter
+from .abc import (
+    AbstractAccessLogger,
+    AbstractAsyncAccessLogger,
+    AbstractStreamWriter,
+)
 from .base_protocol import BaseProtocol
 from .helpers import CeilTimeout, current_task
 from .http import (
@@ -65,6 +69,25 @@ class PayloadAccessError(Exception):
     """Payload was accessed after response was sent."""
 
 
+class AccessLoggerWrapper(AbstractAsyncAccessLogger):
+    """
+    Wraps an AbstractAccessLogger so it behaves
+    like an AbstractAsyncAccessLogger.
+    """
+    def __init__(self, access_logger: AbstractAccessLogger):
+        self.access_logger = access_logger
+        super().__init__(
+            self.access_logger.logger,
+            self.access_logger.log_format,
+        )
+
+    async def log(self,
+                  request: BaseRequest,
+                  response: StreamResponse,
+                  request_start: float) -> None:
+        self.access_logger.log(request, response, request_start)
+
+
 class RequestHandler(BaseProtocol):
     """HTTP protocol implementation.
 
@@ -164,8 +187,11 @@ def __init__(self, manager: 'Server', *,
         self.debug = debug
         self.access_log = access_log
         if access_log:
-            self.access_logger = access_log_class(
-                access_log, access_log_format)  # type: Optional[AbstractAccessLogger]  # noqa
+            access_logger = access_log_class(access_log, access_log_format)
+            if isinstance(access_logger, AbstractAsyncAccessLogger):
+                self.access_logger = access_logger  # type: Optional[AbstractAsyncAccessLogger]  # noqa
+            else:
+                self.access_logger = AccessLoggerWrapper(access_logger)
         else:
             self.access_logger = None
 
@@ -339,13 +365,13 @@ def force_close(self) -> None:
             self.transport.close()
             self.transport = None
 
-    def log_access(self,
-                   request: BaseRequest,
-                   response: StreamResponse,
-                   request_start: float) -> None:
+    async def log_access(self,
+                         request: BaseRequest,
+                         response: StreamResponse,
+                         request_start: float) -> None:
         if self.access_logger is not None:
-            self.access_logger.log(request, response,
-                                   self._loop.time() - request_start)
+            await self.access_logger.log(request, response,
+                                         self._loop.time() - request_start)
 
     def log_debug(self, *args: Any, **kw: Any) -> None:
         if self.debug:
@@ -526,10 +552,10 @@ async def finish_response(self,
             await prepare_meth(request)
             await resp.write_eof()
         except ConnectionResetError:
-            self.log_access(request, resp, start_time)
+            await self.log_access(request, resp, start_time)
             return True
         else:
-            self.log_access(request, resp, start_time)
+            await self.log_access(request, resp, start_time)
             return False
 
     def handle_error(self,