Fehler und Exceptions erklärt: warum Fehlerbehandlung Design ist

Kurz gesagt

Niveau: Einstieg

Software geht ständig schief. Entscheidend ist, was sie als Nächstes tut, und das wird entschieden, bevor der Code entsteht.

  • Eine Fehlerursache erzeugt einen Fehlzustand, und der wird nur zum Ausfall, wenn ihn nichts behandelt.
  • Erwartete Fehler (eine abgelehnte Karte) bekommen eine ruhige Nachricht. Unerwartete (ein Bug) einen sicheren Halt und die Aufmerksamkeit der Entwicklung.
  • Schnell scheitern bei falscher Konfiguration, sicher scheitern, wenn beim Geld etwas unklar ist, sanft zurückfahren, wenn ein Extra ausfällt.
  • Schluck nie einen Fehler: In einer Studie gingen 92 % der katastrophalen Ausfälle auf schlecht behandelte Fehler zurück.
  • Wiederhole nur Vorübergehendes, mit Idempotenzschlüssel. Halte jeden Fehlerfall und seine Antwort vorher in einer Tabelle fest.

Eine Bank lehnt eine Karte ab, ein Server antwortet nicht, ein kleiner Bug wacht an einem vollen Samstag auf. Das ist alles normal. Ob ein Unternehmen dabei Geld verliert, entscheidet sich daran, was die Software als Nächstes tut, und das ist eine Designfrage. Hier ist Fehlerbehandlung von null erklärt, mit einem erfundenen Grazer Teeshop, zwei berühmten Vorfällen und einer Tabelle, die du als Inhaberin oder Inhaber selbst ausfüllen kannst.

Was wirklich passiert, wenn Software schiefgeht

Jede Software geht irgendwann schief. Eine Bank lehnt eine Karte ab. Der Server eines Dienstleisters antwortet nicht mehr. Ein Entwickler macht an einem Dienstag einen kleinen Fehler, den niemand bemerkt, bis zu einem Samstag im Advent.

Das ist eh normal und nicht die eigentliche Frage. Die eigentliche Frage ist, was die Software als Nächstes tut. Sagt sie der Kundin etwas Brauchbares, oder zeigt sie eine leere Seite? Versucht sie es noch einmal, oder belastet sie die Karte doppelt? Erfährt ein Mensch innerhalb von Minuten davon, oder liegt das Problem in einer Logdatei, bis die Steuerberaterin fragt, warum die Zahlen nicht stimmen?

Dieses "was als Nächstes" heißt Fehlerbehandlung. Viele behandeln sie wie eine Pflichtübung, die man am Ende noch drüberstreut. Dieser Artikel sagt das Gegenteil: Fehlerbehandlung ist Design. Sie besteht aus geschäftlichen Entscheidungen darüber, was passieren soll, wenn etwas schiefgeht, bewusst getroffen, bevor der Code entsteht. Und du kannst sie treffen, ohne selbst eine Zeile Code zu schreiben.

Ich baue das Ganze von null auf, mit einem erfundenen Unternehmen. Das Teehaus am Grieskai ist ein kleiner Onlineshop für Tee in Graz (teehausgrieskai.example). Er verkauft losen Tee und monatliche Abos, nimmt Kartenzahlungen über einen Zahlungsanbieter an, bietet Rabattcodes, führt einen Lagerbestand und verschickt Bestellmails. Die Entwicklerin heißt Jana. Am Ende hat Jana jede Art aufgelistet, wie der Zahlungsschritt schiefgehen kann, und für jede entschieden, was der Shop tut.

Das ist Kapitel fünf einer Serie über Tests, und es steht für sich. Die nächsten beiden Kapitel machen aus diesen Entscheidungen echten Code in Rails und JavaScript und Tests für den Unhappy Path.

Fehlerursache, Fehlzustand, Ausfall: drei Wörter für drei Momente

Im Deutschen ist alles einfach "ein Fehler". Wer zuverlässige Systeme erforscht, trennt die Begriffe, weil jeder einen anderen Moment derselben Geschichte beschreibt. Die Standardtaxonomie von Avizienis, Laprie, Randell und Landwehr definiert sie auf Englisch so1.

  • Ein Ausfall (failure) tritt ein, wenn die Leistung, die ein System erbringt, von der korrekten Leistung abweicht. Das ist, was die Kundschaft tatsächlich erlebt: eine falsche Summe, ein Absturz, eine fehlende Mail.
  • Ein Fehlzustand (error) ist der Teil des inneren Zustands eines Systems, der zu einem Ausfall führen kann. Eine falsche Zahl im Speicher ist ein Fehlzustand, auch wenn sie noch niemand gesehen hat.
  • Eine Fehlerursache (fault) ist der Grund für einen Fehlzustand: eine falsche Codezeile, ein falsch konfigurierter Server, ein durchtrenntes Netzwerkkabel.

Eine Fehlerursache kann außerdem schlafen. Sie liegt untätig im Code, bis die passende Eingabe sie weckt1. Deshalb kann ein Fehler monatelang harmlos sein und an einem bestimmten Nachmittag teuer werden.

Die Kette läuft von der Ursache über den Fehlzustand zum Ausfall. Fehlerbehandlung lebt in der Lücke zwischen dem zweiten und dem dritten Glied: Die Software bemerkt, dass ihr Zustand falsch ist, und verhindert, dass die Kundschaft es zu spüren bekommt.

Beispiel: der Rabattcode, der eine negative Bestellung erzeugt

