beans-logging-fastapi 1.1.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

beans_logging_fastapi/_base.py

@@ -1,100 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from typing import Dict, Any
-
-from fastapi import Request, Response
-from fastapi.concurrency import run_in_threadpool
-from starlette.middleware.base import BaseHTTPMiddleware
-
-from beans_logging import logger
-
-
-class HttpAccessLogMiddleware(BaseHTTPMiddleware):
-    """Http access log middleware for FastAPI.
-
-    Inherits:
-        BaseHTTPMiddleware: Base HTTP middleware class from starlette.
-
-    Attributes:
-        _DEBUG_FORMAT     (str ): Default http access log debug message format. Defaults to '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'.
-        _MSG_FORMAT       (str ): Default http access log message format. Defaults to '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}" {status_code} {content_length}B {response_time}ms'.
-
-        debug_format      (str ): Http access log debug message format. Defaults to `HttpAccessLogMiddleware._DEBUG_FORMAT`.
-        msg_format        (str ): Http access log message format. Defaults to `HttpAccessLogMiddleware._MSG_FORMAT`.
-        use_debug_log     (bool): If True, use debug log to log http access log. Defaults to True.
-    """
-
-    _DEBUG_FORMAT = '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
-    _MSG_FORMAT = '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}" {status_code} {content_length}B {response_time}ms'
-
-    def __init__(
-        self,
-        app,
-        debug_format: str = _DEBUG_FORMAT,
-        msg_format: str = _MSG_FORMAT,
-        use_debug_log: bool = True,
-    ):
-        super().__init__(app)
-        self.debug_format = debug_format
-        self.msg_format = msg_format
-        self.use_debug_log = use_debug_log
-
-    async def dispatch(self, request: Request, call_next) -> Response:
-        _logger = logger.opt(colors=True, record=True)
-
-        _http_info: Dict[str, Any] = {}
-        if hasattr(request.state, "http_info") and isinstance(
-            request.state.http_info, dict
-        ):
-            _http_info: Dict[str, Any] = request.state.http_info
-
-        ## Debug log:
-        if self.use_debug_log:
-            _debug_msg = self.debug_format.format(**_http_info)
-
-            # _logger.debug(_debug_msg)
-            await run_in_threadpool(
-                _logger.debug,
-                _debug_msg,
-            )
-        ## Debug log
-
-        ## Process request:
-        response: Response = await call_next(request)
-        ## Response processed.
-
-        if hasattr(request.state, "http_info") and isinstance(
-            request.state.http_info, dict
-        ):
-            _http_info: Dict[str, Any] = request.state.http_info
-
-        ## Http access log:
-        _LEVEL = "INFO"
-        _msg_format = self.msg_format
-        if _http_info["status_code"] < 200:
-            _LEVEL = "DEBUG"
-            _msg_format = f'<d>{_msg_format.replace("{status_code}", "<n><b><k>{status_code}</k></b></n>")}</d>'
-        elif (200 <= _http_info["status_code"]) and (_http_info["status_code"] < 300):
-            _LEVEL = "SUCCESS"
-            _msg_format = f'<w>{_msg_format.replace("{status_code}", "<lvl>{status_code}</lvl>")}</w>'
-        elif (300 <= _http_info["status_code"]) and (_http_info["status_code"] < 400):
-            _LEVEL = "INFO"
-            _msg_format = f'<d>{_msg_format.replace("{status_code}", "<n><b><c>{status_code}</c></b></n>")}</d>'
-        elif (400 <= _http_info["status_code"]) and (_http_info["status_code"] < 500):
-            _LEVEL = "WARNING"
-            _msg_format = _msg_format.replace("{status_code}", "<r>{status_code}</r>")
-        elif 500 <= _http_info["status_code"]:
-            _LEVEL = "ERROR"
-            _msg_format = (
-                f'{_msg_format.replace("{status_code}", "<n>{status_code}</n>")}'
-            )
-
-        _msg = _msg_format.format(**_http_info)
-        # _logger.bind(http_info=_http_info).log(_LEVEL, _msg)
-        await run_in_threadpool(_logger.bind(http_info=_http_info).log, _LEVEL, _msg)
-        ## Http access log
-
-        return response
-
-
-__all__ = ["HttpAccessLogMiddleware"]

