Comment implémenter la journalisation et la surveillance des requêtes dans FastAPI

Comment implémenter la journalisation et la surveillance des requêtes dans FastAPI

Introduction :
FastAPI est un framework Web hautes performances basé sur Python 3.7+, qui fournit de nombreuses fonctions et fonctionnalités puissantes, notamment la vérification automatisée des modèles de requêtes et de réponses, la sécurité, l'optimisation des performances, etc. Dans le développement réel, nous avons souvent besoin d'enregistrer les journaux de requêtes dans l'application à des fins de débogage et d'analyse de surveillance. Cet article explique comment implémenter la journalisation et la surveillance des requêtes dans FastAPI et fournit des exemples de code correspondants.

1. Installer les packages de dépendances
Avant de commencer, nous devons installer certains packages de dépendances nécessaires. Ouvrez le terminal et exécutez la commande suivante :

pip install fastapi uvicorn loguru

Parmi elles, loguru est une bibliothèque de journalisation facile à utiliser, nous l'utiliserons pour enregistrer les journaux de requêtes.

2. Créer une application FastAPI
Tout d'abord, nous devons créer une application FastAPI. Dans le répertoire du projet, créez un fichier nommé main.py et écrivez le code suivant :

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

3. Enregistrez les journaux de requêtes
Ensuite, nous utiliserons la bibliothèque loguru pour enregistrer les journaux de requêtes. Ajoutez le code suivant au fichier main.py :

from loguru import logger
import uvicorn
from fastapi import FastAPI

app = FastAPI()

@app.on_event("startup")
async def startup_event():
    logger.add("logs/request.log", rotation="10 MB")

@app.get("/")
async def root():
    logger.info("Hello World")
    return {"message": "Hello World"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Dans le code ci-dessus, nous importons d'abord l'objet logger de la bibliothèque loguru et ajoutons un enregistreur de fichiers. Nous avons spécifié le chemin du fichier journal sous la forme logs/request.log et défini la taille maximale du fichier journal sur 10 Mo. Ensuite, dans la fonction root(), nous utilisons la méthode logger.info() pour enregistrer la requête.

4. Démarrez l'application
Enregistrez le fichier main.py et revenez au terminal, exécutez la commande suivante pour démarrer l'application FastAPI :

uvicorn main:app --reload

Le terminal affichera l'URL d'accès de l'application, telle que http:// 127.0.0.1:8000. En accédant à cette URL dans le navigateur, nous verrons le message "Hello World". Ouvrez le fichier logs/request.log et nous verrons les enregistrements du journal des demandes.

5. Surveillance des demandes
En plus d'enregistrer les journaux de demandes, nous pouvons également surveiller le temps de traitement et le code d'état de la demande. Afin d'implémenter cette fonction, nous devons utiliser le Middleware fourni par FastAPI. Ajoutez le code suivant au fichier main.py :

from loguru import logger
import time
import uvicorn
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

@app.on_event("startup")
async def startup_event():
    logger.add("logs/request.log", rotation="10 MB")

@app.on_event("shutdown")
async def shutdown_event():
    logger.remove(handler_id="request_logger")

@app.middleware("http")
async def log_request(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time

    logger.info(
        "Request: {method} {url} {status_code} {process_time:.2f}ms",
        method=request.method,
        url=request.url,
        status_code=response.status_code,
        process_time=process_time * 1000,
    )

    return response

@app.get("/")
async def root():
    logger.info("Hello World")
    return {"message": "Hello World"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Dans le code ci-dessus, nous importons d'abord le module time et ajoutons un temps de sommeil dans la fonction root() pour simuler le temps de traitement de la requête. Ensuite, nous avons ajouté la logique pour calculer le temps de traitement de la demande et enregistrer le code d'état de la demande dans la fonction middleware log_request(). Dans la fonction shutdown_event(), nous supprimons le logger précédemment ajouté.

Maintenant, redémarrez l'application FastAPI et visitez l'URL de l'application dans votre navigateur. Actualisez la page dans le navigateur et ouvrez le fichier logs/request.log. Nous verrons les enregistrements du journal des demandes, y compris la méthode de demande, l'URL, le code d'état et le temps de traitement.

Conclusion :
Cet article explique comment implémenter la journalisation et la surveillance des requêtes dans FastAPI. Nous utilisons la bibliothèque loguru pour enregistrer les journaux de demandes et utilisons le middleware de FastAPI pour surveiller le temps de traitement des demandes et le code d'état. Ces fonctionnalités nous permettent de mieux suivre et surveiller les demandes et les réponses des candidatures. Ce qui précède est un exemple de code pour implémenter la journalisation et la surveillance des demandes.

Matériaux de référence :

• Documentation officielle de FastAPI : https://fastapi.tiangolo.com/
• documentation officielle de loguru : https://loguru.readthedocs.io/

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!