Beim Teehaus am Grieskai zieht der Code WILLKOMMEN10 € 10 von der ersten Bestellung ab.

  1. Die Fehlerursache. Janas Rabattregel zieht den Rabatt vom Warenkorb ab und prüft nie, ob das Ergebnis unter null fallen kann. Bisher war jeder Warenkorb mehr als € 10 wert, also schläft die Ursache.
  2. Die Aktivierung. Eine Kundin legt nur eine Probe von 50 g Darjeeling für € 6,00 in den Warenkorb und gibt WILLKOMMEN10 ein.
  3. Der Fehlzustand. Der Code speichert eine Bestellsumme von minus € 4,00. Sichtbar ist noch nichts. Der falsche Zustand existiert nur in der Anwendung.
  4. Zwei mögliche Enden. Prüft niemand die Summe, schickt der Zahlungsschritt minus € 4,00 an den Zahlungsanbieter, der lehnt ab, die Kundin sieht eine verwirrende Meldung und geht: ein Ausfall. Steht eine Prüfung dazwischen ("eine Bestellsumme ist nie kleiner als null"), wird der Fehlzustand abgefangen, der Rabatt auf den Warenwert gedeckelt, und die Kundin bekommt ihre Probe für € 0,00. Kein Ausfall.

Die Fehlerursache war in beiden Fällen dieselbe. Nur die Behandlung war anders.

Zum Vergrößern antippen: Vollbild, frei verschiebbar

Erwartete und unerwartete Fehler

Die nützlichste Frage zu allem, was schiefgeht: Gehört das zum normalen Geschäft, oder ist etwas kaputt?

Erwartete Fehler kannst du vorher beschreiben. Eine Karte wird abgelehnt, eine Postleitzahl gibt es nicht, ein Tee ist ausverkauft, während er noch im Warenkorb liegt. Kaputt ist dabei nichts. Der Zahlungsanbieter Stripe schreibt das in seiner eigenen Dokumentation über Ablehnungen: Der Fehler "can occur when your integration is working correctly", er kann also auftreten, obwohl deine Anbindung einwandfrei funktioniert2. Ein erwarteter Fehler verdient eine geplante, ruhige Antwort, meist eine klare Nachricht an die Kundschaft.

Unerwartete Fehler zeigen, dass mit dem System selbst etwas nicht stimmt: ein Bug, eine volle Festplatte, ein fehlender Konfigurationswert. Im Moment selbst lässt sich daran nichts reparieren. Die Software sollte sicher anhalten und jemandem aus der Entwicklung Bescheid geben.

Programmiersprachen ziehen dieselbe Linie. Das offizielle Buch zur Sprache Rust trennt behebbare Fehler, etwa eine Datei, die nicht gefunden wird, von nicht behebbaren, die "are always symptoms of bugs", also immer Symptome von Bugs sind3. Joe Armstrong hat es in seiner Doktorarbeit über die Sprache Erlang in zwei Sätzen gesagt: Exceptions entstehen, wenn das Laufzeitsystem nicht weiß, was zu tun ist, Fehler entstehen, wenn die Programmiererin nicht weiß, was zu tun ist4. Hat sie die Lage vorhergesehen und weiß, was zu tun ist, ist es eigentlich gar kein Fehler. Es ist nur ein weiterer Weg durch den Code.

Beispiel: die Probleme im Checkout auf zwei Stapel sortiert

Jana setzt sich mit der Inhaberin des Teehauses zusammen, sammelt, was im Checkout schiefgehen kann, und sortiert.

Was passiertErwartet oder unerwartetWarum
Die Bank lehnt die Karte abErwartetBanken lehnen jeden Tag Karten ab
Jemand gibt einen Rabattcode ein, den es nicht gibtErwartetMenschen vertippen sich
Ein Tee ist zwischen Warenkorb und Zahlung ausverkauftErwartetDer Bestand ist begrenzt
Der Zahlungsanbieter antwortet nicht innerhalb von zehn SekundenUnerwartet, aber absehbarNetze fallen ab und zu aus, und noch weiß niemand, ob gezahlt wurde
Die Bestellsumme ist kleiner als nullUnerwartetDas kann nur ein Bug verursachen
Der geheime Schlüssel des Anbieters fehlt auf dem ServerUnerwartetEin Konfigurationsfehler, den keine Kundin beheben kann

Die mittlere Zeile ist wichtig. Manche Probleme sind weder Bug noch normales Geschäft. Da benimmt sich die Außenwelt daneben, und dafür braucht es eine eigene, sorgfältige Antwort. Sie kommt weiter unten mehrmals vor.

Exceptions: wie Code ruft, dass etwas schiefgegangen ist

Ruby, JavaScript und die meisten modernen Sprachen haben einen eingebauten Weg, ein Problem zu melden: die Exception, auf Deutsch Ausnahme. Sie arbeitet in drei Schritten.

  1. Raise (Ruby) oder throw (JavaScript). Code, der auf ein Problem stößt, das er nicht selbst lösen kann, erzeugt ein Exception Objekt, das das Problem beschreibt. Die normale Ausführung endet in dieser Zeile.
  2. Weiterreichen. Die Exception wandert die Kette der Methoden zurück, die einander aufgerufen haben, den Call Stack, Ebene für Ebene. Eine Ebene, die nichts tut, lässt sie durch.
  3. Rescue (Ruby) oder catch (JavaScript). Code, der mit dieser Art Problem umgehen kann, fängt sie. Fängt sie niemand, gibt Ruby eine Meldung aus und beendet die Ausführung5.

Zwei Details aus der Ruby Dokumentation werden später wichtig: Ein rescue, das eine Klasse nennt, fängt nur diese Klasse und ihre Unterklassen, und ein nacktes rescue ohne Klasse fängt jeden StandardError5.

Beispiel: eine Exception auf ihrem Weg durch den Teeshop

Hier ein vereinfachter Checkout des Teehauses in Ruby on Rails: Ein Controller nimmt den Klick entgegen, ein Service Objekt legt die Bestellung an, eine Lagermethode reserviert den Tee.

class OutOfStockError < StandardError; end

class Stock
  def self.reserve!(tea, grams)
    if tea.stock_grams < grams
      raise OutOfStockError, "#{tea.name}: #{grams} g gewünscht, #{tea.stock_grams} g übrig"
    end
    tea.update!(stock_grams: tea.stock_grams - grams)
  end