beans_logging_fastapi/_formats.py

@@ -1,77 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from typing import Dict, Any
-from zoneinfo import ZoneInfo
-
-
-def http_file_format(
-    record: dict,
-    msg_format: str = '{client_host} {request_id} {user_id} [{datetime}] "{method} {url_path} HTTP/{http_version}" {status_code} {content_length} "{h_referer}" "{h_user_agent}" {response_time}',
-    tz: str = "localtime",
-) -> str:
-    """Http access log file format.
-
-    Args:
-        record (dict): Log record as dictionary.
-
-    Returns:
-        str: Format for http access log record.
-    """
-
-    if "http_info" not in record["extra"]:
-        return ""
-
-    if "http_message" not in record:
-        _http_info: Dict[str, Any] = record["extra"]["http_info"]
-        if "datetime" not in _http_info:
-            _dt = record["time"]
-            if tz != "localtime":
-                if not _dt.tzinfo:
-                    _dt = _dt.replace(tzinfo=ZoneInfo("UTC"))
-
-                _dt = _dt.astimezone(ZoneInfo(tz))
-
-            _http_info["datetime"] = _dt.isoformat(timespec="milliseconds")
-
-        if "content_length" not in _http_info:
-            _http_info["content_length"] = 0
-
-        if "h_referer" not in _http_info:
-            _http_info["h_referer"] = "-"
-
-        if "h_user_agent" not in _http_info:
-            _http_info["h_user_agent"] = "-"
-
-        if "response_time" not in _http_info:
-            _http_info["response_time"] = 0
-
-        record["extra"]["http_info"] = _http_info
-
-        _msg = msg_format.format(**_http_info)
-        record["http_message"] = _msg
-
-    return "{http_message}\n"
-
-
-def http_file_json_format(record: dict) -> str:
-    """Http access json log file format.
-
-    Args:
-        record (dict): Log record as dictionary.
-
-    Returns:
-        str: Format for http access json log record.
-    """
-
-    if "http_info" not in record["extra"]:
-        return ""
-
-    _http_info: Dict[str, Any] = record["extra"]["http_info"]
-    if "datetime" not in _http_info:
-        _http_info["datetime"] = record["time"].isoformat(timespec="milliseconds")
-        record["extra"]["http_info"] = _http_info
-
-    return "{extra[http_info]}\n"
-
-
-__all__ = ["http_file_format", "http_file_json_format"]

