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_afterfeuert 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_afterodersales_order_place_after, nichtsales_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 erneut10 }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 erneut12 }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.
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.
$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.
Weiterführende Artikel
-
Redis Session Locking in Magento 2: Wann
disable_locking=1deinen Checkout rettet. Observer-Kaskaden und Session-Lock-Contention treten meistens auf demselben Bestellpfad gemeinsam auf. Nur eins davon zu fixen und das andere liegen zu lassen, ist ziemlich unbefriedigend. - Preference vs Plugin in Magento 2: Wenn Class-Rewrites zur Belastung werden. Module mit vielen Preferences bringen erfahrungsgemäß auch Observer-Kaskaden mit, weil beides aus derselben „überall einhaken"-Denke entsteht.
Die Observer-Rekursions-Checkliste
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.