Logo run_as_root - Magento B2B Agentur Würzburg
PERFORMANCE

Magento 2 Observer-Rekursion: Warum sales_order_save_after den Checkout ausbremst

Drei Observer, die bei sales_order_save_after jeweils $order->save() aufrufen, erzeugen schnell 4+ Saves pro Checkout. So findest du die Kaskade und fixt sie mit dem passenden Refactor.


On this page

    Der Kunde klickt auf „Bestellung abschicken" und wartet. Fünf Sekunden. Sieben. Zehn. Das Stripe-Token war nach 600 Millisekunden durch, auf Stripe-Seite bestätigt, im Dashboard sichtbar. Der Kunde starrt derweil auf einen Spinner, während Magento intern mit sich selbst telefoniert.

    Du öffnest Blackfire. Irgendwo im Call-Graph taucht Magento\Sales\Model\Order::save() auf, einmal, zweimal, viermal, jedes Mal ineinander verschachtelt. Jeder Aufruf feuert erneut alle Observer auf sales_order_save_after. Jeder Observer speichert den Order noch einmal. Und jeder dieser Saves stößt wieder alle Observer an.

    Das sehen wir bei den meisten Magento-2-Shops mit gewachsener Checkout-Logik. Niemand baut diese Schleife absichtlich. Drei Entwickler ergänzen über drei Jahre hinweg je einen für sich genommen sinnvollen Observer. Sobald alle drei gleichzeitig aktiv sind, speichern sie den Order gegenseitig in ihren eigenen Callbacks, und die Kaskade entsteht wie von selbst.

    TL;DR

    • sales_order_save_after feuert bei jedem $order->save(). Ruft dein Observer $order->save() (oder $this->orderRepository->save($order)) auf, hast du das Event gerade selbst erneut ausgelöst.
    • Drei Observer auf diesem Event, die alle speichern, reichen für vier oder mehr komplette Order-Saves pro Checkout. Jeder Save durchläuft die gesamte Observer-Kette, nicht nur den einen Observer, um den es dir eigentlich geht.
    • Welches Event richtig ist, hängt vom Zweck ab. Für Arbeit, die genau einmal pro platzierter Bestellung laufen soll, nimm checkout_submit_all_after oder sales_order_place_after, nicht sales_order_save_after.
    • Alles, was sich aufschieben lässt, gehört in einen Queue-Job. Der Kunde soll nicht auf deinen Freshdesk-Webhook warten müssen.
    • $order->setDataChanges(false) vor dem letzten Save ist der taktische Notbehelf, wenn du das Upstream-Modul nicht anfassen kannst. Er kurzschließt aber nur den äußersten Save, nicht die gesamte Kaskade.

    Wie die Kaskade entsteht

    Magentos Event-System arbeitet synchron. Ruft dein Code $order->save() auf, durchläuft die AbstractModel::save()-Pipeline zuerst _beforeSave, schreibt die Zeile in die Datenbank und dispatcht anschließend sales_order_save_after. Jeder Observer, der dieses Event abonniert hat, läuft inline ab, bevor save() überhaupt zurückkehrt.

    Ruft einer dieser Observer im Rahmen seiner Arbeit selbst $order->save() auf, feuert das Event ein zweites Mal. Alle Observer laufen erneut. Macht ein weiterer Observer dasselbe, feuert es ein drittes Mal. Einen eingebauten Schutz gegen Rekursion gibt es nicht. AbstractModel::save() verschachtelt sich klaglos so tief, wie es der PHP-Stack zulässt.

    Der Grund, warum das auf so vielen Magento-2-Shops passiert: „den Order speichern, sobald er gespeichert wurde" fühlt sich wie der naheliegendste Ort für Post-Save-Buchhaltung an. Ein Entwickler hängt sich an sales_order_save_after, schreibt etwas in ein Order-Attribut und ruft save() auf, um es zu persistieren. Für sich genommen ist so ein einzelner Observer unproblematisch. Die Schleife bleibt unsichtbar, die Kosten sind ein zusätzlicher Save, ärgerlich, aber nicht dramatisch.

    Zur Katastrophe wird es, wenn ein zweites Team einen zweiten Observer ergänzt und ein drittes Team einen dritten. Keines der Teams weiß von den anderen. Niemand fährt einen Blackfire-Trace über den Checkout. Und irgendwann fragt jemand, warum der Checkout in Production eine TTFB von zehn Sekunden hat, und der erste Verdacht fällt reflexartig auf das Payment-Gateway.

    So sieht das in deiner Codebasis aus

    Das Muster, bewusst generisch gehalten: drei Observer aus drei verschiedenen Modulen, jeder für sich betrachtet plausibel.

    1// app/code/Acme/Checkout/Observer/SplitOrderData.php
    2final class SplitOrderData implements ObserverInterface
    3{
    4 public function execute(Observer $observer): void
    5 {
    6 $order = $observer->getEvent()->getOrder();
    7 $order->setData('acme_split_segments', $this->splitter->forOrder($order));
    8 $order->save(); // feuert sales_order_save_after erneut
    9 }
    10}
    1// app/code/Acme/Notifications/Observer/SyncExternalCustomer.php
    2final class SyncExternalCustomer implements ObserverInterface
    3{
    4 public function execute(Observer $observer): void
    5 {
    6 $order = $observer->getEvent()->getOrder();
    7 $this->notifications->push($order); // HTTP-Call an Freshdesk
    8 $order->setData('acme_notified_at', time());
    9 $this->orderRepository->save($order); // feuert sales_order_save_after erneut
    10 }
    11}
    1// app/code/Acme/Warehouse/Observer/CheckOrderItems.php
    2final class CheckOrderItems implements ObserverInterface
    3{
    4 public function execute(Observer $observer): void
    5 {
    6 $order = $observer->getEvent()->getOrder();
    7 foreach ($order->getAllVisibleItems() as $item) {
    8 $item->getProduct()->getStockItem(); // N+1 pro Kind-Item
    9 }
    10 $order->setData('acme_items_checked', 1);
    11 $order->save(); // feuert sales_order_save_after erneut
    12 }
    13}

    Der erste Save des Orders stößt alle drei Observer an. Jeder speichert selbst. Jeder dieser Saves lässt wiederum alle drei laufen. Je nachdem, welche Daten-Flags und Short-Circuits in der Logik der einzelnen Observer greifen, landest du irgendwo zwischen vier und einem Dutzend vollständiger Order::save()-Durchläufe für eine einzige platzierte Bestellung. Und macht einer dieser Observer nebenbei einen synchronen HTTP-Call (der Freshdesk-Push oben zum Beispiel), zahlst du den Netzwerk-Roundtrip auf jeder Kaskadenstufe erneut.

    ⚠️
    Das eigentliche Anti-Pattern ist nicht „Observer plus Save". Es ist „Observer auf sales_order_save_after plus Save". Observer auf sales_order_place_after oder checkout_submit_all_after können save() problemlos aufrufen, ohne eine Schleife auszulösen, weil diese Events einmal pro platzierter Bestellung feuern, nicht einmal pro Model-Save. Prüf also immer zuerst, an welchem Event dein Observer hängt, bevor du ihm die Schuld gibst.

    Die Schleife in unter fünf Minuten aufspüren

    Für die Diagnose brauchst du keinen kompletten Performance-Audit. Zwei Wege führen zum Ziel.

    Option A: Blackfire-Call-Graph. Fahr einen Blackfire-Trace gegen eine platzierte Bestellung, am besten auf einer Staging-Umgebung mit echtem Payment-Gateway im Testmodus. Such im Call-Tree nach Magento\Sales\Model\Order::save und zähl die inklusiven Aufrufe. Alles über zwei ist verdächtig, alles über fünf ist sicher eine Kaskade. Der Call-Graph zeigt dir gleich die Observer-Klassen innerhalb jedes Saves, also genau dein Refactor-Ziel.

    Option B: ein Zehn-Zeilen-Counter. Hast du kein Blackfire auf der Umgebung, wirf dieses Plugin in ein Dev-Modul und leer den DI-Cache:

    1// app/code/Acme/Debug/Plugin/OrderSaveCounter.php
    2final class OrderSaveCounter
    3{
    4 public function beforeSave(\Magento\Sales\Model\Order $order): void
    5 {
    6 error_log(sprintf(
    7 '[order-save-counter] order=%s backtrace=%s',
    8 (string) $order->getIncrementId(),
    9 (new \Exception())->getTraceAsString()
    10 ));
    11 }
    12}

    Platzier eine Bestellung. Greif dir var/log/system.log (oder wo dein error_log sonst landet) und such nach order-save-counter. Eine Zeile pro Treffer heißt ein Order::save()-Aufruf. Vier oder mehr Treffer für dieselbe increment_id, und du hast deine Kaskade gefunden. Der Backtrace in jeder Zeile verrät dir genau, welcher Observer die nächste Stufe ausgelöst hat.

    Entfern das Plugin wieder, sobald du deine Zahlen hast. Ein Stacktrace-Dump in Production-Observern ist außerhalb von gezieltem Debugging keine gute Idee.

    Refactor 1: Post-Order-Arbeit in einen Queue-Job auslagern

    Das meiste, was deine Observer erledigen, muss den Kunden gar nicht blockieren. Freshdesk-Syncs, Order-Split-Berechnungen, Lagerbestand-Benachrichtigungen, systemübergreifende Audit-Logs, all das kann laufen, nachdem die Checkout-Response längst beim Browser angekommen ist. Muss der Sync nicht zwingend abgeschlossen sein, bevor der Kunde die Danke-Seite sieht, gehört die Arbeit dort auch nicht hin.

    So sieht das aus:

    1final class SyncExternalCustomer implements ObserverInterface
    2{
    3 public function __construct(
    4 private readonly PublisherInterface $publisher,
    5 ) {}
    6 
    7 public function execute(Observer $observer): void
    8 {
    9 $order = $observer->getEvent()->getOrder();
    10 $this->publisher->publish(
    11 'acme.order.sync_external_customer',
    12 (int) $order->getId(),
    13 );
    14 }
    15}

    Der Handler auf der Queue-Seite lädt den Order frisch, macht den HTTP-Call, aktualisiert das Attribut und speichert genau einmal. Keine Kaskade. Der Kunde bekommt seine Danke-Seite in der Zeit, die es braucht, eine Nachricht an RabbitMQ zu serialisieren, auf einem gesunden Cluster einstellige Millisekunden.

    Das richtige Event zum Einhängen ist sales_order_place_after. Es feuert einmal pro platzierter Bestellung, nicht einmal pro Model-Save. Damit bist du raus aus der Schleife und musst dir auch keine Gedanken mehr machen, in welcher der vier kaskadierenden Saves dein Observer gerade hängt.

    Refactor 2: auf ein Single-Fire-Event wechseln

    Muss die Arbeit wirklich synchron laufen, liegt der Fix meist im Event, nicht in der Logik. Magentos Checkout-Flow feuert checkout_submit_all_after genau einmal, nachdem Quote und Order beide committed sind, noch innerhalb der ursprünglichen Transaktion. Das ist das richtige Event für alles, was „im Moment der Bestellplatzierung" passieren muss, den Order verändert und dabei atomar mit dem Checkout bleiben soll.

    1<event name="checkout_submit_all_after">
    2 <observer name="acme_split_order_data" instance="Acme\Checkout\Observer\SplitOrderData"/>
    3</event>

    Gleiche Observer-Klasse, anderes Event. Der Observer läuft jetzt exakt einmal. Ruft er intern $order->save() auf, feuert das zwar wieder sales_order_save_after und lässt alle dort registrierten Observer laufen, aber der Observer, den du gerade umgezogen hast, ist selbst nicht mehr Teil der Kaskade, weil er an diesem Event gar nicht mehr hängt.

    Die Falle dabei: sales_order_save_commit_after. Auch dieses Event feuert bei jedem Save. Von sales_order_save_after auf sales_order_save_commit_after zu wechseln, verschiebt nur die Möbel im selben Zimmer, die Kaskade bleibt bestehen. Der einzige echte Fix ist, die komplette save-after-Event-Familie zu verlassen.

    Refactor 3: der taktische Patch mit setDataChanges(false)

    Manchmal sitzt der problematische Observer in Vendor-Code, den du nicht anfassen darfst, ausgeliefert von einem Marketplace-Modul mit einem Support-Vertrag, der Patches ausdrücklich verbietet. Für solche Fälle bleibt als letzter taktischer Patch, dem äußeren Save vorzugaukeln, es gäbe nichts zu schreiben, sodass der Dispatch von vornherein ausbleibt.

    1$order->setDataChanges(false);
    2$order->save();

    Steht data_changes auf false und stimmt das Dirty-Attribute-Tracking des Models zu, überspringt die save()-Pipeline nicht nur das eigentliche UPDATE, sondern auch das Dispatchen des _save_after-Events komplett. Die Observer-Kette läuft dann gar nicht erst an.

    ⚠️
    Das wirkt nur auf den äußeren Save. Hat ein innerer Observer schon vorher $order->save() aufgerufen, ohne selbst data_changes=false zu setzen, steckst du bereits in der Kaskade, und das Flag holt dich im Nachhinein nicht mehr raus. Setz dieses Muster nur ganz oben in der Kette ein, und nur dann, wenn der eigentliche Fix (Refactor 1 oder 2) diesen Sprint nicht machbar ist.

    Die andere Schwachstelle: Es ist ein Verhaltens-Patch ohne erkennbaren Namen. Sechs Monate später schaut ein anderer Entwickler auf die Zeile, hält sie für toten Code und löscht sie. Die Kaskade ist zurück. Lieferst du das aus, dann mit einem Kommentar, der das Warum erklärt, und einem Link zu diesem Artikel, deiner Blackfire-Baseline oder dem internen Ticket.

    Welcher Refactor wann passt

    Szenario Refactor
    Arbeit kann asynchron laufen (E-Mail, Webhook, CRM-Sync, Audit-Log) Refactor 1: Queue-Job auf sales_order_place_after
    Arbeit muss innerhalb der Checkout-Transaktion laufen (Order-Attribut-Änderung, Line-Item-Rewrite) Refactor 2: Observer auf checkout_submit_all_after umziehen
    Der problematische Observer ist Vendor-Code, den du nicht patchen kannst Refactor 3: setDataChanges(false)-Wrapper, mit Kommentar
    Du besitzt den gesamten Code und hast Zeit für den richtigen Fix Refactor 2 für die synchronen Teile, Refactor 1 für den Rest

    Faustregel: Gehört die Arbeit zur platzierten Bestellung und nicht zu jedem einzelnen Order-Save, ist das Event falsch gewählt. Fix das Event, nicht die Kaskade.

    Die Observer-Rekursions-Checkliste

    1. Eine Bestellplatzierung tracen

      Blackfire oder Tideways über einen Staging-Checkout auf dem Pfad, den du untersuchst. Notier den inklusiven Aufrufcount für Magento\Sales\Model\Order::save. Alles über zwei ist verdächtig.

    2. Jeden Observer auf der save-Event-Familie auflisten

      grep -rn --include='*.xml' -E 'sales_order_save_after|sales_order_save_commit_after' app/code/. Jeder Treffer ist ein Kandidat für den Audit. Lies dir jeden durch; jeder Observer, der $order->save() oder $this->orderRepository->save($order) aufruft, steckt in der Kaskade.

    3. Jeden Observer nach seiner Aufgabe einordnen

      Async-tauglich (Webhook, E-Mail, Audit-Log) versus synchron (Order-Attribut-Änderung, die atomar mit der Platzierung sein muss). Diese Einordnung entscheidet über den passenden Refactor.

    4. Async-taugliche Arbeit in einen Queue-Job verschieben

      Trigger an sales_order_place_after hängen, eine Message publishen, in einem Handler verarbeiten, der den Order frisch lädt und einmal speichert. RabbitMQ oder MySQL-Queue, deine Wahl.

    5. Synchrone Arbeit von sales_order_save_after wegziehen

      checkout_submit_all_after für Arbeit zur Checkout-Zeit, sales_order_place_after für Arbeit zur Platzierungs-Zeit. Beide feuern einmal pro Bestellung. Keins von beiden erzeugt eine Schleife.

    6. setDataChanges(false) nur dort einsetzen, wo Refactor nicht geht

      Vendor-Code ohne Patch-Möglichkeit, knappe Deadline, wenig Vertrauen ins Zeitfenster für den echten Fix. Kommentier das Warum. Mach es nicht zur Standardstrategie.

    7. Nach jedem Refactor neu tracen

      Derselbe Blackfire-Trace auf demselben Pfad. Der inklusive Order::save-Count sollte auf eins fallen. Die TTFB der platzierten Bestellung sollte um genau das sinken, was die Kaskade gekostet hat, auf gut besuchten Shops üblicherweise im Bereich von zwei bis fünf Sekunden.

    8. Einen CI-Guard einbauen

      Eine statische Analyse-Regel oder ein grep in deiner CI-Config, der den Build stoppt, sobald jemand einen neuen Observer auf sales_order_save_after ergänzt, der save() aufruft. Billige Versicherung gegen die nächste Kaskade, die ein anderer Entwickler ungewollt wieder aufbaut.

    Observer-Kaskaden sind ein Symptom, nicht die eigentliche Krankheit

    Wir machen Magento-2-Code-Audits, die dir die genaue Observer-Liste, die Kaskadentiefe und einen priorisierten Refactor-Plan liefern. Auf Wunsch übernehmen wir die Umsetzung direkt in der Custom Development. Klartext, direkt im Code.

    Sprich mit uns über den Refactor

    Related articles

    01
    Security

    Cloudflare-WAF bei Magento 2: Warum "Protected" nicht gleich sicher heißt

    Ein grünes Cloudflare-Dashboard schützt deinen Magento-2-Shop nicht automatisch. Der Neun-Punkte-Check zu OWASP-Regeln, UA-Bypässen, Admin-Pfaden und TLS.

    von david-lambauer
    Apr 21, 2026
    02
    Security

    Subdomain-Takeover bei Magento: wenn vergessene CNAMEs zur Sicherheitslücke werden

    Nach dem Hosting-Wechsel weg von Hypernode oder Hipex bleiben CNAME-Einträge in deiner DNS-Zone liegen. Wie daraus ein Subdomain-Takeover wird und wie du deine Zone selbst prüfst.

    von david-lambauer
    Apr 21, 2026
    03
    Performance

    Magento 2: Niedrige Varnish-Hit-Rate diagnostizieren und fixen

    Hit-Rate unter 30 %? So findest du den PHP-Code, die Cookies und die Fehlkonfiguration, die Magento am Full Page Cache vorbeischleusen, Schritt für Schritt.

    von david-lambauer
    Apr 21, 2026