beans_logging_fastapi/_handlers.py

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from typing import Union, Callable
-
-import pydantic
-
-if "2.0.0" <= pydantic.__version__:
-    from pydantic import validate_call
-else:
-    from pydantic import validate_arguments as validate_call
-
-from beans_logging import LoggerLoader
-
-from ._filters import use_http_filter
-from ._formats import http_file_format, http_file_json_format
-
-
-@validate_call(config=dict(arbitrary_types_allowed=True))
-def add_http_file_handler(
-    logger_loader: LoggerLoader,
-    log_path: str = "http/{app_name}.http.access.log",
-    err_path: str = "http/{app_name}.http.err.log",
-    formatter: Union[Callable, str] = http_file_format,
-):
-    """Add http access log file and error file handler.
-
-    Args:
-        logger_loader (LoggerLoader,         required): LoggerLoader instance.
-        log_path      (str,                  optional): Log file path. Defaults to "http/{app_name}.http.access.log".
-        err_path      (str,                  optional): Error log file path. Defaults to "http/{app_name}.http.err.log".
-        formatter     (Union[Callable, str], optional): Log formatter. Defaults to `http_file_format` function.
-    """
-
-    logger_loader.add_custom_handler(
-        handler_name="FILE.HTTP",
-        sink=log_path,
-        filter=use_http_filter,
-        format=formatter,
-    )
-
-    logger_loader.add_custom_handler(
-        handler_name="FILE.HTTP_ERR",
-        sink=err_path,
-        level="WARNING",
-        filter=use_http_filter,
-        format=formatter,
-    )
-
-
-@validate_call(config=dict(arbitrary_types_allowed=True))
-def add_http_file_json_handler(
-    logger_loader: LoggerLoader,
-    log_path: str = "json.http/{app_name}.json.http.access.log",
-    err_path: str = "json.http/{app_name}.json.http.err.log",
-    formatter: Union[Callable, str] = http_file_json_format,
-):
-    """Add http access json log file and json error file handler.
-
-    Args:
-        logger_loader (LoggerLoader,         required): LoggerLoader instance.
-        log_path      (str,                  optional): Json log file path. Defaults to "http.json/{app_name}.json.http.access.log".
-        err_path      (str,                  optional): Json error log file path. Defaults to "http.json/{app_name}.json.http.err.log".
-        formatter     (Union[Callable, str], optional): Log formatter. Defaults to `http_file_json_format` function.
-    """
-
-    logger_loader.add_custom_handler(
-        handler_name="FILE.JSON.HTTP",
-        sink=log_path,
-        filter=use_http_filter,
-        format=formatter,
-    )
-
-    logger_loader.add_custom_handler(
-        handler_name="FILE.JSON.HTTP_ERR",
-        sink=err_path,
-        level="WARNING",
-        filter=use_http_filter,
-        format=formatter,
-    )
-
-
-__all__ = ["add_http_file_handler", "add_http_file_json_handler"]

beans_logging_fastapi-1.1.1.dist-info/METADATA

