0Pricing
PHP Academy · Leçon

Journalisation des erreurs et bonnes pratiques

Consigner les erreurs dans des fichiers et appliquer les bonnes pratiques de gestion des erreurs en production.

Journalisation des erreurs et bonnes pratiques est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Pourquoi la journalisation est importante

En production, vous ne pouvez pas afficher les erreurs aux utilisateurs, mais vous devez tout de même savoir quand un problème survient. La journalisation enregistre les détails des erreurs dans des fichiers ou des services afin que vous puissiez les examiner ultérieurement.

error_log()

La fonction de journalisation la plus simple — elle écrit un message dans le journal d'erreurs de PHP :

<?php
error_log('User login failed for: ' . $email);
error_log('DB query took: ' . $duration . 'ms');

// Send to email (not recommended for high traffic)
error_log('Critical: server out of memory', 1, 'admin@example.com');

Journalisation structurée

Consignez les données structurées au format JSON pour faciliter leur analyse et leur interrogation :

<?php
function logEvent(string $level, string $message, array $context = []): void {
    $entry = array_merge([
        'ts'      => date('c'),
        'level'   => $level,
        'message' => $message,
    ], $context);

    error_log(json_encode($entry));
}

logEvent('ERROR', 'Payment failed', [
    'order_id' => 123,
    'amount'   => 99.99,
    'user_id'  => 45,
]);

Niveaux de journalisation (PSR-3)

PSR-3 définit des niveaux de journalisation standard :

  • emergency — système inutilisable
  • alert — une action doit être effectuée
  • critical — situations critiques
  • error — erreurs à l'exécution
  • warning — événements exceptionnels qui ne sont pas des erreurs
  • notice — événements normaux mais importants
  • info — messages informatifs
  • debug — informations détaillées de débogage

Enregistreur Monolog

Monolog est la bibliothèque PHP standard de journalisation, compatible avec PSR-3 :

<?php
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$log = new Logger('app');
$log->pushHandler(new StreamHandler('/var/log/app.log', Logger::DEBUG));

$log->info('User logged in', ['user_id' => 42]);
$log->error('Payment failed', ['order' => 99, 'reason' => 'card_declined']);
$log->warning('Slow query', ['duration_ms' => 3200]);

Gestion des exceptions en production

Un gestionnaire d'exceptions adapté à la production, qui consigne l'erreur et renvoie une réponse sûre :

<?php
set_exception_handler(function(\Throwable $e) {
    $id = uniqid('err_');
    error_log(json_encode([
        'error_id' => $id,
        'class'    => get_class($e),
        'message'  => $e->getMessage(),
        'file'     => $e->getFile(),
        'line'     => $e->getLine(),
        'trace'    => $e->getTraceAsString(),
    ]));
    http_response_code(500);
    echo json_encode(['error' => 'Server error', 'id' => $id]);
    exit(1);
});

Rotation des journaux

Les fichiers journaux grossissent indéfiniment — faites-les tourner avec logrotate sous Linux ou avec des gestionnaires fondés sur le temps dans Monolog :

<?php
use Monolog\Handler\RotatingFileHandler;

$handler = new RotatingFileHandler(
    '/var/log/app.log',
    30,              // keep 30 days
    Logger::DEBUG
);

// Creates dated files: app-2024-05-27.log
$log = new Logger('app');
$log->pushHandler($handler);

Journalisation riche en contexte

Incluez le contexte de la requête dans chaque entrée du journal pour faciliter le débogage :

<?php
function getRequestContext(): array {
    return [
        'url'     => $_SERVER['REQUEST_URI'] ?? '',
        'method'  => $_SERVER['REQUEST_METHOD'] ?? '',
        'ip'      => $_SERVER['REMOTE_ADDR'] ?? '',
        'user_id' => $_SESSION['user_id'] ?? null,
    ];
}

// Add to every log call:
$log->error('Order failed', array_merge(
    getRequestContext(),
    ['order_id' => $orderId]
));

Éviter les données sensibles dans les journaux

Ne consignez jamais d'informations sensibles :

  • Mots de passe et jetons
  • Numéros de carte bancaire
  • Données personnelles (respect du GDPR)
  • Traces d'appels complètes des exceptions dans les réponses destinées aux utilisateurs
<?php
// Bad:
error_log('Login attempt: ' . $email . ' / ' . $password);

// Good:
error_log('Login failed for user: ' . substr($email, 0, 3) . '***');

Sentry et suivi externe des erreurs

En production, utilisez des services de suivi des erreurs comme Sentry pour les centraliser et déclencher des alertes :

<?php
// After composer require sentry/sdk
\Sentry\init(['dsn' => getenv('SENTRY_DSN')]);

// Automatic capture of unhandled exceptions
// Manual capture:
try {
    processOrder();
} catch (\Throwable $e) {
    \Sentry\captureException($e);
    throw $e;
}

Préconditions fondées sur des assertions

Utilisez des assertions pour détecter les erreurs de programmation pendant le développement :

<?php
// assert() throws AssertionError when false (dev mode)
assert(is_int($userId), 'userId must be an integer');
assert($amount > 0, 'amount must be positive');

// Or throw explicitly:
if (!is_int($userId)) {
    throw new \InvalidArgumentException('userId must be int');
}

Vérification rapide

Selon PSR-3, quel niveau de journalisation indique une situation nécessitant une attention immédiate ?

Récapitulatif : journalisation des erreurs

Bonnes pratiques de journalisation :

  • Utiliser une journalisation JSON structurée avec l'horodatage, le niveau, le message et le contexte
  • Respecter les niveaux de journalisation PSR-3
  • Utiliser Monolog dans les applications de production
  • Faire tourner les journaux pour éviter de remplir le disque
  • Ne jamais consigner de mots de passe ni de données sensibles
  • Utiliser Sentry ou un service similaire pour le suivi des erreurs en temps réel

Questions Fréquemment Posées

La leçon « Journalisation des erreurs et bonnes pratiques » est-elle gratuite ?

Oui — le texte complet de « Journalisation des erreurs et bonnes pratiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Journalisation des erreurs et bonnes pratiques » ?

Consigner les erreurs dans des fichiers et appliquer les bonnes pratiques de gestion des erreurs en production. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Journalisation des erreurs et bonnes pratiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Types d’erreurs PHP et signalement
  2. Try, Catch et Finally
  3. Créer des exceptions personnalisées
  4. Journalisation des erreurs et bonnes pratiques
← Retour à PHP Academy