Logging config

README.md

@@ -1,5 +1,7 @@
 <img alt="StarLite logo" src="./starlite-logo.svg" width=100%, height="auto">
 
+![Discord](https://img.shields.io/discord/919193495116337154?logo=discord)
+
 # starlite
 
 Pre-Alpha WIP.

docs/0-introduction.md

@@ -1,10 +1,12 @@
-# Starlite
+# StarLite
 
-Starlite is a flexible and extensible ASGI API framework built on top of Starlette and Pydantic.
+Starlite is a simple, flexible and extensible ASGI API framework built on top of Starlette and Pydantic. It was inspired
+by FastAPI and NestJS.
 
 ## Example: Controller Pattern
 
-Starlite supports class API components called "Controllers". Controllers are meant to group logical subcomponents, for example - consider the following `UserController`:
+Starlite supports class API components called "Controllers". Controllers are meant to group logical subcomponents, for
+example - consider the following `UserController`:
 
 ```python3
 from pydantic import BaseModel, UUID4

docs/usage/0-the-starlite-app.md

@@ -0,0 +1,26 @@
+# The Starlite App
+
+At the root of every starlite application is an instance of the `Starlite` class or a subclass of it:
+
+Instantiating the app is straightforward:
+
+```python
+from starlite import Starlite
+
+app = Starlite()
+```
+
+The `Starlite` class supports the following (optional) kwargs:
+
+* `debug`: a boolean flag toggling debug mode on and off
+* `middleware`: a sequence of `Middleware` subclasses
+* `exception_handlers`: a dictionary mapping exceptions or exception codes to callables
+* `route_handlers`: a sequence of route handlers
+* `on_startup`: a sequence of callables to be called during the application startup
+* `on_shutdown`: a sequence of callables to be called during the application shutdown
+* `lifespan`: an async-context that handles startup and shutdown
+* `dependencies`: a dictionary mapping keys to dependency providers
+* `logging_config`: either a subclass of `starlite.logging.LoggingConfig` or None (disable logging)
+
+> :warning: **Warning**: debug should not be used in production
+> :warning: **Warning**: you can specify either `on_startup`/`on_shutdown` or `lifespan` but not both

starlite/app.py

@@ -15,6 +15,7 @@
 from typing_extensions import Type
 
 from starlite.handlers import RouteHandler
+from starlite.logging import LoggingConfig
 from starlite.provide import Provide
 from starlite.routing import Router
 from starlite.utils import DeprecatedProperty
@@ -27,6 +28,7 @@
 class Starlite(Starlette):
     def __init__(  # pylint: disable=super-init-not-called
         self,
+        *,
         debug: bool = False,
         middleware: Sequence[Middleware] = None,
         exception_handlers: Dict[Union[int, Type[Exception]], Callable] = None,
@@ -35,7 +37,10 @@ def __init__(  # pylint: disable=super-init-not-called
         on_shutdown: Optional[Sequence[Callable]] = None,
         lifespan: Optional[Callable[[Any], AsyncContextManager]] = None,
         dependencies: Optional[Dict[str, Provide]] = None,
+        logging_config: Optional[LoggingConfig] = LoggingConfig()
     ):
+        if logging_config:
+            logging_config.configure(debug)
         self._debug = debug
         self.state = State()
         self.router = Router(

starlite/logging.py

@@ -0,0 +1,32 @@
+from logging import config
+from typing import Dict, Optional, Union
+
+from pydantic import BaseModel
+from typing_extensions import Literal
+
+
+class LoggingConfig(BaseModel):
+    version: Literal[1] = 1
+    incremental: bool = False
+    disable_existing_loggers: bool = False
+    filters: Optional[Dict[str, dict]] = None
+    formatters: Dict[str, dict] = {
+        "standard": {"format": "%(levelname)s - %(asctime)s - %(name)s - %(module)s - %(message)s"}
+    }
+    handlers: Dict[str, dict] = {
+        "console": {"class": "logging.StreamHandler", "level": "DEBUG", "formatter": "standard"}
+    }
+    loggers: Dict[str, dict] = {
+        "starlite": {
+            "level": "INFO",
+            "handlers": ["console"],
+        },
+    }
+    root: Dict[str, Union[dict, list, str]] = {"handlers": ["console"], "level": "WARNING"}
+
+    def configure(self, debug: bool = False):
+        """Configure logging by converting 'self' to dict and passing it to logging.config.dictConfig"""
+        logging_config = self.dict(exclude_none=True)
+        if debug and "starlite" in logging_config["loggers"]:
+            logging_config["loggers"]["starlite"]["level"] = "DEBUG"
+        config.dictConfig(logging_config)

starlite/routing.py

@@ -78,6 +78,7 @@ class Router(StarletteRouter):
 
     def __init__(
         self,
+        *,
         path: str,
         route_handlers: Optional[Sequence[Union[Type[Controller], RouteHandler, "Router", Callable]]] = None,
         redirect_slashes: bool = True,

tests/test_logging.py

@@ -0,0 +1,13 @@
+from unittest.mock import Mock, patch
+
+from starlite.logging import LoggingConfig
+
+
+@patch("logging.config.dictConfig")
+def test_logging_debug(dictConfigMock: Mock):
+    config = LoggingConfig()
+    config.configure()
+    assert dictConfigMock.mock_calls[0][1][0]["loggers"]["starlite"]["level"] == "INFO"
+    dictConfigMock.reset_mock()
+    config.configure(debug=True)
+    assert dictConfigMock.mock_calls[0][1][0]["loggers"]["starlite"]["level"] == "DEBUG"