Un client demande "pourquoi le statut de cette commande est passé de en préparation à annulée hier à 14h32, et qui a fait ça ?" La table orders ne contient que l'état final : status = 'cancelled'. Aucune trace de la transition, aucune trace de l'auteur. Reconstruire du full event sourcing (event store, projections, replay) pour répondre à cette question serait disproportionné. La bonne échelle de réponse, c'est l'event sourcing léger : capturer les événements métier significatifs via les Events Laravel, sans jeter le modèle relationnel existant.

Le problème concret

Le event sourcing "complet" remplace la source de vérité : au lieu de stocker l'état courant, on stocke la séquence d'événements qui y a mené, et l'état courant devient une projection recalculée. C'est puissant mais ça change radicalement l'architecture (event store dédié, gestion de versions de schéma d'événements, reconstruction par replay) et c'est rarement justifié pour une application métier classique. Ce qu'on veut souvent en pratique, c'est plus modeste : garder le modèle Eloquent classique comme source de vérité, mais capturer fidèlement chaque transition métier importante dans un journal consultable, pour l'audit, le support client, et parfois pour déclencher des effets de bord (notification, facturation, webhook).

Modéliser l'événement métier, pas l'événement technique

La première erreur est de confondre "événement Laravel" (le mécanisme technique : Event::dispatch()) avec "événement métier" (le fait qu'il faut enregistrer : commande annulée, paiement validé, stock ajusté). Un événement métier bien modélisé porte un nom au passé, un identifiant d'agrégat, et le contexte nécessaire pour comprendre ce qui s'est passé sans avoir à recharger l'état complet.

// app/Events/OrderCancelled.php
namespace App\Events;

use App\Models\Order;
use Illuminate\Foundation\Events\Dispatchable;

class OrderCancelled
{
    use Dispatchable;

    public function __construct(
        public readonly Order $order,
        public readonly string $reason,
        public readonly ?int $cancelledByUserId,
        public readonly string $previousStatus,
    ) {}
}

Le modèle déclenche l'événement au moment de la transition, pas après coup dans un job de nettoyage :

// app/Models/Order.php
public function cancel(string $reason, ?int $byUserId = null): void
{
    $previousStatus = $this->status;

    $this->update(['status' => OrderStatus::Cancelled]);

    event(new OrderCancelled(
        order: $this,
        reason: $reason,
        cancelledByUserId: $byUserId,
        previousStatus: $previousStatus,
    ));
}

Le journal d'événements : la table qui répond aux questions d'audit

Un Listener dédié persiste chaque événement métier dans une table event_log, indépendamment de l'état courant du modèle :

// app/Listeners/PersistDomainEvent.php
namespace App\Listeners;

use App\Models\EventLog;

class PersistDomainEvent
{
    public function handle(object $event): void
    {
        EventLog::create([
            'aggregate_type' => get_class($event->order),
            'aggregate_id' => $event->order->id,
            'event_type' => class_basename($event),
            'payload' => [
                'reason' => $event->reason ?? null,
                'previous_status' => $event->previousStatus ?? null,
                'cancelled_by_user_id' => $event->cancelledByUserId ?? null,
            ],
            'occurred_at' => now(),
        ]);
    }
}
// EventServiceProvider ou bootstrap/app.php (Laravel 11+)
protected $listen = [
    \App\Events\OrderCancelled::class => [
        \App\Listeners\PersistDomainEvent::class,
        \App\Listeners\NotifyCustomerOfCancellation::class,
    ],
];
-- migration
CREATE TABLE event_log (
    id BIGSERIAL PRIMARY KEY,
    aggregate_type VARCHAR(255) NOT NULL,
    aggregate_id BIGINT NOT NULL,
    event_type VARCHAR(255) NOT NULL,
    payload JSONB NOT NULL,
    occurred_at TIMESTAMPTZ NOT NULL,
    created_at TIMESTAMPTZ DEFAULT now()
);
CREATE INDEX idx_event_log_aggregate ON event_log (aggregate_type, aggregate_id, occurred_at);

Désormais, la question "pourquoi et par qui" se répond par une simple requête :

SELECT event_type, payload, occurred_at
FROM event_log
WHERE aggregate_type = 'App\\Models\\Order' AND aggregate_id = 4821
ORDER BY occurred_at ASC;

Un Listener séparé pour la persistance (plutôt que de l'insérer directement dans le modèle) garde le modèle métier propre et permet d'ajouter ou retirer des effets de bord (notification, facturation) sans toucher à la logique de transition d'état.

Observers : capturer ce que le code "oublie" de déclencher

Les Events explicites capturent les transitions que le code métier déclenche intentionnellement. Mais une mise à jour directe via Eloquent (Order::find($id)->update(['status' => 'cancelled']) dans un script de maintenance, un job batch, ou un contrôleur mal écrit qui contourne la méthode cancel()) ne passe pas par là. Les Observers Laravel comblent ce trou en s'accrochant directement aux événements du cycle de vie Eloquent :

// app/Observers/OrderObserver.php
namespace App\Observers;

use App\Models\Order;
use App\Models\EventLog;

class OrderObserver
{
    public function updated(Order $order): void
    {
        if ($order->wasChanged('status')) {
            EventLog::create([
                'aggregate_type' => Order::class,
                'aggregate_id' => $order->id,
                'event_type' => 'OrderStatusChanged',
                'payload' => [
                    'from' => $order->getOriginal('status'),
                    'to' => $order->status,
                ],
                'occurred_at' => now(),
            ]);
        }
    }
}
// app/Providers/AppServiceProvider.php
public function boot(): void
{
    Order::observe(OrderObserver::class);
}

Ce filet de sécurité capture toute modification de statut, même celles qui contournent la méthode métier dédiée. En contrepartie, il perd le contexte riche (raison, auteur) que seul l'appelant intentionnel connaît : c'est un compromis entre couverture exhaustive et richesse d'information, pas un remplacement des Events explicites.

Fiabiliser la persistance : listeners en file d'attente et gestion des échecs

Un piège fréquent de cette approche est de traiter la persistance du journal comme un détail secondaire alors qu'elle doit être au moins aussi fiable que l'écriture métier elle-même. Par défaut, un Listener Laravel s'exécute de manière synchrone, dans la même requête que la transition métier : si la connexion à la base de données du journal est momentanément indisponible, l'exception remonte et peut faire échouer toute la requête, y compris la transition métier qui n'a rien à voir avec le problème de logging.

La solution standard est de rendre le Listener asynchrone via une file d'attente, en implémentant ShouldQueue :

// app/Listeners/PersistDomainEvent.php
namespace App\Listeners;

use App\Models\EventLog;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;

class PersistDomainEvent implements ShouldQueue
{
    use InteractsWithQueue;

    public int $tries = 5;
    public int $backoff = 10;

    public function handle(object $event): void
    {
        EventLog::create([
            'aggregate_type' => get_class($event->order),
            'aggregate_id' => $event->order->id,
            'event_type' => class_basename($event),
            'payload' => [
                'reason' => $event->reason ?? null,
                'previous_status' => $event->previousStatus ?? null,
            ],
            'occurred_at' => now(),
        ]);
    }

    public function failed(object $event, \Throwable $exception): void
    {
        // Alerte explicite : un trou dans le journal d'audit est un incident,
        // pas un simple job en échec silencieux
        report($exception);
        Log::critical('Échec de persistance d\'un événement métier', [
            'event' => class_basename($event),
            'order_id' => $event->order->id ?? null,
        ]);
    }
}

Ce découplage a un coût : la transition métier (le update() sur la commande) et la persistance du journal ne sont plus atomiques dans la même transaction. Un crash du worker de queue entre la transition et le traitement du job peut, dans de rares cas, laisser une transition sans trace dans le journal. Pour un besoin d'audit strict (secteur financier, réglementé), la bonne réponse est souvent une approche hybride : écrire la ligne du journal dans la même transaction SQL que la transition métier elle-même (Listener synchrone, dans la transaction), et réserver la file d'attente aux effets de bord qui tolèrent un délai (notification email, webhook sortant).

public function cancel(string $reason, ?int $byUserId = null): void
{
    DB::transaction(function () use ($reason, $byUserId) {
        $previousStatus = $this->status;
        $this->update(['status' => OrderStatus::Cancelled]);

        // Écriture synchrone du journal dans la MÊME transaction :
        // soit les deux écritures réussissent, soit aucune.
        EventLog::create([
            'aggregate_type' => static::class,
            'aggregate_id' => $this->id,
            'event_type' => 'OrderCancelled',
            'payload' => ['reason' => $reason, 'previous_status' => $previousStatus],
            'occurred_at' => now(),
        ]);
    });

    // Les effets de bord non critiques (notification) restent en file d'attente,
    // en dehors de la transaction.
    event(new OrderCancelled($this, $reason, $byUserId, $previousStatus));
}

Diagnostiquer les trous de couverture

Pour vérifier que le journal capture bien toutes les transitions critiques, le réflexe est d'auditer tous les points d'écriture du champ concerné :

grep -rn "status.*=.*cancelled\|update(\['status'" app/ --include="*.php"

Chaque point trouvé qui ne passe ni par la méthode cancel() ni par un Observer qui couvre ce modèle est un trou dans l'audit. C'est typiquement là que se cachent les "comment ça a pu changer sans qu'on le sache" en production.

Quand cette approche ne suffit pas

Si le besoin métier évolue vers la nécessité de reconstruire un état passé (savoir exactement à quoi ressemblait la commande à n'importe quel instant T, pas seulement la dernière transition), ou vers des projections multiples dérivées des mêmes événements (un tableau de bord financier et un tableau de bord logistique recalculés indépendamment à partir du même flux), c'est le signal qu'il faut basculer vers un vrai event store avec replay et versionnement de schéma d'événements, probablement avec un package dédié comme spatie/laravel-event-sourcing plutôt que de complexifier à la main ce pattern léger.

À retenir

L'event sourcing léger avec Events et Observers Laravel donne 80% de la valeur d'audit du event sourcing complet (traçabilité des transitions, contexte métier, déclenchement d'effets de bord) pour une fraction de la complexité architecturale, à condition d'auditer explicitement les points d'écriture qui contournent les méthodes métier. Ce n'est pas un vrai event store : l'état courant reste la source de vérité, et le journal n'est consultable qu'en lecture, pas rejouable pour reconstruire un état.