@@ -1,385 +0,0 @@
-Metadata-Version: 2.1
-Name: beans-logging-fastapi
-Version: 1.1.1
-Summary: 'beans_logging_fastapi' is a middleware for FastAPI to log HTTP access. It is based on 'beans-logging' package.
-Home-page: https://github.com/bybatkhuu/module.fastapi-logging
-Download-URL: https://github.com/bybatkhuu/module.fastapi-logging/archive/v1.1.1.tar.gz
-Author: Batkhuu Byambajav
-Author-email: batkhuu10@gmail.com
-License: MIT
-Keywords: beans_logging_fastapi,fastapi-logging,fastapi-logging-middleware,fastapi-middleware,logging-middleware,middleware,beans-logging,http-access-logging,logging,logger,loguru
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Build Tools
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENCE.txt
-Requires-Dist: fastapi <1.0.0,>=0.99.1
-Requires-Dist: beans-logging <7.0.0,>=6.0.0
-
-# beans_logging_fastapi
-
-[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit)
-[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/bybatkhuu/module.fastapi-logging/2.build-publish.yml?logo=GitHub)](https://github.com/bybatkhuu/module.fastapi-logging/actions/workflows/2.build-publish.yml)
-[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/bybatkhuu/module.fastapi-logging?logo=GitHub)](https://github.com/bybatkhuu/module.fastapi-logging/releases)
-[![PyPI](https://img.shields.io/pypi/v/beans-logging-fastapi?logo=PyPi)](https://pypi.org/project/beans-logging-fastapi)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/beans-logging-fastapi?logo=Python)](https://docs.conda.io/en/latest/miniconda.html)
-
-`beans_logging_fastapi` is a middleware for FastAPI to log HTTP access.
-
-It is based on **'beans-logging'** package.
-
-## Features
-
-- **Logger** based on **'beans-logging'** package
-- **FastAPI** HTTP access logging **middleware**
-
----
-
-## Installation
-
-### 1. Prerequisites
-
-- **Python (>= v3.8)**
-- **PyPi (>= v23)**
-
-### 2. Install beans-logging-fastapi package
-
-Choose one of the following methods to install the package **[A ~ F]**:
-
-**A.** [**RECOMMENDED**] Install from **PyPi**
-
-```sh
-# Install or upgrade package:
-pip install -U beans-logging-fastapi
-```
-
-**B.** Install latest version from **GitHub**
-
-```sh
-# Install package by git:
-pip install git+https://github.com/bybatkhuu/module.fastapi-logging.git
-```
-
-**C.** Install from **pre-built release** files
-
-1. Download **`.whl`** or **`.tar.gz`** file from **releases** - <https://github.com/bybatkhuu/module.fastapi-logging/releases>
-2. Install with pip:
-
-```sh
-# Install from .whl file:
-pip install ./beans_logging_fastapi-[VERSION]-py3-none-any.whl
-# Or install from .tar.gz file:
-pip install ./beans_logging_fastapi-[VERSION].tar.gz
-```
-
-**D.** Install from **source code** by building package
-
-```sh
-# Clone repository by git:
-git clone https://github.com/bybatkhuu/module.fastapi-logging.git beans_logging_fastapi
-cd ./beans_logging_fastapi
-
-# Install python build tool:
-pip install -U pip build
-
-# Build python package:
-python -m build
-
-_VERSION=$(./scripts/get-version.sh)
-
-# Install from .whl file:
-pip install ./dist/beans_logging_fastapi-${_VERSION}-py3-none-any.whl
-# Or install from .tar.gz file:
-pip install ./dist/beans_logging_fastapi-${_VERSION}.tar.gz
-```
-
-**E.** Install with pip editable **development mode** (from source code)
-
-```sh
-# Clone repository by git:
-git clone https://github.com/bybatkhuu/module.fastapi-logging.git beans_logging_fastapi
-cd ./beans_logging_fastapi
-
-# Install with editable development mode:
-pip install -e .
-```
-
-**F.** Manually add to **PYTHONPATH** (not recommended)
-
-```sh
-# Clone repository by git:
-git clone https://github.com/bybatkhuu/module.fastapi-logging.git beans_logging_fastapi
-cd ./beans_logging_fastapi
-
-# Install python dependencies:
-pip install -r ./requirements.txt
-
-# Add current path to PYTHONPATH:
-export PYTHONPATH="${PWD}:${PYTHONPATH}"
-```
-
-## Usage/Examples
-
-To use `beans_logging_fastapi`:
-
-### **FastAPI**
-
-[**`configs/logger.yml`**](https://github.com/bybatkhuu/module.fastapi-logging/blob/main/examples/configs/logger.yml):
-
-```yaml
-logger:
-  app_name: "fastapi-app"
-  level: "TRACE"
-  use_diagnose: false
-  stream:
-    use_color: true
-    use_icon: false
-    format_str: "[<c>{time:YYYY-MM-DD HH:mm:ss.SSS Z}</c> | <level>{level_short:<5}</level> | <w>{name}:{line}</w>]: <level>{message}</level>"
-    std_handler:
-      enabled: true
-  file:
-    logs_dir: "./logs"
-    rotate_size: 10000000 # 10MB
-    rotate_time: "00:00:00"
-    backup_count: 90
-    log_handlers:
-      enabled: true
-      format_str: "[{time:YYYY-MM-DD HH:mm:ss.SSS Z} | {level_short:<5} | {name}:{line}]: {message}"
-      log_path: "{app_name}.std.all.log"
-      err_path: "{app_name}.std.err.log"
-    json_handlers:
-      enabled: true
-      use_custom: false
-      log_path: "json/{app_name}.json.all.log"
-      err_path: "json/{app_name}.json.err.log"
-  intercept:
-    auto_load:
-      enabled: true
-      only_base: false
-      ignore_modules: []
-    include_modules: []
-    mute_modules: ["uvicorn.access"]
-  extra:
-    http_std_debug_format: '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
-    http_std_msg_format: '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}" {status_code} {content_length}B {response_time}ms'
-    http_file_enabled: true
-    http_file_format: '{client_host} {request_id} {user_id} [{datetime}] "{method} {url_path} HTTP/{http_version}" {status_code} {content_length} "{h_referer}" "{h_user_agent}" {response_time}'
-    http_file_tz: "localtime"
-    http_log_path: "http/{app_name}.http.access.log"
-    http_err_path: "http/{app_name}.http.err.log"
-    http_json_enabled: true
-    http_json_path: "json.http/{app_name}.json.http.access.log"
-    http_json_err_path: "json.http/{app_name}.json.http.err.log"
-```
-
-[**`.env`**](https://github.com/bybatkhuu/module.fastapi-logging/blob/main/examples/.env):
-
-```sh
-ENV=development
-DEBUG=true
-
-BEANS_LOGGING_DISABLE_DEFAULT=false
-BEANS_LOGGING_CONFIG_PATH="./configs/logger.yml"
-BEANS_LOGGING_LOGS_DIR="./logs"
-```
-
-[**`logger.py`**](https://github.com/bybatkhuu/module.fastapi-logging/blob/main/examples/logger.py):
-
-```python
-from beans_logging import Logger, LoggerLoader
-from beans_logging_fastapi import (
-    add_http_file_handler,
-    add_http_file_json_handler,
-    http_file_format,
-)
-
-logger_loader = LoggerLoader()
-logger: Logger = logger_loader.load()
-
-
-def _http_file_format(record: dict) -> str:
-    _format = http_file_format(
-        record=record,
-        msg_format=logger_loader.config.extra.http_file_format,
-        tz=logger_loader.config.extra.http_file_tz,
-    )
-    return _format
-
-
-if logger_loader.config.extra.http_file_enabled:
-    add_http_file_handler(
-        logger_loader=logger_loader,
-        log_path=logger_loader.config.extra.http_log_path,
-        err_path=logger_loader.config.extra.http_err_path,
-        formatter=_http_file_format,
-    )
-
-if logger_loader.config.extra.http_json_enabled:
-    add_http_file_json_handler(
-        logger_loader=logger_loader,
-        log_path=logger_loader.config.extra.http_json_path,
-        err_path=logger_loader.config.extra.http_json_err_path,
-    )
-```
-
-[**`main.py`**](https://github.com/bybatkhuu/module.fastapi-logging/blob/main/examples/main.py):
-
-```python
-from typing import Union
-from contextlib import asynccontextmanager
-
-import uvicorn
-from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import RedirectResponse
-
-load_dotenv()
-
-from beans_logging_fastapi import (
-    HttpAccessLogMiddleware,
-    RequestHTTPInfoMiddleware,
-    ResponseHTTPInfoMiddleware,
-)
-
-from logger import logger, logger_loader
-from __version__ import __version__
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    logger.info("Preparing to startup...")
-    logger.success("Finished preparation to startup.")
-    logger.info(f"API version: {__version__}")
-
-    yield
-    logger.info("Praparing to shutdown...")
-    logger.success("Finished preparation to shutdown.")
-
-
-app = FastAPI(lifespan=lifespan, version=__version__)
-
-app.add_middleware(ResponseHTTPInfoMiddleware)
-app.add_middleware(
-    HttpAccessLogMiddleware,
-    debug_format=logger_loader.config.extra.http_std_debug_format,
-    msg_format=logger_loader.config.extra.http_std_msg_format,
-)
-app.add_middleware(
-    RequestHTTPInfoMiddleware, has_proxy_headers=True, has_cf_headers=True
-)
-
-
-@app.get("/")
-def root():
-    return {"Hello": "World"}
-
-
-@app.get("/items/{item_id}")
-def read_item(item_id: int, q: Union[str, None] = None):
-    return {"item_id": item_id, "q": q}
-
-
-@app.get("/continue", status_code=100)
-def get_continue():
-    return {}
-
-
-@app.get("/redirect")
-def redirect():
-    return RedirectResponse("/")
-
-
-@app.get("/error")
-def error():
-    raise HTTPException(status_code=500)
-
-
-if __name__ == "__main__":
-    uvicorn.run(
-        app="main:app",
-        host="0.0.0.0",
-        port=8000,
-        access_log=False,
-        server_header=False,
-        proxy_headers=True,
-        forwarded_allow_ips="*",
-    )
-```
-
-Run the [**`examples`**](https://github.com/bybatkhuu/module.fastapi-logging/tree/main/examples):
-
-```sh
-cd ./examples
-# Install python dependencies for examples:
-pip install -r ./requirements.txt
-
-uvicorn main:app --host=0.0.0.0 --port=8000
-```
-
-**Output**:
-
-```txt
-[2023-10-31 12:38:46.733 +09:00 | TRACE | beans_logging._base:578]: Intercepted modules: ['concurrent', 'concurrent.futures', 'watchfiles.watcher', 'dotenv.main', 'watchfiles.main', 'watchfiles', 'asyncio', 'fastapi', 'uvicorn.error', 'uvicorn', 'dotenv']; Muted modules: ['uvicorn.access'];
-[2023-10-31 12:38:46.749 +09:00 | INFO  | uvicorn.server:76]: Started server process [56216]
-[2023-10-31 12:38:46.749 +09:00 | INFO  | uvicorn.lifespan.on:46]: Waiting for application startup.
-[2023-10-31 12:38:46.750 +09:00 | INFO  | main:26]: Preparing to startup...
-[2023-10-31 12:38:46.750 +09:00 | OK    | main:27]: Finished preparation to startup.
-[2023-10-31 12:38:46.750 +09:00 | INFO  | main:28]: API version: 0.0.0-000000
-[2023-10-31 12:38:46.750 +09:00 | INFO  | uvicorn.lifespan.on:60]: Application startup complete.
-[2023-10-31 12:38:46.752 +09:00 | INFO  | uvicorn.server:218]: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
-[2023-10-31 12:38:48.701 +09:00 | DEBUG | anyio._backends._asyncio:807]: [c3d76377250947c29559cb103a6d2c56] 127.0.0.1 - "GET / HTTP/1.1"
-[2023-10-31 12:38:48.703 +09:00 | OK    | anyio._backends._asyncio:807]: [c3d76377250947c29559cb103a6d2c56] 127.0.0.1 - "GET / HTTP/1.1" 200 17B 0.8ms
-^C[2023-10-31 12:38:49.793 +09:00 | INFO  | uvicorn.server:264]: Shutting down
-[2023-10-31 12:38:49.903 +09:00 | INFO  | uvicorn.lifespan.on:65]: Waiting for application shutdown.
-[2023-10-31 12:38:49.903 +09:00 | INFO  | main:31]: Praparing to shutdown...
-[2023-10-31 12:38:49.904 +09:00 | OK    | main:32]: Finished preparation to shutdown.
-[2023-10-31 12:38:49.904 +09:00 | INFO  | uvicorn.lifespan.on:76]: Application shutdown complete.
-[2023-10-31 12:38:49.904 +09:00 | INFO  | uvicorn.server:86]: Finished server process [56216]
-```
-
----
-
-## Running Tests
-
-To run tests, run the following command:
-
-```sh
-# Install python test dependencies:
-pip install -r ./requirements.test.txt
-
-# Run tests:
-python -m pytest -sv
-```
-
-## Environment Variables
-
-You can use the following environment variables inside [**`.env.example`**](https://github.com/bybatkhuu/module.fastapi-logging/blob/main/.env.example) file:
-
-```sh
-ENV=development
-DEBUG=true
-
-BEANS_LOGGING_DISABLE_DEFAULT=false
-BEANS_LOGGING_CONFIG_PATH="./configs/logger.yml"
-BEANS_LOGGING_LOGS_DIR="./logs"
-```
-
-## Documentation
-
-- [docs](https://github.com/bybatkhuu/module.fastapi-logging/blob/main/docs/README.md)
-- [scripts](https://github.com/bybatkhuu/module.fastapi-logging/blob/main/docs/scripts/README.md)
-
----
-
-## References
-
-- <https://github.com/bybatkhuu/module.python-logging>
-- <https://github.com/Delgan/loguru>
-- <https://loguru.readthedocs.io/en/stable/api/logger.html>
-- <https://loguru.readthedocs.io/en/stable/resources/recipes.html>

beans_logging_fastapi-1.1.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-beans_logging_fastapi/__init__.py,sha256=BRaF1AtJeVBvYtDyvx9YUBUe7Ez632UAwVW6rUQU72I,874
-beans_logging_fastapi/__version__.py,sha256=vaO-yG68LsdKNrjwKiIqxA34q000eeRpru3EyLGSxsY,47
-beans_logging_fastapi/_async_log.py,sha256=2J-LBW0IQRCtZOfcYHZSUSbzQipWF-MuWbXgd6tqP9Q,3334
-beans_logging_fastapi/_base.py,sha256=ChpSFJ0yXUUdgV9Y-2SyrjPRuGHdYCf5UvMDxnPRAGg,4186
-beans_logging_fastapi/_filters.py,sha256=SmluD4RDMk_wsRJVSpE5jp7AylotYJy2N6aw9AVWwFI,541
-beans_logging_fastapi/_formats.py,sha256=MdS5x5EV7BVWEjVstQCeQn8XUz3qW12ltQS8-rNrCKc,2166
-beans_logging_fastapi/_handlers.py,sha256=eEgQD7ho6dqLzUfoN7CNAq7hD-fd97oeo-HROb6x1xk,2794
-beans_logging_fastapi/_middlewares.py,sha256=h9-turKSGnK__4mLAId3Slno3avz7Hu9lNpdmoepjY0,9278
-tests/__init__.py,sha256=iwhKnzeBJLKxpRVjvzwiRE63_zNpIBfaKLITauVph-0,24
-tests/conftest.py,sha256=ycEL83-UMU-fcXQUZWTCNEPcBOZ38pzhoCPpXpCjIEM,319
-tests/test_beans_logging_fastapi.py,sha256=khxZzk-UZJU4BfM3KLytzKZATnsjsYts0UJqn1UB5cU,489
-beans_logging_fastapi-1.1.1.dist-info/LICENCE.txt,sha256=8jrXqC7FZbke39LPGo_mUFR81CkoUCP_vyefZjlQDOg,1074
-beans_logging_fastapi-1.1.1.dist-info/METADATA,sha256=_Jw2qKu3bDukUEkmJI8goSLgIsoalx5G4D7wqqWrfTE,12502
-beans_logging_fastapi-1.1.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-beans_logging_fastapi-1.1.1.dist-info/top_level.txt,sha256=i97pAfk2NcT9DA7cPsBmF6_90GzNObQ9UJpZFuXdt1s,28
-beans_logging_fastapi-1.1.1.dist-info/RECORD,,

tests/__init__.py

@@ -1 +0,0 @@
-# -*- coding: utf-8 -*-

tests/conftest.py

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import pytest
-
-from beans_logging import logger
-
-
-@pytest.fixture(scope="session", autouse=True)
-def setup_and_teardown():
-    # Equivalent of setUp
-    logger.info("Setting up...")
-
-    yield  # This is where the testing happens!
-
-    # Equivalent of tearDown
-    logger.info("Tearing down!")