end

class PlaceOrder
  def call(basket)
    Order.transaction do
      basket.lines.each { |line| Stock.reserve!(line.tea, line.grams) }
      Order.create!(basket: basket, status: "pending")
    end
  end
end

class CheckoutsController < ApplicationController
  def create
    order = PlaceOrder.new.call(current_basket)
    redirect_to new_payment_path(order)
  rescue OutOfStockError
    flash.now[:alert] = "Einer deiner Tees ist gerade ausverkauft. Bitte prüf deinen Warenkorb."
    render :new, status: :unprocessable_entity
  end
end

Zeile für Zeile:

  • OutOfStockError < StandardError definiert eine neue Art Exception, deren Name genau sagt, was passiert ist.
  • Gibt es in Stock.reserve! weniger Tee als gewünscht, erzeugt raise die Exception mit einer Nachricht für die Entwicklung (Teename und Mengen). Der Bestand wird nicht verringert.
  • PlaceOrder#call reserviert für jede Zeile im Warenkorb und fängt nichts ab, also läuft die Exception einfach durch.
  • Alles steckt in Order.transaction. Eine Datenbanktransaktion bündelt Änderungen, sodass entweder alle passieren oder keine. Eine Exception im Block löst ein Rollback aus und wird danach weitergeworfen6. Ist der dritte von drei Tees ausverkauft, wird der Bestand für die ersten beiden automatisch zurückgebucht.
  • CheckoutsController#create hat rescue OutOfStockError, der erste Code, der weiß, was zu tun ist: den Checkout mit einer klaren Nachricht und dem Status 422 erneut zeigen, der dem Browser sagt, dass die Anfrage so nicht verarbeitet werden konnte.
  • Jede andere Exception, etwa ein Datenbankausfall, wird hier nicht gefangen, weil das rescue nur OutOfStockError nennt. Das ist Absicht. Einen Datenbankausfall wie ein Lagerproblem zu behandeln, würde ihn verstecken.

Eine Exception, drei Ebenen tief ausgelöst, wandert genau an die Stelle, die damit umgehen kann, und macht unterwegs die halbe Arbeit rückgängig.

In JavaScript funktioniert das genauso mit throw, try und catch, mit einer Falle für Einsteiger. Die Browserfunktion fetch wirft keine Exception, wenn der Server mit einem Fehlerstatus wie 404 oder 504 antwortet. Laut MDN schlägt sie nur fehl, wenn die Anfrage selbst scheitert, etwa an einem Netzwerkfehler. Deinen Code musst du also selbst response.ok prüfen lassen7.

async function loadSubscription(id) {
  const response = await fetch(`/api/subscriptions/${id}`)
  if (!response.ok) {
    // Fehlerstatus in eine echte Exception verwandeln
    throw new Error(`Abo ${id} konnte nicht geladen werden: HTTP ${response.status}`)
  }
  return response.json()
}

await fetch(...) wartet auf die Antwort. Das if macht aus einem Fehlerstatus eine echte Exception, die Abo und Status nennt. So kann niemand, der die Funktion aufruft, ein gescheitertes Laden mit einem leeren Abo verwechseln.

Rückgabewerte und Ergebnisobjekte: die leisere Alternative

Der andere Weg, ein Problem zu melden: Du gibst es als ganz normalen Wert zurück und zwingst den Aufrufer, hinzusehen. Rust hat überhaupt keine Exceptions, sondern einen Typ Result für behebbare Fehler und panic!, um bei nicht behebbaren anzuhalten3. Rails mischt beide Stile: save gibt false zurück, wenn ein Datensatz ungültig ist, save! wirft dagegen ActiveRecord::RecordInvalid8.

Eine gute Faustregel: Gib einen Wert zurück für alltägliche Ergebnisse, die der Aufrufer immer bedenken muss, und wirf eine Exception für Lagen, die im normalen Betrieb nicht vorkommen sollten.

Beispiel: ein Rabattcode, geprüft mit einem Ergebnisobjekt

Jana baut die Rabattprüfung so um, dass sie ein kleines Ergebnisobjekt zurückgibt. Rubys Klasse Data erzeugt so etwas in einer Zeile.

DiscountCheck = Data.define(:ok, :amount, :reason)

def check_discount(code, basket_total)
  discount = Discount.find_by(code: code.strip.upcase)
  return DiscountCheck.new(ok: false, amount: 0, reason: :unknown_code) if discount.nil?
  return DiscountCheck.new(ok: false, amount: 0, reason: :expired) if discount.expires_on < Date.current

  # Nie mehr Rabatt als der Warenwert
  amount = [discount.amount, basket_total].min
  DiscountCheck.new(ok: true, amount: amount, reason: nil)
end
  • Data.define erzeugt ein kleines, unveränderliches Objekt: Hat es geklappt, wie viel wird abgezogen, und wenn nicht, warum nicht.
  • Die Suche entfernt Leerzeichen und schreibt den Code groß, " willkommen10 " passt also trotzdem.
  • Ein unbekannter oder abgelaufener Code liefert ok: false mit einem Grund. Das sind erwartete Ergebnisse, also kommen sie als Werte zurück, und der Checkout macht aus jedem Grund einen eigenen freundlichen Satz.
  • [discount.amount, basket_total].min nimmt die kleinere Zahl. Ein Code über € 10 auf einen Warenkorb von € 6 zieht € 6 ab, nie mehr. Genau diese Prüfung hat im ersten Beispiel gefehlt. Die negative Bestellung ist jetzt unmöglich.

Keine einzige Exception, weil hier nichts kaputt ist.

Fail fast, fail safe, sanft zurückfahren

Ist etwas schiefgegangen, gibt es drei grundsätzliche Strategien.

