Logging et monitoring Django

Pourquoi Logging et monitoring Django ?

Le logging est un outil essentiel pour suivre l'activité d'une application Django, ce qui lui permet de diagnostiquer les problèmes rapidement. Un cas concret est celui d'un service web où il peut y avoir des erreurs ou des comportements inattendus qui nécessitent une intervention rapide.

Prerequis

• Connaissance de base de Python et Django
• Connaissance du systeme de fichiers en Python (os, path)
• Familiarité avec les bases de données SQL
• Connaissance des outils de gestion de versions comme Git

Outils à installer :

• Python 3.7+
• Django 3.2+
• pip (Python package installer)

Concepts fondamentaux

Logging

Le logging est un mécanisme qui permet de suivre les événements clés dans une application en générant des messages qui sont ensuite affichés dans la console ou stockés dans un fichier.

Schema Mental :

Application -> Logger -> Handlers -> Formatters
python
## Importer le module logging
import logging

## Configuration du logger
logging.basicConfig(level=logging.DEBUG, filename='app.log', filemode='w',
                    format='%(name)s - %(levelname)s - %(message)s')

## Création d'un logger
logger = logging.getLogger(__name__)

## Écriture de messages
logger.debug('Ceci est un message debug')
logger.info('Ceci est un message info')
logger.warning('Ceci est un message warning')
logger.error('Ceci est un message error')
logger.critical('Ceci est un message critical')

Middleware

Les middleware sont des fonctions qui prennent les requêtes HTTP, les traitent et renvoient ensuite les réponses HTTP. Ils permettent d'ajouter des fonctionnalités à l’application sans modifier le code de l’application elle-même.

Schema Mental :

Request -> Middleware -> View
python
## Importer le module middleware
from django.utils.deprecation import MiddlewareMixin

class LoggingMiddleware(MiddlewareMixin):
    def process_request(self, request):
        logger.info(f"Requête reçue: {request.method} {request.path}")

    def process_response(self, request, response):
        logger.info(f"Réponse renvoyée: {response.status_code}")
        return response

Monitoring

Le monitoring permet de suivre les performances et l'état d'une application en temps réel. Django-Ops est un outil populaire pour ce faire.

Schema Mental :

Application -> Metrics -> Monitoring Tool
bash
## Installer Django-Ops avec pip
pip install django-ops
python
## Ajouter Django-Ops à INSTALLED_APPS dans settings.py
INSTALLED_APPS = [
    ...
    'django_ops',
]

## Configurer les métriques
from django_ops.utils import metrics

metrics.register('request_time', description='Temps de réponse des requêtes')

## Dans une vue, incrémenter la métrique
def my_view(request):
    # ... (logique de la vue)
    request_time.inc()

Mise en pratique : projet fil rouge

Mini-projet : Gestionnaire de tâches

1. Création du Projet

## Créer un nouveau projet Django
django-admin startproject task_manager
cd task_manager

## Créer une application
python manage.py startapp tasks

2. Configuration des fichiers importants

Structure de l'application tasks :

• models.py
• views.py
• urls.py
• middleware.py
• apps.py

3. Définition du modèle Task

## models.py
from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField(blank=True, null=True)
    completed = models.BooleanField(default=False)

    def __str__(self):
        return self.title

4. Configuration de la base de données

Ajouter le modèle Task dans settings.py :

## settings.py
INSTALLED_APPS += ['tasks']

Migrer les modèles :

python manage.py makemigrations tasks
python manage.py migrate

5. Définition des vues

## views.py
from django.shortcuts import render, redirect
from .models import Task

def task_list(request):
    tasks = Task.objects.all()
    return render(request, 'tasks/task_list.html', {'tasks': tasks})

def task_create(request):
    if request.method == 'POST':
        title = request.POST.get('title')
        description = request.POST.get('description')
        completed = False
        Task.objects.create(title=title, description=description, completed=completed)
        return redirect('task_list')
    return render(request, 'tasks/task_create.html')

def task_update(request, pk):
    task = Task.objects.get(pk=pk)
    if request.method == 'POST':
        task.title = request.POST.get('title')
        task.description = request.POST.get('description')
        task.completed = request.POST.get('completed', False) == 'on'
        task.save()
        return redirect('task_list')
    return render(request, 'tasks/task_update.html', {'task': task})

def task_delete(request, pk):
    task = Task.objects.get(pk=pk)
    if request.method == 'POST':
        task.delete()
        return redirect('task_list')
    return render(request, 'tasks/task_confirm_delete.html', {'task': task})

6. Configuration des URL

## urls.py
from django.urls import path
from .views import task_list, task_create, task_update, task_delete

urlpatterns = [
    path('', task_list, name='task_list'),
    path('create/', task_create, name='task_create'),
    path('update/<int:pk>/', task_update, name='task_update'),
    path('delete/<int:pk>/', task_delete, name='task_delete'),
]

7. Middleware Logging

## middleware.py
from django.utils.deprecation import MiddlewareMixin

class TaskLoggingMiddleware(MiddlewareMixin):
    def process_request(self, request):
        logger.info(f"Requête reçue: {request.method} {request.path}")

    def process_response(self, request, response):
        logger.info(f"Réponse renvoyée: {response.status_code}")
        return response

8. Configuration du Middleware

## settings.py
MIDDLEWARE += ['tasks.middleware.TaskLoggingMiddleware']

9. Templates HTML

Créer les fichiers task_list.html, task_create.html, task_update.html et task_confirm_delete.html dans le dossier templates/tasks.

10. Exécution de l'application

python manage.py runserver

Visitez http://127.0.0.1:8000/ pour voir le gestionnaire de tâches en action.

Erreurs frequentes et debugging

Erreur 1 : AttributeError: 'module' object has no attribute 'Task'

Code incorrect :

## views.py
from tasks.models import Task

Code correct :

## views.py
from .models import Task

Erreur 2 : No module named 'tasks.apps'

Code incorrect :

## apps.py
default_app_config = 'tasks.apps.TasksConfig'

Code correct :

## apps.py
default_app_config = 'tasks.apps.AppsConfig'

Erreur 3 : TemplateDoesNotExist: tasks/task_list.html

Code incorrect :

## views.py
return render(request, 'task_list.html', {'tasks': tasks})

Code correct :

## views.py
return render(request, 'tasks/task_list.html', {'tasks': tasks})

Pour aller plus loin

1. Utiliser des loggers spécifiques à l'application

2. Intégrer le monitoring avec Prometheus et Grafana

3. Créer des tests unitaires pour les vues et les modèles

Défi pratique :

Ajouter une fonctionnalité de notification par email lorsque une tâche est marquée comme terminée.

Ce tutoriel couvre en détail la mise en place du logging et du monitoring dans un projet Django, ainsi qu'un mini-projet complet pour mettre en œuvre ces concepts.