Abschnitt 16 · Lektion 3
Der zentrale Fehler-Handler
Setzt jede Route ihren Statuscode selbst, entscheidet auch jede für sich, ob ein fehlendes Buch 404 ist oder 400. Nach ein paar Monaten antworten dann zwei Routen verschieden auf denselben Fehler. Welcher Fehler welchen Statuscode bekommt, gehört deshalb an eine Stelle, in den Fehler-Handler.
Die naheliegende Antwort ist die falsche
Der Fehler-Handler aus Lektion 11.6 nimmt fehler.status ?? 500. Das klappt, solange alle Fehler
aus dem eigenen Code kommen. Tun sie aber nicht.
import express from "express";
const app = express();
// Ein Fehler aus einem fremden Paket. Er traegt einen Status und einen
// Code, und beide gehoeren nicht deiner Anwendung.
app.get("/preis", (req, res, next) => {
const fehler = new Error("Preisdienst antwortete 404 auf /v2/preise");
fehler.status = 404;
fehler.code = "preisdienst_404";
next(fehler);
});
// Der Fehler-Handler aus Lektion 11.6: er glaubt, was am Fehler steht.
app.use((fehler, req, res, next) => {
res.status(fehler.status ?? 500).json({ code: fehler.code ?? "serverfehler" });
});
app.listen(3000); Ein Aufruf nach draußen scheitert, und das Paket hängt den Statuscode des fremden Dienstes an seinen Fehler. Der Fehler-Handler reicht ihn einfach durch. Die API antwortet dann mit 404, und der Aufrufer liest daraus, dass es nicht gibt, wonach er gefragt hat. Vielleicht löscht er es sogar aus seinem Zwischenspeicher.
Der Code in der Antwort ist genauso schlimm. preisdienst_404 verrät den Namen eines internen
Dienstes und die Struktur des Systems. Reagiert ein Aufrufer darauf, hängt er an einem Detail, das
du morgen austauschen willst.
Ein Fehlerobjekt ist eine Eingabe wie jede andere. status ist eine Eigenschaft daran, die
irgendwer gesetzt hat. Dagegen hilft die Allowlist aus dem Abschnitt über Sicherheit, hier eine
Aufzählung der Fehler, die die Anwendung kennt.
Zwei Fragen, in dieser Reihenfolge
import express from "express";
class AppFehler extends Error {
constructor(meldung, code) {
super(meldung);
this.name = new.target.name;
this.code = code;
}
}
class NichtGefunden extends AppFehler {
constructor(was) {
super(`${was} gibt es nicht.`, "nicht_gefunden");
}
}
// Die Zuordnung, an genau einer Stelle. Was hier nicht steht, ist ein 500.
const STATUS = { nicht_gefunden: 404, ungueltig: 400, nicht_angemeldet: 401, konflikt: 409 };
const app = express();
app.get("/buecher/99", (req, res, next) => next(new NichtGefunden("Buch 99")));
app.get("/preis", (req, res, next) => {
const fehler = new Error("Preisdienst antwortete 404 auf /v2/preise");
fehler.status = 404;
fehler.code = "preisdienst_404";
next(fehler);
});
app.use((fehler, req, res, next) => {
const bekannt = fehler instanceof AppFehler && STATUS[fehler.code] !== undefined;
const status = bekannt ? STATUS[fehler.code] : 500;
res.status(status).json({
fehler: {
code: bekannt ? fehler.code : "serverfehler",
meldung: bekannt ? fehler.message : "Da ist etwas schiefgegangen.",
},
});
});
app.listen(3000); Der Fehler-Handler stellt zwei Fragen. Die Reihenfolge zählt, weil auch ein fremder Fehler einen Code tragen kann, der zufällig in der Tabelle steht.
Die erste ist, ob das überhaupt einer der eigenen Fehler ist. Das beantwortet
fehler instanceof AppFehler. Eine gemeinsame Wurzelklasse kostet sieben Zeilen, und alle eigenen
Fehlerklassen erben von ihr. Damit gibt es eine einzige Prüfung statt einer Liste von Klassen.
Die zweite ist, welchen Status dieser Code hat. Das beantwortet die Tabelle STATUS, ein
gewöhnliches Objekt an einer Stelle. Ein neuer Fehlercode ist eine Zeile mehr darin.
Heißt eine der beiden Antworten nein, wird es eine 500, mit dem eigenen Code und dem eigenen Satz.
Was am Fehler stand, kommt nicht in die Antwort. Mit /preis in der Adresszeile siehst du das
Ergebnis. Es ist derselbe Fehler wie eben, jetzt als sauberer Serverfehler.
Jeder andere Code als 500 wäre eine Aussage über die Anfrage, die der Server nicht belegen kann. Mit 500 sagt der Server, dass der Fehler bei ihm liegt und nicht beim Aufrufer.
Wann ein fremder Status doch stimmt
import express from "express";
const app = express();
app.use(express.json());
app.post("/buecher", (req, res) => res.status(201).json({ ok: true }));
app.get("/", (req, res) =>
res.type("text/plain").send(
`curl -si -X POST -H "Content-Type: application/json" -d '{kaputt' http://localhost:3000/buecher\n`
)
);
app.use((fehler, req, res, next) => {
// Was express.json() an den Fehler haengt, steht hier in der Antwort.
res
.status(fehler.status ?? 500)
.type("text/plain")
.send(
[
`name: ${fehler.name}`,
`status: ${fehler.status}`,
`type: ${fehler.type}`,
`expose: ${fehler.expose}`,
].join("\n") + "\n"
);
});
app.listen(3000); Der curl mit {kaputt schickt absichtlich kaputtes JSON. In der Antwort steht dann, was
express.json() an den Fehler gehängt hat.
Bekommt express.json() einen kaputten Rumpf, wirft es einen SyntaxError mit status: 400 und
type: "entity.parse.failed". Hier stimmt der Status, denn der Aufrufer hat wirklich Unsinn
geschickt und kann etwas dagegen tun. So kam in der abgesicherten Bücher-API auch schon die 413 für
einen zu großen Rumpf zustande.
Dass das der Regel von eben nicht widerspricht, liegt am dritten Feld, expose. Das Paket
http-errors, das Express dafür benutzt, setzt es auf true, wenn der Status unter 500 liegt.
Gemeint ist damit, dass diese Meldung nach außen darf. Bei einem 5xx steht dort false.
Willst du solche Fehler durchlassen, fragst du fehler.expose === true && fehler.status < 500 statt
nur fehler.status. Diese Zeile kommt nicht von selbst, die schreibt man bewusst in den
Fehler-Handler.
Zwei Leser einer Fehlermeldung
Eine Fehlerantwort und ein Protokolleintrag sind zwei verschiedene Texte für zwei verschiedene Leser.
Nach außen gehen der Statuscode, der eigene Code und ein Satz. Bei 4xx darf der Satz konkret sein, denn der Aufrufer soll etwas ändern können. Bei 5xx bleibt er allgemein. Den Aufrufer geht das nichts an, und jedes Detail verrät etwas über das System.
Nach innen geht alles, also der volle Fehler mit Stacktrace, seine cause-Kette, der Pfad, die
Methode und eine Anfragekennung, und das nur bei einem 5xx. Ein 400 ist eine Nachricht an den
Aufrufer, auf der eigenen Seite ist dabei nichts passiert. Wer jeden 404 protokolliert, hat nach
einer Woche ein Protokoll, in dem man nichts mehr findet.
Manche Anwendungen hängen das zusätzlich an die Umgebung. Nur unter NODE_ENV=development steht
dann auch der Stacktrace in der Antwort, in jeder anderen Umgebung bleibt es beim einen Satz.
Express selbst macht es mit seiner eingebauten Fehlerseite umgekehrt und zeigt den Stacktrace
überall außer unter production. Wie das Protokoll nach innen aussieht, steht in Lektion 16.5.
Unter die fertigen Routen der Aufgabe kommen der Standardfall und der Fehler-Handler, samt einer Fehlerseite für den Browser.
Zum Mitnehmen
Den Statuscode bestimmt eine Tabelle für die eigenen Fehlerklassen, alles andere wird 500, bis auf das, was ein Paket mit expose ausdrücklich freigibt. Nach außen geht ein Satz, ins Protokoll der ganze Fehler.
Jetzt du
Basis Konto, kostenlosZu 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.