Fail fast, schnell scheitern. Sofort und sichtbar anhalten, statt mit falschen Daten weiterzumachen. Jim Shore hat das 2004 in IEEE Software beschrieben: Ein System, das schnell scheitert, "fails immediately and visibly", eines, das Probleme umschifft, "fails slowly" und geht später auf seltsame Weise kaputt9. Das klingt zerbrechlich, aber Bugs werden leicht auffindbar, und weniger davon erreichen die Kundschaft.

Fail safe, sicher scheitern. Wenn du anhalten musst, dann in dem Zustand, der am wenigsten schadet. Eine Zahlung, bei der du unsicher bist, wird nie als bezahlt markiert. Bestand, bei dem du unsicher bist, wird nie doppelt verkauft.

Sanft zurückfahren (graceful degradation). Fällt etwas aus, das nur nett ist, schaltest du es ab und hältst das Wesentliche am Laufen.

Welche Strategie passt, hängt davon ab, was auf dem Spiel steht. Darum ist es eine Designentscheidung.

Beispiel: drei Probleme beim Teehaus, drei Antworten

  1. Fail fast: der fehlende Schlüssel. Nach einem Deployment fehlt auf dem Server der geheime Schlüssel für den Zahlungsanbieter. Janas Anwendung prüft ihn beim Start und weigert sich zu starten. Mit einem Deploymentwerkzeug, das den Verkehr erst auf eine neue Version umlenkt, wenn sie sauber gestartet ist, bedient die alte Version einfach weiter, und draußen merkt niemand etwas. Die Alternative, ein Shop, der gut aussieht, bis die erste Kundin zahlen will, ist viel schlimmer.
  2. Fail safe: die Zahlung, bei der niemand sicher ist. Die Verbindung zum Anbieter bricht ab, bevor eine Antwort kommt. Ist das Geld geflossen? Stripes Dokumentation sagt, das Ergebnis als unbestimmt zu behandeln, weder Erfolg noch Misserfolg anzunehmen und es beim Anbieter nachzuprüfen2. Also wird die Bestellung als "Zahlung ausstehend" gespeichert: nicht versendet, nicht noch einmal belastet, geprüft, bevor irgendetwas anderes passiert.
  3. Sanft zurückfahren: die Empfehlungen. Der Kasten "Das könnte dir auch schmecken" kommt von einem eigenen Dienst, der an einem Abend nicht antwortet. Die Seite lässt den Kasten weg und zeigt Tee, Preis und Warenkorbknopf wie immer.

Lass es abstürzen, und lass etwas anderes aufräumen

Eine vierte Strategie klingt leichtsinnig und ist das Gegenteil. Sie stammt aus Erlang, das aus der Arbeit bei Ericsson an Telekommunikationssoftware entstanden ist, die einfach weiterlaufen muss. Armstrongs Doktorarbeit sagt es klar: Lass einen anderen Prozess den Fehler beheben, und im Code, der auf das Problem stößt, "let it crash"4. Kleine, voneinander getrennte Worker erledigen je eine Aufgabe. Trifft einer auf eine Lage, die er nicht beherrscht, hört er auf, und ein Supervisor, dessen einzige Aufgabe das Beobachten der Worker ist, startet einen frischen in sauberem Zustand.

Die entscheidenden Wörter sind klein und getrennt. Ein Absturz ist sicher, wenn er ein kleines Stück Arbeit betrifft, nichts halb fertig zurücklässt und etwas Verlässliches ihn neu startet.

Beispiel: die Bestellmail, die abstürzt

Nach einer Zahlung verschickt das Teehaus eine Bestätigungsmail. Jana kann das auf zwei Arten bauen.

  • Zerbrechlich: Die Mail geht im selben Schritt wie die Zahlung raus. Ist der Maildienst gestört, wirft der Checkout eine Exception, und die Kundin sieht eine Fehlerseite, obwohl ihre Karte belastet wurde.
  • Robust: Die Zahlung abschließen, die Bestellung als bezahlt speichern und die Mail dann an einen Hintergrundjob übergeben, der getrennt von der Anfrage der Kundin läuft. Ist der Maildienst gestört, stürzt der Job ab, das Jobsystem startet ihn später erneut, und erst nach dem letzten Versuch bittet es einen Menschen, nachzusehen. Die Kundin hat die Dankeseite längst gesehen, und die Mail kommt ein paar Minuten später.

Derselbe Fehler. Im zweiten Design ist der Absturz klein, getrennt und wird neu gestartet. Wie du diese Wiederholungen in Rails einrichtest, zeigt das nächste Kapitel.

Schluck nie einen Fehler stillschweigend

Die schädlichste Gewohnheit in der Fehlerbehandlung: einen Fehler fangen und nichts damit tun. Man nennt das einen Fehler verschlucken. Der Code läuft weiter, als wäre nichts gewesen, und die Spur ist weg.

Das ist gemessen, keine Geschmacksfrage. Ein Team der University of Toronto hat 198 echte Ausfälle in fünf weit verbreiteten verteilten Systemen untersucht, darunter Cassandra, HDFS und Redis, und sich die 48 katastrophalen genau angesehen, also die, die alle oder die meisten Nutzer trafen10. 92 % davon gingen auf falsche Behandlung von nicht fatalen Fehlern zurück, die die Software ausdrücklich gemeldet hatte. Das System hatte das Problem bemerkt und dann schlecht behandelt. 35 % stammten aus drei banalen Mustern: ein Handler, der leer war oder nur eine Logzeile schrieb, ein Handler, der bei einer zu allgemein gefangenen Exception alles abbrach, und ein Handler mit "TODO" oder "FIXME" darin10. Die Autoren nennen Fehlerbehandlungscode die letzte Verteidigungslinie und fanden, dass einfaches Testen dieses Codes die meisten dieser Fälle gefunden hätte.

Aufschlüsselung von 48 katastrophalen Ausfällen aus der Studie von Yuan und anderen, 2014. Fehler vom Handler ignoriert: 25 %. Abbruch nach zu allgemeinem catch: 8 %. TODO im Handler: 2 %. Andere leicht auffindbare Fehler: 23 %. Komplexe Fehler in der Behandlung: 34 %. Nicht durch Fehlerbehandlung verursacht: 8 %. Zum Vergrößern antippen: Vollbild, frei verschiebbar

