fastapi-and-logging

FastAPI-and-Logging simplifies log handling, allowing for effective organization, tracking, and analysis of logs in FastAPI applications, aiding in debugging and issue resolution.

Support for:

• Incoming Logger
• Exception Logger
• APICall Logger (HTTPX, AIOHttp, requests (coming soon...))
• Kafka (coming soon...)

Install

pip install fastapi-and-logging

Incomiong Logger

This FastAPIIncomingLog class is designed to log incoming system requests using FastAPI.

Parameters:

• app: It is used to set route_class.
• request_id_builder: A function to build a request identifier, if specified(It uses uuid4 by default).
• log_builder: A function used to construct logs.
• get_request_data: A function used to retrieve request information.
• get_response_data: A function used to retrieve response information.
• response_max_len: The maximum length of a response stored in the log (default is 5000).
• log_path (optional): Log file path.
• log_type: The type of logging, which can be one of various types (default is LogTypeEnum.FILE).

How to Use:

To use this class, you can create an instance of it and set it as the route_class for your relevant Router in your FastAPI application.

from fastapi import FastAPI
from fastapi_and_logging import FastAPIIncomingLog

app = FastAPI()
FastAPIIncomingLog(app)

Customizing and Using Default Functions

The provided default functions (get_request_data, get_response_data, and log_builder) serve as customizable components for the FastAPIIncomingLog class. Here's how you can customize and use them:

get_request_data

This function is responsible for extracting and formatting request data.

from fastapi_and_logging import Request
from fastapi_and_logging.fastapi import get_request_data


async def customize_get_request_data(request: Request):
    # You can also use the output of the default function
    data = await get_request_data(request)
    return data

get_response_data

This function handles the processing of response data.

from fastapi import Response
from fastapi_and_logging.fastapi import get_response_data


def customize_get_response_data(response: Response) -> dict | str:
    # You can also use the output of the default function
    data = get_response_data(response)
    return data

log_builder

The log_builder function constructs the log data based on various parameters.

from fastapi import Request, Response
from user_agents.parsers import UserAgent
from fastapi_and_logging.fastapi import log_builder


def customize_log_builder(
    request: Request,
    response: Response,
    request_data: dict | str,
    response_data: dict | str,
    user_agent: UserAgent,
    start_time: int,
    end_time: int,
    duration: int,
):
    # You can also use the output of the default function
    data = log_builder(**)
    return data

Exception Logger

To log all exceptions, simply use the ExceptionLogger class.

Parameters:

• app: It is used to add exception handlers.
• log_path (optional): Log file path.
• log_type: The type of logging, which can be one of various types (default is LogTypeEnum.FILE).
• set_default_handlers: Whether to set default exception handlers (default: True).

How to Use:

from fastapi import FastAPI
from fastapi_and_logging import ExceptionLogger

app = FastAPI()
ExceptionLogger(app)

You can also add your own exception handlers as follows:

from fastapi import FastAPI, Request
from fastapi_and_logging import ExceptionLogger

app = FastAPI(debug=False)
exception_logger = ExceptionLogger(app=app)

async def test_exception_handler(request: Request, exc: Exception):
    return JSONResponse(
        content={"message": "Internal Server Error"},
    )

exception_logger.add_exception_handler(Exception, test_exception_handler)

APICall Logger

Note: Currently it only supports httpx and aiohttp.

HTTPXLogger

You can easily log all apicalls using httpx by adding the HTTPXLogger class.

Parameters:

• request_hook (optional): A callable object that serves as a hook for capturing and logging HTTP requests. It takes a single parameter, the request object, and does not return any value. Defaults to None..
• response_hook (optional): A callable object that acts as a hook to capture and log HTTP responses. Any value returned will be logged.
• sync_client (optional): A boolean value indicating whether the logging functionality should be applied to synchronous HTTP clients. If True, the hooks and configuration will be set for synchronous clients. Defaults to True.
• async_client (optional): A boolean value indicating whether the logging functionality should be applied to asynchronous HTTP clients. If True, the hooks and configuration will be set for asynchronous clients. Defaults to True.
• request_max_len (optional): An integer specifying the maximum length of the request body to be logged. If the request body exceeds this length, it will be truncated. Defaults to 5000 .
• response_max_len (optional): An integer specifying the maximum length of the response body to be logged. If the response body exceeds this length, it will be truncated. Defaults to 5000.
• log_path (optional): Log file path.
• log_type (optional): Specifies the type of logging, currently it takes two values: console and file.

How to Use:

import httpx
from fastapi import FastAPI
from fastapi_and_logging.http_clients import HTTPXLogger


app = FastAPI()
HTTPXLogger()


@app.get("/")
def index():
    with httpx.Client() as client:
        response = client.get("http://localhost:8000/path")


# AsyncClient
@app.get("/")
async def index():
    async with httpx.AsyncClient() as client:
        response = await client.get("http://localhost:8000/path")

AioHttpLogger

You can easily log all apicalls using httpx by adding the AioHttpLogger class.

Parameters:

• request_hook (optional): A callable object that serves as a hook for capturing and logging HTTP requests. It takes a single parameter, the request object, and does not return any value. Defaults to None..
• response_hook (optional): A callable object that acts as a hook to capture and log HTTP responses. Any value returned will be logged.
• request_max_len (optional): An integer specifying the maximum length of the request body to be logged. If the request body exceeds this length, it will be truncated. Defaults to 5000 .
• response_max_len (optional): An integer specifying the maximum length of the response body to be logged. If the response body exceeds this length, it will be truncated. Defaults to 5000.
• log_path (optional): Log file path.
• log_type (optional): Specifies the type of logging, currently it takes two values: console and file.

How to Use:

import aiohttp
from fastapi import FastAPI
from fastapi_and_logging.http_clients import AioHttpLogger


app = FastAPI()
AioHttpLogger()


@app.get("/")
async def index():
    async with aiohttp.ClientSession() as session:
        async with session.get(
            "http://localhost:8000/path",
        ) as response:
            ...

To be able to have the request data or request ID associated with the incoming log in the apicall log, you need to follow the following steps. Additionally, you can send your desired parameters to log in the trace_request_ctx as well.

import aiohttp
from fastapi import Request


@app.get("/")
async def index(request: Request):
    payload = {"name": "FastAPI And Logging"}
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "http://localhost:8000/path",
            json = payload,
            trace_request_ctx = {
                "request_id": request.state.request_id,
                "request_data": payload,
            }
        ) as response:
            ...