mitmario.dev

Fehler-Handler

Node.js Sandbox 4 Min Lesezeit 3 BeispieleLektion 5 von 7

In jeder Route ein try und in jedem catch dieselben vier Zeilen. So sieht Fehlerbehandlung beim ersten Mal aus. Irgendwann antwortet dann eine Route anders als die übrigen, weil in ihrem catch der Statuscode fehlt. Keiner merkt es, bis sich ein Aufrufer wundert.

Was ohne dich passiert

Was Express von sich aus tut
import express from "express";

// Ohne diese Zeile schriebe Express den vollen Stacktrace zusaetzlich ins
// Terminal, mit den Pfaden dieser Maschine. Hier soll nur die Antwort zaehlen.
process.env.NODE_ENV = "test";

const app = express();

app.get("/kaputt", (req, res) => {
  throw new Error("Datenbank nicht erreichbar");
});

app.listen(3000);

Ein geworfener Fehler stürzt den Server nicht ab. Express fängt ihn, antwortet mit 500 und schreibt den Stacktrace zusätzlich auf den Fehlerkanal. Für die Entwicklung ist das gar nicht schlecht. Im Beispiel fehlt nur die Ausgabe auf dem Fehlerkanal, denn ganz oben steht NODE_ENV auf test.

Für den Betrieb nicht. Im Reiter Browser steht die Antwort, und darin stehen deine Dateinamen, deine Zeilennummern und die Pfade deiner Pakete. Die Seite ist ein Bericht über deinen Server. Wer wissen will, welche Pakete darin stecken und wo die Dateien liegen, muss nur einen Fehler auslösen.

Ganz naiv ist Express dabei nicht. Steht NODE_ENV auf production, schickt es nur noch Internal Server Error. Es bleibt aber HTML, und was ins Protokoll kommt, entscheidest du auch nicht. Für eine API ist das zweimal das Falsche.

Vier Argumente statt drei

Ein Fehler-Handler mit vier Argumenten
import express from "express";

const app = express();

app.get("/kaputt", (req, res) => {
  throw new Error("Datenbank nicht erreichbar");
});

// Vier Argumente. Das ist die einzige Kennzeichnung, an der Express einen
// Fehler-Handler erkennt, und er gehoert ganz nach unten.
app.use((fehler, req, res, next) => {
  res.status(500).json({ fehler: "Serverfehler" });
});

app.listen(3000);

Eine Middleware mit vier Argumenten ist für Express ein Fehler-Handler (in der Express-Doku error-handling middleware). Dafür zählen weder der Name noch die Position, nur die Anzahl der Argumente.

Diese Sonderregel kann man nicht erraten, und sie hat eine unangenehme Folge. Lässt du das vierte Argument weg, weil du es sowieso nicht brauchst, hast du plötzlich eine ganz normale Middleware. Bei einem Fehler wird sie nie aufgerufen, der landet weiter bei Express. Dafür bekommt sie jede Anfrage, die ohne Fehler bis zu ihr durchfällt. Dort heißen ihre Parameter plötzlich anders. Was fehler heißt, ist die Anfrage, und res.status ist keine Funktion. Den Grund sucht man dann an der falschen Stelle. Ich lasse next deshalb nie weg, auch wenn ich es nicht benutze.

Und der Fehler-Handler gehört ganz nach unten, unter alle Routen und alle anderen Middlewares. Beim Standardfall aus Lektion 9.2 war es genauso. Nur was unter etwas steht, kann von dort etwas entgegennehmen.

/kaputt liefert jetzt statt des Stacktraces von eben ein kurzes JSON.

Dieser Fehler-Handler kennt nur einen Ausgang, 500 und Serverfehler. Für eine unerreichbare Datenbank stimmt das, aber nicht für jeden Fehler. Was der Aufrufer selbst ändern kann, darf er erfahren. Was nur du ändern kannst, geht ihn nichts an. Eine Kennung, zu der es kein Buch gibt, ist sein Fehler, eine unerreichbare Datenbank deiner. Woran ein Fehler-Handler den Unterschied erkennt, steht weiter unten bei next(fehler).

Wie ein Fehler dort ankommt

Drei Wege, wie ein Fehler dort ankommt
import express from "express";

const app = express();

// 1. Geworfen in einem gewoehnlichen Handler.
app.get("/geworfen", (req, res) => {
  throw new Error("geworfen");
});

// 2. Von Hand per next weitergereicht.
app.get("/weitergereicht", (req, res, next) => {
  next(new Error("weitergereicht"));
});

// 3. Geworfen in einem async-Handler. Das faengt Express 5 von selbst ab.
//    Unter Express 4 riss es seit Node 15 den ganzen Prozess mit.
app.get("/async", async (req, res) => {
  await new Promise((r) => setTimeout(r, 5));
  throw new Error("aus einem async-Handler");
});

app.use((fehler, req, res, next) => {
  res.status(500).json({ weg: fehler.message });
});

app.listen(3000);

Den ersten Weg siehst du auf der Seite, die beiden anderen holst du mit den Befehlen der Befehlsleiste. In der Antwort steht jedes Mal, welcher Weg es war.

Alle drei Wege führen zum selben Fehler-Handler. Beim dritten lohnt sich ein Blick auf die Versionsnummer. In Express 4 wurde ein abgelehntes Promise aus einem async-Handler nicht aufgefangen. Seit Node 15 reißt so ein unbehandelter Fehler den ganzen Prozess mit und damit auch alle anderen Anfragen. Deshalb findest du in älteren Anleitungen ein Hilfsmittel namens asyncHandler oder ein Paket namens express-async-errors, und in vielen Projekten steht in jedem async-Handler ein try/catch mit next(fehler) darin.

In Express 5 braucht es beides nicht mehr. Ein abgelehntes Promise landet von selbst beim Fehler-Handler. Code, der das noch von Hand macht, ist nicht falsch, nur älter als nötig.

Der Weg über next(fehler) bleibt trotzdem wichtig, und zwar für alles, was kein geworfener Fehler ist. Ein Buch, das es nicht gibt, ist keine Ausnahme im Programmablauf. Es soll nur denselben Ausgang nehmen. Dann baut man ein Fehlerobjekt, hängt einen Statuscode dran und reicht es weiter.

Was der Fehler-Handler tun soll

Drei Dinge gehören hinein:

  • Protokollieren, und zwar vollständig. Nach innen will man alles: Meldung, Stacktrace und im Idealfall die Anfragekennung, die eine eigene Middleware vergeben hat.
  • Einen Statuscode wählen. Voreinstellung ist 500, und wer es besser weiß, hängt status an den Fehler.
  • Eine kurze Meldung senden, ohne Stacktrace und in derselben Form wie alle anderen Fehler der Anwendung. Wie diese Form aussieht, kommt in Lektion 11.6.

In der Aufgabe laufen drei Routen auf drei verschiedene Arten in einen Fehler.

Zum Mitnehmen

Express erkennt einen Fehler-Handler allein an seinen vier Argumenten, und er steht unter allen Routen, deren Fehler er auffangen soll. Was schiefging, kommt vollständig ins Protokoll, nach außen geht nur eine kurze Meldung ohne Stacktrace.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.