Die ersten drei Balken ergeben zusammen die 35 % banaler Fehler. Mit dem vierten sind es 58 %, der Anteil, den laut den Autoren einfaches Testen des Fehlerbehandlungscodes gefunden hätte10.

Beispiel: das stille Rescue, das unbezahlte Bestellungen verschickt

Hier eine Zahlungsmethode mit allen drei banalen Mustern auf einmal.

def pay(order)
  begin
    PaymentGateway.charge(order.total_cents, order.payment_token)
  rescue => e
    # TODO: später richtig behandeln
  end
  order.update!(status: "paid")
  OrderMailer.confirmation(order).deliver_later
end

Wenn der Zahlungsanbieter nicht rechtzeitig antwortet:

  1. PaymentGateway.charge wirft eine Timeout Exception.
  2. Das nackte rescue => e fängt sie, weil ein nacktes Rescue jeden StandardError fängt5. Der Handler ist bis auf einen Kommentar leer.
  3. Die Ausführung läuft weiter, als hätte die Zahlung geklappt. Die Bestellung wird als "paid" markiert.
  4. Eine Bestätigungsmail geht raus, der Tee wird gepackt.
  5. Es ist nie Geld angekommen, und niemand weiß es: Nichts wurde geloggt, niemand gewarnt, die einzige Spur ist ein TODO.

Janas korrigierte Fassung tut weniger, und genau deshalb ist sie richtig.

def pay(order)
  PaymentGateway.charge(order.total_cents, order.payment_token)
  order.update!(status: "paid")
  OrderMailer.confirmation(order).deliver_later
  :paid
rescue PaymentGateway::CardDeclined
  # Nur die erwartete Ablehnung wird hier behandelt
  order.update!(status: "declined")
  :declined
end
  • Sie fängt genau ein erwartetes Ergebnis, PaymentGateway::CardDeclined. Die Bestellung wird als abgelehnt markiert, die Methode gibt :declined zurück, und der Checkout kann nach einer anderen Karte fragen.
  • Jede andere Exception, ein Timeout, ein Bug, ein falscher Schlüssel, wandert nach oben. Die Bestellung bleibt "pending" (fail safe), und die Fehlerüberwachung des Shops hält es für Jana fest.

PaymentGateway ist Janas eigene dünne Hülle um den Anbieter, damit der Rest des Shops mit ein paar klaren Fehlernamen arbeitet statt mit der vollen Liste des Anbieters.

Der Fehler, den niemand gelesen hat: ein Alarm muss einen Menschen erreichen

Einen Fehler im Code gut zu behandeln, ist die halbe Arbeit. Die andere Hälfte: sicherstellen, dass ein Mensch davon erfährt, wenn es darauf ankommt.

Die deutlichste Lektion steht in der Verfügung der US Börsenaufsicht SEC gegen Knight Capital Americas aus dem Jahr 201311. Am 1. August 2012 hatte ein Techniker neuen Code auf einen von acht Servern nicht kopiert. Alter, ungenutzter Code auf diesem Server wurde durch eine wiederverwendete Einstellung ausgelöst. In etwa 45 Minuten entstanden über 4 Millionen Ausführungen in 154 Aktien über mehr als 397 Millionen Stück, und Knight verlor mehr als 460 Millionen Dollar11.

Was in diesen Artikel gehört, geschah vor Börsenöffnung. Ab etwa 8:01 Uhr New Yorker Zeit verschickte ein internes System automatische Mails, die das betroffene System und einen Fehler namens "Power Peg disabled" nannten, 97 Stück bis zur Öffnung um 9:30 Uhr. Knight hatte diese Nachrichten nicht als Alarme gedacht, und die Belegschaft sah sie in der Regel nicht an. Die SEC nennt sie "a potential opportunity to identify and fix the coding issue prior to the market open", also eine Gelegenheit, den Fehler vor Börsenöffnung zu finden und zu beheben11.

Der Fehler wurde erkannt und 97 Mal gemeldet. Er landete nur dort, wo niemand hinsah.

Beispiel: Janas Alarmliste

Jana legt auf Papier fest, wohin welches Signal geht. Ein Alarm muss so selten sein, dass ihn immer jemand liest, und so konkret, dass klar ist, was zu tun ist.

SignalWohin es gehtWer handelt
Eine Zahlung steht länger als 15 Minuten auf "ausstehend"Sofort auf Janas HandyJana prüft sie beim Anbieter
Mehr als drei Serverfehler auf Checkoutseiten in fünf MinutenSofort auf Janas HandyJana
Ein Mailjob, dessen letzter Versuch gescheitert istTägliche SammelmailJana, am nächsten Morgen
Abgelehnte KartenWöchentliche ZahlDie Inhaberin, wenn die Quote springt
Alles andereDurchsuchbare LogsNiemand, bis es eine Frage gibt

Eine abgelehnte Karte weckt niemanden. Die Kundin hat schon eine Nachricht bekommen, und ein Alarm würde Jana nur beibringen, Alarme zu übersehen. Genau so bleiben 97 Warnungen ungelesen.

Ein Fehler, zwei Nachrichten: für die Kundschaft und für die Entwicklung

Jeder Fehler hat zwei Publikume, die Gegensätzliches brauchen. Die Kundschaft braucht einen kurzen, freundlichen Satz: was passiert ist und was jetzt zu tun ist. Die Entwicklung braucht jedes technische Detail. Das Open Worldwide Application Security Project (OWASP) warnt, dass detaillierte Fehlerausgaben Angreifern verraten, wie ein System gebaut ist, und empfiehlt eine allgemeine Antwort an die Nutzer, während die Details auf dem Server geloggt werden12. Das GOV.UK Design System, die Gestaltungsrichtlinie der britischen Regierung, ergänzt: Eine Fehlermeldung sagt, was passiert ist und wie man es behebt, und meidet Fachjargon, Schuldzuweisungen wie "forbidden", leere Wörter wie "invalid" und flapsige wie "oops"13.

In die Hälfte für die Entwicklung gehört, was du zum Verstehen brauchst, und nichts Persönliches, das du nicht brauchst. Wie du mit Kontext und ohne personenbezogene Daten loggst, zeigt das nächste Kapitel.

Beispiel: eine abgelehnte Karte, zweimal geschrieben

Ein Kunde bezahlt 250 g Assam und ein Abo, und die Bank lehnt die Karte ab.

Das sieht der Kunde:

Deine Bank hat diese Karte abgelehnt. Probier eine andere Karte, oder frag bei deiner Bank nach und versuch es dann noch einmal. Dein Warenkorb bleibt gespeichert.

Die Nachricht sagt, wer abgelehnt hat (die Bank, nicht der Shop), was zu tun ist und was nicht verloren ist. Keine Codes, kein "ungültig".

Das steht in Janas Log:

{"event":"payment.declined","order_id":"TG-20931","provider_request_id":"req_8Hc2","decline_code":"insufficient_funds","amount_cents":2450,"at":"2026-11-14T19:42:07Z"}

Jedes Feld hilft, genau diesen Versuch beim Anbieter nachzuverfolgen. Keines identifiziert den Kunden. Der Ablehnungscode bleibt im Log und erscheint nie am Bildschirm, denn wer über eine Schulter schaut, muss nicht erfahren, dass ein Konto nicht gedeckt ist.

Was schlechte Fehlerbehandlung Ariane 5 gekostet hat

Die berühmteste Lektion der Fehlerbehandlung hat mit Shops nichts zu tun. Am 4. Juni 1996 kam die erste Ariane 5 keine 40 Sekunden nach dem Start vom Kurs ab, brach auseinander und explodierte14. Der Untersuchungsausschuss unter dem Vorsitz von Professor J. L. Lions stellte Folgendes fest14.

  1. Im Trägheitsnavigationssystem, das der Rakete sagt, wohin sie zeigt, wandelte Software eine 64 Bit Gleitkommazahl in eine 16 Bit Ganzzahl mit Vorzeichen um. Die Zahl war zu groß, und die Umwandlung löste eine Exception aus, einen Operand Error.
  2. Diese Umwandlung war nicht abgesichert, obwohl vergleichbare Umwandlungen an derselben Stelle im Code es waren.
  3. Der betroffene Code berechnete eine Ausrichtung, die nur vor dem Abheben Sinn ergibt. Er lief trotzdem etwa 40 Sekunden in den Flug hinein weiter, ein Zeitablauf, der von der Ariane 4 übernommen war.
  4. Das Reservegerät mit identischer Software war schon 72 Millisekunden vorher aus demselben Grund ausgefallen.
  5. Die Spezifikation verlangte, bei jeder Exception den Fehler zu melden, den Kontext zu speichern und den Prozessor abzuschalten. Der Bericht: "It was the decision to cease the processor operation which finally proved fatal", die Entscheidung, den Prozessor anzuhalten, war am Ende tödlich.
  6. Diese Regel ging davon aus, dass eine Exception einen zufälligen Hardwaredefekt bedeutet, bei dem der Wechsel aufs Reservegerät sinnvoll ist. Hier lag ein Designfehler vor, identisch in beiden Geräten. Der Ausschuss kam zu dem Schluss, dass die Exception erkannt, aber unangemessen behandelt wurde, weil Software als korrekt galt, bis ihr ein Fehler nachgewiesen ist, und sprach sich für die umgekehrte Sicht aus.

Der Überlauf war die Fehlerursache. Eine funktionierende Steuerung wegen einer Rechnung abzuschalten, die gar nicht mehr gebraucht wurde, war eine Entscheidung der Fehlerbehandlung, Jahre vorher in einer Spezifikation getroffen.

Beispiel: was eine Rakete einem Teeshop beibringt

Das Teehaus läuft auf zwei Anwendungsservern, damit der Shop offen bleibt, wenn eine Maschine stirbt. Das schützt vor Hardwaredefekten. Gegen einen Bug hilft es nicht: Beide Server haben denselben Code, also legt dieselbe Eingabe beide lahm, genau wie die beiden Trägheitsnavigationsgeräte.

Janas Handler müssen also unterscheiden zwischen "die Maschine ist kaputt" (auf die andere wechseln) und "der Code ist falsch" (diese eine Anfrage stoppen, alles andere weiterlaufen lassen, die Entwicklung alarmieren). Und einen Bug zu wiederholen, auf dem zweiten Server oder zehnmal auf dem ersten, wiederholt nur den Fehler. Damit sind wir bei den Wiederholungen.

Wann ein neuer Versuch hilft und wann er nur den Fehler wiederholt

Es noch einmal zu versuchen, ist die verlockendste Antwort auf jeden Fehler. Für eine Art ist sie richtig, für die anderen falsch, und ein bisschen Wahrscheinlichkeitsrechnung zeigt, warum.

Ist ein Problem vorübergehend und zufällig, etwa ein kurzer Netzwerkschluckauf, und scheitert jeder Versuch unabhängig vom vorigen, dann ist die Wahrscheinlichkeit, dass alle Versuche scheitern:

Palle scheitern=pkP_{\text{alle scheitern}} = p^{k}

Dabei ist pp die Wahrscheinlichkeit, dass ein einzelner Versuch scheitert, kk die Gesamtzahl der Versuche und Palle scheiternP_{\text{alle scheitern}} die Wahrscheinlichkeit, dass alle kk Versuche scheitern. Das gilt nur, wenn die Versuche unabhängig sind, ein Scheitern also nichts über das nächste verrät. Grundlagen: Wahrscheinlichkeit erklärt unabhängige Ereignisse von Grund auf.

Eine abgelehnte Karte bleibt abgelehnt, und ein Bug scheitert jedes Mal gleich. Dafür gilt p=1p = 1, und 1k=11^{k} = 1, egal wie oft du es versuchst.

Beispiel: der Timeout beim Teehaus, in Zahlen

Nimm als erfundene Zahl für dieses Beispiel an, dass 2 von 100 Aufrufen beim Zahlungsanbieter in einen Timeout laufen, also p=0,02p = 0{,}02, unabhängig voneinander. Bei drei Versuchen insgesamt:

Palle scheitern=0,023=0,000008P_{\text{alle scheitern}} = 0{,}02^{3} = 0{,}000008

Das sind 0,000008=0,0008 %0{,}000008 = 0{,}0008\,\%, etwa 8 von einer Million Zahlungen. Drei Versuche machen aus einem Problem, das zwei von hundert Kundinnen trifft, eines, das fast niemanden mehr erreicht. Einen Timeout zu wiederholen, zahlt sich aus.

Bei einer abgelehnten Karte bedeuten drei Versuche drei Ablehnungen, und Stripes Dokumentation zu Ablehnungen spricht sogar von Netzwerkkosten und "excessive retry penalties", also Strafgebühren für zu viele Wiederholungen15. Auch der Timeout hat eine Falle. Ist der erste Versuch beim Anbieter angekommen und nur die Antwort verloren gegangen, belastet ein naiver neuer Versuch die Kundin doppelt. Der Schutz ist ein Idempotenzschlüssel, eine eindeutige Kennung, die mit der Anfrage mitgeht, damit der Anbieter eine Wiederholung nur einmal ausführt. Stripe rät, Verbindungsfehler mit demselben Schlüssel und denselben Parametern zu wiederholen2, und das nächste Kapitel baut es in Code.

Janas Regel: Wiederhole, was vorübergehend ist, mit demselben Idempotenzschlüssel und wachsender Wartezeit zwischen den Versuchen. Wiederhole nie eine Entscheidung wie eine Ablehnung, und nie einen Bug.

Fehlerbehandlung ist Design: entscheide, bevor du programmierst

Alles bisher läuft in einer Übung zusammen. Für jeden wichtigen Schritt listest du auf, was schiefgehen kann, und legst vorher fest, welche Antwort jeder Fall bekommt:

  • Wiederholen: Das Problem ist vorübergehend, ein neuer Versuch ist sicher.
  • Der Kundschaft sagen: ein erwartetes Ergebnis, auf das sie reagieren kann.
  • Die Entwicklung alarmieren: Ein Mensch muss draufschauen.
  • Anhalten: Weitermachen würde es schlimmer machen, also in einem sicheren Zustand stoppen.

Viele Fälle bekommen zwei Antworten, etwa "anhalten und alarmieren". Der Punkt ist, dass niemand um zwei Uhr nachts entscheidet, während der Shop Bestellungen verliert. Entschieden wird an einem ruhigen Nachmittag, schriftlich, und daraus werden dann Tests und Code.

Das kannst du als Inhaberin oder Inhaber auch ohne eine Zeile Code. Soll jemand mit ausstehender Zahlung "Wir prüfen deine Zahlung" lesen oder "Bitte versuch es später noch einmal"? Willst du von einem Anstieg der Ablehnungen erfahren? Das sind Entscheidungen über Kundschaft und Geld.

In meiner eigenen Arbeit beginnt genau hier die testgetriebene Entwicklung: Jede Zeile wird zu einem Szenario und einem fehlschlagenden Test, bevor es Code für die Behandlung gibt, und der Zahlungsschritt liegt in der höchsten Risikostufe, in der ich entscheide und KI nur berät. Wie diese Tests aussehen, zeigt den Unhappy Path testen, und wie die Regel hält, wenn ein Assistent einen Großteil des Codes schreibt, steht in testgetriebene Entwicklung mit KI.

Beispiel: jede Art, wie der Zahlungsschritt beim Teehaus schiefgehen kann

Jana und die Inhaberin füllen die Tabelle bei einer Kanne Tee gemeinsam aus, in weniger als einer Stunde. Passt.

Was schiefgehtErwartet?AntwortWas die Kundschaft sieht
Die Bank lehnt die Karte abJaDer Kundschaft sagen"Deine Bank hat diese Karte abgelehnt. Probier eine andere Karte, oder frag bei deiner Bank nach."
Karte abgelaufen oder Prüfnummer falschJaDer Kundschaft sagenEine Nachricht am richtigen Feld: "Gib die Prüfnummer von der Rückseite deiner Karte ein"
Der Anbieter blockiert die Zahlung als riskantJaDer Kundschaft sagen"Diese Zahlung konnte nicht abgeschlossen werden. Probier eine andere Zahlungsart."
Die Verbindung läuft in einen TimeoutNein, aber absehbarZweimal mit demselben Idempotenzschlüssel wiederholen, dann als "ausstehend" anhalten und alarmieren, wenn weiter unklar"Wir bestätigen gerade deine Zahlung. Du bekommst in wenigen Minuten eine Mail."
Der Anbieter meldet einen Fehler auf seiner SeiteNeinAls "ausstehend" anhalten, vor dem Versand beim Anbieter bestätigen, alarmierenWie oben
Der Anbieter meldet zu viele AnfragenNein, aber absehbarNach einer Pause wiederholen, die jedes Mal wächstNichts, solange nicht alle Versuche scheitern
Der Anbieter lehnt den geheimen Schlüssel abNeinSofort anhalten und alarmieren, beim Start geprüft, damit ein Deployment schnell scheitert"Zahlungen sind gerade nicht möglich. Dein Warenkorb bleibt gespeichert."
Die Bestellsumme ist null oder kleinerNein (ein Bug)Vor jeder Belastung anhalten, alarmieren"Bei deiner Bestellsumme ist etwas schiefgegangen. Es wurde nichts abgebucht."
Die Bestätigungsmail scheitert nach der ZahlungNein, aber absehbarSanft zurückfahren: Die Bestellung steht, der Mailjob wiederholt, Alarm nach dem letzten VersuchDie normale Dankeseite

Drei Dinge fallen auf. Jede Zeile, in der Geld geflossen sein könnte, ohne dass der Shop es weiß, endet in "ausstehend", nie in "bezahlt" oder "gescheitert". Nur zwei Zeilen wecken Jana sofort. Und keine Zeile sagt "ignorieren".

Der Ablauf unten ist die Entscheidung, die Janas Code jedes Mal trifft, wenn im Checkout ein Fehler passiert.

Zum Vergrößern antippen: Vollbild, frei verschiebbar

Kurz gesagt

Jede Software hat Fehlerursachen. Was einen Shop, der Geld verliert, von einem unterscheidet, der mit den Schultern zuckt, ist das, was zwischen Fehlzustand und Ausfall passiert, und das entscheiden Menschen, bevor der Code entsteht.

Eine Fehlerursache erzeugt einen Fehlzustand, und der wird nur zum Ausfall, wenn ihn nichts behandelt. Erwartete Probleme verdienen eine ruhige Nachricht, unerwartete einen sicheren Halt und die Aufmerksamkeit eines Menschen. Nimm Exceptions für das Außergewöhnliche und Rückgabewerte für den Alltag. Scheitere schnell bei falscher Konfiguration, scheitere sicher, wenn beim Geld etwas unklar ist, fahr sanft zurück, wenn ein Extra ausfällt, und lass kleine, getrennte Arbeit abstürzen und neu starten. Schluck nie einen Fehler, schick Alarme nur dorthin, wo jemand liest, und schreib zwei Nachrichten, eine für die Kundschaft und eine für die Entwicklung.

Und dann schreib alles auf, Schritt für Schritt, bevor irgendjemand Code schreibt. Diese Tabelle ist das Design. Code und Tests machen sie wahr.

Wenn du wissen willst, was dein Shop oder dein Produkt tut, wenn eine Zahlung scheitert, ein Server nicht antwortet oder ein Bug aufwacht, buch den kostenlosen Workshop: Wir gehen gemeinsam jeden Fehlerfall auf deinen wichtigsten Schritten durch und legen fest, was passieren soll, und die ersten zwei Wochen Arbeit gehen auf mich.

Quellen

  1. 1.

    Algirdas Avizienis, Jean Claude Laprie, Brian Randell und Carl Landwehr, Basic concepts and taxonomy of dependable and secure computing, IEEE Transactions on Dependable and Secure Computing, Bd. 1, Nr. 1, 2004 (DOI 10.1109/TDSC.2004.2); Autorenfassung im Repositorium der University of Maryland, https://drum.lib.umd.edu/handle/1903/6459

  2. 2.

    Stripe, Error handling, Stripe Dokumentation (Ruby Fassung), abgerufen im November 2026, https://docs.stripe.com/error-handling

  3. 3.

    Steve Klabnik, Carol Nichols und Chris Krycho, The Rust Programming Language, Kapitel 9: Error handling, rust-lang.org, abgerufen im November 2026, https://doc.rust-lang.org/book/ch09-00-error-handling.html

  4. 4.

    Joe Armstrong, Making reliable distributed systems in the presence of software errors, Dissertation, Royal Institute of Technology (KTH), Stockholm, 2003, Abschnitt 4.4 "Let it crash", https://erlang.org/download/armstrong_thesis_2003.pdf

  5. 5.

    Ruby Dokumentation, Exceptions, Ruby 3.4, ruby-lang.org, https://docs.ruby-lang.org/en/3.4/exceptions_md.html

  6. 6.

    Ruby on Rails API Dokumentation, ActiveRecord::Transactions::ClassMethods, rubyonrails.org, https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html

  7. 7.

    MDN Web Docs, Window: fetch() method, Mozilla, abgerufen im November 2026, https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch

  8. 8.

    Ruby on Rails Guides, Active Record Validations, rubyonrails.org, https://guides.rubyonrails.org/active_record_validations.html

  9. 9.

    Jim Shore, Fail fast, IEEE Software, Bd. 21, Nr. 5, September/Oktober 2004, S. 21 bis 25, https://martinfowler.com/ieeeSoftware/failFast.pdf

  10. 10.

    Ding Yuan, Yu Luo, Xin Zhuang, Guilherme Renna Rodrigues, Xu Zhao, Yongle Zhang, Pranay U. Jain und Michael Stumm, Simple testing can prevent most critical failures: an analysis of production failures in distributed data intensive systems, 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), 2014, https://www.usenix.org/conference/osdi14/technical-sessions/presentation/yuan

  11. 11.

    U.S. Securities and Exchange Commission, In the Matter of Knight Capital Americas LLC, Administrative Proceeding File No. 3-15570, Release No. 34-70694, 16. Oktober 2013, Absätze 1 und 15 bis 19, https://www.sec.gov/litigation/admin/2013/34-70694.pdf

  12. 12.

    OWASP Cheat Sheet Series, Error Handling Cheat Sheet, OWASP Foundation, abgerufen im November 2026, https://cheatsheetseries.owasp.org/cheatsheets/Error_Handling_Cheat_Sheet.html

  13. 13.

    GOV.UK Design System, Error message, Government Digital Service, abgerufen im November 2026, https://design-system.service.gov.uk/components/error-message/

  14. 14.

    J. L. Lions (Vorsitz) und der Untersuchungsausschuss, Ariane 5 Flight 501 Failure: Report by the Inquiry Board, Paris, 19. Juli 1996, Europäische Weltraumorganisation (ESA), https://esamultimedia.esa.int/docs/esa-x-1819eng.pdf

  15. 15.

    Stripe, Declines, Stripe Dokumentation, abgerufen im November 2026, https://docs.stripe.com/declines